Merge pep modules & use events
* merge mood, tune, activity, geoloc, avatar
* split them into functionality/ui
* tune, geoloc: fix timeout bug
* geoloc: fix guard unregistering
* tune, mood: fix memleaking delayed info
* mood: fix non-publish of offline-delayed data
* activity: unregister reply handler on disconnect
* fix silly copyright typo
* update hgignore
* v0.0.3
/*
* pep_activity.c -- Pep activity events
*
* Copyright (C) 2009-2012 Myhailo Danylenko <isbear@ukrpost.net>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
* USA
*/
#include <glib.h>
#include <loudmouth/loudmouth.h>
#include <string.h>
#include <mcabber/utils.h>
#include <mcabber/logprint.h>
#include <mcabber/hooks.h>
#include <mcabber/modules.h>
#include <mcabber/xmpp.h>
#include <mcabber/xmpp_helper.h>
#include "pep.h"
#include "activity.h"
#include "config.h"
//
// module description
//
void pep_activity_init (void);
void pep_activity_uninit (void);
#define DESCRIPTION ( "PEP activity support" )
static const gchar *deps[] = { "pep", NULL };
static module_info_t info_activity_dev = {
.branch = "dev",
.api = 20,
.version = PROJECT_VERSION,
.description = DESCRIPTION,
.requires = deps,
.init = pep_activity_init,
.uninit = pep_activity_uninit,
.next = NULL,
};
static module_info_t info_activity_0_10_1 = {
.branch = "0.10.1",
.api = 1,
.version = PROJECT_VERSION,
.description = DESCRIPTION,
.requires = deps,
.init = pep_activity_init,
.uninit = pep_activity_uninit,
.next = &info_activity_dev,
};
module_info_t info_pep_activity = {
.branch = "0.10.0",
.api = 1,
.version = PROJECT_VERSION,
.description = DESCRIPTION,
.requires = deps,
.init = pep_activity_init,
.uninit = pep_activity_uninit,
.next = &info_activity_0_10_1,
};
//
// globals
//
static GQuark activity_gerror_quark = 0;
static gboolean activity_delayed = FALSE;
static guint activity_hid_connect = 0;
static guint activity_hid_disconnect = 0;
static guint activity_hid_activityout = 0;
static gchar *activity_major = NULL;
static gchar *activity_minor = NULL;
static gchar *activity_text = NULL;
static LmMessageHandler *activity_reply_handler = NULL;
//
// code
//
static LmHandlerResult activity_publish_reply_handler (LmMessageHandler *handler, LmConnection *connection, LmMessage *message, gpointer userdata)
{
switch (lm_message_get_sub_type (message)) {
case LM_MESSAGE_SUB_TYPE_RESULT:
break;
case LM_MESSAGE_SUB_TYPE_ERROR:
{
LmMessageNode *node = lm_message_get_node (message);
const gchar *type;
const gchar *reason;
node = lm_message_node_get_child (node, "error");
type = lm_message_node_get_attribute (node, "type");
if (node->children)
reason = node->children->name;
else
reason = "undefined";
scr_log_print (LPRINT_LOGNORM, "activity: Publish failed: %s - %s", type, reason);
}
break;
default:
return LM_HANDLER_RESULT_ALLOW_MORE_HANDLERS;
break;
}
return LM_HANDLER_RESULT_REMOVE_MESSAGE;
}
void activity_publish (const gchar *major, const gchar *minor, const gchar *text)
{
if (!xmpp_is_online ()) {
g_free (activity_major);
g_free (activity_minor);
g_free (activity_text);
activity_major = g_strdup (major);
activity_minor = g_strdup (minor);
activity_text = g_strdup (text);
activity_delayed = TRUE;
return;
}
LmMessage *request = lm_message_new_with_sub_type (NULL, LM_MESSAGE_TYPE_IQ, LM_MESSAGE_SUB_TYPE_SET);
LmMessageNode *node = lm_message_get_node (request);
lm_message_node_set_attribute (node, "from", lm_connection_get_jid (lconnection));
node = lm_message_node_add_child (node, "pubsub", NULL);
lm_message_node_set_attribute (node, "xmlns", NS_PUBSUB);
node = lm_message_node_add_child (node, "publish", NULL);
lm_message_node_set_attribute (node, "node", NS_ACTIVITY);
node = lm_message_node_add_child (node, "item", NULL);
node = lm_message_node_add_child (node, "activity", NULL);
lm_message_node_set_attribute (node, "xmlns", NS_ACTIVITY);
if (major) {
LmMessageNode *mnode = lm_message_node_add_child (node, major, NULL);
if (minor)
lm_message_node_add_child (mnode, minor, NULL);
}
if (text)
lm_message_node_add_child (node, "text", text);
{ // send
GError *error = NULL;
lm_connection_send_with_reply (lconnection, request, activity_reply_handler, &error);
if (error) {
scr_log_print (LPRINT_DEBUG, "activity: Publish failed: %s.", error -> message);
g_error_free (error);
}
}
lm_message_unref (request);
}
gboolean activity_request ( const gchar *to, GError **err )
{
LmMessage *request;
LmMessageNode *node;
if ( ! xmpp_is_online () ) {
g_set_error ( err, activity_gerror_quark, ACTIVITY_ERROR_NOTCONNECTED, "You are not connected" );
return FALSE;
}
request = lm_message_new_with_sub_type (to, LM_MESSAGE_TYPE_IQ, LM_MESSAGE_SUB_TYPE_GET);
node = lm_message_get_node (request);
lm_message_node_set_attribute (node, "from", lm_connection_get_jid (lconnection));
node = lm_message_node_add_child (node, "pubsub", NULL);
lm_message_node_set_attribute (node, "xmlns", NS_PUBSUB);
node = lm_message_node_add_child (node, "items", NULL);
lm_message_node_set_attribute (node, "node", NS_ACTIVITY);
{ // send, result will be handled by pep
GError *error = NULL;
lm_connection_send (lconnection, request, &error);
if (error) {
g_propagate_error ( err, error );
return FALSE;
}
}
lm_message_unref (request);
return TRUE;
}
static void activity_handler ( const gchar *from, const gchar *enode, LmMessageNode *n, const gchar *id, gpointer ignore )
{
LmMessageNode *node;
hk_arg_t args[] = {
{ "major", NULL },
{ "minor", NULL },
{ "text", NULL },
{ "from", from },
{ NULL, NULL },
};
for ( node = n -> children; node; node = node -> next ) {
const gchar *name = node -> name;
if ( ! strcmp ( name, "text" ) )
args[2].value = lm_message_node_get_value ( node );
else {
LmMessageNode *mnode = node -> children;
if ( mnode ) // XXX check for xmlns presence?
args[1].value = mnode -> name;
args[0].value = name;
}
}
hk_run_handlers ( HOOK_ACTIVITY_IN, args );
}
static guint activity_hch ( const gchar *hid, hk_arg_t *args, gpointer userdata )
{
if (activity_delayed) {
gchar *tmp_major = activity_major;
gchar *tmp_minor = activity_minor;
gchar *tmp_text = activity_text;
activity_delayed = FALSE;
activity_major = activity_minor = activity_text = NULL;
activity_publish (tmp_major, tmp_minor, tmp_text);
g_free (tmp_major);
g_free (tmp_minor);
g_free (tmp_text);
}
return HOOK_HANDLER_RESULT_ALLOW_MORE_HANDLERS;
}
static guint activity_hdh ( const gchar *hid, hk_arg_t *args, gpointer userdata )
{
#ifdef HAVE_LM_CONNECTION_UNREGISTER_REPLY_HANDLER
if ( lconnection && activity_reply_handler )
lm_connection_unregister_reply_handler ( lconnection, activity_reply_handler );
#endif
return HOOK_HANDLER_RESULT_ALLOW_MORE_HANDLERS;
}
static guint activity_haoh ( const gchar *hid, hk_arg_t *args, gpointer userdata )
{
const gchar *minor = NULL;
const gchar *major = NULL;
const gchar *text = NULL;
{
hk_arg_t *arg;
for ( arg = args; arg -> name; arg ++ ) {
const gchar *value = arg -> value;
if ( value ) {
const gchar *name = arg -> name;
if ( ! strcmp ( name, "major" ) )
major = value;
else if ( ! strcmp ( name, "minor" ) )
minor = value;
else if ( !strcmp ( name, "text" ) )
text = value;
}
}
}
activity_publish ( major, minor, text );
return HOOK_HANDLER_RESULT_ALLOW_MORE_HANDLERS;
}
void pep_activity_init (void)
{
activity_gerror_quark = g_quark_from_string ( "pep-activity-gerror-quark" );
activity_reply_handler = lm_message_handler_new (activity_publish_reply_handler, NULL, NULL);
pep_register_xmlns_handler (NS_ACTIVITY, activity_handler, NULL, NULL);
activity_hid_connect = hk_add_handler (activity_hch, HOOK_POST_CONNECT, G_PRIORITY_DEFAULT, NULL);
activity_hid_disconnect = hk_add_handler (activity_hdh, HOOK_PRE_DISCONNECT, G_PRIORITY_DEFAULT, NULL);
activity_hid_activityout = hk_add_handler (activity_haoh, HOOK_ACTIVITY_OUT, G_PRIORITY_DEFAULT, NULL);
xmpp_add_feature ( NS_ACTIVITY );
xmpp_add_feature ( NS_ACTIVITY_NOTIFY );
}
void pep_activity_uninit (void)
{
xmpp_del_feature ( NS_ACTIVITY );
xmpp_del_feature ( NS_ACTIVITY_NOTIFY );
hk_del_handler ( HOOK_POST_CONNECT, activity_hid_connect );
hk_del_handler ( HOOK_PRE_DISCONNECT, activity_hid_disconnect );
hk_del_handler ( HOOK_ACTIVITY_OUT, activity_hid_activityout );
pep_unregister_xmlns_handler ( NS_ACTIVITY );
#ifdef HAVE_LM_CONNECTION_UNREGISTER_REPLY_HANDLER
if (lconnection)
lm_connection_unregister_reply_handler (lconnection, activity_reply_handler);
#endif
lm_message_handler_invalidate (activity_reply_handler);
lm_message_handler_unref (activity_reply_handler);
g_free (activity_major);
g_free (activity_minor);
g_free (activity_text);
}
/* vim: se ts=4 sw=4: */