Beispiel #1
0
/**
 * @brief Get number of peers in the conference.
 * @return The number of peers in the conference. UINT32_MAX on failure.
 */
uint32_t Core::getGroupNumberPeers(int groupId) const
{
    TOX_ERR_CONFERENCE_PEER_QUERY error;
    uint32_t count = tox_conference_peer_count(tox, groupId, &error);
    if (!parsePeerQueryError(error)) {
        return std::numeric_limits<uint32_t>::max();
    }

    return count;
}
Beispiel #2
0
static void cmd_info(Tox *m, uint32_t friendnum, int argc, char (*argv)[MAX_COMMAND_LENGTH])
{
    char outmsg[MAX_COMMAND_LENGTH];
    char timestr[64];

    uint64_t curtime = (uint64_t) time(NULL);
    get_elapsed_time_str(timestr, sizeof(timestr), curtime - Tox_Bot.start_time);
    snprintf(outmsg, sizeof(outmsg), "Uptime: %s", timestr);
    tox_friend_send_message(m, friendnum, TOX_MESSAGE_TYPE_NORMAL, (uint8_t *) outmsg, strlen(outmsg), NULL);

    uint32_t numfriends = tox_self_get_friend_list_size(m);
    snprintf(outmsg, sizeof(outmsg), "Friends: %d (%d online)", numfriends, Tox_Bot.num_online_friends);
    tox_friend_send_message(m, friendnum, TOX_MESSAGE_TYPE_NORMAL, (uint8_t *) outmsg, strlen(outmsg), NULL);

    snprintf(outmsg, sizeof(outmsg), "Inactive friends are purged after %"PRIu64" days",
             Tox_Bot.inactive_limit / SECONDS_IN_DAY);
    tox_friend_send_message(m, friendnum, TOX_MESSAGE_TYPE_NORMAL, (uint8_t *) outmsg, strlen(outmsg), NULL);

    /* List active group chats and number of peers in each */
    size_t num_chats = tox_conference_get_chatlist_size(m);

    if (num_chats == 0) {
        tox_friend_send_message(m, friendnum, TOX_MESSAGE_TYPE_NORMAL, (uint8_t *) "No active groupchats",
                                strlen("No active groupchats"), NULL);
        return;
    }

    uint32_t groupchat_list[num_chats];

    tox_conference_get_chatlist(m, groupchat_list);

    uint32_t i;

    for (i = 0; i < num_chats; ++i) {
        TOX_ERR_CONFERENCE_PEER_QUERY err;
        uint32_t groupnum = groupchat_list[i];
        uint32_t num_peers = tox_conference_peer_count(m, groupnum, &err);

        if (err == TOX_ERR_CONFERENCE_PEER_QUERY_OK) {
            int idx = group_index(groupnum);
            const char *title = Tox_Bot.g_chats[idx].title_len
                                ? Tox_Bot.g_chats[idx].title : "None";
            const char *type = tox_conference_get_type(m, groupnum, NULL) == TOX_CONFERENCE_TYPE_AV ? "Audio" : "Text";
            snprintf(outmsg, sizeof(outmsg), "Group %d | %s | peers: %d | Title: %s", groupnum, type,
                     num_peers, title);
            tox_friend_send_message(m, friendnum, TOX_MESSAGE_TYPE_NORMAL, (uint8_t *) outmsg, strlen(outmsg), NULL);
        }
    }
}
Beispiel #3
0
/**
 * @brief Get the names of the peers of a group
 */
QList<QString> Core::getGroupPeerNames(int groupId) const
{
    if (!tox)
    {
        qWarning() << "Can't get group peer names, tox is null";
        return {};
    }

    uint32_t nPeers = getGroupNumberPeers(groupId);
    if (nPeers == std::numeric_limits<uint32_t>::max())
    {
        qWarning() << "getGroupPeerNames: Unable to get number of peers";
        return {};
    }

    // TODO: Change to std::vector
    std::unique_ptr<uint8_t[][TOX_MAX_NAME_LENGTH]> namesArray{
        new uint8_t[nPeers][TOX_MAX_NAME_LENGTH]};

    std::unique_ptr<uint16_t[]> lengths{new uint16_t[nPeers]};
    TOX_ERR_CONFERENCE_PEER_QUERY error;

    uint32_t count = tox_conference_peer_count(tox, groupId, &error);
    if (!parsePeerQueryError(error))
    {
        return {};
    }

    if (count != nPeers)
    {
        qWarning() << "getGroupPeerNames: Unexpected peer count";
        return {};
    }

    QList<QString> names;
    for (uint32_t i = 0; i < nPeers; ++i)
    {
        lengths[i] = tox_conference_peer_get_name_size(tox, groupId, i, &error);
        bool ok = tox_conference_peer_get_name(tox, groupId, i, namesArray[i], &error);
        if (parsePeerQueryError(error) && ok)
        {
            names.push_back(CString::toString(namesArray[i], lengths[i]));
        }
    }

    return names;
}
static void handle_conference_peer_list_changed(Tox *tox, uint32_t conference_number, void *user_data)
{
    State *state = (State *)user_data;

    fprintf(stderr, "handle_conference_peer_list_changed(#%u, %u, _)\n",
            state->id, conference_number);

    Tox_Err_Conference_Peer_Query err;
    uint32_t count = tox_conference_peer_count(tox, conference_number, &err);

    if (err != TOX_ERR_CONFERENCE_PEER_QUERY_OK) {
        fprintf(stderr, "ERROR: %d\n", err);
        exit(EXIT_FAILURE);
    }

    fprintf(stderr, "tox%u has %u peers online\n", state->id, count);
    state->peers = count;
}
Beispiel #5
0
/**
 * @brief Get the names of the peers of a group
 */
QStringList Core::getGroupPeerNames(int groupId) const
{
    if (!tox) {
        qWarning() << "Can't get group peer names, tox is null";
        return {};
    }

    uint32_t nPeers = getGroupNumberPeers(groupId);
    if (nPeers == std::numeric_limits<uint32_t>::max()) {
        qWarning() << "getGroupPeerNames: Unable to get number of peers";
        return {};
    }

    TOX_ERR_CONFERENCE_PEER_QUERY error;
    uint32_t count = tox_conference_peer_count(tox, groupId, &error);
    if (!parsePeerQueryError(error)) {
        return {};
    }

    if (count != nPeers) {
        qWarning() << "getGroupPeerNames: Unexpected peer count";
        return {};
    }

    QStringList names;
    for (uint32_t i = 0; i < nPeers; ++i) {
        uint8_t name[TOX_MAX_NAME_LENGTH] = {0};
        size_t length = tox_conference_peer_get_name_size(tox, groupId, i, &error);
        bool ok = tox_conference_peer_get_name(tox, groupId, i, name, &error);
        if (ok && parsePeerQueryError(error)) {
            names.append(ToxString(name, length).getQString());
        }
    }

    return names;
}