Merge lp:~ken-vandine/indicator-me/libgwibber-port into lp:indicator-me

[Ken VanDine]

Port to libgwibber

[David Barth (dbarth)]

Sounds good to me and works well on my test build. There are a few changes required though:

Line 343: the test for priv->send_enabled should probably be removed, ie toggling the boolean to true on each loop iteration; what matters is the end result

Line 350: the STATUS_RUNNING flag should be set in all cases, as a reply from gwibber implies that it is available for sending messages; the state name is a bit misleading though, it should be more about gwibber being "available" as a gateway service, but I chose running to make the distinction with the "availability" status of other online/chat services

Line 545: not sure about the void if (!exists), i don't think there is anything particular to do in this case either

Line 625: has_configured_accounts should return a positive value even if the service is temporarily down, ie a send would restart it anyway; i found it difficult to understand as a user that the entry is "sometimes" not there, for no apparent reason; it's better to have it always there, whatever the state of the service; the visibility criteria is only that gwibber is "configured".

review: Needs Fixing

[lp:~ken-vandine/indicator-me/libgwibber-port]

102. By Ken VanDine on 2010-08-17

remove a noop

103. By Ken VanDine on 2010-08-17

Don't set status to NOT_RUNNING if we get a response from gwibber

104. By Ken VanDine on 2010-08-17

Don't set status based on configured accounts

[Ken VanDine (ken-vandine)]

OK, I think I addressed all of those. It will no longer hide the entry if the service shuts down, but it does hide if you disable all the accounts.

review: Resubmit

[lp:~ken-vandine/indicator-me/libgwibber-port]

105. By Ken VanDine on 2010-08-17

check for send_enabled even if configured_accounts was TRUE before

[David Barth (dbarth)]

Thanks for the branch, I appreciate your help

review: Approve

=== modified file 'configure.ac'
--- configure.ac	2010-03-24 09:42:26 +0000
+++ configure.ac	2010-08-17 14:44:43 +0000
@@ -28,6 +28,7 @@
 
 GTK_REQUIRED_VERSION=2.12
 INDICATOR_REQUIRED_VERSION=0.3.0
+GWIBBER_REQUIRED_VERSION=0.0.4
 DBUSMENUGTK_REQUIRED_VERSION=0.2.2
 DBUSMENUGLIB_REQUIRED_VERSION=0.2.2
 TELEPATHYGLIB_REQUIRED_VERSION=0.9.0
@@ -41,6 +42,7 @@
 PKG_CHECK_MODULES(MESERVICE,     dbusmenu-glib >= $DBUSMENUGLIB_REQUIRED_VERSION
 				 gconf-2.0 >= $GCONF_REQUIRED_VERSION
                                  indicator >= $INDICATOR_REQUIRED_VERSION
+                                 gwibber >= $GWIBBER_REQUIRED_VERSION
                                  telepathy-glib >= $TELEPATHYGLIB_REQUIRED_VERSION)
 
 ###########################

=== modified file 'src/entry-menu-item.c'
--- src/entry-menu-item.c	2010-03-17 16:19:44 +0000
+++ src/entry-menu-item.c	2010-08-17 14:44:43 +0000
@@ -128,8 +128,8 @@
 
 	g_debug ("handle_event");
 	if (g_strcmp0 (name, "send") == 0) {
-		GwibberService *gwibber = gwibber_service_get ();
-		gwibber_service_send (gwibber, g_value_get_string (value));
+		MeGwibberService *me_gwibber_service = me_gwibber_service_get ();
+		me_gwibber_service_send (me_gwibber_service, g_value_get_string (value));
 		dbusmenu_menuitem_property_set (mi, ENTRY_MENUITEM_PROP_TEXT, "");
 	}
 

=== modified file 'src/me-service-gwibber.c'
--- src/me-service-gwibber.c	2010-03-24 09:38:22 +0000
+++ src/me-service-gwibber.c	2010-08-17 14:44:43 +0000
@@ -24,23 +24,14 @@
 
 #include <glib.h>
 
-#include <dbus/dbus-glib.h>
-#include <dbus/dbus-glib-bindings.h>
-
-#define DBUS_SERVICE_ADDRESS            "com.Gwibber.Service"
-#define DBUS_SERVICE_SERVICE_OBJECT     "/com/gwibber/Service"
-#define DBUS_SERVICE_SERVICE_INTERFACE  "com.Gwibber.Service"
-
-#define DBUS_SERVICE_ACCOUNTS_OBJECT    "/com/gwibber/Accounts"
-#define DBUS_SERVICE_ACCOUNTS_INTERFACE "com.Gwibber.Accounts"
+#include <gwibber.h>
 
 /* gobject infrastructure */
 
