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
  47 /* This class doesn't store or ref any of the individuals, since they're already
  48  * stored and referenced in the aggregator.
  49  *
  50  * This class merely forwards along signals from the aggregator and individuals
  51  * and wraps aggregator functions for other client code. */
  52 typedef struct
  53 {
  54   FolksIndividualAggregator *aggregator;
  55   EmpathyContactManager *contact_manager;
  56 } EmpathyIndividualManagerPriv;
  57
  58 enum
  59 {
  60   FAVOURITES_CHANGED,
  61   GROUPS_CHANGED,
  62   MEMBERS_CHANGED,
  63   LAST_SIGNAL
  64 };
  65
  66 static guint signals[LAST_SIGNAL] = { 0 };
  67
  68 G_DEFINE_TYPE (EmpathyIndividualManager, empathy_individual_manager,
  69     G_TYPE_OBJECT);
  70
  71 static EmpathyIndividualManager *manager_singleton = NULL;
  72
  73 static void
  74 individual_group_changed_cb (FolksIndividual *individual,
  75     gchar *group,
  76     gboolean is_member,
  77     EmpathyIndividualManager *self)
  78 {
  79   g_signal_emit (self, signals[GROUPS_CHANGED], 0, individual, group,
  80       is_member);
  81 }
  82
  83 static void
  84 individual_notify_is_favourite_cb (FolksIndividual *individual,
  85     GParamSpec *pspec,
  86     EmpathyIndividualManager *self)
  87 {
  88   gboolean is_favourite = folks_favourite_get_is_favourite (
  89       FOLKS_FAVOURITE (individual));
  90   g_signal_emit (self, signals[FAVOURITES_CHANGED], 0, individual,
  91       is_favourite);
  92 }
  93
  94 static void
  95 aggregator_individuals_changed_cb (FolksIndividualAggregator *aggregator,
  96     GList *added,
  97     GList *removed,
  98     const char *message,
  99     FolksPersona *actor,
 100     guint reason,
 101     EmpathyIndividualManager *self)
 102 {
 103   GList *l;
 104
 105   for (l = added; l; l = l->next)
 106     {
 107       g_signal_connect (l->data, "group-changed",
 108           G_CALLBACK (individual_group_changed_cb), self);
 109       g_signal_connect (l->data, "notify::is-favourite",
 110           G_CALLBACK (individual_notify_is_favourite_cb), self);
 111     }
 112
 113   for (l = removed; l; l = l->next)
 114     {
 115       g_signal_handlers_disconnect_by_func (l->data,
 116           individual_group_changed_cb, self);
 117       g_signal_handlers_disconnect_by_func (l->data,
 118           individual_notify_is_favourite_cb, self);
 119     }
 120
 121   g_signal_emit (self, signals[MEMBERS_CHANGED], 0, message,
 122       added, removed,
 123       tp_chanel_group_change_reason_from_folks_groups_change_reason (reason),
 124       TRUE);
 125 }
 126
 127 static void
 128 individual_manager_dispose (GObject *object)
 129 {
 130   EmpathyIndividualManagerPriv *priv = GET_PRIV (object);
 131
 132   tp_clear_object (&priv->contact_manager);
 133   tp_clear_object (&priv->aggregator);
 134
 135   G_OBJECT_CLASS (empathy_individual_manager_parent_class)->dispose (object);
 136 }
 137
 138 static GObject *
 139 individual_manager_constructor (GType type,
 140     guint n_props,
 141     GObjectConstructParam *props)
 142 {
 143   GObject *retval;
 144
 145   if (manager_singleton)
 146     {
 147       retval = g_object_ref (manager_singleton);
 148     }
 149   else
 150     {
 151       retval =
 152           G_OBJECT_CLASS (empathy_individual_manager_parent_class)->
 153           constructor (type, n_props, props);
 154
 155       manager_singleton = EMPATHY_INDIVIDUAL_MANAGER (retval);
 156       g_object_add_weak_pointer (retval, (gpointer) & manager_singleton);
 157     }
 158
 159   return retval;
 160 }
 161
 162 /**
 163  * empathy_individual_manager_initialized:
 164  *
 165  * Reports whether or not the singleton has already been created.
 166  *
 167  * There can be instances where you want to access the #EmpathyIndividualManager
 168  * only if it has been set up for this process.
 169  *
 170  * Returns: %TRUE if the #EmpathyIndividualManager singleton has previously
 171  * been initialized.
 172  */
 173 gboolean
 174 empathy_individual_manager_initialized (void)
 175 {
 176   return (manager_singleton != NULL);
 177 }
 178
 179 static void
 180 empathy_individual_manager_class_init (EmpathyIndividualManagerClass *klass)
 181 {
 182   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 183
 184   object_class->dispose = individual_manager_dispose;
 185   object_class->constructor = individual_manager_constructor;
 186
 187   signals[GROUPS_CHANGED] =
 188       g_signal_new ("groups-changed",
 189           G_TYPE_FROM_CLASS (klass),
 190           G_SIGNAL_RUN_LAST,
 191           0,
 192           NULL, NULL,
 193           _empathy_marshal_VOID__OBJECT_STRING_BOOLEAN,
 194           G_TYPE_NONE, 3, FOLKS_TYPE_INDIVIDUAL, G_TYPE_STRING, G_TYPE_BOOLEAN);
 195
 196   signals[FAVOURITES_CHANGED] =
 197       g_signal_new ("favourites-changed",
 198           G_TYPE_FROM_CLASS (klass),
 199           G_SIGNAL_RUN_LAST,
 200           0,
 201           NULL, NULL,
 202           _empathy_marshal_VOID__OBJECT_BOOLEAN,
 203           G_TYPE_NONE, 2, FOLKS_TYPE_INDIVIDUAL, G_TYPE_BOOLEAN);
 204
 205   signals[MEMBERS_CHANGED] =
 206       g_signal_new ("members-changed",
 207           G_TYPE_FROM_CLASS (klass),
 208           G_SIGNAL_RUN_LAST,
 209           0,
 210           NULL, NULL,
 211           _empathy_marshal_VOID__STRING_OBJECT_OBJECT_UINT,
 212           G_TYPE_NONE,
 213           4, G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_POINTER, G_TYPE_UINT);
 214
 215   g_type_class_add_private (object_class,
 216       sizeof (EmpathyIndividualManagerPriv));
 217 }
 218
 219 static void
 220 empathy_individual_manager_init (EmpathyIndividualManager *self)
 221 {
 222   EmpathyIndividualManagerPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
 223       EMPATHY_TYPE_INDIVIDUAL_MANAGER, EmpathyIndividualManagerPriv);
 224
 225   self->priv = priv;
 226   priv->contact_manager = empathy_contact_manager_dup_singleton ();
 227
 228   priv->aggregator = folks_individual_aggregator_new ();
 229   g_signal_connect (priv->aggregator, "individuals-changed",
 230       G_CALLBACK (aggregator_individuals_changed_cb), self);
 231 }
 232
 233 EmpathyIndividualManager *
 234 empathy_individual_manager_dup_singleton (void)
 235 {
 236   return g_object_new (EMPATHY_TYPE_INDIVIDUAL_MANAGER, NULL);
 237 }
 238
 239 GList *
 240 empathy_individual_manager_get_members (EmpathyIndividualManager *self)
 241 {
 242   EmpathyIndividualManagerPriv *priv = GET_PRIV (self);
 243   GHashTable *individuals;
 244
 245   g_return_val_if_fail (EMPATHY_IS_INDIVIDUAL_MANAGER (self), NULL);
 246
 247   individuals = folks_individual_aggregator_get_individuals (priv->aggregator);
 248   return individuals ? g_hash_table_get_values (individuals) : NULL;
 249 }
 250
 251 FolksIndividual *
 252 empathy_individual_manager_lookup_member (EmpathyIndividualManager *self,
 253     const gchar *id)
 254 {
 255   EmpathyIndividualManagerPriv *priv = GET_PRIV (self);
 256   GHashTable *individuals;
 257
 258   g_return_val_if_fail (EMPATHY_IS_INDIVIDUAL_MANAGER (self), NULL);
 259
 260   individuals = folks_individual_aggregator_get_individuals (priv->aggregator);
 261   if (individuals != NULL)
 262     return g_hash_table_lookup (individuals, id);
 263
 264   return NULL;
 265 }
 266
 267 static void
 268 aggregator_add_persona_from_details_cb (GObject *source,
 269     GAsyncResult *result,
 270     gpointer user_data)
 271 {
 272   FolksIndividualAggregator *aggregator = FOLKS_INDIVIDUAL_AGGREGATOR (source);
 273   EmpathyContact *contact = EMPATHY_CONTACT (user_data);
 274   FolksPersona *persona;
 275   GError *error = NULL;
 276
 277   persona = folks_individual_aggregator_add_persona_from_details_finish (
 278       aggregator, result, &error);
 279   if (error != NULL)
 280     {
 281       g_warning ("failed to add individual from contact: %s", error->message);
 282       g_clear_error (&error);
 283     }
 284
 285   /* We can unref the contact now */
 286   g_object_unref (contact);
 287 }
 288
 289 void
 290 empathy_individual_manager_add_from_contact (EmpathyIndividualManager *self,
 291     EmpathyContact *contact)
 292 {
 293   EmpathyIndividualManagerPriv *priv;
 294   GHashTable* details;
 295   TpAccount *account;
 296   GValue value = {0};
 297   const gchar *store_id;
 298
 299   g_return_if_fail (EMPATHY_IS_INDIVIDUAL_MANAGER (self));
 300   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
 301
 302   priv = GET_PRIV (self);
 303
 304   /* We need to ref the contact since otherwise its linked TpHandle will be
 305    * destroyed. */
 306   g_object_ref (contact);
 307
 308   DEBUG ("adding individual from contact %s (%s)",
 309       empathy_contact_get_id (contact), empathy_contact_get_name (contact));
 310
 311   account = empathy_contact_get_account (contact);
 312   store_id = tp_proxy_get_object_path (TP_PROXY (account));
 313
 314   details = g_hash_table_new (g_str_hash, g_str_equal);
 315   g_value_init (&value, G_TYPE_STRING);
 316   g_value_set_string (&value, empathy_contact_get_id (contact));
 317   g_hash_table_insert (details, "contact", &value);
 318
 319   folks_individual_aggregator_add_persona_from_details (
 320       priv->aggregator, NULL, "telepathy", store_id, details,
 321       aggregator_add_persona_from_details_cb, contact);
 322
 323   g_hash_table_destroy (details);
 324 }
 325
 326 /**
 327  * Removes the inner contact from the server (and thus the Individual). Not
 328  * meant for de-shelling inner personas from an Individual.
 329  */
 330 void
 331 empathy_individual_manager_remove (EmpathyIndividualManager *self,
 332     FolksIndividual *individual,
 333     const gchar *message)
 334 {
 335   EmpathyIndividualManagerPriv *priv;
 336
 337   g_return_if_fail (EMPATHY_IS_INDIVIDUAL_MANAGER (self));
 338   g_return_if_fail (FOLKS_IS_INDIVIDUAL (individual));
 339
 340   priv = GET_PRIV (self);
 341
 342   DEBUG ("removing individual %s (%s)",
 343       folks_individual_get_id (individual),
 344       folks_individual_get_alias (individual));
 345
 346   folks_individual_aggregator_remove_individual (priv->aggregator, individual);
 347 }
 348
 349 static void
 350 remove_group_cb (const gchar *id,
 351     FolksIndividual *individual,
 352     const gchar *group)
 353 {
 354   folks_groups_change_group (FOLKS_GROUPS (individual), group, FALSE);
 355 }
 356
 357 void
 358 empathy_individual_manager_remove_group (EmpathyIndividualManager *manager,
 359     const gchar *group)
 360 {
 361   EmpathyIndividualManagerPriv *priv;
 362   GHashTable *individuals;
 363
 364   g_return_if_fail (EMPATHY_IS_INDIVIDUAL_MANAGER (manager));
 365   g_return_if_fail (group != NULL);
 366
 367   priv = GET_PRIV (manager);
 368
 369   DEBUG ("removing group %s", group);
 370
 371   /* Remove every individual from the group */
 372   individuals = folks_individual_aggregator_get_individuals (priv->aggregator);
 373   g_hash_table_foreach (individuals, (GHFunc) remove_group_cb,
 374       (gpointer) group);
 375 }
 376
 377 EmpathyIndividualManagerFlags
 378 empathy_individual_manager_get_flags_for_connection (
 379     EmpathyIndividualManager *self,
 380     TpConnection *connection)
 381 {
 382   EmpathyIndividualManagerPriv *priv;
 383   EmpathyContactListFlags list_flags;
 384   EmpathyIndividualManagerFlags flags;
 385
 386   g_return_val_if_fail (EMPATHY_IS_INDIVIDUAL_MANAGER (self),
 387       EMPATHY_INDIVIDUAL_MANAGER_NO_FLAGS);
 388
 389   priv = GET_PRIV (self);
 390
 391   list_flags = empathy_contact_manager_get_flags_for_connection (
 392     priv->contact_manager, connection);
 393
 394   flags = EMPATHY_INDIVIDUAL_MANAGER_NO_FLAGS;
 395   if (list_flags & EMPATHY_CONTACT_LIST_CAN_ADD)
 396     flags |= EMPATHY_INDIVIDUAL_MANAGER_CAN_ADD;
 397   if (list_flags & EMPATHY_CONTACT_LIST_CAN_REMOVE)
 398     flags |= EMPATHY_INDIVIDUAL_MANAGER_CAN_REMOVE;
 399   if (list_flags & EMPATHY_CONTACT_LIST_CAN_ALIAS)
 400     flags |= EMPATHY_INDIVIDUAL_MANAGER_CAN_ALIAS;
 401   if (list_flags & EMPATHY_CONTACT_LIST_CAN_GROUP)
 402     flags |= EMPATHY_INDIVIDUAL_MANAGER_CAN_GROUP;
 403
 404   return flags;
 405 }