static void insert_status_change_from_purple_status(CapStatistics *statistics, PurpleStatus *status) {
PurpleAccount *account = purple_buddy_get_account(statistics->buddy);
char *sql;
const gchar *status_id;
const gchar *buddy_name;
const gchar *protocol_id;
const gchar *account_id;
/* It would seem that some protocols receive periodic updates of the buddies status.
* Check to make sure the last status is not the same as current status to prevent
* to many duplicated useless database entries. */
if(strcmp(statistics->last_status_id, purple_status_get_id(status)) == 0)
return;
status_id = purple_status_get_id(status);
buddy_name = purple_buddy_get_name(statistics->buddy);
protocol_id = purple_account_get_protocol_id(account);
account_id = purple_account_get_username(account);
statistics->last_status_id = purple_status_get_id(status);
purple_debug_info("cap", "Executing: insert into cap_status (buddy, account, protocol, status, event_time) values(%s, %s, %s, %s, now());\n", buddy_name, account_id, protocol_id, status_id);
sql = sqlite3_mprintf("insert into cap_status values (%Q, %Q, %Q, %Q, now());", buddy_name, account_id, protocol_id, status_id);
sqlite3_exec(_db, sql, NULL, NULL, NULL);
sqlite3_free(sql);
}
void QuetzalAccount::setStatus(Status status)
{
PurpleStatus *purple_status = quetzal_get_correct_status(m_account->presence, status);
debug() << purple_status_get_id(purple_status) << purple_status_get_name(purple_status);
purple_presence_set_status_active(m_account->presence, purple_status_get_id(purple_status), TRUE);
if (status.type() != Status::Offline)
purple_account_connect(m_account);
}
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;
}
guint sipe_backend_status(struct sipe_core_public *sipe_public)
{
struct sipe_backend_private *purple_private = sipe_public->backend_private;
PurpleStatus *status = purple_account_get_active_status(purple_private->account);
if (!status) return(SIPE_ACTIVITY_UNSET);
return(sipe_purple_token_to_activity(purple_status_get_id(status)));
}
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;
}
static void insert_cap_success(CapStatistics *stats) {
PurpleAccount *account = purple_buddy_get_account(stats->buddy);
const gchar *buddy_name = purple_buddy_get_name(stats->buddy);
const gchar *protocol_id = purple_account_get_protocol_id(account);
const gchar *account_id = purple_account_get_username(account);
const gchar *status_id = (stats->last_message_status_id) ?
stats->last_message_status_id :
purple_status_get_id(get_status_for(stats->buddy));
struct tm *current_time;
int minute;
if(stats->last_message == -1) {
time_t now = time(NULL);
current_time = localtime(&now);
} else {
current_time = localtime(&stats->last_message);
}
minute = current_time->tm_min + current_time->tm_hour * 60;
insert_cap_msg_count_success(buddy_name, account_id, protocol_id, minute);
insert_cap_status_count_success(buddy_name, account_id, protocol_id, status_id);
stats->last_message = -1;
stats->last_message_status_id = NULL;
}
void sipe_purple_set_status(PurpleAccount *account,
PurpleStatus *status)
{
SIPE_DEBUG_INFO("sipe_purple_set_status[CB]: status=%s",
purple_status_get_id(status));
if (!purple_status_is_active(status))
return;
if (account->gc) {
const gchar *status_id = purple_status_get_id(status);
const gchar *note = purple_status_get_attr_string(status,
SIPE_PURPLE_STATUS_ATTR_ID_MESSAGE);
sipe_core_status_set(PURPLE_ACCOUNT_TO_SIPE_CORE_PUBLIC,
sipe_purple_token_to_activity(status_id),
note);
}
}
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;
}
static void waprpl_set_status(PurpleAccount *acct, PurpleStatus *status) {
whatsapp_connection * wconn = purple_connection_get_protocol_data(purple_account_get_connection(acct));
const char * sid = purple_status_get_id(status);
char * mid = purple_status_get_attr_string(status, "message");
if (mid == 0) mid = "";
waAPI_setmypresence(wconn->waAPI,sid,mid);
waprpl_check_output(purple_account_get_connection(acct));
}
//gets the text of whatever the user sets the status to. (not necessarily what status is on the server)
//client_text and server_text are freed if it returns false
static gboolean getStatusText(char** client_text, char** server_text, PurpleAccount *account, const char** sid)
{
PurpleStatus* status;
PurpleSavedStatus* savedStatus;
PurpleSavedStatusSub* substat;
const char* statusMessage;
status = purple_account_get_active_status(account);
if (status == NULL)
{
purple_debug_fatal("MusicInfo", "Account with NULL status\n");
return FALSE;
}
*sid = purple_status_get_id(status);
statusMessage = purple_status_get_attr_string(status, "message");
if(statusMessage != NULL)
{
*server_text = g_strdup(statusMessage);
}
else
{
*server_text = g_strdup("\0");
}
savedStatus = purple_savedstatus_get_current();
if (savedStatus == NULL)
{
purple_debug_fatal("MusicInfo", "Account with NULL saved status\n");
g_free(*server_text);
return FALSE;
}
statusMessage = NULL;
if(purple_savedstatus_has_substatuses(savedStatus))
{
substat = purple_savedstatus_get_substatus(savedStatus, account);
if(substat != NULL)
statusMessage = purple_savedstatus_substatus_get_message(substat);
}
if(statusMessage == NULL)
{
statusMessage = purple_savedstatus_get_message(savedStatus);
}
if(statusMessage == NULL)
{
g_free(*server_text);
return FALSE;
}
*client_text = g_strdup(statusMessage);
return TRUE;
}
EntryStatus FromPurpleStatus (PurpleAccount *account, PurpleStatus *status)
{
const auto id = purple_status_get_id (status);
const auto statusType = purple_account_get_status_type (account, id);
const auto message = purple_status_get_attr_string (status, "message");
return EntryStatus (FromPurpleState (purple_status_type_get_primitive (statusType)),
message ? QString::fromUtf8 (message) : QString ());
}
/**
* purplemot_set_status - wrapper for motmot_report_status
* @param acct The account
* @param status The status
*/
static void
purplemot_set_status(PurpleAccount *acct, PurpleStatus *status)
{
PurpleConnection *gc = purple_account_get_connection(acct);
struct pm_account *account = gc->proto_data;
purple_debug_info("motmot", "setting status and reporting");
motmot_report_status(purple_status_get_id(status), account);
}
QuetzalAccount::QuetzalAccount(const QString &id, QuetzalProtocol *protocol) : Account(id, protocol)
{
Q_ASSERT(!"Shouldn't use this constructor");
m_isLoading = false;
Config cfg = config();
QString purpleId = id;
if (protocol->id() == QLatin1String("irc")) {
purpleId = cfg.value(QLatin1String("nicks"), QStringList()).value(0);
purpleId += QLatin1Char('@');
int size = cfg.beginArray("servers");
if (size == 0) {
qCritical("Invalid irc account without server info: \"%s\"", qPrintable(id));
deleteLater();
return;
}
cfg.setArrayIndex(0);
purpleId += cfg.value(QLatin1String("hostName"), QString());
cfg.endArray();
}
m_account = purple_account_new(purpleId.toUtf8(), protocol->plugin()->info->id);
m_account->ui_data = this;
fillStatusActions();
setContactsFactory(new QuetzalContactsFactory(this));
// if (PURPLE_PLUGIN_PROTOCOL_INFO(m_account->gc->prpl)->chat_info != NULL) {
// addAction((new ActionGenerator(QIcon(), QT_TRANSLATE_NOOP("Quetzal", "Join groupchat"), this, SLOT(showJoinGroupChat())))->setType(1));
// }
debug() << "created!" << this << m_account->protocol_id;
// Hack for anti-auto-connect
for (GList *it = purple_presence_get_statuses(m_account->presence); it; it = it->next) {
PurpleStatus *status = reinterpret_cast<PurpleStatus *>(it->data);
// debug() << purple_status_type_get_primitive(purple_status_get_type(status))
// << !!purple_status_is_online(status)
// << purple_status_get_id(status)
// << purple_status_get_name(status);
if (!purple_status_is_online(status)) {
purple_presence_set_status_active(m_account->presence, purple_status_get_id(status), TRUE);
break;
}
}
m_isLoading = true;
load(cfg);
m_isLoading = false;
// if (protocol->id() == "jabber" && id.contains("qutim.org")) {
if (!purple_account_get_enabled(m_account, "qutim"))
purple_account_set_enabled(m_account, "qutim", TRUE);
// purple_account_connect(m_account);
// } else
// purple_account_set_enabled(m_account, "qutim", FALSE);
}
/*------------------------------------------------------------------------
* 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 );
}
static void fetion_set_status(PurpleAccount * account, PurpleStatus * status)
{
/*
Away = 100,
BeRightBack = 300,
Busy = 600,
DoNotDisturb = 800,
InTheMeeting = 850,
Invisible = 0x383,
Offline = 0,
Online = 400,
OnThePhone = 500,
OutToLunch = 150,
SmsOnline = 1,
Unknown = -1
*/
const char *status_id;
char *body;
int status_code;
status_id = purple_status_get_id(status);
if (!strcmp(status_id, "away"))
status_code = 100;
else if (!strcmp(status_id, "brb"))
status_code = 300;
else if (!strcmp(status_id, "busy"))
status_code = 600;
else if (!strcmp(status_id, "phone"))
status_code = 500;
else if (!strcmp(status_id, "lunch"))
status_code = 150;
else if (!strcmp(status_id, "invisible"))
status_code = 0x383;
else
status_code = 400;
body =
g_strdup_printf
("<args><presence><basic value=\"%d\" /></presence></args>",
status_code);
send_sip_request(account->gc, "S", "", "", "N: SetPresence\r\n", body,
NULL, NULL);
g_free(body);
//<args><presence><basic value="400" /></presence></args>
}
static void insert_cap_failure(CapStatistics *stats) {
gchar *buddy_name = stats->buddy->name;
const gchar *protocol_id = purple_account_get_protocol_id(stats->buddy->account);
const gchar *account_id = purple_account_get_username(stats->buddy->account);
const gchar *status_id = (stats->last_message_status_id) ?
stats->last_message_status_id :
purple_status_get_id(get_status_for(stats->buddy));
struct tm *current_time = localtime(&stats->last_message);
int minute = current_time->tm_min + current_time->tm_hour * 60;
insert_cap_msg_count_failed(buddy_name, account_id, protocol_id, minute);
insert_cap_status_count_failed(buddy_name, account_id, protocol_id, status_id);
stats->last_message = -1;
stats->last_message_status_id = NULL;
}
static void fx_set_status(PurpleAccount *account, PurpleStatus *status)
{
const gchar *status_id;
gint state;
PurpleConnection *gc = purple_account_get_connection(account);
fetion_account *ses = purple_connection_get_protocol_data(gc);
status_id = purple_status_get_id(status);
if (!strcmp(status_id, "Online")) state = P_ONLINE;
else if (!strcmp(status_id, "Away")) state = P_AWAY;
else if (!strcmp(status_id, "Busy")) state = P_BUSY;
else if (!strcmp(status_id, "Hidden")) state = P_HIDDEN;
else if (!strcmp(status_id, "Offline")) state = P_OFFLINE;
else state = 400;
fetion_user_set_state(ses, state);
}
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;
}
Data IMInvoker::buddyToData(PurpleBuddy *buddy) {
Data data;
std::string buddyName = purple_buddy_get_name(buddy);
if (purple_buddy_get_name(buddy)) data.compound["name"] = Data(purple_buddy_get_name(buddy), Data::VERBATIM);
if (purple_buddy_get_alias(buddy)) data.compound["alias"] = Data(purple_buddy_get_alias(buddy), Data::VERBATIM);
if (purple_buddy_get_alias_only(buddy)) data.compound["aliasOnly"] = Data(purple_buddy_get_alias_only(buddy), Data::VERBATIM);
if (purple_buddy_get_server_alias(buddy)) data.compound["server"] = Data(purple_buddy_get_server_alias(buddy), Data::VERBATIM);
PurpleGroup* group = purple_buddy_get_group(buddy);
if (group) {
if (purple_group_get_name(group)) data.compound["group"] = Data(purple_group_get_name(group), Data::VERBATIM);
}
PurpleBuddyIcon* icon = purple_buddy_get_icon(buddy);
if (icon) {
size_t iconSize = 0;
gconstpointer iconData = purple_buddy_icon_get_data(icon, &iconSize);
data.compound["icon"] = Data((char*)iconData, iconSize, "application/octet-stream", false);
}
PurplePresence* presence = purple_buddy_get_presence(buddy);
if (presence) {
GList *statusElem;
GList *statusList = purple_presence_get_statuses(presence);
PurpleStatus* status;
for(statusElem = statusList; statusElem; statusElem = statusElem->next) {
status = (PurpleStatus*)statusElem->data;
const char* statusId = purple_status_get_id(status);
PurpleStatusPrimitive statusPrimitive = purple_primitive_get_type_from_id(statusId);
// only include active states
if(statusPrimitive == PURPLE_STATUS_UNSET || !purple_presence_is_status_primitive_active(presence, statusPrimitive))
continue;
data.compound["status"].compound[statusId] = statusToData(status);
}
}
return data;
}
static void* _background_login(void* data)
{
qq_account* ac=(qq_account*)data;
if(!qq_account_valid(ac)) return NULL;
LwqqClient* lc = ac->qq;
LwqqErrorCode err;
//it would raise a invalid ac when wake up from sleep.
//it would login twice,why?
//so what i can do is disable the invalid one.
if(!lwqq_client_valid(lc)) return NULL;
const char* status = purple_status_get_id(purple_account_get_active_status(ac->account));
lwqq_login(lc,lwqq_status_from_str(status), &err);
if (err == LWQQ_EC_LOGIN_NEED_VC) {
lc->dispatch(vp_func_pi,(CALLBACK_FUNC)extra_async_opt.need_verify,lc,err);
}else{
lc->dispatch(vp_func_pi,(CALLBACK_FUNC)extra_async_opt.login_complete,lc,err);
}
return NULL;
}
NateonAwayType
nateon_state_from_account(PurpleAccount *account)
{
NateonAwayType nateonstatus;
PurplePresence *presence;
PurpleStatus *status;
const char *status_id;
purple_debug_info("nateon", "[%s] have some bugs.\n", __FUNCTION__);
presence = purple_account_get_presence(account);
status = purple_presence_get_active_status(presence);
status_id = purple_status_get_id(status);
purple_debug_info("nateon", "[%s] status_id(%s)\n", __FUNCTION__, status_id);
if (!strcmp(status_id, "A"))
nateonstatus = NATEON_AWAY;
else if (!strcmp(status_id, "B"))
nateonstatus = NATEON_BUSY;
else if (!strcmp(status_id, "P"))
nateonstatus = NATEON_PHONE;
else if (!strcmp(status_id, "M"))
nateonstatus = NATEON_MEETING;
else if (!strcmp(status_id, "X"))
nateonstatus = NATEON_HIDDEN;
else
nateonstatus = NATEON_ONLINE;
purple_debug_info("nateon", "[%s] nateonstatus(%s)\n", __FUNCTION__, nateon_state_get_text(nateonstatus));
// if ((nateonstatus == NATEON_ONLINE) && purple_presence_is_idle(presence))
// nateonstatus = NATEON_IDLE;
purple_debug_info("nateon", "[%s] nateonstatus(%s)\n", __FUNCTION__, nateon_state_get_text(nateonstatus));
return nateonstatus;
}
/* sent-im-msg */
static void sent_im_msg(PurpleAccount *account, const char *receiver, const char *message) {
PurpleBuddy *buddy;
guint interval, words;
CapStatistics *stats = NULL;
buddy = purple_find_buddy(account, receiver);
if (buddy == NULL)
return;
interval = purple_prefs_get_int("/plugins/gtk/cap/max_msg_difference") * 60;
words = word_count(message);
stats = get_stats_for(buddy);
insert_word_count(purple_account_get_username(account), receiver, words);
stats->last_message = time(NULL);
stats->last_message_status_id = purple_status_get_id(get_status_for(buddy));
if(stats->timeout_source_id != 0)
purple_timeout_remove(stats->timeout_source_id);
stats->timeout_source_id = purple_timeout_add_seconds(interval, max_message_difference_cb, stats);
}
gboolean sipe_backend_status_changed(struct sipe_core_public *sipe_public,
guint activity,
const gchar *message)
{
struct sipe_backend_private *purple_private = sipe_public->backend_private;
PurpleStatus *status = purple_account_get_active_status(purple_private->account);
const gchar *status_id = sipe_purple_activity_to_token(activity);
gboolean changed = TRUE;
if (g_str_equal(status_id, purple_status_get_id(status)) &&
sipe_strequal(message,
purple_status_get_attr_string(status,
SIPE_PURPLE_STATUS_ATTR_ID_MESSAGE)))
{
changed = FALSE;
}
if (purple_savedstatus_is_idleaway()) {
changed = FALSE;
}
return(changed);
}
static void irc_set_status(PurpleAccount *account, PurpleStatus *status)
{
PurpleConnection *gc = purple_account_get_connection(account);
struct irc_conn *irc;
const char *args[1];
const char *status_id = purple_status_get_id(status);
g_return_if_fail(gc != NULL);
irc = gc->proto_data;
if (!purple_status_is_active(status))
return;
args[0] = NULL;
if (!strcmp(status_id, "away")) {
args[0] = purple_status_get_attr_string(status, "message");
if ((args[0] == NULL) || (*args[0] == '\0'))
args[0] = _("Away");
irc_cmd_away(irc, "away", NULL, args);
} else if (!strcmp(status_id, "available")) {
irc_cmd_away(irc, "back", NULL, args);
}
}
static void discover_status(PurpleConnection *from, PurpleConnection *to,
gpointer userdata) {
const char *from_username = purple_account_get_username(purple_connection_get_account(from));
const char *to_username = purple_account_get_username(purple_connection_get_account(to));
if (purple_blist_find_buddy(purple_connection_get_account(from), to_username)) {
PurpleStatus *status = purple_account_get_active_status(purple_connection_get_account(to));
const char *status_id = purple_status_get_id(status);
const char *message = purple_status_get_attr_string(status, "message");
if (!strcmp(status_id, NULL_STATUS_ONLINE) ||
!strcmp(status_id, NULL_STATUS_AWAY) ||
!strcmp(status_id, NULL_STATUS_OFFLINE)) {
purple_debug_info("nullprpl", "%s sees that %s is %s: %s\n",
from_username, to_username, status_id, message);
purple_prpl_got_user_status(purple_connection_get_account(from), to_username, status_id,
(message) ? "message" : NULL, message, NULL);
} else {
purple_debug_error("nullprpl",
"%s's buddy %s has an unknown status: %s, %s",
from_username, to_username, status_id, message);
}
}
}
static double generate_prediction_for(PurpleBuddy *buddy) {
double prediction = 1.0f;
gboolean generated = FALSE;
PurpleAccount *account = purple_buddy_get_account(buddy);
const gchar *buddy_name = purple_buddy_get_name(buddy);
const gchar *protocol_id = purple_account_get_protocol_id(account);
const gchar *account_id = purple_account_get_username(account);
const gchar *status_id = purple_status_get_id(get_status_for(buddy));
time_t t = time(NULL);
struct tm *current_time = localtime(&t);
int current_minute = current_time->tm_min + current_time->tm_hour * 60;
int threshold = purple_prefs_get_int("/plugins/gtk/cap/threshold");
int min_minute = (current_minute - threshold) % 1440;
int max_minute = (current_minute + threshold) % 1440;
gchar *sql;
sqlite3_stmt *stmt = NULL;
const char *tail = NULL;
int rc;
sql = sqlite3_mprintf("select sum(success_count) as successes, sum(failed_count) as failures "
"from cap_msg_count where "
"buddy=%Q and account=%Q and protocol=%Q and minute_val>=%d and minute_val<=%d;",
buddy_name, account_id, protocol_id, min_minute, max_minute);
rc = sqlite3_prepare(_db, sql, -1, &stmt, &tail);
if(rc == SQLITE_OK) {
int successes = 0;
int failures = 0;
if(stmt != NULL) {
if(sqlite3_step(stmt) == SQLITE_ROW) {
successes = sqlite3_column_int(stmt, 0);
failures = sqlite3_column_int(stmt, 1);
if(failures + successes > 0) {
prediction *= ((double)successes/((double)(successes+failures)));
generated = TRUE;
}
}
sqlite3_finalize(stmt);
}
}
sqlite3_free(sql);
sql = sqlite3_mprintf("select sum(success_count) as successes, sum(failed_count) as failures "
"from cap_status_count where "
"buddy=%Q and account=%Q and protocol=%Q and status=%Q;",
buddy_name, account_id, protocol_id, status_id);
rc = sqlite3_prepare(_db, sql, -1, &stmt, &tail);
if(rc == SQLITE_OK) {
int successes = 0;
int failures = 0;
if(stmt != NULL) {
if(sqlite3_step(stmt) == SQLITE_ROW) {
successes = sqlite3_column_int(stmt, 0);
failures = sqlite3_column_int(stmt, 1);
if(failures + successes > 0) {
prediction *= ((double)successes/((double)(successes+failures)));
generated = TRUE;
}
}
sqlite3_finalize(stmt);
}
}
sqlite3_free(sql);
if(generated)
return prediction;
else
return -1;
}
static void buddy_presence(PurpleBuddy *buddy)
{
PurplePresence *presence = purple_buddy_get_presence(buddy);
PurpleStatus *status = purple_presence_get_active_status(presence);
printf("buddy %s is now %s\n", buddy->name, purple_status_get_id(status));
}