-typedef struct _GwibberServicePrivate GwibberServicePrivate;
-struct _GwibberServicePrivate {
-	DBusGProxy * dbus_proxy;
-	DBusGProxy * service_proxy;
-	DBusGProxy * accounts_proxy;
+typedef struct _MeGwibberServicePrivate MeGwibberServicePrivate;
+struct _MeGwibberServicePrivate {
+	GwibberService * me_gwibber_service;
+	GwibberAccounts * me_gwibber_accounts;
 	int status;
 	gboolean has_configured_accounts;
 };
@@ -54,35 +45,35 @@
 static guint signals[LAST_SIGNAL] = { 0 };
 
 /* Prototypes */
-static void gwibber_service_class_init (GwibberServiceClass *klass);
-static void gwibber_service_init       (GwibberService *self);
-static void gwibber_service_dispose    (GObject *object);
-static void gwibber_service_finalize   (GObject *object);
-
-static void dbus_namechange (DBusGProxy * proxy, const gchar * name, const gchar * prev, const gchar * new, GwibberService * self);
-static void gwibber_exists_cb (DBusGProxy * proxy, gboolean exists, GError * error, gpointer userdata);
-static void setup_service_proxies (GwibberService *self);
-static void query_account_manager (GwibberService *self);
-
-G_DEFINE_TYPE (GwibberService, gwibber_service, G_TYPE_OBJECT);
-
-#define GWIBBER_SERVICE_GET_PRIVATE(o) \
-(G_TYPE_INSTANCE_GET_PRIVATE ((o), GWIBBER_SERVICE_TYPE, GwibberServicePrivate))
+static void me_gwibber_service_class_init (MeGwibberServiceClass *klass);
+static void me_gwibber_service_init       (MeGwibberService *self);
+static void me_gwibber_service_dispose    (GObject *object);
+static void me_gwibber_service_finalize   (GObject *object);
+
+static void me_gwibber_service_exists_cb (GwibberService * me_gwibber_service, gboolean exists, gpointer userdata);
+static void me_gwibber_accounts_exists_cb (GwibberAccounts * me_gwibber_accounts, gboolean exists, gpointer userdata);
+static void setup_service_proxies (MeGwibberService *self);
+static void query_account_manager (MeGwibberService *self);
+
+G_DEFINE_TYPE (MeGwibberService, me_gwibber_service, G_TYPE_OBJECT);
+
+#define ME_GWIBBER_SERVICE_GET_PRIVATE(o) \
+(G_TYPE_INSTANCE_GET_PRIVATE ((o), ME_GWIBBER_SERVICE_TYPE, MeGwibberServicePrivate))
 
 static void
-gwibber_service_class_init (GwibberServiceClass *klass)
+me_gwibber_service_class_init (MeGwibberServiceClass *klass)
 {
 	GObjectClass *object_class = G_OBJECT_CLASS (klass);
 
-	g_type_class_add_private (klass, sizeof (GwibberServicePrivate));
-
-	object_class->dispose = gwibber_service_dispose;
-	object_class->finalize = gwibber_service_finalize;
-
-	signals[STATUS_CHANGED]  = g_signal_new(GWIBBER_SERVICE_SIGNAL_STATUS_CHANGED,
+	g_type_class_add_private (klass, sizeof (MeGwibberServicePrivate));
+
+	object_class->dispose = me_gwibber_service_dispose;
+	object_class->finalize = me_gwibber_service_finalize;
+
+	signals[STATUS_CHANGED]  = g_signal_new(ME_GWIBBER_SERVICE_SIGNAL_STATUS_CHANGED,
 											G_TYPE_FROM_CLASS(klass),
 											G_SIGNAL_RUN_LAST,
-											G_STRUCT_OFFSET(GwibberServiceClass, status_changed),
+											G_STRUCT_OFFSET(MeGwibberServiceClass, status_changed),
 											NULL, NULL,
 											g_cclosure_marshal_VOID__UINT,
 											G_TYPE_NONE, 1, G_TYPE_UINT);
@@ -90,316 +81,222 @@
 }
 
 static void
-gwibber_service_init (GwibberService *self)
-{
-	GwibberServicePrivate * priv = GWIBBER_SERVICE_GET_PRIVATE(self);
-
-	priv->dbus_proxy = NULL;
-	priv->service_proxy = NULL;
-	priv->accounts_proxy = NULL;
-	priv->status = GWIBBER_SERVICE_STATUS_NOT_RUNNING;
-	priv->has_configured_accounts = FALSE;
-
-	DBusGConnection * bus = dbus_g_bus_get(DBUS_BUS_SESSION, NULL);
-	g_return_if_fail(bus != NULL); /* Can't do anymore DBus stuff without this,
-	                                  all non-DBus stuff should be done */
-
-	GError * error = NULL;
-
-	/* Set up the dbus Proxy */
-	priv->dbus_proxy = dbus_g_proxy_new_for_name_owner (bus,
-	                                                    DBUS_SERVICE_DBUS,
-	                                                    DBUS_PATH_DBUS,
-	                                                    DBUS_INTERFACE_DBUS,
-	                                                    &error);
-	if (error != NULL) {
-		g_warning("Unable to connect to DBus events: %s", error->message);
-		g_error_free(error);
-		return;
-	}
-
-	/* Configure the name owner changing */
-	dbus_g_proxy_add_signal(priv->dbus_proxy, "NameOwnerChanged",
-	                        G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
-							G_TYPE_INVALID);
-	dbus_g_proxy_connect_signal(priv->dbus_proxy, "NameOwnerChanged",
-	                        G_CALLBACK(dbus_namechange),
-	                        self, NULL);
-
-	org_freedesktop_DBus_name_has_owner_async(priv->dbus_proxy, DBUS_SERVICE_ADDRESS, gwibber_exists_cb, self);
-
-	return;
-}
-
-static void
-gwibber_service_dispose (GObject *object)
-{
-	GwibberServicePrivate * priv = GWIBBER_SERVICE_GET_PRIVATE(object);
-
-	if (priv->dbus_proxy != NULL) {
-		g_object_unref(priv->dbus_proxy);
-		priv->dbus_proxy = NULL;
-	}
-
-	if (priv->service_proxy != NULL) {
-		g_object_unref(priv->service_proxy);
-		priv->service_proxy = NULL;
-	}
-
-	if (priv->accounts_proxy != NULL) {
-		g_object_unref(priv->accounts_proxy);
-		priv->accounts_proxy = NULL;
-	}
-
-	G_OBJECT_CLASS (gwibber_service_parent_class)->dispose (object);
-	return;
-}
-
-static void
-gwibber_service_finalize (GObject *object)
-{
-	G_OBJECT_CLASS (gwibber_service_parent_class)->finalize (object);
-	return;
-}
-
-
-/* Watch for Gwibber coming on and off the bus. */
-static void
-dbus_namechange (DBusGProxy * proxy, const gchar * name, const gchar * prev, const gchar * new, GwibberService * self)
-{
-	g_return_if_fail (IS_GWIBBER_SERVICE (self));
-
-	GwibberServicePrivate * priv = GWIBBER_SERVICE_GET_PRIVATE(self);
-
-	if (prev[0] == '\0' && g_strcmp0(name, DBUS_SERVICE_ADDRESS) == 0) {
-		g_debug("Gwibber Service coming online");
-		priv->status = GWIBBER_SERVICE_STATUS_RUNNING;
-		if (priv->service_proxy == NULL ||
-			priv->accounts_proxy == NULL)
-			setup_service_proxies (self);
-		query_account_manager (self);
-	}
-
-	if (new[0] == '\0' && g_strcmp0(name, DBUS_SERVICE_ADDRESS) == 0) {
-		g_debug("Gwibber Service going offline");
-		priv->status = GWIBBER_SERVICE_STATUS_NOT_RUNNING;
-		g_signal_emit (G_OBJECT (self), GWIBBER_SERVICE_SIGNAL_STATUS_CHANGED_ID, 0, priv->status, TRUE);
-		if (priv->service_proxy != NULL) {
-			g_object_unref(priv->service_proxy);
-			priv->service_proxy = NULL;
-		}
-		if (priv->accounts_proxy != NULL) {
-			g_object_unref(priv->accounts_proxy);
-			priv->accounts_proxy = NULL;
-		}
-	}
-
-	return;
-}
-
-static void
-get_accounts_response (DBusGProxy * proxy, DBusGProxyCall * call, gpointer data)
-{
-	GError *error = NULL;
-	gchar  *accounts_string = NULL;
-
-	dbus_g_proxy_end_call (proxy, call, &error,
-						   G_TYPE_STRING, &accounts_string,
-						   G_TYPE_INVALID);
-
-	if (error != NULL) {
-		g_warning ("GetAccounts: %s", error->message);
-		g_error_free (error);
-		g_free (accounts_string);
-		return;
-	}
-
-	/* don't print the accounts string, it contains passwords */
-	/* g_debug ("GetAccounts: %s", accounts_string); */
-
-	g_return_if_fail (IS_GWIBBER_SERVICE (data));
-	GwibberServicePrivate * priv = GWIBBER_SERVICE_GET_PRIVATE(data);
-	g_return_if_fail (priv != NULL);
-	/* Note: not free'ing accounts_string here, but g_return_if_fail are
-	   meant to catch design errors, not runtime ones */
-
-	priv->status = GWIBBER_SERVICE_STATUS_RUNNING;
-	priv->has_configured_accounts = g_strrstr (accounts_string, " \"send_enabled\": true,") ? TRUE : FALSE;
-
-	/* trigger a status update */
-	g_signal_emit (G_OBJECT (data),
-				   GWIBBER_SERVICE_SIGNAL_STATUS_CHANGED_ID,
+me_gwibber_service_init (MeGwibberService *self)
+{
+	MeGwibberServicePrivate * priv = ME_GWIBBER_SERVICE_GET_PRIVATE(self);
+
+	priv->me_gwibber_service = NULL;
+	priv->me_gwibber_accounts = NULL;
+	priv->status = ME_GWIBBER_SERVICE_STATUS_NOT_RUNNING;
+	priv->has_configured_accounts = FALSE;
+
+	setup_service_proxies(self);
+	return;
+}
+
+static void
+me_gwibber_service_dispose (GObject *object)
+{
+	MeGwibberServicePrivate * priv = ME_GWIBBER_SERVICE_GET_PRIVATE(object);
+
+	if (priv->me_gwibber_service != NULL) {
+		g_object_unref(priv->me_gwibber_service);
+		priv->me_gwibber_service = NULL;
+	}
+
+	if (priv->me_gwibber_accounts != NULL) {
+		g_object_unref(priv->me_gwibber_accounts);
+		priv->me_gwibber_accounts = NULL;
+	}
+
+	G_OBJECT_CLASS (me_gwibber_service_parent_class)->dispose (object);
+	return;
+}
+
+static void
+me_gwibber_service_finalize (GObject *object)
+{
+	G_OBJECT_CLASS (me_gwibber_service_parent_class)->finalize (object);
+	return;
+}
+
+static gboolean
+check_account_send_enabled (GHashTable * account_table) {
+        return g_value_get_boolean(g_hash_table_lookup(account_table, "send_enabled"));
+}
+
+static void
+query_account_manager (MeGwibberService *self)
+{
+	g_return_if_fail (IS_ME_GWIBBER_SERVICE (self));
+
+	gpointer accounts_table;
+	gpointer account_table;
+	GHashTableIter accounts_iter;
+	gpointer account;
+	gboolean send_enabled;
+
+	MeGwibberServicePrivate * priv = ME_GWIBBER_SERVICE_GET_PRIVATE(self);
+
+	if (priv->me_gwibber_accounts == NULL) {
+		g_warning ("no accounts, can't query for accounts");
+		return;
+	}
+	
+        accounts_table = gwibber_accounts_list (priv->me_gwibber_accounts);
+        if (accounts_table == NULL) {
+                g_warning ("failed to get accounts list");
+                return;
+        }
+
+	g_hash_table_iter_init (&accounts_iter, accounts_table);
+
+	priv->has_configured_accounts = FALSE;
+
+	while (g_hash_table_iter_next (&accounts_iter, &account, &account_table)) {
+		send_enabled = check_account_send_enabled (account_table);
+		if (send_enabled) {
+			priv->has_configured_accounts = TRUE;
+		}
+	}
+
+	g_signal_emit (G_OBJECT (self),
+				   ME_GWIBBER_SERVICE_SIGNAL_STATUS_CHANGED_ID,
 				   0, priv->status, TRUE);
 
-	g_free (accounts_string);
-
+	g_hash_table_destroy(accounts_table);
 	return;
 }
 
 static void
-query_account_manager (GwibberService *self)
-{
-	g_return_if_fail (IS_GWIBBER_SERVICE (self));
-
-	GwibberServicePrivate * priv = GWIBBER_SERVICE_GET_PRIVATE(self);
-
-	if (priv->service_proxy == NULL) {
-		g_warning ("no service_proxy, can't query for accounts");
-		return;
-	}
-
-	dbus_g_proxy_begin_call(priv->service_proxy,
-	                        "GetAccounts",
-	                        get_accounts_response,
-	                        self,
-	                        NULL,
-							G_TYPE_INVALID);
-}
-
-static void
-accounts_changed (DBusGProxy *proxy, const gchar *id, GwibberService *self)
-{
-	g_return_if_fail (IS_GWIBBER_SERVICE (self));
-
-	g_debug ("accounts_changed");
+accounts_changed (GwibberAccounts *me_gwibber_accounts, GHashTable *account_table, MeGwibberService *self)
+{
+	g_return_if_fail (IS_ME_GWIBBER_SERVICE (self));
 
 	query_account_manager (self);
 
 	return;
 }
 
-static void
-setup_service_proxies (GwibberService *self)
-{
-	g_return_if_fail (IS_GWIBBER_SERVICE (self));
-
-	GwibberServicePrivate * priv = GWIBBER_SERVICE_GET_PRIVATE(self);
-
-	DBusGConnection * bus = dbus_g_bus_get(DBUS_BUS_SESSION, NULL);
-	g_return_if_fail(bus != NULL); /* Can't do anymore DBus stuff without this,
-	                                  all non-DBus stuff should be done */
-
-	if (priv->service_proxy == NULL) {
-		priv->service_proxy = dbus_g_proxy_new_for_name(
-			bus,
-			DBUS_SERVICE_ADDRESS,
-			DBUS_SERVICE_SERVICE_OBJECT,
-			DBUS_SERVICE_SERVICE_INTERFACE);
-		if (priv->service_proxy == NULL) {
-			g_warning ("can't setup service_proxy");
-			return;
-		}
-	}
-
-	if (priv->accounts_proxy == NULL) {
-		priv->accounts_proxy =
-			dbus_g_proxy_new_for_name(bus,
-									  DBUS_SERVICE_ADDRESS,
-									  DBUS_SERVICE_ACCOUNTS_OBJECT,
-									  DBUS_SERVICE_ACCOUNTS_INTERFACE);
-		if (priv->accounts_proxy == NULL) {
-			g_warning ("can't setup accounts_proxy");
-			return;
-		}
-	}
-
-	/* Monitor signals about account changes */
-	dbus_g_proxy_add_signal(priv->accounts_proxy, "AccountChanged",
-	                        G_TYPE_STRING,
-							G_TYPE_INVALID);
-	dbus_g_proxy_connect_signal(priv->accounts_proxy, "AccountChanged",
-	                        G_CALLBACK(accounts_changed),
-	                        self, NULL);
-	dbus_g_proxy_add_signal(priv->accounts_proxy, "AccountDeleted",
-	                        G_TYPE_STRING,
-							G_TYPE_INVALID);
-	dbus_g_proxy_connect_signal(priv->accounts_proxy, "AccountDeleted",
-	                        G_CALLBACK(accounts_changed),
-	                        self, NULL);
-
-}
-
-static void
-gwibber_exists_cb (DBusGProxy * proxy, gboolean exists, GError * error, gpointer userdata)
-{
-	if (error) {
-		g_warning ("Unable to check if Gwibber is running: %s", error->message);
-		return;
-	}
-
-	if (exists) {
-		setup_service_proxies (GWIBBER_SERVICE (userdata));
-		query_account_manager (GWIBBER_SERVICE (userdata));
-	}
-
-	return;
-}
-
-GwibberService * gwibber_service_new (void){
-	return GWIBBER_SERVICE (g_object_new (GWIBBER_SERVICE_TYPE, NULL));
-}
-
-static void
-send_message_response (DBusGProxy * proxy, DBusGProxyCall * call, gpointer data)
-{
-	g_debug ("send_message_response");
-
-	return;
+
+static void
+setup_service_proxies (MeGwibberService *self)
+{
+	g_return_if_fail (IS_ME_GWIBBER_SERVICE (self));
+
+	MeGwibberServicePrivate * priv = ME_GWIBBER_SERVICE_GET_PRIVATE(self);
+
+	if (priv->me_gwibber_service == NULL) {
+		priv->me_gwibber_service = gwibber_service_new ();
+		if (priv->me_gwibber_service == NULL) {
+			g_warning ("can't setup me_gwibber_service");
+			return;
+		}
+	}
+
+	g_signal_connect (priv->me_gwibber_service, "is-available", 
+				G_CALLBACK(me_gwibber_service_exists_cb), ME_GWIBBER_SERVICE (self));
+
+	if (priv->me_gwibber_accounts == NULL) {
+		priv->me_gwibber_accounts = gwibber_accounts_new ();;
+		if (priv->me_gwibber_accounts == NULL) {
+			g_warning ("can't setup me_gwibber_accounts");
+			return;
+		}
+	}
+
+	g_signal_connect (priv->me_gwibber_accounts, "is-available", 
+				G_CALLBACK(me_gwibber_accounts_exists_cb), ME_GWIBBER_SERVICE (self));
+}
+
+static void
+me_gwibber_service_exists_cb (GwibberService * me_gwibber_service, gboolean exists, gpointer userdata)
+{
+	MeGwibberServicePrivate * priv = ME_GWIBBER_SERVICE_GET_PRIVATE(ME_GWIBBER_SERVICE (userdata));
+
+	if (exists) {
+		priv->status = ME_GWIBBER_SERVICE_STATUS_RUNNING;
+	}
+
+
+	if (!exists) {
+		priv->status = ME_GWIBBER_SERVICE_STATUS_NOT_RUNNING;
+		g_signal_emit (G_OBJECT (ME_GWIBBER_SERVICE (userdata)), ME_GWIBBER_SERVICE_SIGNAL_STATUS_CHANGED_ID, 0, priv->status, TRUE);
+	}
+	return;
+}
+
+static void
+me_gwibber_accounts_exists_cb (GwibberAccounts * me_gwibber_accounts, gboolean exists, gpointer userdata)
+{
+	MeGwibberServicePrivate * priv = ME_GWIBBER_SERVICE_GET_PRIVATE(ME_GWIBBER_SERVICE (userdata));
+
+	if (exists) {
+		if (priv->me_gwibber_accounts == NULL) {
+			priv->me_gwibber_accounts = gwibber_accounts_new ();;
+			if (priv->me_gwibber_accounts == NULL) {
+				g_warning ("can't setup me_gwibber_accounts");
+				return;
+			}
+		}
+
+		query_account_manager (ME_GWIBBER_SERVICE (userdata));
+		g_signal_emit (G_OBJECT (ME_GWIBBER_SERVICE (userdata)), ME_GWIBBER_SERVICE_SIGNAL_STATUS_CHANGED_ID, 0, priv->status, TRUE);
+		g_signal_connect (priv->me_gwibber_accounts, "account-updated",
+				G_CALLBACK(accounts_changed), ME_GWIBBER_SERVICE (userdata));
+	}
+	return;
+}
+		
+
+MeGwibberService * me_gwibber_service_new (void){
+	return ME_GWIBBER_SERVICE (g_object_new (ME_GWIBBER_SERVICE_TYPE, NULL));
 }
 
 void
-gwibber_service_send (GwibberService *self, const gchar *msg)
+me_gwibber_service_send (MeGwibberService *self, const gchar *msg)
 {
-	g_return_if_fail (IS_GWIBBER_SERVICE (self));
+	g_return_if_fail (IS_ME_GWIBBER_SERVICE (self));
 
-	GwibberServicePrivate * priv = GWIBBER_SERVICE_GET_PRIVATE(self);
+	MeGwibberServicePrivate * priv = ME_GWIBBER_SERVICE_GET_PRIVATE(self);
 
 	GValue value = {0};
 	g_value_init(&value, G_TYPE_STRING);
 	g_value_set_string(&value, msg);
 
-	g_debug ("gwibber_send: %s\n", msg);
-
-	if (priv->service_proxy == NULL) {
+	if (priv->me_gwibber_service == NULL) {
 		setup_service_proxies (self);
-		if (priv->service_proxy == NULL) {
-			g_warning ("can't setup service_proxy");
+		if (priv->me_gwibber_service == NULL) {
+			g_warning ("can't setup me_gwibber_service");
 			return;
 		}
 	}
 
-	dbus_g_proxy_begin_call(priv->service_proxy,
-	                        "SendMessage",
-	                        send_message_response,
-	                        NULL,
-	                        NULL,
-	                        G_TYPE_VALUE,
-							&value,
-							G_TYPE_INVALID);
+	gwibber_service_send_message (priv->me_gwibber_service, g_value_get_string (&value));
 
 	g_value_unset(&value);
 
 	return;
 }
 
-GwibberService *
-gwibber_service_get (void)
+MeGwibberService *
+me_gwibber_service_get (void)
 {
-  static GwibberService *singleton = NULL;
+  static MeGwibberService *singleton = NULL;
 
   if (! singleton) {
-	  singleton = gwibber_service_new ();
+	  singleton = me_gwibber_service_new ();
   }	
 
   return singleton;
 }
 
 gboolean
-gwibber_service_has_configured_accounts (GwibberService *self)
+me_gwibber_service_has_configured_accounts (MeGwibberService *self)
 {
-	g_return_val_if_fail (IS_GWIBBER_SERVICE (self), FALSE);
+	g_return_val_if_fail (IS_ME_GWIBBER_SERVICE (self), FALSE);
 
-	GwibberServicePrivate * priv = GWIBBER_SERVICE_GET_PRIVATE(self);
+	MeGwibberServicePrivate * priv = ME_GWIBBER_SERVICE_GET_PRIVATE(self);
 
 	return priv->has_configured_accounts;
 }

=== modified file 'src/me-service-gwibber.h'
--- src/me-service-gwibber.h	2010-03-17 16:19:44 +0000
+++ src/me-service-gwibber.h	2010-08-17 14:44:43 +0000
@@ -20,57 +20,56 @@
 with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#ifndef __GWIBBER_SERVICE_H__
-#define __GWIBBER_SERVICE_H__
+#ifndef __ME_GWIBBER_SERVICE_H__
+#define __ME_GWIBBER_SERVICE_H__
 
 #include <glib.h>
 #include <glib-object.h>
 
+#include <gwibber.h>
+
 G_BEGIN_DECLS
 
-#define GWIBBER_SERVICE_TYPE            (gwibber_service_get_type ())
-#define GWIBBER_SERVICE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GWIBBER_SERVICE_TYPE, GwibberService))
-#define GWIBBER_SERVICE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GWIBBER_SERVICE_TYPE, GwibberServiceClass))
-#define IS_GWIBBER_SERVICE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GWIBBER_SERVICE_TYPE))
-#define IS_GWIBBER_SERVICE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GWIBBER_SERVICE_TYPE))
-#define GWIBBER_SERVICE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GWIBBER_SERVICE_TYPE, GwibberServiceClass))
+#define ME_GWIBBER_SERVICE_TYPE            (me_gwibber_service_get_type ())
+#define ME_GWIBBER_SERVICE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), ME_GWIBBER_SERVICE_TYPE, MeGwibberService))
+#define ME_GWIBBER_SERVICE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), ME_GWIBBER_SERVICE_TYPE, MeGwibberServiceClass))
+#define IS_ME_GWIBBER_SERVICE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ME_GWIBBER_SERVICE_TYPE))
+#define IS_ME_GWIBBER_SERVICE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), ME_GWIBBER_SERVICE_TYPE))
+#define ME_GWIBBER_SERVICE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), ME_GWIBBER_SERVICE_TYPE, MeGwibberServiceClass))
 
 typedef enum
 {
-	GWIBBER_SERVICE_STATUS_NOT_RUNNING,
-	/* GWIBBER_SERVICE_STATUS_LOADING_STARTED,
-	GWIBBER_SERVICE_STATUS_LOADING_COMPLETE, */
-	GWIBBER_SERVICE_STATUS_RUNNING,
-	GWIBBER_SERVICE_STATUS_LAST
+	ME_GWIBBER_SERVICE_STATUS_NOT_RUNNING,
+	/* ME_GWIBBER_SERVICE_STATUS_LOADING_STARTED,
+	ME_GWIBBER_SERVICE_STATUS_LOADING_COMPLETE, */
+	ME_GWIBBER_SERVICE_STATUS_RUNNING,
+	ME_GWIBBER_SERVICE_STATUS_LAST
 }
-GwibberServiceStatus;
-
-#define GWIBBER_SERVICE_SIGNAL_STATUS_CHANGED     "status-changed"
-#define GWIBBER_SERVICE_SIGNAL_STATUS_CHANGED_ID  (g_signal_lookup(GWIBBER_SERVICE_SIGNAL_STATUS_CHANGED, GWIBBER_SERVICE_TYPE))
-
-typedef struct _GwibberServiceClass GwibberServiceClass;
-struct _GwibberServiceClass {
+MeGwibberServiceStatus;
+
+#define ME_GWIBBER_SERVICE_SIGNAL_STATUS_CHANGED     "status-changed"
+#define ME_GWIBBER_SERVICE_SIGNAL_STATUS_CHANGED_ID  (g_signal_lookup(ME_GWIBBER_SERVICE_SIGNAL_STATUS_CHANGED, ME_GWIBBER_SERVICE_TYPE))
+
+typedef struct _MeGwibberServiceClass MeGwibberServiceClass;
+struct _MeGwibberServiceClass {
 	GObjectClass parent_class;
 
 	/* Signals */
-	void (*status_changed) (GwibberServiceStatus newstatus);
+	void (*status_changed) (MeGwibberServiceStatus newstatus);
 };
 
-typedef struct _GwibberService      GwibberService;
-struct _GwibberService {
+typedef struct _MeGwibberService      MeGwibberService;
+struct _MeGwibberService {
 	GObject parent;
 };
 
-GType gwibber_service_get_type (void) G_GNUC_CONST;
-GwibberService * gwibber_service_new (void);
-GwibberService * gwibber_service_get (void);
-void gwibber_service_send (GwibberService *self, const gchar *msg);
-gboolean gwibber_service_has_configured_accounts (GwibberService *self);
-
-/* old API */
-void gwibber_send (const gchar *msg);
+GType me_gwibber_service_get_type (void) G_GNUC_CONST;
+MeGwibberService * me_gwibber_service_new (void);
+MeGwibberService * me_gwibber_service_get (void);
+void me_gwibber_service_send (MeGwibberService *self, const gchar *msg);
+gboolean me_gwibber_service_has_configured_accounts (MeGwibberService *self);
 
 G_END_DECLS
 
-#endif /* __GWIBBER_SERVICE_H__ */
+#endif /* __ME_GWIBBER_SERVICE_H__ */
 

=== modified file 'src/me-service.c'
--- src/me-service.c	2010-03-25 20:25:31 +0000
+++ src/me-service.c	2010-08-17 14:44:43 +0000
@@ -81,7 +81,7 @@
   /* STATUS_PROVIDER_STATUS_DISCONNECTED */"user-offline"
 };
 
-static GwibberService * gwibber = NULL;
+static MeGwibberService * me_gwibber_service = NULL;
 
 static DbusmenuMenuitem * root_menuitem = NULL;
 static DbusmenuMenuitem * status_menuitems[STATUS_PROVIDER_STATUS_LAST] = {0};
@@ -170,7 +170,7 @@
 }
 
 static void
-gwibber_status_update (GwibberService *instance, GwibberServiceStatus status, gpointer data) {
+me_gwibber_status_update (MeGwibberService *instance, MeGwibberServiceStatus status, gpointer data) {
   g_return_if_fail (instance != NULL);
 
   g_debug ("gwibber service status changed to: %d", status);
@@ -180,7 +180,7 @@
     return;
   }
 
-  if (! gwibber_service_has_configured_accounts (instance)) {
+  if (! me_gwibber_service_has_configured_accounts (instance)) {
     g_debug ("no configured accounts detected, so hiding the broadcast field");
     dbusmenu_menuitem_property_set_bool (broadcast_field, DBUSMENU_MENUITEM_PROP_VISIBLE, FALSE);
     return;
@@ -189,16 +189,6 @@
   if (! dbusmenu_menuitem_property_get_bool (broadcast_field, DBUSMENU_MENUITEM_PROP_VISIBLE))
     dbusmenu_menuitem_property_set_bool (broadcast_field, DBUSMENU_MENUITEM_PROP_VISIBLE, TRUE);
 
-#if 0
-  if (status == GWIBBER_SERVICE_STATUS_RUNNING) {
-    g_debug ("enabling the broadcast field");
-    dbusmenu_menuitem_property_set_bool (broadcast_field, DBUSMENU_MENUITEM_PROP_ENABLED, TRUE);
-  } else {
-    g_debug ("disabling the broadcast field");
-    dbusmenu_menuitem_property_set_bool (broadcast_field, DBUSMENU_MENUITEM_PROP_ENABLED, FALSE);
-  }
-#endif
-
   return;
 }
 
@@ -287,9 +277,9 @@
 
 	status_update();
 
-  gwibber = gwibber_service_new ();
-  if (gwibber != NULL) {
-    g_signal_connect (G_OBJECT (gwibber), GWIBBER_SERVICE_SIGNAL_STATUS_CHANGED, G_CALLBACK (gwibber_status_update), NULL);
+  me_gwibber_service = me_gwibber_service_get ();
+  if (me_gwibber_service != NULL) {
+    g_signal_connect (G_OBJECT (me_gwibber_service), ME_GWIBBER_SERVICE_SIGNAL_STATUS_CHANGED, G_CALLBACK (me_gwibber_status_update), NULL);
   }
 
   return FALSE;