[empathy/mc5] Add empathy-import-mc4-accounts files

[Sjoerd Simons <sjoerds src gnome org>]

commit 1173e9d086df6304f2436edf0d8cc6c1540414f9
Author: Arnaud Maillet <arnaud maillet collabora co uk>
Date:   Sat Aug 22 14:52:15 2009 +0200

    Add empathy-import-mc4-accounts files

 src/empathy-import-mc4-accounts.c |  555 +++++++++++++++++++++++++++++++++++++
 src/empathy-import-mc4-accounts.h |   31 ++
 2 files changed, 586 insertions(+), 0 deletions(-)
---
diff --git a/src/empathy-import-mc4-accounts.c b/src/empathy-import-mc4-accounts.c
new file mode 100644
index 0000000..0dbadd6
--- /dev/null
+++ b/src/empathy-import-mc4-accounts.c
@@ -0,0 +1,555 @@
+/*
+ * Copyright (C) 2008 Collabora Ltd.
+ *
+ * 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., 51 Franklin St, Fifth Floor,
+ * Boston, MA  02110-1301  USA
+ *
+ * Authors: Arnaud Maillet <arnaud maillet collabora co uk>
+ */
+
+#include <string.h>
+#include <glib.h>
+#include <gconf/gconf-client.h>
+#include <telepathy-glib/util.h>
+#include <libempathy/empathy-account-manager.h>
+#include <libempathy/empathy-connection-managers.h>
+
+#include "empathy-import-mc4-accounts.h"
+
+#define DEBUG_FLAG EMPATHY_DEBUG_IMPORT_MC4_ACCOUNTS
+#include <libempathy/empathy-debug.h>
+
+#define MC_ACCOUNTS_GCONF_BASE "/apps/telepathy/mc/accounts"
+#define IMPORT_MC4_ACCOUNTS "/apps/empathy/accounts/import_mc4_accounts"
+
+typedef struct
+{
+  gchar *profile;
+  gchar *protocol;
+} ProfileProtocolMapItem;
+
+static ProfileProtocolMapItem profile_protocol_map[] =
+{
+  { "aim", "aim" },
+  { "ekiga", "sip" },
+  { "fwd", "sip" },
+  { "gadugadu", "gadugadu" },
+  { "groupwise", "groupwise" },
+  { "gtalk", "jabber" },
+  { "icq", "icq" },
+  { "irc", "irc" },
+  { "jabber", "jabber" },
+  { "msn-haze", "msn" },
+  { "msn", "msn" },
+  { "qq", "qq" },
+  { "salut", "local-xmpp" },
+  { "sametime", "sametime" },
+  { "sipphone", "sip" },
+  { "sofiasip", "sip" },
+  { "yahoo", "yahoo" },
+};
+
+typedef struct
+{
+  gchar *connection_manager;
+  gchar *protocol;
+  gchar *display_name;
+  gchar *param_account;
+  gchar *param_server;
+  gboolean enabled;
+  GHashTable *parameters;
+} AccountData;
+
+static void
+_account_data_free (AccountData *account)
+{
+  if (account->connection_manager != NULL)
+    {
+      g_free (account->connection_manager);
+      account->connection_manager = NULL;
+    }
+
+  if (account->protocol != NULL)
+    {
+      g_free (account->protocol);
+      account->protocol = NULL;
+    }
+
+  if (account->display_name != NULL)
+    {
+      g_free (account->display_name);
+      account->display_name = NULL;
+    }
+
+  if (account->param_account != NULL)
+    {
+      g_free (account->param_account);
+      account->param_account = NULL;
+    }
+
+  if (account->param_server != NULL)
+    {
+      g_free (account->param_server);
+      account->param_server = NULL;
+    }
+
+  if (account->parameters != NULL)
+    {
+      g_hash_table_destroy (account->parameters);
+      account->parameters = NULL;
+    }
+
+  g_slice_free (AccountData, account);
+}
+
+static gchar *
+_account_name_from_key (const gchar *key)
+{
+  guint base_len = strlen (MC_ACCOUNTS_GCONF_BASE);
+  const gchar *base, *slash;
+
+  g_assert (key == strstr (key, MC_ACCOUNTS_GCONF_BASE));
+  g_assert (strlen (key) > base_len + 1);
+
+  base = key + base_len + 1;
+  slash = strchr (base, '/');
+
+  if (slash == NULL)
+    return g_strdup (base);
+  else
+    return g_strndup (base, slash - base);
+}
+
+static gchar *
+_param_name_from_key (const gchar *key)
+{
+ const gchar *base, *slash;
+ gchar *account_name;
+
+ account_name = _account_name_from_key (key);
+ base = strstr (key, account_name);
+ slash = strchr (base, '/');
+ g_free (account_name);
+
+ return g_strdup (slash+1);
+}
+
+static void
+_normalize_display_name (AccountData *account)
+{
+
+  if (account->display_name != NULL)
+    return;
+
+  if (!tp_strdiff (account->protocol, "local-xmpp"))
+    {
+      account->display_name = g_strdup ("Nearby People");
+    }
+
+  else if (!tp_strdiff (account->protocol, "irc"))
+    {
+
+      if (account->display_name != NULL)
+        {
+          g_free (account->display_name);
+          account->display_name = NULL;
+        }
+
+      account->display_name = g_strdup_printf
+          ("%s on %s", account->param_account, account->param_server);
+
+    }
+
+  else if (account->display_name == NULL)
+    {
+
+      if (account->param_account != NULL)
+        account->display_name = g_strdup
+            ((const gchar *) account->param_account);
+      else
+        account->display_name = g_strdup
+            ("No display name");
+
+    }
+}
+
+static gboolean
+_protocol_is_supported (AccountData *data)
+{
+  EmpathyConnectionManagers *cm =
+      empathy_connection_managers_dup_singleton ();
+  GList *cms = empathy_connection_managers_get_cms (cm);
+  GList *l;
+  gboolean proto_is_supported = FALSE;
+
+  for (l = cms; l; l = l->next)
+    {
+      TpConnectionManager *tp_cm = l->data;
+      const gchar *cm_name = tp_connection_manager_get_name (tp_cm);
+      if (tp_connection_manager_has_protocol (tp_cm,
+          (const gchar*)data->protocol))
+        {
+          data->connection_manager = g_strdup (cm_name);
+          proto_is_supported = TRUE;
+          break;
+        }
+    }
+
+  g_object_unref (cm);
+
+  return proto_is_supported;
+}
+
+static void
+_create_account_cb (GObject *source,
+  GAsyncResult *result,
+  gpointer user_data)
+{
+  AccountData *data = (AccountData*) user_data;
+  EmpathyAccount *account;
+  GError *error = NULL;
+
+  account = empathy_account_manager_create_account_finish (
+    EMPATHY_ACCOUNT_MANAGER (source), result, &error);
+
+  if (account == NULL)
+    {
+      DEBUG ("Failed to create account: %s",
+          error ? error->message : "No error given");
+      g_clear_error (&error);
+      _account_data_free (data);
+      return;
+    }
+
+  DEBUG ("account created\n");
+  empathy_account_set_enabled (account, data->enabled);
+
+  g_object_unref (account);
+  _account_data_free (data);
+}
+
+static void
+_recurse_account (GSList *entries, AccountData *account)
+{
+  GSList *tmp;
+
+  for (tmp = entries; tmp != NULL; tmp = tmp->next)
+    {
+
+      GConfEntry *entry;
+      gchar *param;
+      GConfValue *value;
+
+      entry = (GConfEntry*) tmp->data;
+      param = _param_name_from_key (gconf_entry_get_key (entry));
+
+      if (!tp_strdiff (param, "profile"))
+        {
+          const gchar *profile;
+          gint i;
+          value = gconf_entry_get_value (entry);
+          profile = gconf_value_get_string (value);
+
+          DEBUG ("profile: %s\n", profile);
+
+          for (i = 0; i < G_N_ELEMENTS (profile_protocol_map); i++)
+            {
+              if (!tp_strdiff (profile, profile_protocol_map[i].profile))
+                {
+                  account->protocol = g_strdup
+                      (profile_protocol_map[i].protocol);
+                  break;
+                }
+            }
+        }
+
+      else if (!tp_strdiff (param, "enabled"))
+        {
+          value = gconf_entry_get_value (entry);
+          account->enabled = gconf_value_get_bool (value);
+        }
+
+      else if (!tp_strdiff (param, "display_name"))
+        {
+          value = gconf_entry_get_value (entry);
+          account->display_name = g_strdup (gconf_value_get_string (value));
+        }
+
+      else if (!tp_strdiff (param, "param-account"))
+        {
+
+          GValue *my_g_value;
+
+          value = gconf_entry_get_value (entry);
+          account->param_account = g_strdup (gconf_value_get_string (value));
+
+          my_g_value = tp_g_value_slice_new (G_TYPE_STRING);
+          g_value_set_string (my_g_value, account->param_account);
+          g_hash_table_insert (account->parameters, "account", my_g_value);
+
+        }
+
+      else if (!tp_strdiff (param, "param-server"))
+        {
+
+          GValue *my_g_value;
+
+          value = gconf_entry_get_value (entry);
+          account->param_account = g_strdup (gconf_value_get_string (value));
+
+          my_g_value = tp_g_value_slice_new (G_TYPE_STRING);
+          g_value_set_string (my_g_value, account->param_account);
+          g_hash_table_insert (account->parameters, "server", my_g_value);
+
+        }
+
+      else if (!tp_strdiff (param, "param-port"))
+        {
+
+          GValue *my_g_value;
+
+          value = gconf_entry_get_value (entry);
+          my_g_value = tp_g_value_slice_new (G_TYPE_UINT);
+          g_value_set_uint (my_g_value, gconf_value_get_int (value));
+          g_hash_table_insert (account->parameters, "password", my_g_value);;
+
+        }
+
+
+      else if (!tp_strdiff (param, "param-password"))
+        {
+
+          GValue *my_g_value;
+
+          value = gconf_entry_get_value (entry);
+          my_g_value = tp_g_value_slice_new (G_TYPE_STRING);
+          g_value_set_string (my_g_value, gconf_value_get_string (value));
+          g_hash_table_insert (account->parameters, "password", my_g_value);
+
+        }
+
+      else if (!tp_strdiff (param, "param-require-encryption"))
+        {
+
+          GValue *my_g_value;
+
+          value = gconf_entry_get_value (entry);
+          my_g_value = tp_g_value_slice_new (G_TYPE_BOOLEAN);
+          g_value_set_boolean (my_g_value, gconf_value_get_bool (value));
+          g_hash_table_insert (account->parameters, "require-encryption", my_g_value);
+
+        }
+
+      else if (!tp_strdiff (param, "param-register"))
+        {
+
+          GValue *my_g_value;
+
+          value = gconf_entry_get_value (entry);
+          my_g_value = tp_g_value_slice_new (G_TYPE_BOOLEAN);
+          g_value_set_boolean (my_g_value, gconf_value_get_bool (value));
+          g_hash_table_insert (account->parameters, "require-register", my_g_value);
+
+        }
+
+      else if (!tp_strdiff (param, "param-ident"))
+        {
+
+          GValue *my_g_value;
+
+          value = gconf_entry_get_value (entry);
+          my_g_value = tp_g_value_slice_new (G_TYPE_STRING);
+          g_value_set_string (my_g_value, gconf_value_get_string (value));
+          g_hash_table_insert (account->parameters, "ident", my_g_value);
+
+        }
+
+      else if (!tp_strdiff (param, "param-fullname"))
+        {
+
+          GValue *my_g_value;
+
+          value = gconf_entry_get_value (entry);
+          my_g_value = tp_g_value_slice_new (G_TYPE_STRING);
+          g_value_set_string (my_g_value, gconf_value_get_string (value));
+          g_hash_table_insert (account->parameters, "fullname", my_g_value);
+
+        }
+
+      else if (!tp_strdiff (param, "param-stun-server"))
+        {
+
+          GValue *my_g_value;
+
+          value = gconf_entry_get_value (entry);
+          my_g_value = tp_g_value_slice_new (G_TYPE_STRING);
+          g_value_set_string (my_g_value, gconf_value_get_string (value));
+          g_hash_table_insert (account->parameters, "stun-server", my_g_value);
+
+        }
+
+      else if (!tp_strdiff (param, "param-stun-port"))
+        {
+
+          GValue *my_g_value;
+
+          value = gconf_entry_get_value (entry);
+          my_g_value = tp_g_value_slice_new (G_TYPE_UINT);
+          g_value_set_uint (my_g_value, gconf_value_get_int (value));
+          g_hash_table_insert (account->parameters, "stun-port", my_g_value);;
+
+        }
+
+      else if (!tp_strdiff (param, "param-keepalive-interval"))
+        {
+
+          GValue *my_g_value;
+
+          value = gconf_entry_get_value (entry);
+          my_g_value = tp_g_value_slice_new (G_TYPE_UINT);
+          g_value_set_uint (my_g_value, gconf_value_get_int (value));
+          g_hash_table_insert (account->parameters, "keepalive-interval", my_g_value);;
+
+        }
+
+      g_free (param);
+      gconf_entry_unref (entry);
+
+    }
+
+  _normalize_display_name (account);
+}
+
+void empathy_import_mc4_accounts (void)
+{
+  GConfClient *client;
+  GError *error = NULL;
+  GSList *dir, *dirs, *entries;
+  gboolean import_mc4_accounts;
+
+  client = gconf_client_get_default ();
+
+  import_mc4_accounts = gconf_client_get_bool (client,
+      IMPORT_MC4_ACCOUNTS, &error);
+
+  if (error != NULL)
+    {
+      DEBUG ("Failed to get import_mc4_accounts key: %s\n", error->message);
+      g_clear_error (&error);
+      g_object_unref (client);
+      return;
+    }
+
+  if (!import_mc4_accounts)
+    {
+      g_object_unref (client);
+      return;
+    }
+
+  DEBUG ("MC 4 accounts are going to be imported\n");
+
+  dirs = gconf_client_all_dirs (client, MC_ACCOUNTS_GCONF_BASE, &error);
+
+  if (error != NULL)
+    {
+      DEBUG ("Failed to get mc_accounts_gconf_base dirs: %s\n",
+          error->message);
+      g_clear_error (&error);
+      g_object_unref (client);
+      return;
+    }
+
+  for (dir = dirs; NULL != dir; dir = dir->next)
+    {
+      gchar *account_name = _account_name_from_key (dir->data);
+      AccountData *account;
+
+      account = g_slice_new0 (AccountData);
+
+      account->connection_manager = NULL;
+      account->protocol = NULL;
+      account->enabled = FALSE;
+      account->display_name = NULL;
+      account->param_account = NULL;
+      account->param_server = NULL;
+      account->parameters = g_hash_table_new_full (g_str_hash, g_str_equal,
+          NULL, (GDestroyNotify) tp_g_value_slice_free);
+
+      DEBUG ("name : %s\n", account_name);
+
+      entries = gconf_client_all_entries (client, dir->data, &error);
+
+      if (error != NULL)
+        {
+
+          DEBUG ("Failed to get all entries: %s\n", error->message);
+          g_clear_error (&error);
+
+        }
+      else
+        {
+          _recurse_account (entries, account);
+        }
+
+      if (_protocol_is_supported (account))
+        {
+          EmpathyAccountManager *account_manager;
+          GHashTable *properties;
+
+          account_manager = empathy_account_manager_dup_singleton ();
+
+          properties = g_hash_table_new (NULL, NULL);
+
+          DEBUG ("account cm: %s", account->connection_manager);
+          DEBUG ("account protocol: %s", account->protocol);
+          DEBUG ("account display_name: %s", account->display_name);
+          DEBUG ("account param_account: %s", account->param_account);
+          DEBUG ("account param_server: %s", account->param_server);
+          DEBUG ("enabled: %d", account->enabled);
+          tp_asv_dump (account->parameters);
+
+          empathy_account_manager_create_account_async (account_manager,
+              (const gchar*) account->connection_manager,
+              (const gchar*) account->protocol, account->display_name,
+              account->parameters, properties,
+              _create_account_cb, account);
+
+          g_hash_table_unref (properties);
+          g_object_unref (account_manager);
+        }
+      else
+        {
+          DEBUG ("protocol of this account is not supported\n");
+          _account_data_free (account);
+        }
+
+      g_slist_free (entries);
+      g_free (account_name);
+      g_free (dir->data);
+
+    }
+
+  gconf_client_set_bool (client,
+      IMPORT_MC4_ACCOUNTS, FALSE, &error);
+
+  if (error != NULL)
+    {
+      DEBUG ("Failed to set import_mc4_accounts key: %s\n", error->message);
+      g_clear_error (&error);
+    }
+
+  g_slist_free (dirs);
+  g_object_unref (client);
+}
\ No newline at end of file
diff --git a/src/empathy-import-mc4-accounts.h b/src/empathy-import-mc4-accounts.h
new file mode 100644
index 0000000..fcc5118
--- /dev/null
+++ b/src/empathy-import-mc4-accounts.h
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2008 Collabora Ltd.
+ *
+ * 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., 51 Franklin St, Fifth Floor,
+ * Boston, MA  02110-1301  USA
+ *
+ * Authors: Arnaud Maillet <arnaud maillet collabora co uk>
+ */
+
+#ifndef __EMPATHY_IMPORT_MC4_ACCOUNTS_H__
+#define __EMPATHY_IMPORT_MC4_ACCOUNTS_H__
+
+G_BEGIN_DECLS
+
+void empathy_import_mc4_accounts (void);
+
+G_END_DECLS
+
+#endif /* __EMPATHY_IMPORT_MC4_ACCOUNTS_H__ */
\ No newline at end of file