UOA mc-plugin: Actually implement it

1 files changed, 595 insertions, 16 deletions

diff --git a/ubuntu-online-accounts/mc-plugin/mcp-account-manager-uoa.c b/ubuntu-online-accounts/mc-plugin/mcp-account-manager-uoa.c
index e38067718..87d966f7d 100644
--- a/ubuntu-online-accounts/mc-plugin/mcp-account-manager-uoa.c
+++ b/ubuntu-online-accounts/mc-plugin/mcp-account-manager-uoa.c
@@ -21,6 +21,11 @@
 
 #include <telepathy-glib/telepathy-glib.h>
 
+#include <libaccounts-glib/ag-account.h>
+#include <libaccounts-glib/ag-account-service.h>
+#include <libaccounts-glib/ag-manager.h>
+#include <libaccounts-glib/ag-service.h>
+
 #include <string.h>
 #include <ctype.h>
 
@@ -31,6 +36,10 @@
 
 #define DEBUG g_debug
 
+#define SERVICE_TYPE "IM"
+#define KEY_PREFIX "telepathy/"
+#define KEY_ACCOUNT_NAME "mc-account-name"
+
 static void account_storage_iface_init (McpAccountStorageIface *iface);
 
 G_DEFINE_TYPE_WITH_CODE (McpAccountManagerUoa, mcp_account_manager_uoa,
@@ -40,11 +49,290 @@ G_DEFINE_TYPE_WITH_CODE (McpAccountManagerUoa, mcp_account_manager_uoa,
 
 struct _McpAccountManagerUoaPrivate
 {
+  McpAccountManager *am;
+
+  AgManager *manager;
+
+  /* alloc'ed string -> ref'ed AgAccountService
+   * The key is the account_name, an MC unique identifier.
+   * Note: There could be multiple services in this table having the same
+   * AgAccount, even if unlikely. */
+  GHashTable *accounts;
+
+  /* Queue of owned DelayedSignalData */
+  GQueue *pending_signals;
+
+  gboolean loaded;
+  gboolean ready;
 };
 
+typedef enum {
+  DELAYED_CREATE,
+  DELAYED_DELETE,
+} DelayedSignal;
+
+typedef struct {
+  DelayedSignal signal;
+  AgAccountId account_id;
+} DelayedSignalData;
+
+
+static gchar *
+_service_dup_tp_value (AgAccountService *service,
+    const gchar *key)
+{
+  gchar *real_key = g_strdup_printf (KEY_PREFIX "%s", key);
+  GValue value = { 0, };
+  gchar *ret;
+
+  g_value_init (&value, G_TYPE_STRING);
+  ag_account_service_get_value (service, real_key, &value);
+  ret = g_value_dup_string (&value);
+  g_value_unset (&value);
+
+  return ret;
+}
+
+static void
+_service_set_tp_value (AgAccountService *service,
+    const gchar *key,
+    const gchar *value)
+{
+  gchar *real_key = g_strdup_printf (KEY_PREFIX "%s", key);
+
+  if (value != NULL)
+    {
+      GValue gvalue = { 0, };
+
+      g_value_init (&gvalue, G_TYPE_STRING);
+      g_value_set_string (&gvalue, value);
+      ag_account_service_set_value (service, real_key, &gvalue);
+      g_value_unset (&gvalue);
+      g_free (real_key);
+    }
+  else
+    {
+      ag_account_service_set_value (service, real_key, NULL);
+    }
+}
+
+/* Returns NULL if the account never has been imported into MC before */
+static gchar *
+_service_dup_tp_account_name (AgAccountService *service)
+{
+  return _service_dup_tp_value (service, KEY_ACCOUNT_NAME);
+}
+
+static void
+_service_set_tp_account_name (AgAccountService *service,
+    const gchar *account_name)
+{
+  _service_set_tp_value (service, KEY_ACCOUNT_NAME, account_name);
+}
+
+static void
+_service_enabled_cb (AgAccountService *service,
+    gboolean enabled,
+    McpAccountManagerUoa *self)
+{
+  gchar *account_name = _service_dup_tp_account_name (service);
+
+  if (!self->priv->ready || account_name == NULL)
+    return;
+
+  DEBUG ("UOA account %s toggled: %s", account_name,
+      enabled ? "enabled" : "disabled");
+
+  g_signal_emit_by_name (self, "toggled", account_name, enabled);
+
+  g_free (account_name);
+}
+
+static void
+_service_changed_cb (AgAccountService *service,
+    McpAccountManagerUoa *self)
+{
+  gchar *account_name = _service_dup_tp_account_name (service);
+
+  if (!self->priv->ready || account_name == NULL)
+    return;
+
+  DEBUG ("UOA account %s changed", account_name);
+
+  /* FIXME: Could use ag_account_service_get_changed_fields()
+   * and emit "altered-one" */
+  g_signal_emit_by_name (self, "altered", account_name);
+
+  g_free (account_name);
+}
+
+static void
+_account_stored_cb (AgAccount *account,
+    const GError *error,
+    gpointer user_data)
+{
+  if (error != NULL)
+    {
+      DEBUG ("Error storing UOA account '%s': %s",
+          ag_account_get_display_name (account),
+          error->message);
+    }
+}
+
+static gboolean
+_add_service (McpAccountManagerUoa *self,
+    AgAccountService *service,
+    const gchar *account_name)
+{
+  DEBUG ("UOA account %s added", account_name);
+
+  if (g_hash_table_contains (self->priv->accounts, account_name))
+    {
+      DEBUG ("Already exists, ignoring");
+      return FALSE;
+    }
+
+  g_hash_table_insert (self->priv->accounts,
+      g_strdup (account_name),
+      g_object_ref (service));
+
+  g_signal_connect (service, "enabled",
+      G_CALLBACK (_service_enabled_cb), self);
+  g_signal_connect (service, "changed",
+      G_CALLBACK (_service_changed_cb), self);
+
+  return TRUE;
+}
+
+static void
+_account_created_cb (AgManager *manager,
+    AgAccountId id,
+    McpAccountManagerUoa *self)
+{
+  AgAccount *account;
+  GList *l;
+
+  if (!self->priv->ready)
+    {
+      DelayedSignalData *data = g_slice_new0 (DelayedSignalData);
+
+      data->signal = DELAYED_CREATE;
+      data->account_id = id;
+
+      g_queue_push_tail (self->priv->pending_signals, data);
+      return;
+    }
+
+  account = ag_manager_get_account (self->priv->manager, id);
+
+  l = ag_account_list_services_by_type (account, SERVICE_TYPE);
+  while (l != NULL)
+    {
+      AgAccountService *service = ag_account_service_new (account, l->data);
+      gchar *account_name = _service_dup_tp_account_name (service);
+
+      /* If this is the first time we see this service, we have to generate an
+       * account_name for it. */
+      if (account_name == NULL)
+        {
+          gchar *cm_name = NULL;
+          gchar *protocol_name = NULL;
+          gchar *account_param = NULL;
+
+          cm_name = _service_dup_tp_value (service, "manager");
+          protocol_name = _service_dup_tp_value (service, "protocol");
+          account_param = _service_dup_tp_value (service, "param-account");
+
+          if (!tp_str_empty (cm_name) &&
+              !tp_str_empty (protocol_name) &&
+              !tp_str_empty (account_param))
+            {
+              GHashTable *params;
+
+              params = tp_asv_new (
+                  "account", G_TYPE_STRING, account_param,
+                  NULL);
+
+              account_name = mcp_account_manager_get_unique_name (self->priv->am,
+                  cm_name, protocol_name, params);
+              _service_set_tp_account_name (service, account_name);
+
+              ag_account_store (account, _account_stored_cb, self);
+
+              g_hash_table_unref (params);
+            }
+
+          g_free (cm_name);
+          g_free (protocol_name);
+          g_free (account_param);
+        }
+
+      if (account_name != NULL)
+        {
+          if (_add_service (self, service, account_name))
+            g_signal_emit_by_name (self, "created", account_name);
+        }
+
+      g_free (account_name);
+      g_object_unref (service);
+      ag_service_unref (l->data);
+      l = g_list_delete_link (l, l);
+    }
+
+  g_object_unref (account);
+}
+
+static void
+_account_deleted_cb (AgManager *manager,
+    AgAccountId id,
+    McpAccountManagerUoa *self)
+{
+  GHashTableIter iter;
+  gpointer value;
+
+  if (!self->priv->ready)
+    {
+      DelayedSignalData *data = g_slice_new0 (DelayedSignalData);
+
+      data->signal = DELAYED_DELETE;
+      data->account_id = id;
+
+      g_queue_push_tail (self->priv->pending_signals, data);
+      return;
+    }
+
+  g_hash_table_iter_init (&iter, self->priv->accounts);
+  while (g_hash_table_iter_next (&iter, NULL, &value))
+    {
+      AgAccountService *service = value;
+      AgAccount *account = ag_account_service_get_account (service);
+      gchar *account_name;
+
+      if (account->id != id)
+        continue;
+
+      account_name = _service_dup_tp_account_name (service);
+      if (account_name == NULL)
+        continue;
+
+      DEBUG ("UOA account %s deleted", account_name);
+
+      g_hash_table_iter_remove (&iter);
+      g_signal_emit_by_name (self, "deleted", account_name);
+
+      g_free (account_name);
+    }
+}
+
 static void
 mcp_account_manager_uoa_dispose (GObject *object)
 {
+  McpAccountManagerUoa *self = (McpAccountManagerUoa *) object;
+
+  tp_clear_object (&self->priv->am);
+  tp_clear_object (&self->priv->manager);
+  tp_clear_pointer (&self->priv->accounts, g_hash_table_unref);
+
   G_OBJECT_CLASS (mcp_account_manager_uoa_parent_class)->dispose (object);
 }
 
@@ -55,6 +343,17 @@ mcp_account_manager_uoa_init (McpAccountManagerUoa *self)
 
   self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
       MCP_TYPE_ACCOUNT_MANAGER_UOA, McpAccountManagerUoaPrivate);
+
+  self->priv->accounts = g_hash_table_new_full (g_str_hash, g_str_equal,
+      g_free, g_object_unref);
+  self->priv->pending_signals = g_queue_new ();
+
+  self->priv->manager = ag_manager_new_for_service_type (SERVICE_TYPE);
+
+  g_signal_connect (self->priv->manager, "account-created",
+      G_CALLBACK (_account_created_cb), self);
+  g_signal_connect (self->priv->manager, "account-deleted",
+      G_CALLBACK (_account_deleted_cb), self);
 }
 
 static void
