1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
3 * Copyright (C) 2007-2010 Collabora Ltd.
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.
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.
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
19 * Authors: Xavier Claessens <xclaesse@gmail.com>
20 * Travis Reitter <travis.reitter@collabora.co.uk>
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>
32 #include <folks/folks.h>
33 #include <folks/folks-telepathy.h>
35 #include <extensions/extensions.h>
37 #include "empathy-individual-manager.h"
38 #include "empathy-utils.h"
40 #define DEBUG_FLAG EMPATHY_DEBUG_CONTACT
41 #include "empathy-debug.h"
43 #define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyIndividualManager)
45 /* This class only stores and refs Individuals who contain an EmpathyContact.
47 * This class merely forwards along signals from the aggregator and individuals
48 * and wraps aggregator functions for other client code. */
51 FolksIndividualAggregator
*aggregator
;
52 GHashTable
*individuals
; /* Individual.id -> Individual */
53 gboolean contacts_loaded
;
54 } EmpathyIndividualManagerPriv
;
65 static guint signals
[LAST_SIGNAL
] = { 0 };
67 G_DEFINE_TYPE (EmpathyIndividualManager
, empathy_individual_manager
,
70 static EmpathyIndividualManager
*manager_singleton
= NULL
;
73 individual_group_changed_cb (FolksIndividual
*individual
,
76 EmpathyIndividualManager
*self
)
78 g_signal_emit (self
, signals
[GROUPS_CHANGED
], 0, individual
, group
,
83 individual_notify_is_favourite_cb (FolksIndividual
*individual
,
85 EmpathyIndividualManager
*self
)
87 gboolean is_favourite
= folks_favourite_details_get_is_favourite (
88 FOLKS_FAVOURITE_DETAILS (individual
));
89 g_signal_emit (self
, signals
[FAVOURITES_CHANGED
], 0, individual
,
94 add_individual (EmpathyIndividualManager
*self
, FolksIndividual
*individual
)
96 EmpathyIndividualManagerPriv
*priv
= GET_PRIV (self
);
98 g_hash_table_insert (priv
->individuals
,
99 g_strdup (folks_individual_get_id (individual
)),
100 g_object_ref (individual
));
102 g_signal_connect (individual
, "group-changed",
103 G_CALLBACK (individual_group_changed_cb
), self
);
104 g_signal_connect (individual
, "notify::is-favourite",
105 G_CALLBACK (individual_notify_is_favourite_cb
), self
);
109 remove_individual (EmpathyIndividualManager
*self
, FolksIndividual
*individual
)
111 EmpathyIndividualManagerPriv
*priv
= GET_PRIV (self
);
113 g_signal_handlers_disconnect_by_func (individual
,
114 individual_group_changed_cb
, self
);
115 g_signal_handlers_disconnect_by_func (individual
,
116 individual_notify_is_favourite_cb
, self
);
118 g_hash_table_remove (priv
->individuals
, folks_individual_get_id (individual
));
121 /* This is emitted for *all* individuals in the individual aggregator (not
122 * just the ones we keep a reference to), to allow for the case where a new
123 * individual doesn't contain an EmpathyContact, but later has a persona added
126 individual_notify_personas_cb (FolksIndividual
*individual
,
128 EmpathyIndividualManager
*self
)
130 EmpathyIndividualManagerPriv
*priv
= GET_PRIV (self
);
132 const gchar
*id
= folks_individual_get_id (individual
);
133 gboolean has_contact
= empathy_folks_individual_contains_contact (individual
);
134 gboolean had_contact
= (g_hash_table_lookup (priv
->individuals
,
135 id
) != NULL
) ? TRUE
: FALSE
;
137 if (had_contact
== TRUE
&& has_contact
== FALSE
)
139 GList
*removed
= NULL
;
141 /* The Individual has lost its EmpathyContact */
142 removed
= g_list_prepend (removed
, individual
);
143 g_signal_emit (self
, signals
[MEMBERS_CHANGED
], 0, NULL
, NULL
, removed
,
144 TP_CHANNEL_GROUP_CHANGE_REASON_NONE
/* FIXME */);
145 g_list_free (removed
);
147 remove_individual (self
, individual
);
149 else if (had_contact
== FALSE
&& has_contact
== TRUE
)
153 /* The Individual has gained its first EmpathyContact */
154 add_individual (self
, individual
);
156 added
= g_list_prepend (added
, individual
);
157 g_signal_emit (self
, signals
[MEMBERS_CHANGED
], 0, NULL
, added
, NULL
,
158 TP_CHANNEL_GROUP_CHANGE_REASON_NONE
/* FIXME */);
164 aggregator_individuals_changed_cb (FolksIndividualAggregator
*aggregator
,
165 GeeMultiMap
*changes
,
166 EmpathyIndividualManager
*self
)
168 EmpathyIndividualManagerPriv
*priv
= GET_PRIV (self
);
171 GeeCollection
*added
;
172 GList
*added_set
= NULL
, *added_filtered
= NULL
, *removed_list
= NULL
;
174 /* We're not interested in the relationships between the added and removed
175 * individuals, so just extract collections of them. Note that the added
176 * collection may contain duplicates, while the removed set won't. */
177 removed
= gee_multi_map_get_keys (changes
);
178 added
= gee_multi_map_get_values (changes
);
180 /* Handle the removals first, as one of the added Individuals might have the
181 * same ID as one of the removed Individuals (due to linking). */
182 iter
= gee_iterable_iterator (GEE_ITERABLE (removed
));
183 while (gee_iterator_next (iter
))
185 FolksIndividual
*ind
= gee_iterator_get (iter
);
190 g_signal_handlers_disconnect_by_func (ind
,
191 individual_notify_personas_cb
, self
);
193 if (g_hash_table_lookup (priv
->individuals
,
194 folks_individual_get_id (ind
)) != NULL
)
196 remove_individual (self
, ind
);
197 removed_list
= g_list_prepend (removed_list
, ind
);
200 g_clear_object (&ind
);
202 g_clear_object (&iter
);
204 /* Filter the individuals for ones which contain EmpathyContacts */
205 iter
= gee_iterable_iterator (GEE_ITERABLE (added
));
206 while (gee_iterator_next (iter
))
208 FolksIndividual
*ind
= gee_iterator_get (iter
);
210 /* Make sure we handle each added individual only once. */
211 if (ind
== NULL
|| g_list_find (added_set
, ind
) != NULL
)
213 added_set
= g_list_prepend (added_set
, ind
);
215 g_signal_connect (ind
, "notify::personas",
216 G_CALLBACK (individual_notify_personas_cb
), self
);
218 if (empathy_folks_individual_contains_contact (ind
) == TRUE
)
220 add_individual (self
, ind
);
221 added_filtered
= g_list_prepend (added_filtered
, ind
);
224 g_clear_object (&ind
);
226 g_clear_object (&iter
);
228 g_list_free (added_set
);
230 g_object_unref (added
);
231 g_object_unref (removed
);
233 /* Bail if we have no individuals left */
234 if (added_filtered
== NULL
&& removed
== NULL
)
237 added_filtered
= g_list_reverse (added_filtered
);
239 g_signal_emit (self
, signals
[MEMBERS_CHANGED
], 0, NULL
,
240 added_filtered
, removed_list
,
241 TP_CHANNEL_GROUP_CHANGE_REASON_NONE
,
244 g_list_free (added_filtered
);
245 g_list_free (removed_list
);
249 individual_manager_dispose (GObject
*object
)
251 EmpathyIndividualManagerPriv
*priv
= GET_PRIV (object
);
253 g_hash_table_unref (priv
->individuals
);
255 g_signal_handlers_disconnect_by_func (priv
->aggregator
,
256 aggregator_individuals_changed_cb
, object
);
257 tp_clear_object (&priv
->aggregator
);
259 G_OBJECT_CLASS (empathy_individual_manager_parent_class
)->dispose (object
);
263 individual_manager_constructor (GType type
,
265 GObjectConstructParam
*props
)
269 if (manager_singleton
)
271 retval
= g_object_ref (manager_singleton
);
276 G_OBJECT_CLASS (empathy_individual_manager_parent_class
)->
277 constructor (type
, n_props
, props
);
279 manager_singleton
= EMPATHY_INDIVIDUAL_MANAGER (retval
);
280 g_object_add_weak_pointer (retval
, (gpointer
) & manager_singleton
);
287 * empathy_individual_manager_initialized:
289 * Reports whether or not the singleton has already been created.
291 * There can be instances where you want to access the #EmpathyIndividualManager
292 * only if it has been set up for this process.
294 * Returns: %TRUE if the #EmpathyIndividualManager singleton has previously
298 empathy_individual_manager_initialized (void)
300 return (manager_singleton
!= NULL
);
304 empathy_individual_manager_class_init (EmpathyIndividualManagerClass
*klass
)
306 GObjectClass
*object_class
= G_OBJECT_CLASS (klass
);
308 object_class
->dispose
= individual_manager_dispose
;
309 object_class
->constructor
= individual_manager_constructor
;
311 signals
[GROUPS_CHANGED
] =
312 g_signal_new ("groups-changed",
313 G_TYPE_FROM_CLASS (klass
),
317 g_cclosure_marshal_generic
,
318 G_TYPE_NONE
, 3, FOLKS_TYPE_INDIVIDUAL
, G_TYPE_STRING
, G_TYPE_BOOLEAN
);
320 signals
[FAVOURITES_CHANGED
] =
321 g_signal_new ("favourites-changed",
322 G_TYPE_FROM_CLASS (klass
),
326 g_cclosure_marshal_generic
,
327 G_TYPE_NONE
, 2, FOLKS_TYPE_INDIVIDUAL
, G_TYPE_BOOLEAN
);
329 signals
[MEMBERS_CHANGED
] =
330 g_signal_new ("members-changed",
331 G_TYPE_FROM_CLASS (klass
),
335 g_cclosure_marshal_generic
,
337 4, G_TYPE_STRING
, G_TYPE_POINTER
, G_TYPE_POINTER
, G_TYPE_UINT
);
339 signals
[CONTACTS_LOADED
] =
340 g_signal_new ("contacts-loaded",
341 G_TYPE_FROM_CLASS (klass
),
345 g_cclosure_marshal_generic
,
349 g_type_class_add_private (object_class
,
350 sizeof (EmpathyIndividualManagerPriv
));
354 aggregator_is_quiescent_notify_cb (FolksIndividualAggregator
*aggregator
,
356 EmpathyIndividualManager
*self
)
358 EmpathyIndividualManagerPriv
*priv
= GET_PRIV (self
);
359 gboolean is_quiescent
;
361 if (priv
->contacts_loaded
)
364 g_object_get (aggregator
, "is-quiescent", &is_quiescent
, NULL
);
369 priv
->contacts_loaded
= TRUE
;
371 g_signal_emit (self
, signals
[CONTACTS_LOADED
], 0);
375 empathy_individual_manager_init (EmpathyIndividualManager
*self
)
377 EmpathyIndividualManagerPriv
*priv
= G_TYPE_INSTANCE_GET_PRIVATE (self
,
378 EMPATHY_TYPE_INDIVIDUAL_MANAGER
, EmpathyIndividualManagerPriv
);
381 priv
->individuals
= g_hash_table_new_full (g_str_hash
, g_str_equal
,
382 g_free
, g_object_unref
);
384 priv
->aggregator
= folks_individual_aggregator_new ();
385 g_signal_connect (priv
->aggregator
, "individuals-changed-detailed",
386 G_CALLBACK (aggregator_individuals_changed_cb
), self
);
387 g_signal_connect (priv
->aggregator
, "notify::is-quiescent",
388 G_CALLBACK (aggregator_is_quiescent_notify_cb
), self
);
389 folks_individual_aggregator_prepare (priv
->aggregator
, NULL
, NULL
);
392 EmpathyIndividualManager
*
393 empathy_individual_manager_dup_singleton (void)
395 return g_object_new (EMPATHY_TYPE_INDIVIDUAL_MANAGER
, NULL
);
399 empathy_individual_manager_get_members (EmpathyIndividualManager
*self
)
401 EmpathyIndividualManagerPriv
*priv
= GET_PRIV (self
);
403 g_return_val_if_fail (EMPATHY_IS_INDIVIDUAL_MANAGER (self
), NULL
);
405 return g_hash_table_get_values (priv
->individuals
);
409 empathy_individual_manager_lookup_member (EmpathyIndividualManager
*self
,
412 EmpathyIndividualManagerPriv
*priv
= GET_PRIV (self
);
414 g_return_val_if_fail (EMPATHY_IS_INDIVIDUAL_MANAGER (self
), NULL
);
416 return g_hash_table_lookup (priv
->individuals
, id
);
420 aggregator_add_persona_from_details_cb (GObject
*source
,
421 GAsyncResult
*result
,
424 FolksIndividualAggregator
*aggregator
= FOLKS_INDIVIDUAL_AGGREGATOR (source
);
425 EmpathyContact
*contact
= EMPATHY_CONTACT (user_data
);
426 FolksPersona
*persona
;
427 GError
*error
= NULL
;
429 persona
= folks_individual_aggregator_add_persona_from_details_finish (
430 aggregator
, result
, &error
);
433 g_warning ("failed to add individual from contact: %s", error
->message
);
434 g_clear_error (&error
);
437 /* The persona can be NULL even if there wasn't an error, if the persona was
438 * already in the contact list */
441 /* Set the contact's persona */
442 empathy_contact_set_persona (contact
, persona
);
443 g_object_unref (persona
);
446 g_object_unref (contact
);
450 empathy_individual_manager_add_from_contact (EmpathyIndividualManager
*self
,
451 EmpathyContact
*contact
)
453 EmpathyIndividualManagerPriv
*priv
;
454 FolksBackendStore
*backend_store
;
455 FolksBackend
*backend
;
456 FolksPersonaStore
*persona_store
;
458 GeeMap
*persona_stores
;
460 const gchar
*store_id
;
462 g_return_if_fail (EMPATHY_IS_INDIVIDUAL_MANAGER (self
));
463 g_return_if_fail (EMPATHY_IS_CONTACT (contact
));
465 priv
= GET_PRIV (self
);
467 /* We need to ref the contact since otherwise its linked TpHandle will be
469 g_object_ref (contact
);
471 DEBUG ("adding individual from contact %s (%s)",
472 empathy_contact_get_id (contact
), empathy_contact_get_alias (contact
));
474 account
= empathy_contact_get_account (contact
);
475 store_id
= tp_proxy_get_object_path (TP_PROXY (account
));
477 /* Get the persona store to use */
478 backend_store
= folks_backend_store_dup ();
480 folks_backend_store_dup_backend_by_name (backend_store
, "telepathy");
484 g_warning ("Failed to add individual from contact: couldn't get "
485 "'telepathy' backend");
489 persona_stores
= folks_backend_get_persona_stores (backend
);
490 persona_store
= gee_map_get (persona_stores
, store_id
);
492 if (persona_store
== NULL
)
494 g_warning ("Failed to add individual from contact: couldn't get persona "
495 "store '%s'", store_id
);
499 details
= tp_asv_new (
500 "contact", G_TYPE_STRING
, empathy_contact_get_id (contact
),
503 folks_individual_aggregator_add_persona_from_details (
504 priv
->aggregator
, NULL
, persona_store
, details
,
505 aggregator_add_persona_from_details_cb
, contact
);
507 g_hash_table_unref (details
);
508 g_object_unref (persona_store
);
511 tp_clear_object (&backend
);
512 tp_clear_object (&backend_store
);
516 aggregator_remove_individual_cb (GObject
*source
,
517 GAsyncResult
*result
,
520 FolksIndividualAggregator
*aggregator
= FOLKS_INDIVIDUAL_AGGREGATOR (source
);
521 GError
*error
= NULL
;
523 folks_individual_aggregator_remove_individual_finish (
524 aggregator
, result
, &error
);
527 g_warning ("failed to remove individual: %s", error
->message
);
528 g_clear_error (&error
);
533 * Removes the inner contact from the server (and thus the Individual). Not
534 * meant for de-shelling inner personas from an Individual.
537 empathy_individual_manager_remove (EmpathyIndividualManager
*self
,
538 FolksIndividual
*individual
,
539 const gchar
*message
)
541 EmpathyIndividualManagerPriv
*priv
;
543 g_return_if_fail (EMPATHY_IS_INDIVIDUAL_MANAGER (self
));
544 g_return_if_fail (FOLKS_IS_INDIVIDUAL (individual
));
546 priv
= GET_PRIV (self
);
548 DEBUG ("removing individual %s (%s)",
549 folks_individual_get_id (individual
),
550 folks_alias_details_get_alias (FOLKS_ALIAS_DETAILS (individual
)));
552 folks_individual_aggregator_remove_individual (priv
->aggregator
, individual
,
553 aggregator_remove_individual_cb
, self
);
556 /* FIXME: The parameter @self is not required and the method can be placed in
557 * utilities. I left it as it is to stay coherent with empathy-2.34 */
559 * empathy_individual_manager_supports_blocking
560 * @self: the #EmpathyIndividualManager
561 * @individual: an individual to check
563 * Indicates whether any personas of an @individual can be blocked.
565 * Returns: %TRUE if any persona supports contact blocking
568 empathy_individual_manager_supports_blocking (EmpathyIndividualManager
*self
,
569 FolksIndividual
*individual
)
573 gboolean retval
= FALSE
;
575 g_return_val_if_fail (EMPATHY_IS_INDIVIDUAL_MANAGER (self
), FALSE
);
577 personas
= folks_individual_get_personas (individual
);
578 iter
= gee_iterable_iterator (GEE_ITERABLE (personas
));
579 while (!retval
&& gee_iterator_next (iter
))
581 TpfPersona
*persona
= gee_iterator_get (iter
);
584 if (TPF_IS_PERSONA (persona
))
586 TpContact
*tp_contact
;
588 tp_contact
= tpf_persona_get_contact (persona
);
589 if (tp_contact
!= NULL
)
591 conn
= tp_contact_get_connection (tp_contact
);
593 if (tp_proxy_has_interface_by_id (conn
,
594 TP_IFACE_QUARK_CONNECTION_INTERFACE_CONTACT_BLOCKING
))
598 g_clear_object (&persona
);
600 g_clear_object (&iter
);
606 empathy_individual_manager_set_blocked (EmpathyIndividualManager
*self
,
607 FolksIndividual
*individual
,
614 g_return_if_fail (EMPATHY_IS_INDIVIDUAL_MANAGER (self
));
616 personas
= folks_individual_get_personas (individual
);
617 iter
= gee_iterable_iterator (GEE_ITERABLE (personas
));
618 while (gee_iterator_next (iter
))
620 TpfPersona
*persona
= gee_iterator_get (iter
);
622 if (TPF_IS_PERSONA (persona
))
624 TpContact
*tp_contact
;
627 tp_contact
= tpf_persona_get_contact (persona
);
628 if (tp_contact
== NULL
)
631 conn
= tp_contact_get_connection (tp_contact
);
633 if (!tp_proxy_has_interface_by_id (conn
,
634 TP_IFACE_QUARK_CONNECTION_INTERFACE_CONTACT_BLOCKING
))
638 tp_contact_block_async (tp_contact
, abusive
, NULL
, NULL
);
640 tp_contact_unblock_async (tp_contact
, NULL
, NULL
);
642 g_clear_object (&persona
);
644 g_clear_object (&iter
);
648 groups_change_group_cb (GObject
*source
,
649 GAsyncResult
*result
,
652 FolksGroupDetails
*group_details
= FOLKS_GROUP_DETAILS (source
);
653 GError
*error
= NULL
;
655 folks_group_details_change_group_finish (group_details
, result
, &error
);
658 g_warning ("failed to change group: %s", error
->message
);
659 g_clear_error (&error
);
664 remove_group_cb (const gchar
*id
,
665 FolksIndividual
*individual
,
668 folks_group_details_change_group (FOLKS_GROUP_DETAILS (individual
), group
,
669 FALSE
, groups_change_group_cb
, NULL
);
673 empathy_individual_manager_remove_group (EmpathyIndividualManager
*manager
,
676 EmpathyIndividualManagerPriv
*priv
;
678 g_return_if_fail (EMPATHY_IS_INDIVIDUAL_MANAGER (manager
));
679 g_return_if_fail (group
!= NULL
);
681 priv
= GET_PRIV (manager
);
683 DEBUG ("removing group %s", group
);
685 /* Remove every individual from the group */
686 g_hash_table_foreach (priv
->individuals
, (GHFunc
) remove_group_cb
,
691 link_personas_cb (FolksIndividualAggregator
*aggregator
,
692 GAsyncResult
*async_result
,
695 GError
*error
= NULL
;
697 folks_individual_aggregator_link_personas_finish (aggregator
, async_result
,
702 g_warning ("Failed to link personas: %s", error
->message
);
703 g_clear_error (&error
);
708 empathy_individual_manager_link_personas (EmpathyIndividualManager
*self
,
711 EmpathyIndividualManagerPriv
*priv
;
713 g_return_if_fail (EMPATHY_IS_INDIVIDUAL_MANAGER (self
));
714 g_return_if_fail (personas
!= NULL
);
716 priv
= GET_PRIV (self
);
718 DEBUG ("Linking %u personas",
719 gee_collection_get_size (GEE_COLLECTION (personas
)));
721 folks_individual_aggregator_link_personas (priv
->aggregator
, personas
,
722 (GAsyncReadyCallback
) link_personas_cb
, NULL
);
726 unlink_individual_cb (FolksIndividualAggregator
*aggregator
,
727 GAsyncResult
*async_result
,
730 GError
*error
= NULL
;
732 folks_individual_aggregator_unlink_individual_finish (aggregator
,
733 async_result
, &error
);
737 g_warning ("Failed to unlink individual: %s", error
->message
);
738 g_clear_error (&error
);
743 empathy_individual_manager_unlink_individual (EmpathyIndividualManager
*self
,
744 FolksIndividual
*individual
)
746 EmpathyIndividualManagerPriv
*priv
;
748 g_return_if_fail (EMPATHY_IS_INDIVIDUAL_MANAGER (self
));
749 g_return_if_fail (FOLKS_IS_INDIVIDUAL (individual
));
751 priv
= GET_PRIV (self
);
753 DEBUG ("Unlinking individual '%s'", folks_individual_get_id (individual
));
755 folks_individual_aggregator_unlink_individual (priv
->aggregator
, individual
,
756 (GAsyncReadyCallback
) unlink_individual_cb
, NULL
);
760 empathy_individual_manager_get_contacts_loaded (EmpathyIndividualManager
*self
)
762 EmpathyIndividualManagerPriv
*priv
= GET_PRIV (self
);
764 return priv
->contacts_loaded
;
768 individual_has_contact (FolksIndividual
*individual
,
773 gboolean found
= FALSE
;
775 personas
= folks_individual_get_personas (individual
);
776 iter
= gee_iterable_iterator (GEE_ITERABLE (personas
));
778 while (!found
&& gee_iterator_next (iter
))
780 TpfPersona
*persona
= gee_iterator_get (iter
);
782 if (TPF_IS_PERSONA (persona
))
784 TpContact
*c
= tpf_persona_get_contact (persona
);
790 g_clear_object (&persona
);
793 g_clear_object (&iter
);
798 /* Try finding a FolksIndividual containing @contact as one of his persona */
800 empathy_individual_manager_lookup_by_contact (EmpathyIndividualManager
*self
,
803 EmpathyIndividualManagerPriv
*priv
= GET_PRIV (self
);
807 g_hash_table_iter_init (&iter
, priv
->individuals
);
808 while (g_hash_table_iter_next (&iter
, NULL
, &value
))
810 FolksIndividual
*individual
= value
;
812 if (individual_has_contact (individual
, contact
))