path: root/goa-mc-plugin/mcp-account-manager-goa.c

/*
 * mcp-account-manager-goa.c
 *
 * McpAccountManagerGoa - a Mission Control plugin to expose GNOME Online
 * Accounts with chat capabilities (e.g. Facebook) to Mission Control
 *
 * Copyright (C) 2010-2011 Collabora Ltd.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
 *
 * Authors:
 *    Danielle Madeley <danielle.madeley@collabora.co.uk>
 */

#include <glib/gi18n.h>

#include <telepathy-glib/util.h>

#define GOA_API_IS_SUBJECT_TO_CHANGE /* awesome! */
#include <goa/goa.h>

#include "mcp-account-manager-goa.h"

#define DEBUG g_debug
#define GET_PRIVATE(self) (((McpAccountManagerGoa *) self)->priv)
#define DECLARE_GASYNC_CALLBACK(name) \
  static void name (GObject *, GAsyncResult *, gpointer);

#define PLUGIN_NAME "goa"
#define PLUGIN_PRIORITY (MCP_ACCOUNT_STORAGE_PLUGIN_PRIO_KEYRING + 10)
#define PLUGIN_DESCRIPTION "Provide Telepathy Accounts from GOA"
#define PLUGIN_PROVIDER "org.gnome.OnlineAccounts"

static void account_storage_iface_init (McpAccountStorageIface *iface);

G_DEFINE_TYPE_WITH_CODE (McpAccountManagerGoa,
    mcp_account_manager_goa,
    G_TYPE_OBJECT,
    G_IMPLEMENT_INTERFACE (MCP_TYPE_ACCOUNT_STORAGE,
      account_storage_iface_init))

struct _McpAccountManagerGoaPrivate
{
  gboolean ready;

  GoaClient *client;
  GHashTable *accounts; /* alloc'ed string -> ref'ed GoaAccount */
};


static void
mcp_account_manager_goa_dispose (GObject *self)
{
  McpAccountManagerGoaPrivate *priv = GET_PRIVATE (self);

  tp_clear_object (&priv->client);

  G_OBJECT_CLASS (mcp_account_manager_goa_parent_class)->dispose (self);
}


static void
mcp_account_manager_goa_finalize (GObject *self)
{
  McpAccountManagerGoaPrivate *priv = GET_PRIVATE (self);

  g_hash_table_destroy (priv->accounts);

  G_OBJECT_CLASS (mcp_account_manager_goa_parent_class)->finalize (self);
}


static void
mcp_account_manager_goa_class_init (McpAccountManagerGoaClass *klass)
{
  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);

  gobject_class->dispose = mcp_account_manager_goa_dispose;
  gobject_class->finalize = mcp_account_manager_goa_finalize;

  g_type_class_add_private (gobject_class,
      sizeof (McpAccountManagerGoaPrivate));
}


// static void
// _enable_chat_toggled (GConfClient *client,
//     guint cnxn_id,
//     GConfEntry *entry,
//     gpointer user_data)
// {
//   McpAccountStorage *self = MCP_ACCOUNT_STORAGE (user_data);
//   McpAccountManagerGoaPrivate *priv = GET_PRIVATE (self);
//   gboolean enabled = gconf_value_get_bool (gconf_entry_get_value (entry));
// 
//   DEBUG ("%s: %s", G_STRFUNC, enabled ? "enabled" : "disabled");
// 
//   if (priv->ready && priv->facebook_available)
//     {
//       DEBUG ("Emitting toggled signal");
// 
//       g_signal_emit_by_name (self, "toggled", FACEBOOK_ACCOUNT_NAME, enabled);
//     }
// }


static GHashTable *
get_tp_parameters (GoaAccount *account)
{
  GHashTable *params = g_hash_table_new_full (g_str_hash, g_str_equal,
      NULL, g_free);
  const char *type = goa_account_get_provider_type (account);

#define PARAM(key, value) g_hash_table_insert (params, key, g_strdup (value));

 // { "param-account", "chat.facebook.com" },
 // { "param-server", "chat.facebook.com" },

  if (!tp_strdiff (type, "google"))
    {
      PARAM ("manager", "gabble");
      PARAM ("protocol", "jabber");
      PARAM ("Icon", "im-google-talk");
      PARAM ("Service", "google-talk");

      PARAM ("param-account", goa_account_get_identity (account));
      PARAM ("param-server", "talk.google.com");
    }
  else
    {
      /* unknown account type */
      g_hash_table_destroy (params);
      return NULL;
    }

  /* generic properties */
  PARAM ("DisplayName", goa_account_get_presentation_identity (account));
  PARAM ("ConnectAutomatically", "true");

#undef PARAM

  return params;
}


