/* create purple buddy without data and display with no-auth icon */
PurpleBuddy *qq_buddy_new(PurpleConnection *gc, guint32 uid)
{
PurpleBuddy *buddy;
PurpleGroup *group;
gchar *who;
gchar *group_name;
g_return_val_if_fail(gc->account != NULL && uid != 0, NULL);
group_name = g_strdup_printf(PURPLE_GROUP_QQ_FORMAT,
purple_account_get_username(gc->account));
group = qq_group_find_or_new(group_name);
if (group == NULL) {
purple_debug_error("QQ", "Failed creating group %s\n", group_name);
return NULL;
}
purple_debug_info("QQ", "Add new purple buddy: [%u]\n", uid);
who = uid_to_purple_name(uid);
buddy = purple_buddy_new(gc->account, who, NULL); /* alias is NULL */
purple_buddy_set_protocol_data(buddy, NULL);
g_free(who);
purple_blist_add_buddy(buddy, NULL, group, NULL);
g_free(group_name);
return buddy;
}
void
gevo_add_buddy(PurpleAccount *account, const char *group_name,
const char *buddy_name, const char *alias)
{
PurpleConversation *conv = NULL;
PurpleBuddy *buddy;
PurpleGroup *group;
conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, buddy_name, account);
group = purple_find_group(group_name);
if (group == NULL)
{
group = purple_group_new(group_name);
purple_blist_add_group(group, NULL);
}
buddy = purple_find_buddy_in_group(account, buddy_name, group);
if (buddy == NULL)
{
buddy = purple_buddy_new(account, buddy_name, alias);
purple_blist_add_buddy(buddy, NULL, group, NULL);
}
purple_account_add_buddy(account, buddy);
if (conv != NULL)
{
purple_buddy_icon_update(purple_conv_im_get_icon(PURPLE_CONV_IM(conv)));
purple_conversation_update(conv, PURPLE_CONV_UPDATE_ADD);
}
}
//with invite message
static void plainprpl_add_buddy_by_contact_request(PurpleConnection *gc, const char *addr_str, const char *message)
{
PurpleBuddy *buddy;
/* Create the basic buddy item */
buddy = purple_buddy_new(gc->account, addr_str, NULL);
purple_blist_add_buddy(buddy, NULL, NULL, NULL);
PurpleRequestFields *request;
PurpleRequestFieldGroup *group;
PurpleRequestField *field;
group = purple_request_field_group_new(NULL);
field = purple_request_field_string_new("name", _("Name"), addr_str, FALSE);
purple_request_field_group_add_field(group, field);
request = purple_request_fields_new();
purple_request_fields_add_group(request, group);
char *msg = g_strdup_printf("Add a new contact from %s. Message: %s", addr_str, message);
purple_request_fields(gc, "Contact Request", msg,
NULL, request,
"OK", G_CALLBACK(plainprpl_add_buddy_by_contact_request_ok),
"Cancel", G_CALLBACK(plainprpl_add_buddy_by_contact_request_cancel),
NULL, NULL, NULL, (void *) buddy
);
g_free(msg);
purple_prpl_got_user_status(gc->account, buddy->name, PLAIN_STATUS_OFFLINE, NULL);
}
PurpleBuddy *tgp_blist_buddy_migrate (struct tgl_state *TLS, PurpleBuddy *buddy, struct tgl_user *user) {
purple_blist_remove_buddy (buddy);
buddy = purple_buddy_new (tg_get_acc (TLS), user->print_name, NULL);
tgp_blist_buddy_set_id (buddy, user->id);
purple_blist_add_buddy (buddy, NULL, tgp_blist_group_init ("Telegram"), NULL);
return buddy;
}
static void om_login(PurpleAccount *account)
{
PurpleBuddy *bud;
OmegleAccount *oma;
//make sure there's an Omegle buddy on the buddy list
bud = purple_find_buddy(account, "omegle");
if (bud == NULL)
{
bud = purple_buddy_new(account, "omegle", "Omegle");
purple_blist_add_buddy(bud, NULL, NULL, NULL);
}
purple_prpl_got_user_status(account, "omegle", purple_primitive_get_id_from_type(PURPLE_STATUS_AVAILABLE), NULL);
oma = g_new0(OmegleAccount, 1);
oma->account = account;
oma->pc = purple_account_get_connection(account);
oma->cookie_table = g_hash_table_new_full(g_str_hash, g_str_equal,
g_free, g_free);
oma->hostname_ip_cache = g_hash_table_new_full(g_str_hash, g_str_equal,
g_free, g_free);
account->gc->proto_data = oma;
//No such thing as a login
purple_connection_set_state(purple_account_get_connection(account), PURPLE_CONNECTED);
}
bool PurpleIMContactList::addContactCbk(void * dataIn)
{
// Mutex::ScopedLock lock(PurpleIMContactList::_mutex);
Mutex::ScopedLock lock(PurpleIMContactList::_mutexContact); //VOXOX - JRT - 2009.07.14
PurpleIMContactListCallbackData* cbData = (PurpleIMContactListCallbackData*)dataIn;
PurpleAccount *gAccount = getPurpleAccount( cbData->getInstance() );
PurpleGroup *gGroup = NULL;
PurpleBuddy *gBuddy = NULL;
if ((gGroup = purple_find_group(cbData->getGroupName().c_str())) == NULL)
{
gGroup = purple_group_new(cbData->getGroupName().c_str());
purple_blist_add_group(gGroup, NULL);
}
gBuddy = purple_buddy_new(gAccount, cbData->getContactId().c_str(), cbData->getContactId().c_str() );
purple_blist_add_buddy(gBuddy, NULL, gGroup, NULL);
purple_account_add_buddy(gAccount, gBuddy);
timeoutRemove( cbData );
delete cbData;
return TRUE;
}
bool PurpleIMContactList::moveContactToGroupCbk(void * dataIn)
{
Mutex::ScopedLock lock(PurpleIMContactList::_mutex);
PurpleIMContactListCallbackData* cbData = (PurpleIMContactListCallbackData*)dataIn;
PurpleAccount* gAccount = getPurpleAccount( cbData->getInstance() );
PurpleGroup* gOldGroup = purple_find_group( cbData->getOldGroupName().c_str() );
if (gOldGroup)
{
PurpleBuddy *gBuddy = purple_find_buddy_in_group(gAccount, cbData->getContactId().c_str(), gOldGroup);
if (gBuddy)
{
PurpleGroup *gNewGroup = purple_find_group( cbData->getNewGroupName().c_str() );
if (gNewGroup)
{
gNewGroup = purple_group_new(cbData->getNewGroupName().c_str());
purple_blist_add_buddy(gBuddy, NULL, gNewGroup, NULL);
}
}
}
timeoutRemove( cbData );
delete cbData;
return TRUE;
}
static void update_user_handler (struct tgl_state *TLS, struct tgl_user *user, unsigned flags) {
// if (!(flags & TGL_UPDATE_CREATED)) { return; }
if (TLS->our_id == tgl_get_peer_id (user->id)) {
if (flags & TGL_UPDATE_NAME) {
p2tgl_connection_set_display_name (TLS, (tgl_peer_t *)user);
}
} else {
PurpleBuddy *buddy = p2tgl_buddy_find (TLS, user->id);
if (!buddy) {
buddy = p2tgl_buddy_new (TLS, (tgl_peer_t *)user);
purple_blist_add_buddy (buddy, NULL, tggroup, NULL);
}
if (flags & TGL_UPDATE_CREATED) {
purple_buddy_set_protocol_data (buddy, (gpointer)user);
p2tgl_prpl_got_user_status (TLS, user->id, &user->status);
p2tgl_buddy_update (TLS, (tgl_peer_t *)user, flags);
}
if (flags & (TGL_UPDATE_NAME | TGL_UPDATE_REAL_NAME | TGL_UPDATE_USERNAME) && buddy) {
p2tgl_blist_alias_buddy (buddy, user);
}
if (flags & TGL_UPDATE_PHOTO) {
tgl_do_get_user_info (TLS, user->id, 0, on_user_get_info, 0);
}
if (flags & TGL_UPDATE_DELETED && buddy) {
purple_blist_remove_buddy (buddy);
}
}
}
QuetzalContact *QuetzalAccount::createContact(const QString &id)
{
PurpleContact *pc = purple_contact_new();
purple_blist_add_contact(pc, NULL, NULL);
PurpleBuddy *buddy = purple_buddy_new(m_account, id.toUtf8().constData(), 0);
purple_blist_add_buddy(buddy, pc, purple_contact_get_group(pc), NULL);
return m_contacts.value(id);
}
void rc_push_contact(PurpleAccount *acct,
const char * buddyname)
{
PurpleGroup * grp = purple_find_group(GROUP_NAME);
if (!grp) {
trace("Group %s Not Found. Create one.", GROUP_NAME);
grp = purple_group_new(GROUP_NAME);
}
PurpleBuddy * buddy;
// if we can find it in 'Recent Contacts', skip
if ((buddy = purple_find_buddy_in_group(acct, buddyname, grp)) != NULL) {
trace("Buddy %s is already in %s", buddyname, GROUP_NAME);
purple_blist_add_buddy(buddy, NULL, grp, NULL);
return;
}
buddy = purple_find_buddy(acct, buddyname);
if (!buddy) {
trace("Buddy %s Not Found. You SUCK!", buddyname);
return;
}
PurpleBlistNode * node = PURPLE_BLIST_NODE(buddy);
// back up group info
PurpleGroup * orig_grp = purple_buddy_get_group(buddy);
purple_blist_node_set_string(node, NODE_GROUP_KEY, orig_grp->name);
// back up offline info
gboolean offline = purple_blist_node_get_bool(node, NODE_OFFLINE_KEY);
purple_blist_node_set_bool(node, NODE_ORIG_OFFLINE_KEY, offline);
purple_blist_node_set_bool(node, NODE_OFFLINE_KEY, TRUE);
// Add to Recent Contacts Group
trace(">>>>>>> Add %s", buddyname);
purple_blist_add_buddy(buddy, NULL, grp, NULL);
// Clean up old group if needed
rc_pop_contacts(grp);
}
static void
stress_login(PurpleAccount *account) {
PurpleConnection *pc = NULL;
PurpleGroup *g = NULL;
gint n_buddies = 0, i = 0, interval = 0, maxevents = 0;
/* build our possible events from the account settings */
add_event("trigger_signon", STRESS_EVENT_SIGN_ON, STRESS_EVENT_SIGN_OFF);
add_event("trigger_idle", STRESS_EVENT_IDLE, STRESS_EVENT_UNIDLE);
add_event("trigger_away", STRESS_EVENT_AWAY, STRESS_EVENT_BACK);
add_event("trigger_typing", STRESS_EVENT_TYPING, STRESS_EVENT_STOPPED_TYPING);
add_event("send_messages", STRESS_EVENT_SEND_MESSAGE, -1);
nevents = g_list_length(events);
/* get our connection and set it as online */
pc = purple_account_get_connection(account);
purple_connection_set_state(pc, PURPLE_CONNECTED);
/* grab the account settings we need for buddies */
n_buddies = purple_account_get_int(account, "nbuddies", 50);
maxevents = purple_account_get_int(account, "maxevents", 100);
interval = (guint)purple_account_get_int(account, "interval", 500);
message_min = purple_account_get_int(account, "message_min", 16);
message_max = purple_account_get_int(account, "message_max", 128);
g = purple_group_new("prpl-stress");
for(i = 0; i < n_buddies; i++) {
PurpleBuddy *b = NULL;
StressBuddy *sb = NULL;
gchar *name = NULL;
/* create the buddy and it's name */
name = g_strdup_printf("stress-%04x", i);
b = purple_buddy_new(account, name, NULL);
g_free(name);
/* add our data to the buddy */
sb = g_new0(StressBuddy, 1);
sb->buddy = b;
sb->maxevents = maxevents;
purple_buddy_set_protocol_data(b, sb);
/* add the buddy to our list and the purple blist */
buddies = g_list_prepend(buddies, sb);
purple_blist_add_buddy(b, NULL, g, NULL);
/* add our event timer to the buddy */
sb->timer_id = g_timeout_add(interval, stress_event_cb, sb);
}
}
void BuddyList::add_buddy_ok_cb(PurpleRequestFields *fields)
{
PurpleAccount *account = purple_request_fields_get_account(fields, "account");
const char *name = purple_request_fields_get_string(fields, "name");
const char *alias = purple_request_fields_get_string(fields, "alias");
int selected = purple_request_fields_get_choice(fields, "group");
GList *list = purple_request_field_choice_get_labels(
purple_request_fields_get_field(fields, "group"));
const char *group
= reinterpret_cast<const char*>(g_list_nth_data(list, selected));
bool err = false;
if (!account) {
LOG->Message(_("No account specified."));
err = true;
}
else if (!purple_account_is_connected(account)) {
LOG->Message(_("Selected account is not connected."));
err = true;
}
if (!name || !name[0]) {
LOG->Message(_("No buddy name specified."));
err = true;
}
if (!group || !group[0]) {
LOG->Message(_("No group name specified."));
err = true;
}
if (err) {
purple_blist_request_add_buddy(account, name, group, alias);
return;
}
PurpleGroup *g = purple_find_group(group);
if (!g) {
g = purple_group_new(group);
purple_blist_add_group(g, NULL);
}
PurpleBuddy *b = purple_find_buddy_in_group(account, name, g);
if (b) {
LOG->Message(_("Specified buddy is already in the list."));
return;
}
if (alias && !alias[0])
alias = NULL;
b = purple_buddy_new(account, name, alias);
purple_blist_add_buddy(b, NULL, g, NULL);
purple_account_add_buddy(account, b);
}
gboolean AddBuddy_cb(struct fetion_account_data *sip, struct sipmsg *msg, struct transaction *tc)
{
xmlnode *root,*item;
const gchar *uri, *name ,*group_id;
struct group_attr *g_attr;
gchar *buddy_name;
PurpleBuddy *b;
PurpleGroup *g = NULL;
struct fetion_buddy *bs;
if(msg->response != 522)
{
root = xmlnode_from_str(msg->body, msg->bodylen);
item = xmlnode_get_child(root,"contacts/buddies/buddy");
g_return_val_if_fail(item!=NULL,FALSE);
uri = xmlnode_get_attrib(item, "uri");
name = xmlnode_get_attrib(item, "local-name");
group_id = xmlnode_get_attrib(item, "buddy-lists");
buddy_name = g_strdup_printf("%s", uri);
g_attr = g_hash_table_lookup(sip->group,group_id);
if(g_attr==NULL)
{
g = purple_find_group("未分组");
if(!g)
g = purple_group_new("未分组");
}
else
{
g = purple_find_group(g_attr->name);
if(!g)
g = purple_group_new(g_attr->name);
}
b = purple_find_buddy(sip->account, buddy_name);
if(!b){
b = purple_buddy_new(sip->account, buddy_name, NULL);
}
g_free(buddy_name);
purple_blist_add_buddy(b, NULL, g, NULL);
if(name!=NULL && *name!='\0')
purple_blist_alias_buddy(b, name);
bs = g_new0(struct fetion_buddy, 1);
bs->name = g_strdup(b->name);
g_hash_table_insert(sip->buddies, bs->name, bs);
fetion_subscribe_exp(sip,bs);
}
void rc_pop_contacts(PurpleGroup * grp)
{
if (!grp) return;
PurpleBlistNode * gnode = PURPLE_BLIST_NODE(grp);
PurpleBlistNode * n = NULL;
PurpleBuddy * b = NULL;
int total;
gboolean offline;
//XXX group->totalsize is unreliable!!!
for (n=gnode->child, total=0; n!=NULL; total++, n=n->next);
trace("Total Group Count %d", total);
while (total > g_size) {
n = gnode->child;
if (PURPLE_BLIST_NODE_IS_CONTACT(n)) {
trace("Child Contact : %s", (PURPLE_CONTACT(n)->priority->name));
b = PURPLE_CONTACT(n)->priority;
} else if (PURPLE_BLIST_NODE_IS_BUDDY(n)) {
trace("Child Buddy : %s", (PURPLE_BUDDY(n)->name));
b = PURPLE_BUDDY(n);
}
n = PURPLE_BLIST_NODE(b);
const char *name = purple_blist_node_get_string(n, NODE_GROUP_KEY);
if (!name) { // if cannot find orig group name, put back to Buddies
trace("ERROR!!! cannot find original group name");
name = "Buddies";
}
PurpleGroup * g = purple_find_group(name);
if (!g) {
trace("Group %s Not Found. Create one.", name);
g = purple_group_new(name);
}
trace("<<<<<<< Remove %s", b->name);
offline = purple_blist_node_get_bool(n, NODE_ORIG_OFFLINE_KEY);
purple_blist_node_set_bool(n, NODE_OFFLINE_KEY, offline);
purple_blist_add_buddy(b, NULL, g, NULL);
total--;
}
}
static void purple_add_buddy( struct im_connection *ic, char *who, char *group )
{
PurpleBuddy *pb;
PurpleGroup *pg = NULL;
if( group && !( pg = purple_find_group( group ) ) )
{
pg = purple_group_new( group );
purple_blist_add_group( pg, NULL );
}
pb = purple_buddy_new( (PurpleAccount*) ic->proto_data, who, NULL );
purple_blist_add_buddy( pb, NULL, pg, NULL );
purple_account_add_buddy( (PurpleAccount*) ic->proto_data, pb );
purple_gg_buddylist_export( ((PurpleAccount*)ic->proto_data)->gc );
}
static void
pb_got_phonebook(PushBulletAccount *pba, JsonNode *node, gpointer user_data)
{
PurpleAccount *account = pba->account;
JsonObject *rootobj = json_node_get_object(node);
JsonArray *phonebook = json_object_get_array_member(rootobj, "phonebook");
gint i;
guint len;
gchar *device = user_data;
PurpleGroup *pbgroup;
pbgroup = purple_find_group("PushBullet");
if (!pbgroup)
{
pbgroup = purple_group_new("PushBullet");
purple_blist_add_group(pbgroup, NULL);
}
for(i = 0, len = json_array_get_length(phonebook); i < len; i++)
{
JsonObject *number = json_array_get_object_element(phonebook, i);
const gchar *name = json_object_get_string_member(number, "name");
const gchar *phone = json_object_get_string_member(number, "phone");
const gchar *phone_type = json_object_get_string_member(number, "phone_type");
PurpleBuddy *pbuddy;
//Only handle the right 'type' of phone number.
//home, mobile, work, other
if (purple_account_get_bool(account, "mobile_contacts_only", FALSE) && phone_type[0] != 'm')
continue;
pbuddy = purple_find_buddy(account, phone);
if (!pbuddy)
{
pbuddy = purple_buddy_new(account, phone, name);
purple_blist_add_buddy(pbuddy, NULL, pbgroup, NULL);
purple_debug_info("pushbullet", "Added buddy %s %s\n", phone, name);
}
purple_prpl_got_user_status(account, phone, "mobile", NULL);
purple_prpl_got_user_status(account, phone, purple_primitive_get_id_from_type(PURPLE_STATUS_AVAILABLE), NULL);
}
g_free(device);
}
void Buddy::SetGroups (const QStringList& groups)
{
const auto& newGroup = groups.value (0);
PurpleGroup *group = 0;
if (!newGroup.isEmpty ())
{
const auto& utf8 = newGroup.toUtf8 ();
group = purple_find_group (utf8.constData ());
if (!group)
{
group = purple_group_new (utf8.constData ());
purple_blist_add_group (group, nullptr);
}
}
purple_blist_add_buddy (Buddy_, nullptr, group, nullptr);
}
static VALUE add_buddy(VALUE self, VALUE buddy)
{
PurpleAccount *account;
Data_Get_Struct(self, PurpleAccount, account);
PurpleBuddy* pb = purple_buddy_new(account, StringValueCStr(buddy), NULL);
char* group = _("Buddies");
PurpleGroup* grp = purple_find_group(group);
if (!grp)
{
grp = purple_group_new(group);
purple_blist_add_group(grp, NULL);
}
purple_blist_add_buddy(pb, NULL, grp, NULL);
purple_account_add_buddy(account, pb);
return Qtrue;
}
void
lh_util_add_buddy(const gchar *group, PurpleGroup *purple_group,
const gchar *buddy, const gchar *alias, PurpleAccount *account,
const gchar *buddynotes, gint signed_on, gint signed_off, gint lastseen,
gint last_seen, const gchar *gf_theme, const gchar *icon_file, gchar *lastsaid)
{
PurpleBuddy *purple_buddy = NULL;
PurpleBlistNode *node = NULL;
purple_buddy = purple_buddy_new(account, buddy, alias);
node = (PurpleBlistNode *)purple_buddy;
purple_blist_add_buddy(purple_buddy, NULL, purple_group, NULL);
#if PURPLE_VERSION_CHECK(3,0,0)
purple_account_add_buddy(account, purple_buddy, NULL);
#else
purple_account_add_buddy(account, purple_buddy);
#endif
if(buddynotes)
purple_blist_node_set_string(node, "notes", buddynotes);
if(signed_on)
purple_blist_node_set_int(node, "signedon", signed_on);
if(signed_off)
purple_blist_node_set_int(node, "signedoff", signed_off);
if(lastseen)
purple_blist_node_set_int(node, "lastseen", lastseen);
if(last_seen)
purple_blist_node_set_int(node, "last_seen", last_seen);
if(gf_theme)
purple_blist_node_set_string(node, "guifications-theme", gf_theme);
if(icon_file)
purple_blist_node_set_string(node, "buddy_icon", icon_file);
if(lastsaid)
purple_blist_node_set_string(node, "lastsaid", lastsaid);
purple_debug_info("listhandler: import",
"group: %s\tbuddy: %s\talias: %s\thas been added to the list\n",
group, buddy, alias ? alias : "NULL");
return;
}
void
lh_util_add_to_blist(GList *buddies, GList *groups)
{
GList *tmpb = buddies, *tmpg = groups;
/* walk through both GLists */
while(tmpb && tmpb->data && tmpg && tmpg->data) {
/* add the current buddy to the correct group in the Purple blist */
purple_blist_add_buddy((PurpleBuddy *)(tmpb->data), NULL,
(PurpleGroup *)(tmpg->data), NULL);
purple_debug_info("listhandler: import", "added a buddy to purple blist\n");
/* go to the next element in each list */
tmpb = g_list_next(tmpb);
tmpg = g_list_next(tmpg);
}
return;
}
static void update_secret_chat_handler (struct tgl_state *TLS, struct tgl_secret_chat *U, unsigned flags) {
debug ("secret-chat-state: %d", U->state);
if (flags & TGL_UPDATE_WORKING || flags & TGL_UPDATE_DELETED) {
write_secret_chat_file (TLS);
}
PurpleBuddy *buddy = p2tgl_buddy_find (TLS, U->id);
if (! (flags & TGL_UPDATE_DELETED)) {
if (!buddy) {
buddy = p2tgl_buddy_new (TLS, (tgl_peer_t *)U);
purple_blist_add_buddy (buddy, NULL, tggroup, NULL);
purple_blist_alias_buddy (buddy, U->print_name);
}
p2tgl_prpl_got_set_status_mobile (TLS, U->id);
}
if (flags & TGL_UPDATE_REQUESTED && buddy) {
connection_data *conn = TLS->ev_base;
const char* choice = purple_account_get_string (conn->pa, "accept-secret-chats", "ask");
if (! strcmp (choice, "always")) {
tgl_do_accept_encr_chat_request (TLS, U, write_secret_chat_gw, 0);
} else if (! strcmp(choice, "ask")) {
PurpleBuddy *who = p2tgl_buddy_find (TLS, TGL_MK_USER(U->user_id));
struct accept_secret_chat_data *data = g_new (struct accept_secret_chat_data, 1);
data->TLS = TLS;
data->U = U;
gchar *message = g_strdup_printf ("Accept Secret Chat '%s'?", U->print_name);
purple_request_accept_cancel (conn->gc, "Secret Chat", message, "Secret chats can only have one "
"end point. If you accept a secret chat on this device, its messages will "
"not be available anywhere else. If you decline, you can accept"
" the chat on other devices.", 0, conn->pa, who->name, NULL, data,
G_CALLBACK(accept_secret_chat_cb), G_CALLBACK(decline_secret_chat_cb));
g_free (message);
}
void hon_parse_notification(PurpleConnection *gc,gchar* buffer){
PurpleBuddy* buddy;
guint32 buddyid;
PurpleGroup* buddies;
hon_account* hon = gc->proto_data;
guint8 notification_type = read_byte(buffer);
gchar *title = NULL,*msg = NULL;
switch (notification_type)
{
case HON_NOTIFICATION_ADDED_AS_BUDDY:
case HON_NOTIFICATION_BUDDY_ACCEPTED:
buddies = purple_find_group(HON_BUDDIES_GROUP);
buddyid = read_guint32(buffer);
read_guint32(buffer); /* notification id */
g_hash_table_insert(hon->id2nick,GINT_TO_POINTER(buddyid),g_strdup(buffer));
buddy = purple_buddy_new(gc->account,buffer,NULL);
purple_blist_add_buddy(buddy,NULL,buddies,NULL);
title = g_strdup(_("Friendship Accepted"));
if (notification_type == HON_NOTIFICATION_ADDED_AS_BUDDY)
msg = g_strdup_printf(_("Accepted friendship request from %s"),buffer);
else
msg = g_strdup_printf(_("%s accepted your friendship request"),buffer);
break;
/*
case HON_NOTIFICATION_REMOVED_AS_BUDDY:
title = g_strdup(_("User removed you as buddy"));
break;
case HON_NOTIFICATION_BUDDY_REMOVED:
title = g_strdup(_("Buddy removed"));
break;
*/
default :
title = g_strdup_printf(_("Unknown notification type (%d)"),notification_type);
msg = g_strdup(buffer);
break;
}
purple_notify_info(NULL,title,msg,NULL);
g_free(title);
g_free(msg);
}
Contact *QuetzalContactsFactory::addContact(const QString &id, const QVariantMap &data)
{
QByteArray group = data.value(QLatin1String("group")).toString().toUtf8();
if (group.isEmpty()) {
// For compatibility with other implementations
// Looks like libpurple doesn't support multiple groups
// Or does it at some unknown way
group = data.value(QLatin1String("tags")).toStringList().value(0).toUtf8();
}
QString name = data.value(QLatin1String("name")).toString();
const char *groupName = group.isEmpty() ? "Buddies" : group.constData();
PurpleGroup *pg = purple_find_group(groupName);
if (!pg) {
pg = purple_group_new(groupName);
purple_blist_add_group(pg, quetzal_blist_get_last_sibling(purple_blist_get_root()));
}
PurpleContact *pc = purple_contact_new();
purple_blist_add_contact(pc, pg, quetzal_blist_get_last_child(PURPLE_BLIST_NODE(pg)));
PurpleBuddy *buddy = purple_buddy_new(m_account->purple(), id.toUtf8().constData(),
name.toUtf8().constData());
PurpleBlistNode *node = PURPLE_BLIST_NODE(buddy);
purple_blist_add_buddy(buddy, pc, pg, quetzal_blist_get_last_child(PURPLE_BLIST_NODE(pc)));
QMapIterator<QString, QVariant> it(data.value(QLatin1String("quetzal_settings")).toMap());
while (it.hasNext()) {
it.next();
QByteArray key = it.key().toUtf8();
QVariant::Type type = it.value().type();
if (type == QVariant::Bool) {
purple_blist_node_set_bool(node, key.constData(), it.value().toBool());
} else if (type == QVariant::Int || type == QVariant::UInt
|| type == QVariant::LongLong || type == QVariant::ULongLong) {
purple_blist_node_set_int(node, key.constData(), it.value().toInt());
} else {
purple_blist_node_set_string(node, key.constData(), it.value().toString().toUtf8());
}
}
QuetzalContact *contact = reinterpret_cast<QuetzalContact*>(node->ui_data);
contact->update(buddy);
return contact;
}
/*add group id to User object*/
void
msn_user_add_group_id(MsnUser *user, const char* group_id)
{
MsnUserList *userlist;
PurpleAccount *account;
PurpleBuddy *b;
PurpleGroup *g;
const char *passport;
const char *group_name;
g_return_if_fail(user != NULL);
g_return_if_fail(group_id != NULL);
user->group_ids = g_list_append(user->group_ids, g_strdup(group_id));
userlist = user->userlist;
account = userlist->session->account;
passport = msn_user_get_passport(user);
group_name = msn_userlist_find_group_name(userlist, group_id);
purple_debug_info("msn", "User: group id:%s,name:%s,user:%s\n", group_id, group_name, passport);
g = purple_find_group(group_name);
if ((group_id == NULL) && (g == NULL))
{
g = purple_group_new(group_name);
purple_blist_add_group(g, NULL);
}
b = purple_find_buddy_in_group(account, passport, g);
if (b == NULL)
{
b = purple_buddy_new(account, passport, NULL);
purple_blist_add_buddy(b, NULL, g, NULL);
}
purple_buddy_set_protocol_data(b, user);
/*Update the blist Node info*/
}
static PurpleBuddy* spin_sync_buddy(SpinData* spin,
GSList* buddies,const gchar* id,
const gchar* name,guint online,
const gchar* away,const gchar* photo)
{
PurpleAccount* account = purple_connection_get_account(spin->gc);
/* gchar* lower_name = g_utf8_strdown(name,-1); */
PurpleBuddy* buddy = spin_find_buddy_in_list(buddies,id);
if(!buddy)
{
purple_debug_info("spin","adding buddy: %s\n",/*lower_*/name);
buddy = purple_buddy_new(account,/*lower_*/name,NULL);
purple_blist_add_buddy(buddy,NULL,NULL,NULL);
purple_blist_node_set_string(&buddy->node,"spin-id",id);
}
/* purple_normalize here? */
if(g_strcmp0(purple_buddy_get_name(buddy),name) != 0)
{
spin_notify_nick_changed(spin,purple_buddy_get_name(buddy),name);
purple_blist_rename_buddy(buddy,name);
}
spin_sync_photo(spin,buddy,photo);
/* do not set status if we got a status after the HTTP request */
if(g_hash_table_lookup(spin->updated_status_list,
purple_normalize(account,name)))
return buddy;
if(online && *away)
purple_prpl_got_user_status(account,/*lower_*/name,"away",
"message",away,NULL);
else if(online)
purple_prpl_got_user_status(account,/*lower_*/name,"available",NULL);
else
purple_prpl_got_user_status(account,/*lower_*/name,"offline",NULL);
return buddy;
/* g_free(lower_name); */
}
static VALUE add_buddy(VALUE self, VALUE buddy)
{
PurpleAccount *account = NULL;
PurpleConnection *gc = NULL;
Data_Get_Struct(self, PurpleAccount, account);
gc = purple_account_get_connection( account );
PurpleBuddy* pb = purple_buddy_new(account, RSTRING_PTR(buddy), NULL);
char* group = _("Buddies");
PurpleGroup* grp = purple_find_group(group);
if (!grp)
{
grp = purple_group_new(group);
purple_blist_add_group(grp, NULL);
}
purple_blist_add_buddy(pb, NULL, grp, NULL);
purple_account_add_buddy(account, pb);
serv_add_permit( gc, RSTRING_PTR(buddy) );
return Qtrue;
}
static PurpleBuddy *add_buddy(FacebookAccount *fba,
const gchar *friend_list_id, const gchar *uid, GHashTable *cur_groups)
{
const gchar *group_name;
PurpleGroup *fb_group;
PurpleBuddy *buddy;
group_name = g_hash_table_lookup(fba->friend_lists, purple_normalize_nocase(NULL, friend_list_id));
if (!group_name || group_name[0] == '\0') {
purple_debug_info("facebook",
"did not find name of list %s\n",
friend_list_id);
group_name = DEFAULT_GROUP_NAME;
}
// Initialize group as necessary.
fb_group = purple_find_group(group_name);
if (fb_group == NULL)
{
purple_debug_info("facebook", "adding friend list %s\n",
group_name);
fb_group = purple_group_new(group_name);
purple_blist_add_group(fb_group, NULL);
}
buddy = (PurpleBuddy *)g_hash_table_lookup(cur_groups, purple_normalize_nocase(NULL, group_name));
if (!buddy) {
purple_debug_info("facebook", "adding %s to %s\n",
uid, group_name);
buddy = purple_buddy_new(fba->account, uid, NULL);
purple_blist_add_buddy(buddy, NULL, fb_group, NULL);
g_hash_table_remove(cur_groups, purple_normalize_nocase(NULL, group_name));
}
return buddy;
}
GList *fb_get_buddies_friend_list (FacebookAccount *fba,
const gchar *uid, JsonArray *friend_list_ids)
{
GSList *buddies;
GSList *cur;
GHashTable *cur_groups;
int i;
GList *final_buddies, *cur_buddy;
PurpleGroup *fb_group;
PurpleBuddy *buddy;
final_buddies = NULL;
buddies = purple_find_buddies(fba->account, uid);
// If we're already in the buddy list, stop. Ignore FB info because
// it will be incorrect.
if (atoll(uid) == fba->uid && buddies != NULL) {
purple_debug_info("facebook",
"already have buddies for self, not adding\n");
for (cur = buddies; cur != NULL; cur = cur->next)
{
final_buddies = g_list_append(
final_buddies, cur->data);
}
g_slist_free(buddies);
return final_buddies;
}
//Do we want to ignore groups?
if (!purple_account_get_bool(fba->account, "facebook_use_groups", TRUE))
{
if (buddies != NULL) {
//Copy the slist into the list
for (cur = buddies; cur != NULL; cur = cur->next)
{
final_buddies = g_list_append(
final_buddies, cur->data);
}
g_slist_free(buddies);
return final_buddies;
} else {
buddy = purple_buddy_new(fba->account, uid, NULL);
fb_group = purple_find_group(DEFAULT_GROUP_NAME);
if (fb_group == NULL)
{
fb_group = purple_group_new(DEFAULT_GROUP_NAME);
purple_blist_add_group(fb_group, NULL);
}
purple_blist_add_buddy(buddy, NULL, fb_group, NULL);
final_buddies = g_list_append(final_buddies, buddy);
return final_buddies;
}
}
// Determine what buddies exist and what groups they are in.
cur_groups = g_hash_table_new_full(g_str_hash, g_str_equal,
g_free, NULL);
for (cur = buddies; cur != NULL; cur = cur->next)
{
const gchar *group_name;
group_name = purple_group_get_name(purple_buddy_get_group(
(PurpleBuddy *)cur->data));
group_name = purple_normalize_nocase(NULL, group_name);
g_hash_table_insert(cur_groups, g_strdup(group_name), cur->data);
}
g_slist_free(buddies);
// Create/insert necessary buddies
if (friend_list_ids) {
for (i = 0; i < json_array_get_length(friend_list_ids); i++)
{
const gchar *friend_list_id;
friend_list_id = json_node_get_string(
json_array_get_element(friend_list_ids, i));
buddy = add_buddy(fba, friend_list_id, uid, cur_groups);
final_buddies = g_list_append(final_buddies, buddy);
}
} else {
// No friend list data, so we use the default group.
final_buddies = g_list_append(final_buddies,
add_buddy(fba, "-1", uid, cur_groups));
}
// Figure out which groups/buddies are not represented.
for (cur_buddy = final_buddies; cur_buddy != NULL;
cur_buddy = cur_buddy->next)
{
const gchar *group_name = purple_group_get_name(purple_buddy_get_group(
(PurpleBuddy *)cur_buddy->data));
g_hash_table_remove(cur_groups, purple_normalize_nocase(NULL, group_name));
}
// Delete remaining buddies to maintain sync state with server.
g_hash_table_foreach(cur_groups, destroy_buddy, fba);
// Cleanup!
g_hash_table_destroy(cur_groups);
return final_buddies;
}
gboolean
GetContactList_cb(struct fetion_account_data *sip, struct sipmsg *msg,
struct transaction *tc)
{
xmlnode *item, *group, *isc;
const gchar *name_group, *group_id;
PurpleBuddy *b;
PurpleGroup *g = NULL;
struct fetion_buddy *bs;
struct group_attr *g_attr;
gint len = msg->bodylen;
purple_debug(PURPLE_DEBUG_MISC, "fetion",
"in process GetContactList response response: %d\n",
msg->response);
switch (msg->response) {
case 200:
/*Convert the contact from XML to Purple Buddies */
isc = xmlnode_from_str(msg->body, len);
purple_debug_info("fetion:", "after xmlnode to str\n");
group = xmlnode_get_child(isc, "contacts/buddy-lists");
g_return_val_if_fail(group != NULL, FALSE);
/* ToDo. Find for all groups */
sip->GetContactFlag = 1;
for ((group = xmlnode_get_child(group, "buddy-list")); group;
group = xmlnode_get_next_twin(group)) {
purple_debug_info("fetion:", "buddy-list\n");
name_group = xmlnode_get_attrib(group, "name");
group_id = xmlnode_get_attrib(group, "id");
g_return_val_if_fail(name_group != NULL, FALSE);
purple_debug_info("fetion", "name_group->%s\n",
name_group);
g = purple_find_group(name_group);
if (!g) {
g = purple_group_new(name_group);
}
g_attr = g_new0(struct group_attr, 1);
g_attr->name = g_strdup(name_group);
g_attr->id = g_strdup(group_id);
g_hash_table_insert(sip->group, g_attr->id, g_attr);
g_hash_table_insert(sip->group2id, g_attr->name,
g_attr);
}
group = xmlnode_get_child(isc, "contacts/buddies");
g_return_val_if_fail(group != NULL, FALSE);
for (item = xmlnode_get_child(group, "buddy"); item;
item = xmlnode_get_next_twin(item)) {
const gchar *uri, *name;
char *buddy_name;
const gchar *g_id;
uri = xmlnode_get_attrib(item, "uri");
name = xmlnode_get_attrib(item, "local-name");
g_id = xmlnode_get_attrib(item, "buddy-lists");
buddy_name = g_strdup_printf("%s", uri);
if ((g_id == NULL) || (*g_id == '\0')
|| strlen(g_id) > 1) {
g = purple_find_group("未分组");
if (!g)
g = purple_group_new("未分组");
} else {
g_attr = g_hash_table_lookup(sip->group, g_id);
g_return_val_if_fail(g_attr != NULL, FALSE);
g = purple_find_group(g_attr->name);
if (!g)
g = purple_group_new(g_attr->name);
}
b = purple_find_buddy(sip->account, buddy_name);
if (!b) {
b = purple_buddy_new(sip->account, buddy_name,
NULL);
}
g_free(buddy_name);
purple_blist_add_buddy(b, NULL, g, NULL);
if (name != NULL && *name != '\0')
purple_blist_alias_buddy(b, name);
bs = g_new0(struct fetion_buddy, 1);
bs->name = g_strdup(b->name);
g_hash_table_insert(sip->buddies, bs->name, bs);
purple_prpl_got_user_status(sip->account, uri, "mobile",
NULL);
}
group = xmlnode_get_child(isc, "contacts/mobile-buddies");
g_return_val_if_fail(group != NULL, FALSE);
for (item = xmlnode_get_child(group, "mobile-buddy"); item;
item = xmlnode_get_next_twin(item)) {
const gchar *uri, *name;
gchar *buddy_name;
const gchar *g_id;
uri = xmlnode_get_attrib(item, "uri");
name = xmlnode_get_attrib(item, "local-name");
g_id = xmlnode_get_attrib(item, "buddy-lists");
buddy_name = g_strdup_printf("%s", uri);
if ((g_id == NULL) || (*g_id == '\0')
|| strlen(g_id) > 1) {
g = purple_find_group("未分组");
if (!g)
g = purple_group_new("未分组");
} else {
g_attr = g_hash_table_lookup(sip->group, g_id);
//g_return_val_if_fail(g_attr!=NULL,FALSE);
if (g_attr == NULL)
continue;
g = purple_find_group(g_attr->name);
if (!g)
g = purple_group_new(g_attr->name);
}
b = purple_find_buddy(sip->account, buddy_name);
if (!b) {
b = purple_buddy_new(sip->account, buddy_name,
uri);
}
g_free(buddy_name);
purple_blist_add_buddy(b, NULL, g, NULL);
if (name != NULL && *name != '\0')
purple_blist_alias_buddy(b, name);
else
purple_blist_alias_buddy(b, uri);
bs = g_new0(struct fetion_buddy, 1);
bs->name = g_strdup(b->name);
g_hash_table_insert(sip->buddies, bs->name, bs);
purple_prpl_got_user_status(sip->account, uri, "mobile",
NULL);
}
fetion_subscribe_exp(sip, NULL);
//Add youself
b = purple_find_buddy(sip->account, sip->uri);
if (!b) {
b = purple_buddy_new(sip->account, sip->uri, NULL);
}
purple_blist_add_buddy(b, NULL, g, NULL);
purple_blist_alias_buddy(b, "轰炸自己");
bs = g_new0(struct fetion_buddy, 1);
bs->name = g_strdup(b->name);
g_hash_table_insert(sip->buddies, bs->name, bs);
purple_prpl_got_user_status(sip->account, sip->uri, "mobile",
NULL);
xmlnode_free(isc);
break;
default:
GetContactList(sip);
break;
}
return TRUE;
}
void
AddMobileBuddy(struct fetion_account_data *sip, struct sipmsg *msg,
struct transaction *tc)
{
gint xml_len;
xmlnode *root, *son, *item;
gchar *body;
const gchar *uri, *name, *group_id;
struct group_attr *g_attr = NULL;
gchar *buddy_name;
PurpleBuddy *b;
PurpleGroup *g = NULL;
struct fetion_buddy *bs;
struct sipmsg *old = NULL;
const gchar *real_name;
real_name =
purple_account_get_string(sip->account, "realname", sip->username);
if (!real_name || strlen(real_name) < 1) {
real_name = sip->username;
}
g_return_if_fail(tc->msg != NULL);
old = tc->msg;
g_return_if_fail(old != NULL);
purple_debug_info("fetion:", "AddMobileBuddy:oldmsg[%s]", old->body);
root = xmlnode_from_str(old->body, old->bodylen);
item = xmlnode_get_child(root, "contacts/buddies/buddy");
g_return_if_fail(item != NULL);
uri = xmlnode_get_attrib(item, "uri");
name = xmlnode_get_attrib(item, "local-name");
group_id = xmlnode_get_attrib(item, "buddy-lists");
buddy_name = g_strdup_printf("%s", uri);
g_attr = g_hash_table_lookup(sip->group, group_id);
g_return_if_fail(g_attr != NULL);
g = purple_find_group(g_attr->name);
if (!g)
g = purple_group_new(g_attr->name);
b = purple_find_buddy(sip->account, buddy_name);
if (!b) {
b = purple_buddy_new(sip->account, buddy_name, NULL);
}
purple_blist_add_buddy(b, NULL, g, NULL);
if (name != NULL && *name != '\0')
purple_blist_alias_buddy(b, name);
bs = g_new0(struct fetion_buddy, 1);
bs->name = g_strdup(b->name);
g_hash_table_insert(sip->buddies, bs->name, bs);
xmlnode_free(root);
root = xmlnode_new("args");
g_return_if_fail(root != NULL);
son = xmlnode_new_child(root, "contacts");
g_return_if_fail(son != NULL);
son = xmlnode_new_child(son, "mobile-buddies");
g_return_if_fail(son != NULL);
item = xmlnode_new_child(son, "mobile-buddy");
g_return_if_fail(item != NULL);
xmlnode_set_attrib(item, "expose-mobile-no", "1");
xmlnode_set_attrib(item, "expose-name", "1");
xmlnode_set_attrib(item, "invite", "1");
xmlnode_set_attrib(item, "uri", buddy_name);
xmlnode_set_attrib(item, "buddy-lists", "1");
//xmlnode_set_attrib(item,"desc",sip->mobileno);
xmlnode_set_attrib(item, "desc", real_name);
body = g_strdup_printf("%s",xmlnode_to_str(root, &xml_len));
purple_debug_info("fetion:", "add_buddy:body=[%s]", body);
send_sip_request(sip->gc, "S", "", "", "N: AddMobileBuddy\r\n", body,
NULL, (TransCallback) AddMobileBuddy_cb);
g_free(buddy_name);
xmlnode_free(root);
g_free(body);
}
