static void plainprpl_get_info(PurpleConnection *gc, const char *buddy_name)
{
PurpleBuddy *buddy;
plain_buddy_state *bstate;
PurpleNotifyUserInfo *info;
const char *addr_str;
buddy = purple_find_buddy(gc->account, buddy_name);
bstate = purple_buddy_get_protocol_data(buddy);
info = purple_notify_user_info_new();
if (bstate) {
PurplePresence *presence = purple_buddy_get_presence(buddy);
PurpleStatus *status = purple_presence_get_active_status(presence);
const char *status_name = purple_status_get_name(status);
purple_notify_user_info_add_pair(info, "Status", status_name);
addr_str = purple_blist_node_get_string(PURPLE_BLIST_NODE(buddy), "addr_str");
purple_notify_user_info_add_pair(info, "Address", addr_str);
if (bstate->state == BUDDY_STATE_RESOLVE) {
/* The IP address has not been resolved yet */
purple_notify_user_info_add_pair(info, "Resolved", "Unknown");
} else {
purple_notify_user_info_add_pair(info, "Resolved", str_addr(&bstate->addr));
}
purple_notify_user_info_add_pair(info, "Last Seen", str_time(bstate->time_recv));
} else {
purple_notify_user_info_add_pair(info, "Info", "Missing Data");
}
/* Show a buddy's user info in a nice dialog box */
purple_notify_userinfo(gc, buddy_name, info, NULL, NULL);
}
void IMInvoker::buddyEventCB(PurpleBuddy *buddy, PurpleBuddyEvent event) {
if (!buddy)
return;
PurpleAccount *account = purple_buddy_get_account(buddy);
GET_INSTANCE_IN_CALLBACK(account);
if (!inst)
return;
switch (event) {
case PURPLE_BUDDY_SIGNOFF:
case PURPLE_BUDDY_SIGNON: {
PurplePresence* presence = purple_buddy_get_presence(buddy);
PurpleStatus* status = purple_presence_get_active_status(presence);
buddyStatusChangedCB(buddy, NULL, status, event);
break;
}
case PURPLE_BUDDY_ICON:
break;
default:
break;
}
}
static void prplcb_blist_update( PurpleBuddyList *list, PurpleBlistNode *node )
{
if( node->type == PURPLE_BLIST_BUDDY_NODE )
{
PurpleBuddy *bud = (PurpleBuddy*) node;
PurpleGroup *group = purple_buddy_get_group( bud );
struct im_connection *ic = purple_ic_by_pa( bud->account );
PurpleStatus *as;
int flags = 0;
if( ic == NULL )
return;
if( bud->server_alias )
imcb_rename_buddy( ic, bud->name, bud->server_alias );
else if( bud->alias )
imcb_rename_buddy( ic, bud->name, bud->alias );
if( group )
imcb_add_buddy( ic, bud->name, purple_group_get_name( group ) );
flags |= purple_presence_is_online( bud->presence ) ? OPT_LOGGED_IN : 0;
flags |= purple_presence_is_available( bud->presence ) ? 0 : OPT_AWAY;
as = purple_presence_get_active_status( bud->presence );
imcb_buddy_status( ic, bud->name, flags, purple_status_get_name( as ),
purple_status_get_attr_string( as, "message" ) );
imcb_buddy_times( ic, bud->name,
purple_presence_get_login_time( bud->presence ),
purple_presence_get_idle_time( bud->presence ) );
}
}
static void nullprpl_tooltip_text(PurpleBuddy *buddy,
PurpleNotifyUserInfo *info,
gboolean full) {
PurpleConnection *gc = get_nullprpl_gc(purple_buddy_get_name(buddy));
if (gc) {
/* they're logged in */
PurplePresence *presence = purple_buddy_get_presence(buddy);
PurpleStatus *status = purple_presence_get_active_status(presence);
char *msg = nullprpl_status_text(buddy);
/* TODO: Check whether it's correct to call add_pair_html,
or if we should be using add_pair_plaintext */
purple_notify_user_info_add_pair_html(info, purple_status_get_name(status),
msg);
g_free(msg);
if (full) {
const char *user_info = purple_account_get_user_info(purple_connection_get_account(gc));
if (user_info)
/* TODO: Check whether it's correct to call add_pair_html,
or if we should be using add_pair_plaintext */
purple_notify_user_info_add_pair_html(info, _("User info"), user_info);
}
} else {
/* they're not logged in */
purple_notify_user_info_add_pair_plaintext(info, _("User info"), _("not logged in"));
}
purple_debug_info("nullprpl", "showing %s tooltip for %s\n",
(full) ? "full" : "short", purple_buddy_get_name(buddy));
}
static char *plainprpl_status_text(PurpleBuddy *buddy)
{
PurplePresence *presence;
PurpleStatus *status;
const char *status_name;
const char *message;
char *status_text;
//purple_debug_info("plainprpl", "getting %s's status text for %s\n", buddy->name, buddy->account->username);
presence = purple_buddy_get_presence(buddy);
if (presence) {
status = purple_presence_get_active_status(presence);
} else {
//printf("presence is null for ");
status = NULL;
}
if (status) {
status_name = purple_status_get_name(status);
message = purple_status_get_attr_string(status, "message");
if (message && strlen(message) > 0) {
status_text = g_strdup_printf("%s: %s", status_name, message);
} else {
status_text = g_strdup(status_name);
}
//purple_debug_info("plainprpl", "%s's status text is %s\n", buddy->name, status_text);
return status_text;
} else {
return g_strdup("Not logged in");
}
}
/* set the MSN's PSM info,Currently Read from the status Line
* Thanks for Cris Code
*/
static void
msn_set_psm(MsnSession *session)
{
PurpleAccount *account;
PurplePresence *presence;
PurpleStatus *status;
char *payload;
const char *statusline;
gchar *statusline_stripped, *media = NULL;
g_return_if_fail(session != NULL);
g_return_if_fail(session->notification != NULL);
account = session->account;
/* Get the PSM string from Purple's Status Line */
presence = purple_account_get_presence(account);
status = purple_presence_get_active_status(presence);
statusline = purple_status_get_attr_string(status, "message");
/* MSN expects plain text, not HTML */
statusline_stripped = purple_markup_strip_html(statusline);
media = create_media_string(presence);
g_free(session->psm);
session->psm = msn_build_psm(statusline_stripped, media, session->guid, session->protocol_ver);
payload = session->psm;
msn_notification_send_uux(session, payload);
g_free(statusline_stripped);
g_free(media);
}
int BuddyListNode::getBuddyStatusWeight(PurpleBuddy *buddy) const
{
if (!purple_account_is_connected(purple_buddy_get_account(buddy)))
return 0;
PurplePresence *presence = purple_buddy_get_presence(buddy);
PurpleStatus *status = purple_presence_get_active_status(presence);
PurpleStatusType *status_type = purple_status_get_type(status);
PurpleStatusPrimitive prim = purple_status_type_get_primitive(status_type);
switch (prim) {
case PURPLE_STATUS_OFFLINE:
return 0;
default:
return 1;
case PURPLE_STATUS_UNSET:
return 2;
case PURPLE_STATUS_UNAVAILABLE:
return 3;
case PURPLE_STATUS_AWAY:
return 4;
case PURPLE_STATUS_EXTENDED_AWAY:
return 5;
case PURPLE_STATUS_MOBILE:
return 6;
case PURPLE_STATUS_MOOD:
return 7;
case PURPLE_STATUS_TUNE:
return 8;
case PURPLE_STATUS_INVISIBLE:
return 9;
case PURPLE_STATUS_AVAILABLE:
return 10;
}
}
static gboolean fx_send_attention(PurpleConnection *gc, const gchar *who, guint UNUSED(type))
{
PurpleBuddy *buddy;
PurplePresence *presence;
PurpleStatus *status;
const gchar *status_id;
fetion_account *sec;
fetion_account *ac = purple_connection_get_protocol_data(gc);
if(!(buddy = purple_find_buddy(ac->account, who))) return 0;
presence = purple_buddy_get_presence(buddy);
status = purple_presence_get_active_status(presence);
status_id = purple_status_get_id(status);
/* online,need invite */
if(strcmp(status_id, "Offline") != 0) {
if(!(sec = session_find(who)))
new_chat(ac, who, (gchar*)0);
else
fetion_send_nudge(sec, who);
return TRUE;
}
return FALSE;
}
static char *nullprpl_status_text(PurpleBuddy *buddy) {
purple_debug_info("nullprpl", "getting %s's status text for %s\n",
purple_buddy_get_name(buddy),
purple_account_get_username(purple_buddy_get_account(buddy)));
if (purple_blist_find_buddy(purple_buddy_get_account(buddy), purple_buddy_get_name(buddy))) {
PurplePresence *presence = purple_buddy_get_presence(buddy);
PurpleStatus *status = purple_presence_get_active_status(presence);
const char *name = purple_status_get_name(status);
const char *message = purple_status_get_attr_string(status, "message");
char *text;
if (message && *message)
text = g_strdup_printf("%s: %s", name, message);
else
text = g_strdup(name);
purple_debug_info("nullprpl", "%s's status text is %s\n",
purple_buddy_get_name(buddy), text);
return text;
} else {
purple_debug_info("nullprpl", "...but %s is not logged in\n", purple_buddy_get_name(buddy));
return g_strdup("Not logged in");
}
}
static void
purplemot_tooltip_text(PurpleBuddy *buddy, PurpleNotifyUserInfo *info, int full)
{
PurpleConnection *gc = get_purplemot_gc(buddy->name);
if (gc) {
/* they're logged in */
PurplePresence *presence = purple_buddy_get_presence(buddy);
PurpleStatus *status = purple_presence_get_active_status(presence);
char *msg = purplemot_status_text(buddy);
purple_notify_user_info_add_pair(info, purple_status_get_name(status),
msg);
g_free(msg);
if (full) {
const char *user_info = purple_account_get_user_info(gc->account);
if (user_info)
purple_notify_user_info_add_pair(info, _("User info"), user_info);
}
} else {
/* they're not logged in */
purple_notify_user_info_add_pair(info, _("User info"), _("not logged in"));
}
purple_debug_info("purplemot", "showing %s tooltip for %s\n",
(full) ? "full" : "short", buddy->name);
}
static char *
purplemot_status_text(PurpleBuddy *buddy) {
purple_debug_info("purplemot", "getting %s's status text for %s\n",
buddy->name, buddy->account->username);
if (purple_find_buddy(buddy->account, buddy->name)) {
PurplePresence *presence = purple_buddy_get_presence(buddy);
PurpleStatus *status = purple_presence_get_active_status(presence);
const char *name = purple_status_get_name(status);
const char *message = purple_status_get_attr_string(status, "message");
char *text;
if (message && strlen(message) > 0)
text = g_strdup_printf("%s: %s", name, message);
else
text = g_strdup(name);
purple_debug_info("purplemot", "%s's status text is %s\n", buddy->name, text);
return text;
} else {
purple_debug_info("purplemot", "...but %s is not logged in\n", buddy->name);
return g_strdup("Not logged in");
}
}
void jabber_chat_change_nick(JabberChat *chat, const char *nick)
{
xmlnode *presence;
char *full_jid;
PurplePresence *gpresence;
PurpleStatus *status;
JabberBuddyState state;
char *msg;
int priority;
if(!chat->muc) {
purple_conv_chat_write(PURPLE_CONV_CHAT(chat->conv), "",
_("Nick changing not supported in non-MUC chatrooms"),
PURPLE_MESSAGE_SYSTEM, time(NULL));
return;
}
gpresence = purple_account_get_presence(chat->js->gc->account);
status = purple_presence_get_active_status(gpresence);
purple_status_to_jabber(status, &state, &msg, &priority);
presence = jabber_presence_create(state, msg, priority);
full_jid = g_strdup_printf("%s@%s/%s", chat->room, chat->server, nick);
xmlnode_set_attrib(presence, "to", full_jid);
g_free(full_jid);
g_free(msg);
jabber_send(chat->js, presence);
xmlnode_free(presence);
}
MsnAwayType
msn_state_from_account(PurpleAccount *account)
{
MsnAwayType msnstatus;
PurplePresence *presence;
PurpleStatus *status;
const char *status_id;
presence = purple_account_get_presence(account);
status = purple_presence_get_active_status(presence);
status_id = purple_status_get_id(status);
if (!strcmp(status_id, "away"))
msnstatus = MSN_AWAY;
else if (!strcmp(status_id, "brb"))
msnstatus = MSN_BRB;
else if (!strcmp(status_id, "busy"))
msnstatus = MSN_BUSY;
else if (!strcmp(status_id, "phone"))
msnstatus = MSN_PHONE;
else if (!strcmp(status_id, "lunch"))
msnstatus = MSN_LUNCH;
else if (!strcmp(status_id, "invisible"))
msnstatus = MSN_HIDDEN;
else
msnstatus = MSN_ONLINE;
if ((msnstatus == MSN_ONLINE) && purple_presence_is_idle(presence))
msnstatus = MSN_IDLE;
return msnstatus;
}
const char *BuddyListNode::getBuddyStatus(PurpleBuddy *buddy) const
{
if (!purple_account_is_connected(purple_buddy_get_account(buddy)))
return "";
PurplePresence *presence = purple_buddy_get_presence(buddy);
PurpleStatus *status = purple_presence_get_active_status(presence);
return Utils::getStatusIndicator(status);
}
/**
* \brief Get string representation of buddy.
*
* This function returns the string-representation of a buddy in the format:
* <tt>
* buddies name<TAB>buddies active status<TAB>buddies alias
* </tt>
*
* \param buddy The buddy
* \returns String representation of the buddy. The returned string has to
* be freed by the caller later on.
*/
static char *get_buddy_string(PurpleBuddy *buddy)
{
return g_strdup_printf("%s\t%s\t%s\n",
purple_buddy_get_name(buddy),
purple_status_get_name(
purple_presence_get_active_status(
purple_buddy_get_presence(buddy))),
purple_buddy_get_alias(buddy));
}
static int fx_im_send(PurpleConnection *gc, const gchar *who, const gchar *what, PurpleMessageFlags UNUSED(flags))
{
PurpleBuddy *buddy;
PurplePresence *presence;
PurpleStatus *status;
const gchar *status_id;
fetion_account *sec;
PurpleConversation *conv;
fetion_account *ac = purple_connection_get_protocol_data(gc);
Contact *cnt;
gint shutdown = 0;
if(!(buddy = purple_find_buddy(ac->account, who))) return 0;
presence = purple_buddy_get_presence(buddy);
status = purple_presence_get_active_status(presence);
status_id = purple_status_get_id(status);
cnt = fetion_contact_list_find_by_userid(ac->user->contactList, who);
if(cnt->relationStatus == RELATION_STATUS_UNAUTHENTICATED) {
if(!(conv = purple_find_conversation_with_account(
PURPLE_CONV_TYPE_ANY, who, ac->account))) return -1;
purple_conversation_write(conv, NULL,
_("Failed to send message: Unverified Buddy!"),
PURPLE_MESSAGE_ERROR, time(NULL));
return -1;
}
if(cnt->serviceStatus == BASIC_SERVICE_ABNORMAL){
if(cnt->carrierStatus == CARRIER_STATUS_CLOSED){
shutdown = 1;
}else{
if((cnt->carrier[0] != '\0' && cnt->mobileno[0] == '\0') || cnt->carrier[0] == '\0')
shutdown = 1;
}
}else if(cnt->carrierStatus == CARRIER_STATUS_DOWN)
if(cnt->carrier[0] != '\0') shutdown = 1;
if(shutdown) {
if(!(conv = purple_find_conversation_with_account(
PURPLE_CONV_TYPE_ANY, who, ac->account))) return -1;
purple_conversation_write(conv, NULL,
_("Fail to send message: Buddy has cancled Fetion service!"),
PURPLE_MESSAGE_ERROR, time(NULL));
return -1;
}
/* online,need invite */
if(strcmp(status_id, "Offline") != 0) {
if(!(sec = session_find(who))) new_chat(ac, who, what);
else fetion_send_sms(sec, who, what);
return 1;
}
fetion_send_sms(ac, who, what);
return 1;
}
/*
* Returns the status message of a buddy.
*/
static const char *get_buddys_status_message(PurpleBuddy *buddy)
{
const char *status_message = purple_status_get_attr_string(
purple_presence_get_active_status(
purple_buddy_get_presence(buddy)),
"message");
return (status_message)? status_message : "";
}
char *PurpleLine::status_text(PurpleBuddy *buddy) {
PurplePresence *presence = purple_buddy_get_presence(buddy);
PurpleStatus *status = purple_presence_get_active_status(presence);
const char *msg = purple_status_get_attr_string(status, "message");
if (msg && msg[0])
return g_markup_escape_text(msg, -1);
return nullptr;
}
static gchar *
stress_status_text(PurpleBuddy *buddy) {
PurplePresence *presence = purple_buddy_get_presence(buddy);
PurpleStatus *status = purple_presence_get_active_status(presence);
const gchar *msg = NULL;
msg = purple_status_get_attr_string(status, "message");
return (msg) ? g_strdup(msg) : NULL;
}
static VALUE buddy_get_status( VALUE self ) {
PurpleBuddy *buddy = NULL;
PurpleStatus *status = NULL;
PurpleStatusType *type = NULL;
PURPLE_BUDDY( self, buddy );
status = purple_presence_get_active_status( purple_buddy_get_presence( buddy ) );
type = purple_status_get_type( status );
return INT2NUM( purple_status_type_get_primitive( type ) );
}
static gchar *fx_status_text(PurpleBuddy *buddy)
{
PurplePresence *presence;
PurpleStatus *status;
const gchar *msg;
presence = purple_buddy_get_presence(buddy);
status = purple_presence_get_active_status(presence);
msg = purple_status_get_attr_string(status, "impresa");
if(msg && *msg) return g_markup_escape_text(msg, -1);
return NULL;
}
void jabber_presence_fake_to_self(JabberStream *js, PurpleStatus *status)
{
PurpleAccount *account;
PurplePresence *presence;
JabberBuddy *jb;
JabberBuddyResource *jbr;
const char *username;
JabberBuddyState state;
char *msg;
int priority;
g_return_if_fail(js->user != NULL);
account = purple_connection_get_account(js->gc);
username = purple_connection_get_display_name(js->gc);
presence = purple_account_get_presence(account);
if (status == NULL)
status = purple_presence_get_active_status(presence);
purple_status_to_jabber(status, &state, &msg, &priority);
jb = js->user_jb;
if (state == JABBER_BUDDY_STATE_UNAVAILABLE ||
state == JABBER_BUDDY_STATE_UNKNOWN) {
jabber_buddy_remove_resource(jb, js->user->resource);
} else {
jbr = jabber_buddy_track_resource(jb, js->user->resource, priority,
state, msg);
jbr->idle = purple_presence_is_idle(presence) ?
purple_presence_get_idle_time(presence) : 0;
}
/*
* While we need to track the status of this resource, the core
* only cares if we're on our own buddy list.
*/
if (purple_find_buddy(account, username)) {
jbr = jabber_buddy_find_resource(jb, NULL);
if (jbr) {
purple_prpl_got_user_status(account, username,
jabber_buddy_state_get_status_id(jbr->state),
"priority", jbr->priority,
jbr->status ? "message" : NULL, jbr->status,
NULL);
purple_prpl_got_user_idle(account, username, jbr->idle, jbr->idle);
} else {
purple_prpl_got_user_status(account, username, "offline",
msg ? "message" : NULL, msg,
NULL);
}
}
g_free(msg);
}
void
purple_prpl_got_user_status(PurpleAccount *account, const char *name,
const char *status_id, ...)
{
GSList *list, *l;
PurpleBuddy *buddy;
PurplePresence *presence;
PurpleStatus *status;
PurpleStatus *old_status;
va_list args;
g_return_if_fail(account != NULL);
g_return_if_fail(name != NULL);
g_return_if_fail(status_id != NULL);
g_return_if_fail(purple_account_is_connected(account) || purple_account_is_connecting(account));
if((list = purple_find_buddies(account, name)) == NULL)
return;
for(l = list; l != NULL; l = l->next) {
buddy = l->data;
presence = purple_buddy_get_presence(buddy);
status = purple_presence_get_status(presence, status_id);
if(NULL == status)
/*
* TODO: This should never happen, right? We should call
* g_warning() or something.
*/
continue;
old_status = purple_presence_get_active_status(presence);
va_start(args, status_id);
purple_status_set_active_with_attrs(status, TRUE, args);
va_end(args);
purple_blist_update_buddy_status(buddy, old_status);
}
g_slist_free(list);
/* The buddy is no longer online, they are therefore by definition not
* still typing to us. */
if (!purple_status_is_online(status)) {
serv_got_typing_stopped(purple_account_get_connection(account), name);
purple_prpl_got_media_caps(account, name);
}
}
void IMInvoker::buddyAddedCB(PurpleBuddy* buddy) {
PurpleAccount *account = purple_buddy_get_account(buddy);
GET_INSTANCE_IN_CALLBACK(account);
if (!inst)
return;
std::string buddyName = purple_buddy_get_name(buddy);
Event retEv("im.buddy.added");
retEv.data.compound["name"] = Data(buddyName, Data::VERBATIM);
inst->returnEvent(retEv);
buddyStatusChangedCB(buddy, NULL, purple_presence_get_active_status(purple_buddy_get_presence(buddy)), PURPLE_BUDDY_NONE);
}
void
oscar_user_info_append_extra_info(PurpleConnection *gc, PurpleNotifyUserInfo *user_info, PurpleBuddy *b, aim_userinfo_t *userinfo)
{
OscarData *od;
PurpleAccount *account;
PurplePresence *presence = NULL;
PurpleStatus *status = NULL;
PurpleGroup *g = NULL;
struct buddyinfo *bi = NULL;
char *tmp;
const char *bname = NULL, *gname = NULL;
od = purple_connection_get_protocol_data(gc);
account = purple_connection_get_account(gc);
if ((user_info == NULL) || ((b == NULL) && (userinfo == NULL)))
return;
if (userinfo == NULL)
userinfo = aim_locate_finduserinfo(od, purple_buddy_get_name(b));
if (b == NULL)
b = purple_find_buddy(account, userinfo->bn);
if (b != NULL) {
bname = purple_buddy_get_name(b);
g = purple_buddy_get_group(b);
gname = purple_group_get_name(g);
presence = purple_buddy_get_presence(b);
status = purple_presence_get_active_status(presence);
}
if (userinfo != NULL)
bi = g_hash_table_lookup(od->buddyinfo, purple_normalize(account, userinfo->bn));
if ((bi != NULL) && (bi->ipaddr != 0)) {
tmp = g_strdup_printf("%hhu.%hhu.%hhu.%hhu",
(bi->ipaddr & 0xff000000) >> 24,
(bi->ipaddr & 0x00ff0000) >> 16,
(bi->ipaddr & 0x0000ff00) >> 8,
(bi->ipaddr & 0x000000ff));
oscar_user_info_add_pair(user_info, _("IP Address"), tmp);
g_free(tmp);
}
static void fx_tooltip_text(PurpleBuddy *buddy, PurpleNotifyUserInfo *user_info, gboolean UNUSED(full))
{
PurpleStatus *status;
const gchar *impresa, *alias, *sid, *mobileno;
g_return_if_fail(buddy != NULL);
status = purple_presence_get_active_status(purple_buddy_get_presence(buddy));
impresa = purple_status_get_attr_string(status, "impresa");
sid = purple_status_get_attr_string(status, "fetionno");
mobileno = purple_status_get_attr_string(status, "mobileno");
alias = purple_buddy_get_alias(buddy);
purple_notify_user_info_add_pair(user_info, _("FetionNo"), sid);
purple_notify_user_info_add_pair(user_info, _("MobileNo"), mobileno);
purple_notify_user_info_add_pair(user_info, _("Alias"), alias);
purple_notify_user_info_add_pair(user_info, _("Signature"), impresa);
}
void
purple_prpl_got_user_status(PurpleAccount *account, const char *name,
const char *status_id, ...)
{
GSList *list, *l;
PurpleBuddy *buddy;
PurplePresence *presence;
PurpleStatus *status;
PurpleStatus *old_status;
va_list args;
g_return_if_fail(account != NULL);
g_return_if_fail(name != NULL);
g_return_if_fail(status_id != NULL);
g_return_if_fail(purple_account_is_connected(account) || purple_account_is_connecting(account));
if((list = purple_find_buddies(account, name)) == NULL)
return;
for(l = list; l != NULL; l = l->next) {
buddy = l->data;
presence = purple_buddy_get_presence(buddy);
status = purple_presence_get_status(presence, status_id);
if(NULL == status)
continue;
old_status = purple_presence_get_active_status(presence);
va_start(args, status_id);
purple_status_set_active_with_attrs(status, TRUE, args);
va_end(args);
purple_blist_update_buddy_status(buddy, old_status);
}
g_slist_free(list);
/* we get to re-use the last status we found */
if (!purple_status_is_online(status))
serv_got_typing_stopped(purple_account_get_connection(account), name);
}
static inline PecanStatus
util_status_from_session (MsnSession *session)
{
PurpleAccount *account;
PecanStatus msnstatus;
PurplePresence *presence;
PurpleStatus *status;
const gchar *status_id;
account = msn_session_get_user_data (session);
presence = purple_account_get_presence (account);
status = purple_presence_get_active_status (presence);
status_id = purple_status_get_id (status);
if (strcmp (status_id, "available") == 0)
msnstatus = PN_STATUS_ONLINE;
else if (strcmp (status_id, "away") == 0)
msnstatus = PN_STATUS_AWAY;
else if (strcmp (status_id, "brb") == 0)
msnstatus = PN_STATUS_BRB;
else if (strcmp (status_id, "busy") == 0)
msnstatus = PN_STATUS_BUSY;
else if (strcmp (status_id, "phone") == 0)
msnstatus = PN_STATUS_PHONE;
else if (strcmp (status_id, "lunch") == 0)
msnstatus = PN_STATUS_LUNCH;
else if (strcmp (status_id, "invisible") == 0)
msnstatus = PN_STATUS_HIDDEN;
else if (strcmp (status_id, "online") == 0)
{
if (purple_presence_is_idle (presence))
msnstatus = PN_STATUS_IDLE;
else
msnstatus = PN_STATUS_ONLINE;
}
else
{
pn_error ("wrong: status_id=[%s]", status_id);
msnstatus = PN_STATUS_WRONG;
}
return msnstatus;
}
bool SpectrumBuddy::getStatus(PurpleStatusPrimitive &status, std::string &statusMessage) {
PurplePresence *pres = purple_buddy_get_presence(m_buddy);
if (pres == NULL)
return false;
PurpleStatus *stat = purple_presence_get_active_status(pres);
if (stat == NULL)
return false;
status = purple_status_type_get_primitive(purple_status_get_type(stat));
const char *message = purple_status_get_attr_string(stat, "message");
if (message != NULL) {
char *stripped = purple_markup_strip_html(message);
statusMessage = std::string(stripped);
g_free(stripped);
}
else
statusMessage = "";
return true;
}
static void plainprpl_close(PurpleConnection *gc)
{
purple_debug_info("plainprpl", "plainprpl_close\n");
PurpleAccount *account;
PurpleBuddy *buddy;
plain_plugin_state *pstate;
plain_buddy_state *bstate;
const char *on_logout;
/* notify other plainprpl accounts */
account = purple_connection_get_account(gc);
pstate = purple_connection_get_protocol_data(gc);
/* Notifiy all buddies that we are gone */
GSList *iter = pstate->all_buddies;
while (iter) {
buddy = iter->data;
bstate = purple_buddy_get_protocol_data(buddy);
PurplePresence *presence = purple_buddy_get_presence(buddy);
PurpleStatus *status = purple_presence_get_active_status(presence);
PurpleStatusType *status_type = purple_status_get_type(status);
PurpleStatusPrimitive status_primitive = purple_status_type_get_primitive(status_type);
if (bstate && status_primitive == PURPLE_STATUS_AVAILABLE) {
send_msg(pstate, bstate, "/bye");
}
iter = iter->next;
}
//remove timers
purple_timeout_remove(pstate->receive_timer);
on_logout = purple_account_get_string(account, "on_logout", NULL);
exec_process(on_logout, NULL, NULL, gc, NULL);
free_plugin_data(pstate);
}