static char *
get_tp_account_name (GoaAccount *account)
{
  GHashTable *params = get_tp_parameters (account);
  const char *type = goa_account_get_provider_type (account);
  const char *id = goa_account_get_id (account);
  char *name;

  if (params == NULL)
    return NULL;

  name = g_strdup_printf ("%s/%s/goa_%s_%s",
      (char *) g_hash_table_lookup (params, "manager"),
      (char *) g_hash_table_lookup (params, "protocol"),
      type, id);

  g_hash_table_destroy (params);

  return name;
}


static void
_new_account (McpAccountManagerGoa *self,
    GoaAccount *account)
{
  char *account_name = get_tp_account_name (account);

  if (account_name == NULL)
    return;

  /* @account_name now is owned by the hash table */
  g_hash_table_insert (self->priv->accounts, account_name,
      g_object_ref (account));

  if (self->priv->ready)
    g_signal_emit_by_name (self, "created", account_name);
}


DECLARE_GASYNC_CALLBACK (_goa_client_new_cb);

static void
mcp_account_manager_goa_init (McpAccountManagerGoa *self)
{
  DEBUG ("GOA MC plugin initialised");

  self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
      MCP_TYPE_ACCOUNT_MANAGER_GOA, McpAccountManagerGoaPrivate);

  self->priv->accounts = g_hash_table_new_full (g_str_hash, g_str_equal,
      g_free, g_object_unref);

  goa_client_new (NULL, _goa_client_new_cb, self);
}


static void
_account_added_cb (GoaClient *client,
    GoaObject *object,
    McpAccountManagerGoa *self)
{
      GoaAccount *account = goa_object_peek_account (object);

      _new_account (self, account);
}


static void
_account_removed_cb (GoaClient *client,
    GoaObject *object,
    McpAccountManagerGoa *self)
{
  GoaAccount *account = goa_object_peek_account (object);
  char *name = get_tp_account_name (account);

  if (self->priv->ready)
    g_signal_emit_by_name (self, "deleted", name);

  g_hash_table_remove (self->priv->accounts, name);

  g_free (name);
}


static void
_goa_client_new_cb (GObject *obj,
    GAsyncResult *result,
    gpointer user_data)
{
  McpAccountManagerGoa *self = user_data;
  GoaClient *client;
  GList *accounts, *ptr;
  GError *error = NULL;

  self->priv->client = goa_client_new_finish (result, &error);

  if (error != NULL)
    {
      DEBUG ("Failed to connect to GOA");
      return;
    }

  accounts = goa_client_get_accounts (self->priv->client);

  for (ptr = accounts; ptr != NULL; ptr = ptr->next)
    {
      GoaAccount *account = goa_object_peek_account (ptr->data);

      _new_account (self, account);
    }

  g_list_free_full (accounts, g_object_unref);

  g_signal_connect (self->priv->client, "account-added",
      G_CALLBACK (_account_added_cb), self);
  g_signal_connect (self->priv->client, "account-removed",
      G_CALLBACK (_account_removed_cb), self);
  /* FIXME: do we need to support account-changed ? */
}


static GList *
mcp_account_manager_goa_list (const McpAccountStorage *self,
    const McpAccountManager *am)
{
  McpAccountManagerGoaPrivate *priv = GET_PRIVATE (self);
  GList *accounts = NULL;
  GHashTableIter iter;
  gpointer key;

  DEBUG (G_STRFUNC);

  g_hash_table_iter_init (&iter, priv->accounts);
  while (g_hash_table_iter_next (&iter, &key, NULL))
    accounts = g_list_prepend (accounts, g_strdup (key));

  return accounts;
}


static void
get_enabled (const McpAccountStorage *self,
    const McpAccountManager *am,
    const gchar *acct)
{
  // McpAccountManagerGoaPrivate *priv = GET_PRIVATE (self);
  // GError *error = NULL;
  // gboolean enabled;
  // const char *value;

  // enabled = gconf_client_get_bool (priv->gconf,
  //     BISHO_FB_GCONF_ENABLE_CHAT_KEY, &error);
  // if (error != NULL)
  //   {
  //     g_warning ("Unabled to get value for %s/Enabled from GConf: %s",
  //         acct, error->message);
  //     g_clear_error (&error);
  //   }

  // value = enabled ? "true" : "false";

  // DEBUG ("Facebook Chat enabled = %s", value);

  mcp_account_manager_set_value (am, acct, "Enabled", "true");
}


