libempathy/empathy-individual-manager.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*
   3  * Copyright (C) 2007-2010 Collabora Ltd.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  18  *
  19  * Authors: Xavier Claessens <xclaesse@gmail.com>
  20  *          Travis Reitter <travis.reitter@collabora.co.uk>
  21  */
  22
  23 #include <config.h>
  24
  25 #include <string.h>
  26
  27 #include <telepathy-glib/account-manager.h>
  28 #include <telepathy-glib/enums.h>
  29 #include <telepathy-glib/proxy-subclass.h>
  30 #include <telepathy-glib/util.h>
  31
  32 #include <folks/folks.h>
  33
  34 #include <extensions/extensions.h>
  35
  36 #include "empathy-individual-manager.h"
  37 #include "empathy-contact-manager.h"
  38 #include "empathy-contact-list.h"
  39 #include "empathy-marshal.h"
  40 #include "empathy-utils.h"
  41
  42 #define DEBUG_FLAG EMPATHY_DEBUG_CONTACT
  43 #include "empathy-debug.h"
  44
  45 #define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyIndividualManager)
  46 typedef struct
  47 {
  48   FolksIndividualAggregator *aggregator;
  49   EmpathyContactManager *contact_manager;
  50   TpProxy *logger;
  51 } EmpathyIndividualManagerPriv;
  52
  53 G_DEFINE_TYPE (EmpathyIndividualManager, empathy_individual_manager,
  54     G_TYPE_OBJECT);
  55
  56 static EmpathyIndividualManager *manager_singleton = NULL;
  57
  58 static void
  59 individual_group_changed_cb (FolksIndividual *individual,
  60     gchar *group,
  61     gboolean is_member,
  62     EmpathyIndividualManager *self)
  63 {
  64   g_signal_emit_by_name (self, "groups-changed", individual, group,
  65       is_member);
  66 }
  67
  68 static void
  69 aggregator_individuals_added_cb (FolksIndividualAggregator *aggregator,
  70     GList *individuals,
  71     EmpathyIndividualManager *self)
  72 {
  73   GList *l;
  74
  75   for (l = individuals; l; l = l->next)
  76     {
  77       g_signal_connect (l->data, "group-changed",
  78           G_CALLBACK (individual_group_changed_cb), self);
  79     }
  80
  81   /* TODO: don't hard-code the reason or message */
  82   g_signal_emit_by_name (self, "members-changed",
  83       "individual(s) added", individuals, NULL,
  84       TP_CHANNEL_GROUP_CHANGE_REASON_NONE, TRUE);
  85 }
  86
  87 static void
  88 aggregator_individuals_removed_cb (FolksIndividualAggregator *aggregator,
  89     GList *individuals,
  90     EmpathyIndividualManager *self)
  91 {
  92   GList *l;
  93
  94   for (l = individuals; l; l = l->next)
  95     {
  96       g_signal_handlers_disconnect_by_func (l->data,
  97           individual_group_changed_cb, self);
  98     }
  99
 100   /* TODO: don't hard-code the reason or message */
 101   g_signal_emit_by_name (self, "members-changed",
 102       "individual(s) removed", NULL, individuals,
 103       TP_CHANNEL_GROUP_CHANGE_REASON_NONE, TRUE);
 104 }
 105
 106 static void
 107 individual_manager_finalize (GObject *object)
 108 {
 109   EmpathyIndividualManagerPriv *priv = GET_PRIV (object);
 110
 111   if (priv->logger != NULL)
 112     g_object_unref (priv->logger);
 113
 114   if (priv->contact_manager != NULL)
 115     g_object_unref (priv->contact_manager);
 116
 117   if (priv->aggregator != NULL)
 118     g_object_unref (priv->aggregator);
 119 }
 120
 121 static GObject *
 122 individual_manager_constructor (GType type,
 123     guint n_props,
 124     GObjectConstructParam *props)
 125 {
 126   GObject *retval;
 127
 128   if (manager_singleton)
 129     {
 130       retval = g_object_ref (manager_singleton);
 131     }
 132   else
 133     {
 134       retval =
 135           G_OBJECT_CLASS (empathy_individual_manager_parent_class)->
 136           constructor (type, n_props, props);
 137
 138       manager_singleton = EMPATHY_INDIVIDUAL_MANAGER (retval);
 139       g_object_add_weak_pointer (retval, (gpointer) & manager_singleton);
 140     }
 141
 142   return retval;
 143 }
 144
 145 /**
 146  * empathy_individual_manager_initialized:
 147  *
 148  * Reports whether or not the singleton has already been created.
 149  *
 150  * There can be instances where you want to access the #EmpathyIndividualManager
 151  * only if it has been set up for this process.
 152  *
 153  * Returns: %TRUE if the #EmpathyIndividualManager singleton has previously
 154  * been initialized.
 155  */
 156 gboolean
 157 empathy_individual_manager_initialized (void)
 158 {
 159   return (manager_singleton != NULL);
 160 }
 161
 162 static void
 163 empathy_individual_manager_class_init (EmpathyIndividualManagerClass *klass)
 164 {
 165   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 166
 167   object_class->finalize = individual_manager_finalize;
 168   object_class->constructor = individual_manager_constructor;
 169
 170   g_signal_new ("groups-changed",
 171       G_TYPE_FROM_CLASS (klass),
 172       G_SIGNAL_RUN_LAST,
 173       0,
 174       NULL, NULL,
 175       _empathy_marshal_VOID__OBJECT_STRING_BOOLEAN,
 176       G_TYPE_NONE, 3, FOLKS_TYPE_INDIVIDUAL, G_TYPE_STRING, G_TYPE_BOOLEAN);
 177
 178   g_signal_new ("members-changed",
 179       G_TYPE_FROM_CLASS (klass),
 180       G_SIGNAL_RUN_LAST,
 181       0,
 182       NULL, NULL,
 183       _empathy_marshal_VOID__STRING_OBJECT_OBJECT_UINT,
 184       G_TYPE_NONE,
 185       4, G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_POINTER, G_TYPE_UINT);
 186
 187   g_type_class_add_private (object_class,
 188       sizeof (EmpathyIndividualManagerPriv));
 189 }
 190
 191 static void
 192 empathy_individual_manager_init (EmpathyIndividualManager *self)
 193 {
 194   EmpathyIndividualManagerPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
 195       EMPATHY_TYPE_INDIVIDUAL_MANAGER, EmpathyIndividualManagerPriv);
 196   TpDBusDaemon *bus;
 197   GError *error = NULL;
 198
 199   self->priv = priv;
 200   priv->contact_manager = empathy_contact_manager_dup_singleton ();
 201
 202   priv->aggregator = folks_individual_aggregator_new ();
 203   g_signal_connect (priv->aggregator, "individuals-added",
 204       G_CALLBACK (aggregator_individuals_added_cb), self);
 205   g_signal_connect (priv->aggregator, "individuals-removed",
 206       G_CALLBACK (aggregator_individuals_removed_cb), self);
 207
 208   bus = tp_dbus_daemon_dup (&error);
 209
 210   if (error == NULL)
 211     {
 212       priv->logger = g_object_new (TP_TYPE_PROXY,
 213           "bus-name", "org.freedesktop.Telepathy.Logger",
 214           "object-path",
 215           "/org/freedesktop/Telepathy/Logger", "dbus-daemon", bus, NULL);
 216       g_object_unref (bus);
 217
 218       tp_proxy_add_interface_by_id (priv->logger, EMP_IFACE_QUARK_LOGGER);
 219     }
 220   else
 221     {
 222       DEBUG ("Failed to get telepathy-logger proxy: %s", error->message);
 223       g_clear_error (&error);
 224     }
 225 }
 226
 227 EmpathyIndividualManager *
 228 empathy_individual_manager_dup_singleton (void)
 229 {
 230   return g_object_new (EMPATHY_TYPE_INDIVIDUAL_MANAGER, NULL);
 231 }
 232
 233 /* TODO: support adding and removing Individuals */
 234
 235 GList *
 236 empathy_individual_manager_get_members (EmpathyIndividualManager *self)
 237 {
 238   EmpathyIndividualManagerPriv *priv = GET_PRIV (self);
 239   GHashTable *individuals;
 240
 241   g_return_val_if_fail (EMPATHY_IS_INDIVIDUAL_MANAGER (self), NULL);
 242
 243   individuals = folks_individual_aggregator_get_individuals (priv->aggregator);
 244   return individuals ? g_hash_table_get_values (individuals) : NULL;
 245 }
 246
 247 FolksIndividual *
 248 empathy_individual_manager_lookup_member (EmpathyIndividualManager *self,
 249     const gchar *id)
 250 {
 251   EmpathyIndividualManagerPriv *priv = GET_PRIV (self);
 252   GHashTable *individuals;
 253
 254   g_return_val_if_fail (EMPATHY_IS_INDIVIDUAL_MANAGER (self), NULL);
 255
 256   individuals = folks_individual_aggregator_get_individuals (priv->aggregator);
 257   if (individuals != NULL)
 258     return g_hash_table_lookup (individuals, id);
 259
 260   return NULL;
 261 }
 262
 263 static void
 264 aggregator_add_persona_from_details_cb (GObject *source,
 265     GAsyncResult *result,
 266     gpointer user_data)
 267 {
 268   EmpathyIndividualManager *self = EMPATHY_INDIVIDUAL_MANAGER (user_data);
 269   EmpathyIndividualManagerPriv *priv = GET_PRIV (self);
 270   FolksPersona *persona;
 271   GError *error = NULL;
 272
 273   persona = folks_individual_aggregator_add_persona_from_details_finish (
 274       priv->aggregator, result, &error);
 275   if (error != NULL)
 276     {
 277       g_warning ("failed to add individual from contact: %s", error->message);
 278       g_clear_error (&error);
 279     }
 280 }
 281
 282 void
 283 empathy_individual_manager_add_from_contact (EmpathyIndividualManager *self,
 284     EmpathyContact *contact)
 285 {
 286   EmpathyIndividualManagerPriv *priv;
 287   GHashTable* details;
 288   TpAccount *account;
 289   const gchar *store_id;
 290
 291   g_return_if_fail (EMPATHY_IS_INDIVIDUAL_MANAGER (self));
 292   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
 293
 294   priv = GET_PRIV (self);
 295
 296   DEBUG (G_STRLOC ": adding individual from contact %s (%s)",
 297       empathy_contact_get_id (contact), empathy_contact_get_name (contact));
 298
 299   account = empathy_contact_get_account (contact);
 300   store_id = tp_proxy_get_object_path (TP_PROXY (account));
 301
 302   details = g_hash_table_new (g_str_hash, g_str_equal);
 303   g_hash_table_insert (details, "contact",
 304       (gchar*) empathy_contact_get_id (contact));
 305
 306   folks_individual_aggregator_add_persona_from_details (
 307       priv->aggregator, NULL, "telepathy", store_id, details,
 308       aggregator_add_persona_from_details_cb, self);
 309
 310   g_hash_table_destroy (details);
 311 }
 312
 313 /**
 314  * Removes the inner contact from the server (and thus the Individual). Not
 315  * meant for de-shelling inner personas from an Individual.
 316  */
 317 void
 318 empathy_individual_manager_remove (EmpathyIndividualManager *self,
 319     FolksIndividual *individual,
 320     const gchar *message)
 321 {
 322   EmpathyIndividualManagerPriv *priv;
 323
 324   g_return_if_fail (EMPATHY_IS_INDIVIDUAL_MANAGER (self));
 325   g_return_if_fail (FOLKS_IS_INDIVIDUAL (individual));
 326
 327   priv = GET_PRIV (self);
 328
 329   DEBUG (G_STRLOC ": removing individual %s (%s)",
 330       folks_individual_get_id (individual),
 331       folks_individual_get_alias (individual));
 332
 333   folks_individual_aggregator_remove_individual (priv->aggregator, individual);
 334 }
 335
 336 EmpathyIndividualManagerFlags
 337 empathy_individual_manager_get_flags_for_connection (
 338     EmpathyIndividualManager *self,
 339     TpConnection *connection)
 340 {
 341   EmpathyIndividualManagerPriv *priv;
 342   EmpathyContactListFlags list_flags;
 343   EmpathyIndividualManagerFlags flags;
 344
 345   g_return_val_if_fail (EMPATHY_IS_INDIVIDUAL_MANAGER (self),
 346       EMPATHY_INDIVIDUAL_MANAGER_NO_FLAGS);
 347
 348   priv = GET_PRIV (self);
 349
 350   list_flags = empathy_contact_manager_get_flags_for_connection (
 351     priv->contact_manager, connection);
 352
 353   flags = EMPATHY_INDIVIDUAL_MANAGER_NO_FLAGS;
 354   if (list_flags & EMPATHY_CONTACT_LIST_CAN_ADD)
 355     flags |= EMPATHY_INDIVIDUAL_MANAGER_CAN_ADD;
 356   if (list_flags & EMPATHY_CONTACT_LIST_CAN_REMOVE)
 357     flags |= EMPATHY_INDIVIDUAL_MANAGER_CAN_REMOVE;
 358   if (list_flags & EMPATHY_CONTACT_LIST_CAN_ALIAS)
 359     flags |= EMPATHY_INDIVIDUAL_MANAGER_CAN_ALIAS;
 360   if (list_flags & EMPATHY_CONTACT_LIST_CAN_GROUP)
 361     flags |= EMPATHY_INDIVIDUAL_MANAGER_CAN_GROUP;
 362
 363   return flags;
 364 }