@@ -68,68 +367,347 @@ mcp_account_manager_uoa_class_init (McpAccountManagerUoaClass *klass)
       sizeof (McpAccountManagerUoaPrivate));
 }
 
+static void
+_ensure_loaded (McpAccountManagerUoa *self)
+{
+  GList *services;
+
+  if (self->priv->loaded)
+    return;
+
+  self->priv->loaded = TRUE;
+
+  g_assert (!self->priv->ready);
+
+  services = ag_manager_get_account_services (self->priv->manager);
+  while (services != NULL)
+    {
+      AgAccountService *service = services->data;
+      AgAccount *account = ag_account_service_get_account (service);
+      gchar *account_name = _service_dup_tp_account_name (service);
+
+      if (account_name != NULL)
+        {
+          /* This service was already known, we can add it now */
+          _add_service (self, service, account_name);
+          g_free (account_name);
+        }
+      else
+        {
+          DelayedSignalData *data = g_slice_new0 (DelayedSignalData);
+
+          /* This service was created while MC was not running, delay its
+           * creation until MC is ready */
+          data->signal = DELAYED_CREATE;
+          data->account_id = account->id;
+
+          g_queue_push_tail (self->priv->pending_signals, data);
+        }
+
+      g_object_unref (services->data);
+      services = g_list_delete_link (services, services);
+    }
+}
+
 static GList *
 account_manager_uoa_list (const McpAccountStorage *storage,
     const McpAccountManager *am)
 {
-  return NULL;
+  McpAccountManagerUoa *self = (McpAccountManagerUoa *) storage;
+  GList *accounts = NULL;
+  GHashTableIter iter;
+  gpointer key;
+
+  DEBUG (G_STRFUNC);
+
+  _ensure_loaded (self);
+
+  g_hash_table_iter_init (&iter, self->priv->accounts);
+  while (g_hash_table_iter_next (&iter, &key, NULL))
+    accounts = g_list_prepend (accounts, g_strdup (key));
+
+  return accounts;
 }
 
 static gboolean
 account_manager_uoa_get (const McpAccountStorage *storage,
     const McpAccountManager *am,
-    const gchar *acc,
+    const gchar *account_name,
     const gchar *key)
 {
-  return FALSE;
+  McpAccountManagerUoa *self = (McpAccountManagerUoa *) storage;
+  AgAccountService *service;
+  AgAccount *account;
+  AgService *s;
+  gboolean handled = FALSE;
+
+  service = g_hash_table_lookup (self->priv->accounts, account_name);
+  if (service == NULL)
+    return FALSE;
+
+  DEBUG ("%s: %s, %s", G_STRFUNC, account_name, key);
+
+  account = ag_account_service_get_account (service);
+  s = ag_account_service_get_service (service);
+
+  /* NULL key means we want all settings */
+  if (key == NULL)
+    {
+      AgAccountSettingIter iter;
+      const gchar *k;
+      const GValue *v;
+
+      ag_account_service_settings_iter_init (service, &iter, KEY_PREFIX);
+      while (ag_account_service_settings_iter_next (&iter, &k, &v))
+        {
+          if (!G_VALUE_HOLDS_STRING (v))
+            continue;
+
+          mcp_account_manager_set_value (am, account_name,
+              k, g_value_get_string (v));
+        }
+    }
+
+  /* Some special keys that are not stored in setting */
+  if (key == NULL || !tp_strdiff (key, "Enabled"))
+    {
+      mcp_account_manager_set_value (am, account_name, "Enabled",
+          ag_account_service_get_enabled (service) ? "true" : "false");
+      handled = TRUE;
+    }
+
+  if (key == NULL || !tp_strdiff (key, "DisplayName"))
+    {
+      mcp_account_manager_set_value (am, account_name, "DisplayName",
+          ag_account_get_display_name (account));
+      handled = TRUE;
+    }
+
+  if (key == NULL || !tp_strdiff (key, "Service"))
+    {
+      mcp_account_manager_set_value (am, account_name, "Service",
+          ag_account_get_provider_name (account));
+      handled = TRUE;
+    }
+
+  if (key == NULL || !tp_strdiff (key, "Icon"))
+    {
+      mcp_account_manager_set_value (am, account_name, "Icon",
+          ag_service_get_icon_name (s));
+      handled = TRUE;
+    }
+
+  /* If it was none of the above, then just lookup in service' settings */
+  if (!handled)
+    {
+      gchar *value = _service_dup_tp_value (service, key);
+
+      mcp_account_manager_set_value (am, account_name, key, value);
+      g_free (value);
+    }
+
+  return TRUE;
 }
 
 static gboolean
 account_manager_uoa_set (const McpAccountStorage *storage,
     const McpAccountManager *am,
-    const gchar *acc,
+    const gchar *account_name,
     const gchar *key,
     const gchar *val)
 {
-  return FALSE;
+  McpAccountManagerUoa *self = (McpAccountManagerUoa *) storage;
+  AgAccountService *service;
+  AgAccount *account;
+
+  service = g_hash_table_lookup (self->priv->accounts, account_name);
+  if (service == NULL)
+    return FALSE;
+
+  account = ag_account_service_get_account (service);
+
+  DEBUG ("%s: %s, %s, %s", G_STRFUNC, account_name, key, val);
+
+  if (!tp_strdiff (key, "Enabled"))
+    {
+      ag_account_set_enabled (account, !tp_strdiff (val, "true"));
+    }
+  else if (!tp_strdiff (key, "DisplayName"))
+    {
+      ag_account_set_display_name (account, val);
+    }
+  else
+    {
+      _service_set_tp_value (service, key, val);
+    }
+
+  return TRUE;
+}
+
+static gchar *
+account_manager_uoa_create (const McpAccountStorage *storage,
+    const McpAccountManager *am,
+    const gchar *cm_name,
+    const gchar *protocol_name,
+    GHashTable *params,
+    GError **error)
+{
+  McpAccountManagerUoa *self = (McpAccountManagerUoa *) storage;
+  gchar *account_name;
+  AgAccount *account;
+  AgAccountService *service;
+  GList *l;
+
+  if (!self->priv->ready)
+    {
+      g_set_error (error, TP_ERROR, TP_ERROR_INVALID_ARGUMENT,
+          "Cannot create account before being ready");
+      return NULL;
+    }
+
+  DEBUG (G_STRFUNC);
+
+  /* Create a new AgAccountService and keep it internally. This won't save it
+   * into persistent storage until account_manager_uoa_commit() is called.
+   * We assume there is only one IM service */
+  account = ag_manager_create_account (self->priv->manager, protocol_name);
+  l = ag_account_list_services_by_type (account, SERVICE_TYPE);
+  if (l == NULL)
+    {
+      g_set_error (error, TP_ERROR, TP_ERROR_INVALID_ARGUMENT,
+          "Cannot create a %s service for %s provider",
+          SERVICE_TYPE, protocol_name);
+      g_object_unref (account);
+      return NULL;
+    }
+  service = ag_account_service_new (account, l->data);
+  ag_service_list_free (l);
+  g_object_unref (account);
+
+  account_name = mcp_account_manager_get_unique_name (self->priv->am,
+      cm_name, protocol_name, params);
+  _service_set_tp_account_name (service, account_name);
+  g_assert (_add_service (self, service, account_name));
+
+  /* MC will set all params on the account and commit */
+
+  return account_name;
 }
 
 static gboolean
 account_manager_uoa_delete (const McpAccountStorage *storage,
     const McpAccountManager *am,
-    const gchar *acc,
+    const gchar *account_name,
     const gchar *key)
 {
-  return FALSE;
+  McpAccountManagerUoa *self = (McpAccountManagerUoa *) storage;
+  AgAccountService *service;
+  AgAccount *account;
+
+  service = g_hash_table_lookup (self->priv->accounts, account_name);
+  if (service == NULL)
+    return FALSE;
+
+  account = ag_account_service_get_account (service);
+
+  DEBUG ("%s: %s, %s", G_STRFUNC, account_name, key);
+
+  if (key == NULL)
+    {
+      ag_account_delete (account);
+      g_hash_table_remove (self->priv->accounts, account_name);
+    }
+  else
+    {
+      _service_set_tp_value (service, key, NULL);
+    }
+
+  return TRUE;
 }
 
 static gboolean
 account_manager_uoa_commit (const McpAccountStorage *storage,
     const McpAccountManager *am)
 {
-  return FALSE;
+  McpAccountManagerUoa *self = (McpAccountManagerUoa *) storage;
+  GHashTableIter iter;
+  gpointer value;
+
+  DEBUG (G_STRFUNC);
+
+  g_hash_table_iter_init (&iter, self->priv->accounts);
+  while (g_hash_table_iter_next (&iter, NULL, &value))
+    {
+      AgAccountService *service = value;
+      AgAccount *account = ag_account_service_get_account (service);
+
+      ag_account_store (account, _account_stored_cb, self);
+    }
+
+  return TRUE;
 }
 
 static void
 account_manager_uoa_ready (const McpAccountStorage *storage,
     const McpAccountManager *am)
 {
+  McpAccountManagerUoa *self = (McpAccountManagerUoa *) storage;
+  DelayedSignalData *data;
+
+  if (self->priv->ready)
+    return;
+
+  DEBUG (G_STRFUNC);
+
+  self->priv->ready = TRUE;
+  self->priv->am = g_object_ref (G_OBJECT (am));
+
+  while ((data = g_queue_pop_head (self->priv->pending_signals)) != NULL)
+    {
+      switch (data->signal)
+        {
+          case DELAYED_CREATE:
+            _account_created_cb (self->priv->manager, data->account_id, self);
+            break;
+          case DELAYED_DELETE:
+            _account_deleted_cb (self->priv->manager, data->account_id, self);
+            break;
+          default:
+            g_assert_not_reached ();
+        }
+
+      g_slice_free (DelayedSignalData, data);
+    }
+
+  g_queue_free (self->priv->pending_signals);
+  self->priv->pending_signals = NULL;
 }
 
 static void
 account_manager_uoa_get_identifier (const McpAccountStorage *storage,
-    const gchar *acc,
+    const gchar *account_name,
     GValue *identifier)
 {
+  McpAccountManagerUoa *self = (McpAccountManagerUoa *) storage;
+  AgAccountService *service;
+  AgAccount *account;
+
+  service = g_hash_table_lookup (self->priv->accounts, account_name);
+  if (service == NULL)
+    return;
+
+  account = ag_account_service_get_account (service);
+
+  g_value_init (identifier, G_TYPE_UINT);
+  g_value_set_uint (identifier, account->id);
 }
 
-static gchar *
-account_manager_uoa_create_account (const McpAccountStorage *storage,
-    const gchar *cm_name,
-    const gchar *protocol_name,
-    GHashTable *params)
+static guint
+account_manager_uoa_get_restrictions (const McpAccountStorage *self,
+    const gchar *account_name)
 {
-  return NULL;
+  /* FIXME: We can't set Icon either, but there is no flag for that */
+  return TP_STORAGE_RESTRICTION_FLAG_CANNOT_SET_SERVICE;
 }
 
 static void
@@ -145,11 +723,12 @@ account_storage_iface_init (McpAccountStorageIface *iface)
   IMPLEMENT (get);
   IMPLEMENT (list);
   IMPLEMENT (set);
+  IMPLEMENT (create);
   IMPLEMENT (delete);
   IMPLEMENT (commit);
   IMPLEMENT (ready);
   IMPLEMENT (get_identifier);
-  IMPLEMENT (create_account);
+  IMPLEMENT (get_restrictions);
 #undef IMPLEMENT
 }