static gboolean
mcp_account_manager_goa_get (const McpAccountStorage *self,
    const McpAccountManager *am,
    const gchar *acct,
    const gchar *key)
{
  McpAccountManagerGoaPrivate *priv = GET_PRIVATE (self);
  GoaAccount *account;

  DEBUG ("%s: %s, %s", G_STRFUNC, acct, key);

  account = g_hash_table_lookup (priv->accounts, acct);

  if (account == NULL)
    return FALSE;

  if (key == NULL)
    {
      /* load all keys */
      GHashTable *params = get_tp_parameters (account);
      GHashTableIter iter;
      gpointer key, value;

      g_hash_table_iter_init (&iter, params);
      while (g_hash_table_iter_next (&iter, &key, &value))
        mcp_account_manager_set_value (am, acct, key, value);

      g_hash_table_destroy (params);

      get_enabled (self, am, acct);
    }
  else if (!tp_strdiff (key, "Enabled"))
    {
      get_enabled (self, am, acct);
    }
  else
    {
      /* get a specific key */
      GHashTable *params = get_tp_parameters (account);

      mcp_account_manager_set_value (am, acct, key,
          g_hash_table_lookup (params, key));

      g_hash_table_destroy (params);
    }

  return TRUE;
}


static gboolean
mcp_account_manager_goa_set (const McpAccountStorage *self,
    const McpAccountManager *am,
    const gchar *acct,
    const gchar *key,
    const gchar *val)
{
  GError *error = NULL;

  DEBUG ("%s: (%s, %s, %s)", G_STRFUNC, acct, key, val);

  // if (!tp_strdiff (acct, FACEBOOK_ACCOUNT_NAME))
  //   {
  //     if (!tp_strdiff (key, "Enabled"))
  //       {
  //         gboolean enabled = !tp_strdiff (val, "true");

  //         DEBUG ("set Enabled to %s", enabled ? "enabled" : "disabled");

  //         gconf_client_set_bool (priv->gconf, BISHO_FB_GCONF_ENABLE_CHAT_KEY,
  //             enabled, &error);
  //         if (error != NULL)
  //           {
  //             g_warning ("Unable to save %s/Enable state in GConf: %s",
  //                 acct, error->message);
  //             g_clear_error (&error);
  //           }

  //         return TRUE;
  //       }
  //     else
  //       /* pretend we saved everything else */
  //       return TRUE;
  //   }
  // else
  //   {
  //     return FALSE;
  //   }
}


static gboolean
mcp_account_manager_goa_delete (const McpAccountStorage *self,
    const McpAccountManager *am,
    const gchar *acct,
    const gchar *key)
{
  DEBUG ("%s: (%s, %s)", G_STRFUNC, acct, key);

//  if (!tp_strdiff (acct, FACEBOOK_ACCOUNT_NAME))
//    {
//      if (!tp_strdiff (key, "Enabled"))
//        return TRUE;
//      else
//        /* pretend we deleted everything else */
//        return TRUE;
//    }
//  else
//    {
//      return FALSE;
//    }
}


static gboolean
mcp_account_manager_goa_commit (const McpAccountStorage *self,
    const McpAccountManager *am)
{
  DEBUG ("%s", G_STRFUNC);

  return TRUE;
}


static void
mcp_account_manager_goa_ready (const McpAccountStorage *self,
    const McpAccountManager *am)
{
  McpAccountManagerGoaPrivate *priv = GET_PRIVATE (self);

  priv->ready = TRUE;
}


static guint
mcp_account_manager_goa_get_restrictions (const McpAccountStorage *self,
    const gchar *account)
{
  return TP_STORAGE_RESTRICTION_FLAG_CANNOT_SET_PARAMETERS |
         TP_STORAGE_RESTRICTION_FLAG_CANNOT_SET_SERVICE;
}


static void
mcp_account_manager_goa_get_identifier (const McpAccountStorage *self,
    const gchar *acct,
    GValue *identifier)
{
  McpAccountManagerGoaPrivate *priv = GET_PRIVATE (self);
  GoaAccount *account;

  account = g_hash_table_lookup (priv->accounts, acct);

  g_return_if_fail (account != NULL);

  g_value_init (identifier, G_TYPE_STRING);
  g_value_set_string (identifier, goa_account_get_id (account));
}


static void
account_storage_iface_init (McpAccountStorageIface *iface)
{
  mcp_account_storage_iface_set_name (iface, PLUGIN_NAME);
  mcp_account_storage_iface_set_desc (iface, PLUGIN_DESCRIPTION);
  mcp_account_storage_iface_set_priority (iface, PLUGIN_PRIORITY);
  mcp_account_storage_iface_set_provider (iface, PLUGIN_PROVIDER);

#define IMPLEMENT(x) mcp_account_storage_iface_implement_##x(iface, \
    mcp_account_manager_goa_##x)
  IMPLEMENT (get);
  IMPLEMENT (list);
  IMPLEMENT (set);
  IMPLEMENT (delete);
  IMPLEMENT (commit);
  IMPLEMENT (ready);
  IMPLEMENT (get_restrictions);
  IMPLEMENT (get_identifier);
#undef IMPLEMENT
}