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