Change API of EmpathyTpContactFactory:
[empathy.git] / libempathy / empathy-tp-contact-factory.c
1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
2 /*
3  * Copyright (C) 2007-2009 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  */
21
22 #include <config.h>
23
24 #include <string.h>
25
26 #include <telepathy-glib/util.h>
27 #include <telepathy-glib/gtypes.h>
28
29 #include <extensions/extensions.h>
30
31 #include "empathy-tp-contact-factory.h"
32 #include "empathy-utils.h"
33
34 #define DEBUG_FLAG EMPATHY_DEBUG_TP | EMPATHY_DEBUG_CONTACT
35 #include "empathy-debug.h"
36
37 #define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyTpContactFactory)
38 typedef struct {
39         TpConnection   *connection;
40         GList          *contacts;
41
42         gchar         **avatar_mime_types;
43         guint           avatar_min_width;
44         guint           avatar_min_height;
45         guint           avatar_max_width;
46         guint           avatar_max_height;
47         guint           avatar_max_size;
48         gboolean        can_request_ft;
49 } EmpathyTpContactFactoryPriv;
50
51 G_DEFINE_TYPE (EmpathyTpContactFactory, empathy_tp_contact_factory, G_TYPE_OBJECT);
52
53 enum {
54         PROP_0,
55         PROP_CONNECTION,
56
57         PROP_MIME_TYPES,
58         PROP_MIN_WIDTH,
59         PROP_MIN_HEIGHT,
60         PROP_MAX_WIDTH,
61         PROP_MAX_HEIGHT,
62         PROP_MAX_SIZE
63 };
64
65 static TpContactFeature contact_features[] = {
66         TP_CONTACT_FEATURE_ALIAS,
67         TP_CONTACT_FEATURE_PRESENCE,
68 };
69
70 static EmpathyContact *
71 tp_contact_factory_find_by_handle (EmpathyTpContactFactory *tp_factory,
72                                    guint                    handle)
73 {
74         EmpathyTpContactFactoryPriv *priv = GET_PRIV (tp_factory);
75         GList                       *l;
76
77         for (l = priv->contacts; l; l = l->next) {
78                 if (empathy_contact_get_handle (l->data) == handle) {
79                         return l->data;
80                 }
81         }
82
83         return NULL;
84 }
85
86 static EmpathyContact *
87 tp_contact_factory_find_by_tp_contact (EmpathyTpContactFactory *tp_factory,
88                                        TpContact               *tp_contact)
89 {
90         EmpathyTpContactFactoryPriv *priv = GET_PRIV (tp_factory);
91         GList                       *l;
92
93         for (l = priv->contacts; l; l = l->next) {
94                 if (empathy_contact_get_tp_contact (l->data) == tp_contact) {
95                         return l->data;
96                 }
97         }
98
99         return NULL;
100 }
101
102 static void
103 tp_contact_factory_weak_notify (gpointer data,
104                                 GObject *where_the_object_was)
105 {
106         EmpathyTpContactFactoryPriv *priv = GET_PRIV (data);
107
108         DEBUG ("Remove finalized contact %p", where_the_object_was);
109
110         priv->contacts = g_list_remove (priv->contacts, where_the_object_was);
111 }
112
113 static void
114 tp_contact_factory_set_aliases_cb (TpConnection *connection,
115                                    const GError *error,
116                                    gpointer      user_data,
117                                    GObject      *tp_factory)
118 {
119         if (error) {
120                 DEBUG ("Error: %s", error->message);
121         }
122 }
123
124 static void
125 tp_contact_factory_set_avatar_cb (TpConnection *connection,
126                                   const gchar  *token,
127                                   const GError *error,
128                                   gpointer      user_data,
129                                   GObject      *tp_factory)
130 {
131         if (error) {
132                 DEBUG ("Error: %s", error->message);
133         }
134 }
135
136 static void
137 tp_contact_factory_clear_avatar_cb (TpConnection *connection,
138                                     const GError *error,
139                                     gpointer      user_data,
140                                     GObject      *tp_factory)
141 {
142         if (error) {
143                 DEBUG ("Error: %s", error->message);
144         }
145 }
146
147 static void
148 tp_contact_factory_avatar_retrieved_cb (TpConnection *connection,
149                                         guint         handle,
150                                         const gchar  *token,
151                                         const GArray *avatar_data,
152                                         const gchar  *mime_type,
153                                         gpointer      user_data,
154                                         GObject      *tp_factory)
155 {
156         EmpathyContact *contact;
157
158         contact = tp_contact_factory_find_by_handle (EMPATHY_TP_CONTACT_FACTORY (tp_factory),
159                                                      handle);
160         if (!contact) {
161                 return;
162         }
163
164         DEBUG ("Avatar retrieved for contact %s (%d)",
165                 empathy_contact_get_id (contact),
166                 handle);
167
168         empathy_contact_load_avatar_data (contact,
169                                           avatar_data->data,
170                                           avatar_data->len,
171                                           mime_type,
172                                           token);
173 }
174
175 static void
176 tp_contact_factory_request_avatars_cb (TpConnection *connection,
177                                        const GError *error,
178                                        gpointer      user_data,
179                                        GObject      *tp_factory)
180 {
181         if (error) {
182                 DEBUG ("Error: %s", error->message);
183         }
184 }
185
186 static gboolean
187 tp_contact_factory_avatar_maybe_update (EmpathyTpContactFactory *tp_factory,
188                                         guint                    handle,
189                                         const gchar             *token)
190 {
191         EmpathyContact *contact;
192         EmpathyAvatar  *avatar;
193
194         contact = tp_contact_factory_find_by_handle (tp_factory, handle);
195         if (!contact) {
196                 return TRUE;
197         }
198
199         /* Check if we have an avatar */
200         if (EMP_STR_EMPTY (token)) {
201                 empathy_contact_set_avatar (contact, NULL);
202                 return TRUE;
203         }
204
205         /* Check if the avatar changed */
206         avatar = empathy_contact_get_avatar (contact);
207         if (avatar && !tp_strdiff (avatar->token, token)) {
208                 return TRUE;
209         }
210
211         /* The avatar changed, search the new one in the cache */
212         if (empathy_contact_load_avatar_cache (contact, token)) {
213                 /* Got from cache, use it */
214                 return TRUE;
215         }
216
217         /* Avatar is not up-to-date, we have to request it. */
218         return FALSE;
219 }
220
221 typedef struct {
222         EmpathyTpContactFactory *tp_factory;
223         GArray                  *handles;
224 } TokensData;
225
226 static void
227 tp_contact_factory_avatar_tokens_foreach (gpointer key,
228                                           gpointer value,
229                                           gpointer user_data)
230 {
231         TokensData  *data = user_data;
232         const gchar *token = value;
233         guint        handle = GPOINTER_TO_UINT (key);
234
235         if (!tp_contact_factory_avatar_maybe_update (data->tp_factory,
236                                                      handle, token)) {
237                 g_array_append_val (data->handles, handle);
238         }
239 }
240
241 static void
242 tp_contact_factory_got_known_avatar_tokens (EmpathyTpContactFactory *tp_factory,
243                                             GHashTable              *tokens,
244                                             const GError            *error)
245 {
246         EmpathyTpContactFactoryPriv *priv = GET_PRIV (tp_factory);
247         TokensData data;
248
249         if (error) {
250                 DEBUG ("Error: %s", error->message);
251                 return;
252         }
253
254         data.tp_factory = tp_factory;
255         data.handles = g_array_new (FALSE, FALSE, sizeof (guint));
256         g_hash_table_foreach (tokens,
257                               tp_contact_factory_avatar_tokens_foreach,
258                               &data);
259
260         DEBUG ("Got %d tokens, need to request %d avatars",
261                 g_hash_table_size (tokens), data.handles->len);
262
263         /* Request needed avatars */
264         if (data.handles->len > 0) {
265                 tp_cli_connection_interface_avatars_call_request_avatars (priv->connection,
266                                                                           -1,
267                                                                           data.handles,
268                                                                           tp_contact_factory_request_avatars_cb,
269                                                                           NULL, NULL,
270                                                                           G_OBJECT (tp_factory));
271         }
272
273         g_array_free (data.handles, TRUE);
274         g_hash_table_destroy (tokens);
275 }
276
277 static void
278 tp_contact_factory_avatar_updated_cb (TpConnection *connection,
279                                       guint         handle,
280                                       const gchar  *new_token,
281                                       gpointer      user_data,
282                                       GObject      *tp_factory)
283 {
284         GArray *handles;
285
286         if (tp_contact_factory_avatar_maybe_update (EMPATHY_TP_CONTACT_FACTORY (tp_factory),
287                                                     handle, new_token)) {
288                 /* Avatar was cached, nothing to do */
289                 return;
290         }
291
292         DEBUG ("Need to request avatar for token %s", new_token);
293
294         handles = g_array_new (FALSE, FALSE, sizeof (guint));
295         g_array_append_val (handles, handle);
296
297         tp_cli_connection_interface_avatars_call_request_avatars (connection,
298                                                                   -1,
299                                                                   handles,
300                                                                   tp_contact_factory_request_avatars_cb,
301                                                                   NULL, NULL,
302                                                                   tp_factory);
303         g_array_free (handles, TRUE);
304 }
305
306 static void
307 tp_contact_factory_update_capabilities (EmpathyTpContactFactory *tp_factory,
308                                         guint                    handle,
309                                         const gchar             *channel_type,
310                                         guint                    generic,
311                                         guint                    specific)
312 {
313         EmpathyContact      *contact;
314         EmpathyCapabilities  capabilities;
315
316         contact = tp_contact_factory_find_by_handle (tp_factory, handle);
317         if (!contact) {
318                 return;
319         }
320
321         capabilities = empathy_contact_get_capabilities (contact);
322         capabilities &= ~EMPATHY_CAPABILITIES_UNKNOWN;
323
324         if (strcmp (channel_type, TP_IFACE_CHANNEL_TYPE_STREAMED_MEDIA) == 0) {
325                 capabilities &= ~EMPATHY_CAPABILITIES_AUDIO;
326                 capabilities &= ~EMPATHY_CAPABILITIES_VIDEO;
327                 if (specific & TP_CHANNEL_MEDIA_CAPABILITY_AUDIO) {
328                         capabilities |= EMPATHY_CAPABILITIES_AUDIO;
329                 }
330                 if (specific & TP_CHANNEL_MEDIA_CAPABILITY_VIDEO) {
331                         capabilities |= EMPATHY_CAPABILITIES_VIDEO;
332                 }
333         }
334
335         DEBUG ("Changing capabilities for contact %s (%d) to %d",
336                 empathy_contact_get_id (contact),
337                 empathy_contact_get_handle (contact),
338                 capabilities);
339
340         empathy_contact_set_capabilities (contact, capabilities);
341 }
342
343 static void
344 tp_contact_factory_got_capabilities (EmpathyTpContactFactory *tp_factory,
345                                      GPtrArray *capabilities,
346                                      const GError    *error)
347 {
348         guint i;
349
350         if (error) {
351                 DEBUG ("Error: %s", error->message);
352                 /* FIXME Should set the capabilities of the contacts for which this request
353                  * originated to NONE */
354                 return;
355         }
356
357         for (i = 0; i < capabilities->len; i++) {
358                 GValueArray *values;
359                 guint        handle;
360                 const gchar *channel_type;
361                 guint        generic;
362                 guint        specific;
363
364                 values = g_ptr_array_index (capabilities, i);
365                 handle = g_value_get_uint (g_value_array_get_nth (values, 0));
366                 channel_type = g_value_get_string (g_value_array_get_nth (values, 1));
367                 generic = g_value_get_uint (g_value_array_get_nth (values, 2));
368                 specific = g_value_get_uint (g_value_array_get_nth (values, 3));
369
370                 tp_contact_factory_update_capabilities (tp_factory,
371                                                         handle,
372                                                         channel_type,
373                                                         generic,
374                                                         specific);
375
376                 g_value_array_free (values);
377         }
378
379         g_ptr_array_free (capabilities, TRUE);
380 }
381
382 static void
383 tp_contact_factory_capabilities_changed_cb (TpConnection    *connection,
384                                             const GPtrArray *capabilities,
385                                             gpointer         user_data,
386                                             GObject         *weak_object)
387 {
388         EmpathyTpContactFactory *tp_factory = EMPATHY_TP_CONTACT_FACTORY (weak_object);
389         guint                    i;
390
391         for (i = 0; i < capabilities->len; i++) {
392                 GValueArray *values;
393                 guint        handle;
394                 const gchar *channel_type;
395                 guint        generic;
396                 guint        specific;
397
398                 values = g_ptr_array_index (capabilities, i);
399                 handle = g_value_get_uint (g_value_array_get_nth (values, 0));
400                 channel_type = g_value_get_string (g_value_array_get_nth (values, 1));
401                 generic = g_value_get_uint (g_value_array_get_nth (values, 3));
402                 specific = g_value_get_uint (g_value_array_get_nth (values, 5));
403
404                 tp_contact_factory_update_capabilities (tp_factory,
405                                                         handle,
406                                                         channel_type,
407                                                         generic,
408                                                         specific);
409         }
410 }
411
412 static void
413 get_requestable_channel_classes_cb (TpProxy *connection,
414                                     const GValue *value,
415                                     const GError *error,
416                                     gpointer user_data,
417                                     GObject *weak_object)
418 {
419         EmpathyTpContactFactory     *self = EMPATHY_TP_CONTACT_FACTORY (weak_object);
420         EmpathyTpContactFactoryPriv *priv = GET_PRIV (self);
421         GPtrArray                   *classes;
422         guint                        i;
423
424         if (error != NULL) {
425                 DEBUG ("Error: %s", error->message);
426                 return;
427         }
428
429         classes = g_value_get_boxed (value);
430         for (i = 0; i < classes->len; i++) {
431                 GValueArray *class_struct;
432                 GHashTable *fixed_prop;
433                 GValue *chan_type, *handle_type;
434                 GList *l;
435
436                 class_struct = g_ptr_array_index (classes, i);
437                 fixed_prop = g_value_get_boxed (g_value_array_get_nth (class_struct, 0));
438
439                 chan_type = g_hash_table_lookup (fixed_prop,
440                         TP_IFACE_CHANNEL ".ChannelType");
441                 if (chan_type == NULL ||
442                     tp_strdiff (g_value_get_string (chan_type),
443                                 TP_IFACE_CHANNEL_TYPE_FILE_TRANSFER)) {
444                         continue;
445                 }
446
447                 handle_type = g_hash_table_lookup (fixed_prop,
448                         TP_IFACE_CHANNEL ".TargetHandleType");
449                 if (handle_type == NULL ||
450                     g_value_get_uint (handle_type) != TP_HANDLE_TYPE_CONTACT) {
451                         continue;
452                 }
453
454                 /* We can request file transfer channel to contacts. */
455                 priv->can_request_ft = TRUE;
456
457                 /* Update the capabilities of all contacts */
458                 for (l = priv->contacts; l != NULL; l = g_list_next (l)) {
459                         EmpathyContact *contact = l->data;
460                         EmpathyCapabilities caps;
461
462                         caps = empathy_contact_get_capabilities (contact);
463                         empathy_contact_set_capabilities (contact, caps |
464                                 EMPATHY_CAPABILITIES_FT);
465                 }
466                 break;
467         }
468 }
469
470 static void
471 tp_contact_factory_got_avatar_requirements_cb (TpConnection *proxy,
472                                                const gchar **mime_types,
473                                                guint         min_width,
474                                                guint         min_height,
475                                                guint         max_width,
476                                                guint         max_height,
477                                                guint         max_size,
478                                                const GError *error,
479                                                gpointer      user_data,
480                                                GObject      *tp_factory)
481 {
482         EmpathyTpContactFactoryPriv *priv = GET_PRIV (tp_factory);
483
484         if (error) {
485                 DEBUG ("Failed to get avatar requirements: %s", error->message);
486                 /* We'll just leave avatar_mime_types as NULL; the
487                  * avatar-setting code can use this as a signal that you can't
488                  * set avatars.
489                  */
490         } else {
491                 priv->avatar_mime_types = g_strdupv ((gchar **) mime_types);
492                 priv->avatar_min_width = min_width;
493                 priv->avatar_min_height = min_height;
494                 priv->avatar_max_width = max_width;
495                 priv->avatar_max_height = max_height;
496                 priv->avatar_max_size = max_size;
497         }
498 }
499
500 static void
501 tp_contact_factory_add_contact (EmpathyTpContactFactory *tp_factory,
502                                 EmpathyContact          *contact)
503 {
504         EmpathyTpContactFactoryPriv *priv = GET_PRIV (tp_factory);
505         TpHandle handle;
506         GArray handles = {(gchar*) &handle, 1};
507         GHashTable *tokens;
508         GPtrArray *capabilities;
509         GError *error = NULL;
510
511         /* Keep a weak ref to that contact */
512         g_object_weak_ref (G_OBJECT (contact),
513                            tp_contact_factory_weak_notify,
514                            tp_factory);
515         priv->contacts = g_list_prepend (priv->contacts, contact);
516
517         /* The contact keeps a ref to its factory */
518         g_object_set_data_full (G_OBJECT (contact), "empathy-factory",
519                                 g_object_ref (tp_factory),
520                                 g_object_unref);
521
522         /* Set the FT capability */
523         if (priv->can_request_ft) {
524                 EmpathyCapabilities caps;
525
526                 caps = empathy_contact_get_capabilities (contact);
527                 caps |= EMPATHY_CAPABILITIES_FT;
528
529                 empathy_contact_set_capabilities (contact, caps);
530         }
531
532         /* FIXME: This should be done by TpContact */
533         handle = empathy_contact_get_handle (contact);
534         tp_cli_connection_interface_avatars_run_get_known_avatar_tokens (priv->connection,
535                                                                          -1,
536                                                                          &handles,
537                                                                          &tokens,
538                                                                          &error,
539                                                                          NULL);
540         tp_contact_factory_got_known_avatar_tokens (tp_factory, tokens, error);
541         g_clear_error (&error);
542
543         tp_cli_connection_interface_capabilities_run_get_capabilities (priv->connection,
544                                                                         -1,
545                                                                         &handles,
546                                                                         &capabilities,
547                                                                         &error,
548                                                                         NULL);
549         tp_contact_factory_got_capabilities (tp_factory, capabilities, error);
550         g_clear_error (&error);
551
552         DEBUG ("Contact added: %s (%d)",
553                 empathy_contact_get_id (contact),
554                 empathy_contact_get_handle (contact));
555 }
556
557 typedef struct {
558         EmpathyTpContactFactory *tp_factory;
559         EmpathyTpContactFactoryGotContactsCb callback;
560         gpointer user_data;
561         GDestroyNotify destroy;
562 } GetContactsData;
563
564 static void
565 get_contacts_data_free (gpointer user_data)
566 {
567         GetContactsData *data = user_data;
568
569         if (data->destroy) {
570                 data->destroy (data->user_data);
571         }
572         g_object_unref (data->tp_factory);
573
574         g_slice_free (GetContactsData, data);
575 }
576
577 static void
578 got_contacts (GetContactsData *data,
579               GObject *weak_object,
580               guint n_contacts,
581               TpContact * const *contacts,
582               const GError *error)
583 {
584         GList *ret = NULL;
585         guint i;
586
587         if (error) {
588                 DEBUG ("Error: %s", error->message);
589         }
590
591         for (i = 0; i < n_contacts; i++) {
592                 EmpathyContact *contact;
593
594                 contact = tp_contact_factory_find_by_tp_contact (data->tp_factory,
595                                                                  contacts[i]);
596
597                 if (contact != NULL) {
598                         g_object_ref (contact);
599                 } else {
600                         contact = empathy_contact_new (contacts[i]);
601                         tp_contact_factory_add_contact (data->tp_factory, contact);
602                 }
603                 ret = g_list_prepend (ret, contact);
604         }
605
606         if (data->callback)
607                 data->callback (data->tp_factory, ret, data->user_data, weak_object);
608
609         g_list_foreach (ret, (GFunc) g_object_unref, NULL);
610         g_list_free (ret);
611 }
612
613 static void
614 get_contacts_by_handle_cb (TpConnection *connection,
615                            guint n_contacts,
616                            TpContact * const *contacts,
617                            guint n_failed,
618                            const TpHandle *failed,
619                            const GError *error,
620                            gpointer user_data,
621                            GObject *weak_object)
622 {
623         got_contacts (user_data, weak_object,
624                       n_contacts, contacts,
625                       error);
626 }
627
628 static void
629 get_contacts_by_id_cb (TpConnection *connection,
630                        guint n_contacts,
631                        TpContact * const *contacts,
632                        const gchar * const *requested_ids,
633                        GHashTable *failed_id_errors,
634                        const GError *error,
635                        gpointer user_data,
636                        GObject *weak_object)
637 {
638         got_contacts (user_data, weak_object,
639                       n_contacts, contacts,
640                       error);
641 }
642
643 void
644 empathy_tp_contact_factory_get_from_ids (EmpathyTpContactFactory *tp_factory,
645                                          guint                    n_ids,
646                                          const gchar * const     *ids,
647                                          EmpathyTpContactFactoryGotContactsCb callback,
648                                          gpointer                 user_data,
649                                          GDestroyNotify           destroy,
650                                          GObject                 *weak_object)
651 {
652         EmpathyTpContactFactoryPriv *priv = GET_PRIV (tp_factory);
653         GetContactsData *data;
654
655         g_return_if_fail (EMPATHY_IS_TP_CONTACT_FACTORY (tp_factory));
656         g_return_if_fail (ids != NULL);
657
658         data = g_slice_new (GetContactsData);
659         data->callback = callback;
660         data->user_data = user_data;
661         data->destroy = destroy;
662         data->tp_factory = g_object_ref (tp_factory);
663         tp_connection_get_contacts_by_id (priv->connection,
664                                           n_ids, ids,
665                                           G_N_ELEMENTS (contact_features),
666                                           contact_features,
667                                           get_contacts_by_id_cb,
668                                           data,
669                                           (GDestroyNotify) get_contacts_data_free,
670                                           weak_object);
671 }
672
673 void
674 empathy_tp_contact_factory_get_from_handles (EmpathyTpContactFactory *tp_factory,
675                                              guint n_handles,
676                                              const TpHandle *handles,
677                                              EmpathyTpContactFactoryGotContactsCb callback,
678                                              gpointer                 user_data,
679                                              GDestroyNotify           destroy,
680                                              GObject                 *weak_object)
681 {
682         EmpathyTpContactFactoryPriv *priv = GET_PRIV (tp_factory);
683         GetContactsData *data;
684
685         g_return_if_fail (EMPATHY_IS_TP_CONTACT_FACTORY (tp_factory));
686         g_return_if_fail (handles != NULL);
687
688         data = g_slice_new (GetContactsData);
689         data->callback = callback;
690         data->user_data = user_data;
691         data->destroy = destroy;
692         data->tp_factory = g_object_ref (tp_factory);
693         tp_connection_get_contacts_by_handle (priv->connection,
694                                               n_handles, handles,
695                                               G_N_ELEMENTS (contact_features),
696                                               contact_features,
697                                               get_contacts_by_handle_cb,
698                                               data,
699                                               (GDestroyNotify) get_contacts_data_free,
700                                               weak_object);
701 }
702
703 void
704 empathy_tp_contact_factory_set_alias (EmpathyTpContactFactory *tp_factory,
705                                       EmpathyContact          *contact,
706                                       const gchar             *alias)
707 {
708         EmpathyTpContactFactoryPriv *priv = GET_PRIV (tp_factory);
709         GHashTable                  *new_alias;
710         guint                        handle;
711
712         g_return_if_fail (EMPATHY_IS_TP_CONTACT_FACTORY (tp_factory));
713         g_return_if_fail (EMPATHY_IS_CONTACT (contact));
714
715         handle = empathy_contact_get_handle (contact);
716
717         DEBUG ("Setting alias for contact %s (%d) to %s",
718                 empathy_contact_get_id (contact),
719                 handle, alias);
720
721         new_alias = g_hash_table_new_full (g_direct_hash,
722                                            g_direct_equal,
723                                            NULL,
724                                            g_free);
725
726         g_hash_table_insert (new_alias,
727                              GUINT_TO_POINTER (handle),
728                              g_strdup (alias));
729
730         tp_cli_connection_interface_aliasing_call_set_aliases (priv->connection,
731                                                                -1,
732                                                                new_alias,
733                                                                tp_contact_factory_set_aliases_cb,
734                                                                NULL, NULL,
735                                                                G_OBJECT (tp_factory));
736
737         g_hash_table_destroy (new_alias);
738 }
739
740 void
741 empathy_tp_contact_factory_set_avatar (EmpathyTpContactFactory *tp_factory,
742                                        const gchar             *data,
743                                        gsize                    size,
744                                        const gchar             *mime_type)
745 {
746         EmpathyTpContactFactoryPriv *priv = GET_PRIV (tp_factory);
747
748         g_return_if_fail (EMPATHY_IS_TP_CONTACT_FACTORY (tp_factory));
749
750         if (data && size > 0 && size < G_MAXUINT) {
751                 GArray avatar;
752
753                 avatar.data = (gchar*) data;
754                 avatar.len = size;
755
756                 DEBUG ("Setting avatar on connection %s",
757                         tp_proxy_get_object_path (TP_PROXY (priv->connection)));
758
759                 tp_cli_connection_interface_avatars_call_set_avatar (priv->connection,
760                                                                      -1,
761                                                                      &avatar,
762                                                                      mime_type,
763                                                                      tp_contact_factory_set_avatar_cb,
764                                                                      NULL, NULL,
765                                                                      G_OBJECT (tp_factory));
766         } else {
767                 DEBUG ("Clearing avatar on connection %s",
768                         tp_proxy_get_object_path (TP_PROXY (priv->connection)));
769
770                 tp_cli_connection_interface_avatars_call_clear_avatar (priv->connection,
771                                                                        -1,
772                                                                        tp_contact_factory_clear_avatar_cb,
773                                                                        NULL, NULL,
774                                                                        G_OBJECT (tp_factory));
775         }
776 }
777
778 static void
779 tp_contact_factory_get_property (GObject    *object,
780                                  guint       param_id,
781                                  GValue     *value,
782                                  GParamSpec *pspec)
783 {
784         EmpathyTpContactFactoryPriv *priv = GET_PRIV (object);
785
786         switch (param_id) {
787         case PROP_CONNECTION:
788                 g_value_set_object (value, priv->connection);
789                 break;
790         case PROP_MIME_TYPES:
791                 g_value_set_boxed (value, priv->avatar_mime_types);
792                 break;
793         case PROP_MIN_WIDTH:
794                 g_value_set_uint (value, priv->avatar_min_width);
795                 break;
796         case PROP_MIN_HEIGHT:
797                 g_value_set_uint (value, priv->avatar_min_height);
798                 break;
799         case PROP_MAX_WIDTH:
800                 g_value_set_uint (value, priv->avatar_max_width);
801                 break;
802         case PROP_MAX_HEIGHT:
803                 g_value_set_uint (value, priv->avatar_max_height);
804                 break;
805         case PROP_MAX_SIZE:
806                 g_value_set_uint (value, priv->avatar_max_size);
807                 break;
808         default:
809                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
810                 break;
811         };
812 }
813
814 static void
815 tp_contact_factory_set_property (GObject      *object,
816                                  guint         param_id,
817                                  const GValue *value,
818                                  GParamSpec   *pspec)
819 {
820         EmpathyTpContactFactoryPriv *priv = GET_PRIV (object);
821
822         switch (param_id) {
823         case PROP_CONNECTION:
824                 priv->connection = g_value_dup_object (value);
825                 break;
826         default:
827                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
828                 break;
829         };
830 }
831
832 static void
833 tp_contact_factory_finalize (GObject *object)
834 {
835         EmpathyTpContactFactoryPriv *priv = GET_PRIV (object);
836         GList                       *l;
837
838         DEBUG ("Finalized: %p", object);
839
840         for (l = priv->contacts; l; l = l->next) {
841                 g_object_weak_unref (G_OBJECT (l->data),
842                                      tp_contact_factory_weak_notify,
843                                      object);
844         }
845
846         g_list_free (priv->contacts);
847
848         g_object_unref (priv->connection);
849
850         g_strfreev (priv->avatar_mime_types);
851
852         G_OBJECT_CLASS (empathy_tp_contact_factory_parent_class)->finalize (object);
853 }
854
855 static GObject *
856 tp_contact_factory_constructor (GType                  type,
857                                 guint                  n_props,
858                                 GObjectConstructParam *props)
859 {
860         GObject *tp_factory;
861         EmpathyTpContactFactoryPriv *priv;
862
863         tp_factory = G_OBJECT_CLASS (empathy_tp_contact_factory_parent_class)->constructor (type, n_props, props);
864         priv = GET_PRIV (tp_factory);
865
866         /* FIXME: This should be moved to TpContact */
867         tp_cli_connection_interface_avatars_connect_to_avatar_updated (priv->connection,
868                                                                        tp_contact_factory_avatar_updated_cb,
869                                                                        NULL, NULL,
870                                                                        tp_factory,
871                                                                        NULL);
872         tp_cli_connection_interface_avatars_connect_to_avatar_retrieved (priv->connection,
873                                                                          tp_contact_factory_avatar_retrieved_cb,
874                                                                          NULL, NULL,
875                                                                          tp_factory,
876                                                                          NULL);
877         tp_cli_connection_interface_capabilities_connect_to_capabilities_changed (priv->connection,
878                                                                                   tp_contact_factory_capabilities_changed_cb,
879                                                                                   NULL, NULL,
880                                                                                   tp_factory,
881                                                                                   NULL);
882
883
884         /* FIXME: This should be moved to TpConnection */
885         tp_cli_connection_interface_avatars_call_get_avatar_requirements (priv->connection,
886                                                                           -1,
887                                                                           tp_contact_factory_got_avatar_requirements_cb,
888                                                                           NULL, NULL,
889                                                                           tp_factory);
890         tp_cli_dbus_properties_call_get (priv->connection, -1,
891                 TP_IFACE_CONNECTION_INTERFACE_REQUESTS,
892                 "RequestableChannelClasses",
893                 get_requestable_channel_classes_cb, NULL, NULL,
894                 G_OBJECT (tp_factory));
895
896         return tp_factory;
897 }
898
899 static void
900 empathy_tp_contact_factory_class_init (EmpathyTpContactFactoryClass *klass)
901 {
902         GObjectClass *object_class = G_OBJECT_CLASS (klass);
903
904         object_class->finalize = tp_contact_factory_finalize;
905         object_class->constructor = tp_contact_factory_constructor;
906         object_class->get_property = tp_contact_factory_get_property;
907         object_class->set_property = tp_contact_factory_set_property;
908
909         g_object_class_install_property (object_class,
910                                          PROP_CONNECTION,
911                                          g_param_spec_object ("connection",
912                                                               "Factory's Connection",
913                                                               "The connection associated with the factory",
914                                                               TP_TYPE_CONNECTION,
915                                                               G_PARAM_READWRITE |
916                                                               G_PARAM_CONSTRUCT_ONLY |
917                                                               G_PARAM_STATIC_STRINGS));
918         g_object_class_install_property (object_class,
919                                          PROP_MIME_TYPES,
920                                          g_param_spec_boxed ("avatar-mime-types",
921                                                              "Supported MIME types for avatars",
922                                                              "Types of images that may be set as "
923                                                              "avatars on this connection.  Only valid "
924                                                              "once 'ready' becomes TRUE.",
925                                                              G_TYPE_STRV,
926                                                              G_PARAM_READABLE |
927                                                              G_PARAM_STATIC_STRINGS));
928         g_object_class_install_property (object_class,
929                                          PROP_MIN_WIDTH,
930                                          g_param_spec_uint ("avatar-min-width",
931                                                             "Minimum width for avatars",
932                                                             "Minimum width of avatar that may be set. "
933                                                             "Only valid once 'ready' becomes TRUE.",
934                                                             0,
935                                                             G_MAXUINT,
936                                                             0,
937                                                             G_PARAM_READABLE |
938                                                             G_PARAM_STATIC_STRINGS));
939         g_object_class_install_property (object_class,
940                                          PROP_MIN_HEIGHT,
941                                          g_param_spec_uint ("avatar-min-height",
942                                                             "Minimum height for avatars",
943                                                             "Minimum height of avatar that may be set. "
944                                                             "Only valid once 'ready' becomes TRUE.",
945                                                             0,
946                                                             G_MAXUINT,
947                                                             0,
948                                                             G_PARAM_READABLE |
949                                                             G_PARAM_STATIC_STRINGS));
950         g_object_class_install_property (object_class,
951                                          PROP_MAX_WIDTH,
952                                          g_param_spec_uint ("avatar-max-width",
953                                                             "Maximum width for avatars",
954                                                             "Maximum width of avatar that may be set "
955                                                             "or 0 if there is no maximum. "
956                                                             "Only valid once 'ready' becomes TRUE.",
957                                                             0,
958                                                             G_MAXUINT,
959                                                             0,
960                                                             G_PARAM_READABLE |
961                                                             G_PARAM_STATIC_STRINGS));
962         g_object_class_install_property (object_class,
963                                          PROP_MAX_HEIGHT,
964                                          g_param_spec_uint ("avatar-max-height",
965                                                             "Maximum height for avatars",
966                                                             "Maximum height of avatar that may be set "
967                                                             "or 0 if there is no maximum. "
968                                                             "Only valid once 'ready' becomes TRUE.",
969                                                             0,
970                                                             G_MAXUINT,
971                                                             0,
972                                                             G_PARAM_READABLE |
973                                                             G_PARAM_STATIC_STRINGS));
974         g_object_class_install_property (object_class,
975                                          PROP_MAX_SIZE,
976                                          g_param_spec_uint ("avatar-max-size",
977                                                             "Maximum size for avatars in bytes",
978                                                             "Maximum file size of avatar that may be "
979                                                             "set or 0 if there is no maximum. "
980                                                             "Only valid once 'ready' becomes TRUE.",
981                                                             0,
982                                                             G_MAXUINT,
983                                                             0,
984                                                             G_PARAM_READABLE |
985                                                             G_PARAM_STATIC_STRINGS));
986
987
988         g_type_class_add_private (object_class, sizeof (EmpathyTpContactFactoryPriv));
989 }
990
991 static void
992 empathy_tp_contact_factory_init (EmpathyTpContactFactory *tp_factory)
993 {
994         EmpathyTpContactFactoryPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (tp_factory,
995                 EMPATHY_TYPE_TP_CONTACT_FACTORY, EmpathyTpContactFactoryPriv);
996
997         tp_factory->priv = priv;
998         priv->can_request_ft = FALSE;
999 }
1000
1001 static GHashTable *factories = NULL;
1002
1003 static void
1004 tp_contact_factory_connection_invalidated_cb (TpProxy *connection,
1005                                               guint    domain,
1006                                               gint     code,
1007                                               gchar   *message,
1008                                               gpointer user_data)
1009 {
1010         DEBUG ("Message: %s", message);
1011         g_hash_table_remove (factories, connection);
1012 }
1013
1014 static void
1015 tp_contact_factory_connection_weak_notify_cb (gpointer connection,
1016                                               GObject *where_the_object_was)
1017 {
1018         g_hash_table_remove (factories, connection);
1019 }
1020
1021 static void
1022 tp_contact_factory_remove_connection (gpointer connection)
1023 {
1024         g_signal_handlers_disconnect_by_func (connection,
1025                 tp_contact_factory_connection_invalidated_cb, NULL);
1026         g_object_unref (connection);
1027 }
1028
1029 EmpathyTpContactFactory *
1030 empathy_tp_contact_factory_dup_singleton (TpConnection *connection)
1031 {
1032         EmpathyTpContactFactory *tp_factory;
1033
1034         g_return_val_if_fail (TP_IS_CONNECTION (connection), NULL);
1035
1036         if (factories == NULL) {
1037                 factories = g_hash_table_new_full (empathy_proxy_hash,
1038                                                    empathy_proxy_equal,
1039                                                    tp_contact_factory_remove_connection,
1040                                                    NULL);
1041         }
1042
1043         tp_factory = g_hash_table_lookup (factories, connection);
1044         if (tp_factory == NULL) {
1045                 tp_factory = g_object_new (EMPATHY_TYPE_TP_CONTACT_FACTORY,
1046                                            "connection", connection,
1047                                            NULL);
1048                 g_hash_table_insert (factories, g_object_ref (connection),
1049                                      tp_factory);
1050                 g_object_weak_ref (G_OBJECT (tp_factory),
1051                                    tp_contact_factory_connection_weak_notify_cb,
1052                                    connection);
1053                 g_signal_connect (connection, "invalidated",
1054                                   G_CALLBACK (tp_contact_factory_connection_invalidated_cb),
1055                                   NULL);
1056         } else {
1057                 g_object_ref (tp_factory);
1058         }
1059
1060         return tp_factory;
1061 }
1062