void jabber_set_status(PurpleAccount *account, PurpleStatus *status)
{
PurpleConnection *gc;
JabberStream *js;
if (!purple_account_is_connected(account))
return;
if (purple_status_is_exclusive(status) && !purple_status_is_active(status)) {
/* An exclusive status can't be deactivated. You should just
* activate some other exclusive status. */
return;
}
gc = purple_account_get_connection(account);
js = purple_connection_get_protocol_data(gc);
/* it's a mood update */
if (purple_status_type_get_primitive(purple_status_get_type(status)) == PURPLE_STATUS_MOOD) {
const char *mood =
purple_status_get_attr_string(status, PURPLE_MOOD_NAME);
const char *mood_text =
purple_status_get_attr_string(status, PURPLE_MOOD_COMMENT);
jabber_mood_set(js, mood, mood_text);
return;
}
jabber_presence_send(js, FALSE);
}
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 void fb_set_status_p(PurpleAccount *account, PurpleStatus *status)
{
const gchar *message;
gchar *stripped;
FacebookAccount *fba = account->gc->proto_data;
/* if "away" set idle */
if (fba && purple_status_type_get_primitive(purple_status_get_type(status)) == PURPLE_STATUS_AWAY)
{
fba->is_idle = TRUE;
}
//VOXOX - CJC - 2009.07.06 We always want to do this
///* first check that we actually want to set this through Pidgin */
//if (!purple_account_get_bool(account,
// "facebook_set_status_through_pidgin", FALSE))
//{
// return;
//}
//message = purple_status_get_attr_string(status, "message");
//if (message == NULL)
// message = "";
message = purple_status_get_attr_string(status, "message");
if (message == NULL)
//VOXOX CHANGE CJC DO NOT SET MESSAGE IF BLANK
return;
stripped = purple_markup_strip_html(message);
fb_set_status_ok_cb(account->gc, stripped);
g_free(stripped);
}
static void buddy_status_changed(PurpleBuddy *buddy, PurpleStatus *old_status, PurpleStatus *status) {
PurplePlugin *prpl;
PurplePluginProtocolInfo *prpl_info = NULL;
char *sip_from = find_sip_user(buddy->name);
int d = hashtable_get_counter(buddy->name);
PurpleStatusPrimitive primitive;
enum purple_publish_basic basic;
enum purple_publish_activity activity;
char *statustext = NULL, *tmp = NULL, *new;
const char *end;
LM_DBG("buddy <%s> has changed status\n", buddy->name);
if ((sip_from) && (d>0)) {
primitive = purple_status_type_get_primitive(purple_status_get_type(status));
primitive_parse(primitive, &basic, &activity);
// char *note = purple_status_get_attr_string(status, "message");
prpl = purple_find_prpl(purple_account_get_protocol_id(buddy->account));
if (prpl != NULL)
prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(prpl);
if (prpl_info && prpl_info->status_text && buddy->account->gc) {
tmp = prpl_info->status_text(buddy);
if(tmp && !g_utf8_validate(tmp, -1, &end)) {
new = g_strndup(tmp, g_utf8_pointer_to_offset(tmp, end));
g_free(tmp);
tmp = new;
}
static gboolean purple_status_is_avaliable(PurpleStatus *status)
{
PurpleStatusPrimitive primitive = PURPLE_STATUS_UNSET;
if (!status)
return FALSE;
primitive = purple_status_type_get_primitive(purple_status_get_type(status));
return (primitive == PURPLE_STATUS_AVAILABLE);
}
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 ) );
}
void flist_purple_set_status(PurpleAccount *account, PurpleStatus *status) {
PurpleConnection *pc = purple_account_get_connection(account);
FListAccount *fla = pc->proto_data;
PurpleStatusType *statusType = purple_status_get_type(status);
GList *statusTypes = flist_status_types(account);
GList *cur = statusTypes;
FListStatus fStatus = FLIST_STATUS_UNKNOWN;
// The status isn't active! bail!
if (!purple_status_is_active(status))
return;
// First, get the presence. If it's idle, we default to idle.
PurplePresence *presence = purple_status_get_presence(status);
if(purple_presence_is_idle(presence)) {
flist_set_status(fla, FLIST_STATUS_IDLE, purple_status_get_attr_string(status, FLIST_STATUS_MESSAGE_KEY));
}
// Alright, not idle. Next, compare StatusType IDs. If it's a match, use that.
while(cur) {
PurpleStatusType *type = cur->data;
if(strcmp(purple_status_type_get_id(type), purple_status_type_get_id(statusType)) == 0){
fStatus = flist_parse_status(purple_status_type_get_id(statusType));
break;
} else {
cur = g_list_next(cur);
}
}
// Found a matching F-list Status. Use it!
if(fStatus != FLIST_STATUS_UNKNOWN) {
flist_set_status(fla, fStatus, purple_status_get_attr_string(status, FLIST_STATUS_MESSAGE_KEY));
} else {
// Alright, seems the status we chose isn't an F-list one. Let's convert to the next best primitive.
switch (purple_status_type_get_primitive(statusType)) {
case PURPLE_STATUS_AWAY:
case PURPLE_STATUS_EXTENDED_AWAY:
flist_set_status(fla, FLIST_STATUS_AWAY, purple_status_get_attr_string(status, FLIST_STATUS_MESSAGE_KEY));
break;
case PURPLE_STATUS_UNAVAILABLE:
flist_set_status(fla, FLIST_STATUS_DND, purple_status_get_attr_string(status, FLIST_STATUS_MESSAGE_KEY));
break;
// Assume AVAILABLE by default if it's not an AWAY/DND status
default:
flist_set_status(fla, FLIST_STATUS_AVAILABLE, purple_status_get_attr_string(status, FLIST_STATUS_MESSAGE_KEY));
}
}
g_list_free(statusTypes);
flist_update_server_status(fla);
}
/*------------------------------------------------------------------------
* The user changed their current presence state.
*
* @param account The MXit account object
* @param status The new status (libPurple status type)
*/
static void mxit_set_status( PurpleAccount* account, PurpleStatus* status )
{
struct MXitSession* session = purple_connection_get_protocol_data( purple_account_get_connection( account ) );
const char* statusid;
int presence;
char* statusmsg1;
char* statusmsg2;
/* Handle mood changes */
if ( purple_status_type_get_primitive( purple_status_get_type( status ) ) == PURPLE_STATUS_MOOD ) {
const char* moodid = purple_status_get_attr_string( status, PURPLE_MOOD_NAME );
int mood;
/* convert the purple mood to a mxit mood */
mood = mxit_convert_mood( moodid );
if ( mood < 0 ) {
/* error, mood not found */
purple_debug_info( MXIT_PLUGIN_ID, "Mood status NOT found! (id = %s)\n", moodid );
return;
}
/* update mood state */
mxit_send_mood( session, mood );
return;
}
/* get the status id (reference: "libpurple/status.h") */
statusid = purple_status_get_id( status );
/* convert the purple status to a mxit status */
presence = mxit_convert_presence( statusid );
if ( presence < 0 ) {
/* error, status not found */
purple_debug_info( MXIT_PLUGIN_ID, "Presence status NOT found! (id = %s)\n", statusid );
return;
}
statusmsg1 = purple_markup_strip_html( purple_status_get_attr_string( status, "message" ) );
statusmsg2 = g_strndup( statusmsg1, CP_MAX_STATUS_MSG );
purple_debug_info( MXIT_PLUGIN_ID, "mxit_set_status: '%s'\n", statusmsg2 );
/* update presence state */
mxit_send_presence( session, presence, statusmsg2 );
g_free( statusmsg1 );
g_free( statusmsg2 );
}
/////////////////////////////////////////////////////////////////////////////
// Determines whether Lock'n'Roll should update the status message when the
// workstation is locked. This returns false if the current status is away
// already, invisible, or offline (fixes bug in 1.0.1)
/////////////////////////////////////////////////////////////////////////////
static gboolean lnr_should_change_message(PurpleAccount *acct)
{
PurpleStatusType *activeStatusType = NULL;
activeStatusType = purple_status_get_type(purple_account_get_active_status(acct));
switch (purple_status_type_get_primitive(activeStatusType))
{
case PURPLE_STATUS_AWAY:
case PURPLE_STATUS_EXTENDED_AWAY:
case PURPLE_STATUS_UNAVAILABLE:
case PURPLE_STATUS_INVISIBLE:
case PURPLE_STATUS_OFFLINE:
return FALSE;
default:
return TRUE;
}
}
static void irc_connected(struct irc_conn *irc, const char *nick)
{
PurpleConnection *gc;
PurpleStatus *status;
PurpleBlistNode *gnode, *cnode, *bnode;
if ((gc = purple_account_get_connection(irc->account)) == NULL
|| PURPLE_CONNECTION_IS_CONNECTED(gc))
return;
purple_connection_set_display_name(gc, nick);
purple_connection_set_state(gc, PURPLE_CONNECTED);
/* If we're away then set our away message */
status = purple_account_get_active_status(irc->account);
if (!purple_status_get_type(status) != PURPLE_STATUS_AVAILABLE) {
PurplePluginProtocolInfo *prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl);
prpl_info->set_status(irc->account, status);
}
/* this used to be in the core, but it's not now */
for (gnode = purple_get_blist()->root; gnode; gnode = gnode->next) {
if(!PURPLE_BLIST_NODE_IS_GROUP(gnode))
continue;
for(cnode = gnode->child; cnode; cnode = cnode->next) {
if(!PURPLE_BLIST_NODE_IS_CONTACT(cnode))
continue;
for(bnode = cnode->child; bnode; bnode = bnode->next) {
PurpleBuddy *b;
if(!PURPLE_BLIST_NODE_IS_BUDDY(bnode))
continue;
b = (PurpleBuddy *)bnode;
if(b->account == gc->account) {
struct irc_buddy *ib = g_new0(struct irc_buddy, 1);
ib->name = g_strdup(b->name);
g_hash_table_insert(irc->buddies, ib->name, ib);
}
}
}
}
irc_blist_timeout(irc);
if (!irc->timer)
irc->timer = purple_timeout_add_seconds(45, (GSourceFunc)irc_blist_timeout, (gpointer)irc);
}
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 _elim_status_changed ( PurpleAccount *account ,
PurpleStatus *status )
{
xmlnode *alist = xnode_new( "alist" );
char *ID = new_elim_id();
fprintf( stderr, "(_elim_status_changed)\n" );
PurpleStatusType *type = purple_status_get_type( status );
PurpleStatusPrimitive statp = purple_status_type_get_primitive( type );
AL_PTR ( alist, "account-uid" , account );
AL_STR ( alist, "account-name", purple_account_get_username ( account ) );
AL_STR ( alist, "im-protocol" , purple_account_get_protocol_id( account ) );
AL_STR ( alist, "status-name" , purple_status_get_name ( status ) );
AL_ENUM( alist, "status-type" , statp, ":status-primitive" );
AL_BOOL( alist, "connected" , purple_account_is_connected ( account ) );
xmlnode *mcall = func_call( "elim-account-status-changed", ID, alist );
g_free( ID );
add_outbound_sexp( mcall );
}
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);
}
std::string get_account_status()
{
std::string result;
// :fixme:
// atm we get the status only for the first account (assuming the status is
// identical forall active accounts - which may not be true)
GList *p_accounts = purple_accounts_get_all_active();
if (p_accounts) {
PurpleStatus *p_status = purple_account_get_active_status(
reinterpret_cast<PurpleAccount*>(g_list_first(p_accounts)->data));
const char *p_status_text = purple_primitive_get_name_from_type(
purple_status_type_get_primitive(purple_status_get_type(p_status)));
if (p_status_text) {
result = p_status_text;
} else {
result = "Unknown";
}
} else {
// no active accounts -> offline
result = "Offline";
}
return result;
}
char *getColorSchemeString(const char *base_color_scheme, PurpleBuddy *buddy)
{
if (!purple_account_is_connected(purple_buddy_get_account(buddy))) {
return g_strdup_printf("%s_offline", base_color_scheme);
}
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_UNSET:
return g_strdup_printf("%s_offline", base_color_scheme);
case PURPLE_STATUS_OFFLINE:
return g_strdup_printf("%s_offline", base_color_scheme);
case PURPLE_STATUS_AVAILABLE:
return g_strdup_printf("%s_online", base_color_scheme);
case PURPLE_STATUS_UNAVAILABLE:
return g_strdup_printf("%s_na", base_color_scheme);
case PURPLE_STATUS_INVISIBLE:
return g_strdup_printf("%s_na", base_color_scheme);
case PURPLE_STATUS_AWAY:
return g_strdup_printf("%s_away", base_color_scheme);
case PURPLE_STATUS_EXTENDED_AWAY:
return g_strdup_printf("%s_away", base_color_scheme);
case PURPLE_STATUS_MOBILE:
return g_strdup_printf("%s_online", base_color_scheme);
case PURPLE_STATUS_TUNE:
return g_strdup_printf("%s_online", base_color_scheme);
case PURPLE_STATUS_MOOD:
return g_strdup_printf("%s_online", base_color_scheme);
default:
return g_strdup_printf("%s_offline", base_color_scheme);
}
}
static void pipe_handle_subscribe(struct purple_subscribe *subscribe) {
PurpleAccount *account = NULL;
extern_account_t *accounts = NULL;
extern_user_t *users = NULL;
int naccounts = 0, nusers = 0;
int i, j;
PurpleBuddy *buddy = NULL;
int d = 0;
const char *note;
enum purple_publish_basic basic;
enum purple_publish_activity activity;
LM_DBG("calling find_accounts(\"%s\", &naccounts)\n", subscribe->from);
accounts = find_accounts(subscribe->from, &naccounts);
LM_DBG("found %d extra account(s) for <%s>", naccounts, subscribe->from);
LM_DBG("calling find_users(\"%s\", &nusers)\n", subscribe->to);
users = find_users(subscribe->to, &nusers);
LM_DBG("found %d extra user(s) for <%s>", nusers, subscribe->to);
for (i = 0; i < naccounts; i++) {
LM_DBG("calling client_find_account(\"%s\")\n", accounts[i].username);
account = client_find_account(&accounts[i]);
//if ((account) && (purple_account_is_connected(account) || purple_account_is_connecting(account))) {
if (account) {
for (j = 0; j < nusers; j++) {
if (!strcmp(accounts[i].protocol, users[j].protocol)) {
LM_DBG("found matching protocol: %s\n", accounts[i].protocol);
LM_DBG("subscribe expires : %d\n", subscribe->expires);
if (subscribe->expires == 0)
d = hashtable_dec_counter(users[j].username);
else
d = hashtable_inc_counter(users[j].username);
LM_DBG("<%s> is now referenced %d times\n", users[j].username, d);
if (d == 0) {
LM_DBG("<%s> is no more referenced, removing presence...\n", users[j].username);
if (purple_send_sip_publish(subscribe->to, users[j].username, PURPLE_BASIC_CLOSED, 0, NULL) < 0)
LM_ERR("error sending presence for %s", subscribe->to);
else
LM_DBG("presence message sent successfully\n");
}
else {
buddy = purple_find_buddy(account, users[j].username);
if (buddy == NULL) {
LM_DBG("<%s> not found in <%s> buddy list, adding\n", users[j].username, accounts[i].username);
buddy = purple_buddy_new(account, users[j].username, users[j].username);
//purple_blist_add_buddy(buddy, NULL, NULL, NULL);
purple_account_add_buddy(account, buddy);
}
else {
LM_DBG("<%s> found in <%s> buddy list, sending publish\n", users[j].username, accounts[i].username);
PurplePresence *presence = purple_buddy_get_presence(buddy);
PurpleStatus *status = purple_presence_get_active_status(presence);
PurpleStatusType *type = purple_status_get_type(status);
PurpleStatusPrimitive primitive = purple_status_type_get_primitive(type);
note = purple_status_get_attr_string(status, "message");
primitive_parse(primitive, &basic, &activity);
if (purple_send_sip_publish(subscribe->to, users[j].username, basic, activity, note) < 0)
LM_ERR("error sending presence for %s", subscribe->to);
else
LM_DBG("presence message sent successfully\n");
}
}
break;
}
}
}
}
if (accounts)
extern_account_free(accounts, naccounts);
if (users)
extern_user_free(users, nusers);
}
static void received_im_msg_cb(PurpleAccount *account, char *who, char *buffer,
PurpleConversation *conv, PurpleMessageFlags flags, void *data) {
// A workaround to avoid skipping of the first message as a result on NULL-conv:
if (conv == NULL) conv = purple_conversation_new(PURPLE_CONV_TYPE_IM,
account, who);
PurpleBuddy *buddy = purple_find_buddy(account, who);
PurplePresence *presence = purple_buddy_get_presence(buddy);
msg_metadata_t msg;
//Get message
msg.text = purple_markup_strip_html(buffer);
msg.remote_username = who;
//LOCAL USER:
msg.local_alias = purple_account_get_alias(account);
msg.local_username = (char *) purple_account_get_name_for_display(account);
//REMOTE USER (Buddy):
//Get buddy alias
msg.remote_alias = purple_buddy_get_alias(buddy);
if(msg.remote_alias == NULL) msg.remote_alias = "";
//Get buddy group
PurpleGroup *group = purple_buddy_get_group(buddy);
//return empty string if not in group
msg.remote_from_group = group != NULL ? purple_group_get_name(group) : "";
//Get protocol ID
msg.protocol_id = purple_account_get_protocol_id(account);
//trim out PROTOCOL_PREFIX (eg.: "prpl-irc" => "irc")
if(!strncmp(msg.protocol_id,PROTOCOL_PREFIX,strlen(PROTOCOL_PREFIX)))
msg.protocol_id += strlen(PROTOCOL_PREFIX);
//Get status
PurpleStatus *status = purple_account_get_active_status(account);
PurpleStatusType *type = purple_status_get_type(status);
//remote
PurpleStatus *r_status = purple_presence_get_active_status(presence);
PurpleStatusType *r_status_type = purple_status_get_type(r_status);
//Get status id
msg.local_status_id = NULL;
msg.local_status_id = purple_primitive_get_id_from_type(
purple_status_type_get_primitive(type));
//remote
msg.remote_status_id = NULL;
msg.remote_status_id = purple_primitive_get_id_from_type(
purple_status_type_get_primitive(r_status_type));
//Get status message
msg.local_status_msg = NULL;
if (purple_status_type_get_attr(type, "message") != NULL) {
msg.local_status_msg = purple_status_get_attr_string(status, "message");
} else {
PurpleSavedStatus *savedstatus = purple_savedstatus_get_current();
if(savedstatus)
msg.local_status_msg = purple_savedstatus_get_message(savedstatus);
}
//remote
msg.remote_status_msg = NULL;
if (purple_status_type_get_attr(r_status_type, "message") != NULL) {
msg.remote_status_msg = purple_status_get_attr_string(r_status, "message");
} else {
msg.remote_status_msg = "";
}
run_lua(conv, msg);
}
/**************************************************************************
* Account signal callbacks
**************************************************************************/
static void
account_status_changed_cb(PurpleAccount *account,
PurpleStatus *old_status, PurpleStatus *new_status)
{
acc_status = purple_status_type_get_primitive( purple_status_get_type(new_status) );
}
