46d80d3be6e51854ee5a006b511f7573caa72ede
[empathy.git] / libempathy / empathy-contact.c
1 /* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2; -*- */
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  *          Sjoerd Simons <sjoerd.simons@collabora.co.uk>
21  */
22
23 #include "config.h"
24
25 #include <string.h>
26
27 #include <glib/gi18n-lib.h>
28
29 #include <telepathy-glib/util.h>
30 #include <libmissioncontrol/mc-enum-types.h>
31
32 #include "empathy-contact.h"
33 #include "empathy-account-manager.h"
34 #include "empathy-utils.h"
35 #include "empathy-enum-types.h"
36 #include "empathy-marshal.h"
37
38 #define DEBUG_FLAG EMPATHY_DEBUG_CONTACT
39 #include "empathy-debug.h"
40
41 #define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyContact)
42 typedef struct {
43   TpContact *tp_contact;
44   McAccount *account;
45   gchar *id;
46   gchar *name;
47   EmpathyAvatar *avatar;
48   McPresence presence;
49   gchar *presence_message;
50   guint handle;
51   EmpathyCapabilities capabilities;
52   gboolean is_user;
53   guint hash;
54 } EmpathyContactPriv;
55
56 static void contact_finalize (GObject *object);
57 static void contact_get_property (GObject *object, guint param_id,
58     GValue *value, GParamSpec *pspec);
59 static void contact_set_property (GObject *object, guint param_id,
60     const GValue *value, GParamSpec *pspec);
61
62 G_DEFINE_TYPE (EmpathyContact, empathy_contact, G_TYPE_OBJECT);
63
64 enum
65 {
66   PROP_0,
67   PROP_TP_CONTACT,
68   PROP_ACCOUNT,
69   PROP_ID,
70   PROP_NAME,
71   PROP_AVATAR,
72   PROP_PRESENCE,
73   PROP_PRESENCE_MESSAGE,
74   PROP_HANDLE,
75   PROP_CAPABILITIES,
76   PROP_IS_USER,
77 };
78
79 enum {
80   PRESENCE_CHANGED,
81   LAST_SIGNAL
82 };
83
84 static guint signals[LAST_SIGNAL];
85
86 static void
87 tp_contact_notify_cb (TpContact *tp_contact,
88                       GParamSpec *param,
89                       GObject *contact)
90 {
91   EmpathyContactPriv *priv = GET_PRIV (contact);
92
93   /* Forward property notifications */
94   if (!tp_strdiff (param->name, "alias"))
95     g_object_notify (contact, "name");
96   else if (!tp_strdiff (param->name, "presence-type")) {
97     McPresence presence;
98
99     presence = empathy_contact_get_presence (EMPATHY_CONTACT (contact));
100     g_signal_emit (contact, signals[PRESENCE_CHANGED], 0, presence, priv->presence);
101     priv->presence = presence;
102     g_object_notify (contact, "presence");
103   }
104   else if (!tp_strdiff (param->name, "presence-message"))
105     g_object_notify (contact, "presence-message");
106   else if (!tp_strdiff (param->name, "identifier"))
107     g_object_notify (contact, "id");
108   else if (!tp_strdiff (param->name, "handle"))
109     g_object_notify (contact, "handle");
110 }
111
112 static void
113 contact_dispose (GObject *object)
114 {
115   EmpathyContactPriv *priv = GET_PRIV (object);
116
117   if (priv->tp_contact)
118     {
119       g_signal_handlers_disconnect_by_func (priv->tp_contact,
120           tp_contact_notify_cb, object);
121       g_object_unref (priv->tp_contact);
122     }
123   priv->tp_contact = NULL;
124
125   if (priv->account)
126     g_object_unref (priv->account);
127   priv->account = NULL;
128
129   G_OBJECT_CLASS (empathy_contact_parent_class)->dispose (object);
130 }
131
132 static void
133 empathy_contact_class_init (EmpathyContactClass *class)
134 {
135   GObjectClass *object_class;
136
137   object_class = G_OBJECT_CLASS (class);
138
139   object_class->finalize = contact_finalize;
140   object_class->dispose = contact_dispose;
141   object_class->get_property = contact_get_property;
142   object_class->set_property = contact_set_property;
143
144   g_object_class_install_property (object_class,
145       PROP_TP_CONTACT,
146       g_param_spec_object ("tp-contact",
147         "TpContact",
148         "The TpContact associated with the contact",
149         TP_TYPE_CONTACT,
150         G_PARAM_CONSTRUCT_ONLY | G_PARAM_READABLE));
151
152   g_object_class_install_property (object_class,
153       PROP_TP_CONTACT,
154       g_param_spec_object ("account",
155         "The account",
156         "The account associated with the contact",
157         MC_TYPE_ACCOUNT,
158         G_PARAM_CONSTRUCT_ONLY | G_PARAM_READABLE));
159
160   g_object_class_install_property (object_class,
161       PROP_ID,
162       g_param_spec_string ("id",
163         "Contact id",
164         "String identifying contact",
165         NULL,
166         G_PARAM_READWRITE));
167
168   g_object_class_install_property (object_class,
169       PROP_NAME,
170       g_param_spec_string ("name",
171         "Contact Name",
172         "The name of the contact",
173         NULL,
174         G_PARAM_READWRITE));
175
176   g_object_class_install_property (object_class,
177       PROP_AVATAR,
178       g_param_spec_boxed ("avatar",
179         "Avatar image",
180         "The avatar image",
181         EMPATHY_TYPE_AVATAR,
182         G_PARAM_READWRITE));
183
184   g_object_class_install_property (object_class,
185       PROP_PRESENCE,
186       g_param_spec_uint ("presence",
187         "Contact presence",
188         "Presence of contact",
189         MC_PRESENCE_UNSET,
190         LAST_MC_PRESENCE,
191         MC_PRESENCE_UNSET,
192         G_PARAM_READWRITE));
193
194   g_object_class_install_property (object_class,
195       PROP_PRESENCE_MESSAGE,
196       g_param_spec_string ("presence-message",
197         "Contact presence message",
198         "Presence message of contact",
199         NULL,
200         G_PARAM_READWRITE));
201
202   g_object_class_install_property (object_class,
203       PROP_HANDLE,
204       g_param_spec_uint ("handle",
205         "Contact Handle",
206         "The handle of the contact",
207         0,
208         G_MAXUINT,
209         0,
210         G_PARAM_READWRITE));
211
212   g_object_class_install_property (object_class,
213       PROP_CAPABILITIES,
214       g_param_spec_flags ("capabilities",
215         "Contact Capabilities",
216         "Capabilities of the contact",
217         EMPATHY_TYPE_CAPABILITIES,
218         EMPATHY_CAPABILITIES_UNKNOWN,
219         G_PARAM_CONSTRUCT | G_PARAM_READWRITE));
220
221   g_object_class_install_property (object_class,
222       PROP_IS_USER,
223       g_param_spec_boolean ("is-user",
224         "Contact is-user",
225         "Is contact the user",
226         FALSE,
227         G_PARAM_READWRITE));
228
229   signals[PRESENCE_CHANGED] =
230     g_signal_new ("presence-changed",
231                   G_TYPE_FROM_CLASS (class),
232                   G_SIGNAL_RUN_LAST,
233                   0,
234                   NULL, NULL,
235                   _empathy_marshal_VOID__ENUM_ENUM,
236                   G_TYPE_NONE,
237                   2, MC_TYPE_PRESENCE,
238                   MC_TYPE_PRESENCE);
239
240   g_type_class_add_private (object_class, sizeof (EmpathyContactPriv));
241 }
242
243 static void
244 empathy_contact_init (EmpathyContact *contact)
245 {
246   EmpathyContactPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (contact,
247     EMPATHY_TYPE_CONTACT, EmpathyContactPriv);
248
249   contact->priv = priv;
250 }
251
252 static void
253 contact_finalize (GObject *object)
254 {
255   EmpathyContactPriv *priv;
256
257   priv = GET_PRIV (object);
258
259   DEBUG ("finalize: %p", object);
260
261   g_free (priv->name);
262   g_free (priv->id);
263   g_free (priv->presence_message);
264
265   if (priv->avatar)
266       empathy_avatar_unref (priv->avatar);
267
268   G_OBJECT_CLASS (empathy_contact_parent_class)->finalize (object);
269 }
270
271 static void
272 set_tp_contact (EmpathyContact *contact,
273                 TpContact *tp_contact)
274 {
275   EmpathyContactPriv *priv = GET_PRIV (contact);
276
277   g_assert (priv->tp_contact == NULL);
278   priv->tp_contact = g_object_ref (tp_contact);
279   priv->presence = empathy_contact_get_presence (contact);
280
281   g_signal_connect (priv->tp_contact, "notify",
282     G_CALLBACK (tp_contact_notify_cb), contact);
283 }
284
285 static void
286 contact_get_property (GObject *object,
287                       guint param_id,
288                       GValue *value,
289                       GParamSpec *pspec)
290 {
291   EmpathyContact *contact = EMPATHY_CONTACT (object);
292
293   switch (param_id)
294     {
295       case PROP_TP_CONTACT:
296         g_value_set_object (value, empathy_contact_get_tp_contact (contact));
297         break;
298       case PROP_ACCOUNT:
299         g_value_set_object (value, empathy_contact_get_account (contact));
300         break;
301       case PROP_ID:
302         g_value_set_string (value, empathy_contact_get_id (contact));
303         break;
304       case PROP_NAME:
305         g_value_set_string (value, empathy_contact_get_name (contact));
306         break;
307       case PROP_AVATAR:
308         g_value_set_boxed (value, empathy_contact_get_avatar (contact));
309         break;
310       case PROP_PRESENCE:
311         g_value_set_uint (value, empathy_contact_get_presence (contact));
312         break;
313       case PROP_PRESENCE_MESSAGE:
314         g_value_set_string (value, empathy_contact_get_presence_message (contact));
315         break;
316       case PROP_HANDLE:
317         g_value_set_uint (value, empathy_contact_get_handle (contact));
318         break;
319       case PROP_CAPABILITIES:
320         g_value_set_flags (value, empathy_contact_get_capabilities (contact));
321         break;
322       case PROP_IS_USER:
323         g_value_set_boolean (value, empathy_contact_is_user (contact));
324         break;
325       default:
326         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
327         break;
328     };
329 }
330
331 static void
332 contact_set_property (GObject *object,
333                       guint param_id,
334                       const GValue *value,
335                       GParamSpec *pspec)
336 {
337   EmpathyContact *contact = EMPATHY_CONTACT (object);
338   EmpathyContactPriv *priv = GET_PRIV (object);
339
340   switch (param_id)
341     {
342       case PROP_TP_CONTACT:
343         set_tp_contact (contact, g_value_get_object (value));
344         break;
345       case PROP_ACCOUNT:
346         g_assert (priv->account == NULL);
347         priv->account = g_value_dup_object (value);
348         break;
349       case PROP_ID:
350         empathy_contact_set_id (contact, g_value_get_string (value));
351         break;
352       case PROP_NAME:
353         empathy_contact_set_name (contact, g_value_get_string (value));
354         break;
355       case PROP_AVATAR:
356         empathy_contact_set_avatar (contact, g_value_get_boxed (value));
357         break;
358       case PROP_PRESENCE:
359         empathy_contact_set_presence (contact, g_value_get_uint (value));
360         break;
361       case PROP_PRESENCE_MESSAGE:
362         empathy_contact_set_presence_message (contact, g_value_get_string (value));
363         break;
364       case PROP_HANDLE:
365         empathy_contact_set_handle (contact, g_value_get_uint (value));
366         break;
367       case PROP_CAPABILITIES:
368         empathy_contact_set_capabilities (contact, g_value_get_flags (value));
369         break;
370       case PROP_IS_USER:
371         empathy_contact_set_is_user (contact, g_value_get_boolean (value));
372         break;
373       default:
374         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
375         break;
376     };
377 }
378
379 EmpathyContact *
380 empathy_contact_new (TpContact *tp_contact)
381 {
382   return g_object_new (EMPATHY_TYPE_CONTACT,
383       "tp-contact", tp_contact,
384       NULL);
385 }
386
387 TpContact *
388 empathy_contact_get_tp_contact (EmpathyContact *contact)
389 {
390   EmpathyContactPriv *priv;
391
392   g_return_val_if_fail (EMPATHY_IS_CONTACT (contact), NULL);
393
394   priv = GET_PRIV (contact);
395
396   return priv->tp_contact;
397 }
398
399 const gchar *
400 empathy_contact_get_id (EmpathyContact *contact)
401 {
402   EmpathyContactPriv *priv;
403
404   g_return_val_if_fail (EMPATHY_IS_CONTACT (contact), NULL);
405
406   priv = GET_PRIV (contact);
407
408   if (priv->tp_contact != NULL)
409     return tp_contact_get_identifier (priv->tp_contact);
410
411   return priv->id;
412 }
413
414 void
415 empathy_contact_set_id (EmpathyContact *contact,
416                         const gchar *id)
417 {
418   EmpathyContactPriv *priv;
419
420   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
421   g_return_if_fail (id != NULL);
422
423   priv = GET_PRIV (contact);
424
425   /* We temporally ref the contact because it could be destroyed
426    * during the signal emition */
427   g_object_ref (contact);
428   if (tp_strdiff (id, priv->id))
429     {
430       g_free (priv->id);
431       priv->id = g_strdup (id);
432
433       g_object_notify (G_OBJECT (contact), "id");
434       if (EMP_STR_EMPTY (priv->name))
435           g_object_notify (G_OBJECT (contact), "name");
436     }
437
438   g_object_unref (contact);
439 }
440
441 const gchar *
442 empathy_contact_get_name (EmpathyContact *contact)
443 {
444   EmpathyContactPriv *priv;
445
446   g_return_val_if_fail (EMPATHY_IS_CONTACT (contact), NULL);
447
448   priv = GET_PRIV (contact);
449
450   if (priv->tp_contact != NULL)
451     return tp_contact_get_alias (priv->tp_contact);
452
453   if (EMP_STR_EMPTY (priv->name))
454       return empathy_contact_get_id (contact);
455
456   return priv->name;
457 }
458
459 void
460 empathy_contact_set_name (EmpathyContact *contact,
461                           const gchar *name)
462 {
463   EmpathyContactPriv *priv;
464
465   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
466
467   priv = GET_PRIV (contact);
468
469   g_object_ref (contact);
470   if (tp_strdiff (name, priv->name))
471     {
472       g_free (priv->name);
473       priv->name = g_strdup (name);
474       g_object_notify (G_OBJECT (contact), "name");
475     }
476   g_object_unref (contact);
477 }
478
479 EmpathyAvatar *
480 empathy_contact_get_avatar (EmpathyContact *contact)
481 {
482   EmpathyContactPriv *priv;
483
484   g_return_val_if_fail (EMPATHY_IS_CONTACT (contact), NULL);
485
486   priv = GET_PRIV (contact);
487
488   return priv->avatar;
489 }
490
491 void
492 empathy_contact_set_avatar (EmpathyContact *contact,
493                             EmpathyAvatar *avatar)
494 {
495   EmpathyContactPriv *priv;
496
497   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
498
499   priv = GET_PRIV (contact);
500
501   if (priv->avatar == avatar)
502     return;
503
504   if (priv->avatar)
505     {
506       empathy_avatar_unref (priv->avatar);
507       priv->avatar = NULL;
508     }
509
510   if (avatar)
511       priv->avatar = empathy_avatar_ref (avatar);
512
513   g_object_notify (G_OBJECT (contact), "avatar");
514 }
515
516 McAccount *
517 empathy_contact_get_account (EmpathyContact *contact)
518 {
519   EmpathyContactPriv *priv;
520
521   g_return_val_if_fail (EMPATHY_IS_CONTACT (contact), NULL);
522
523   priv = GET_PRIV (contact);
524
525   if (priv->account != NULL)
526     return priv->account;
527
528   if (priv->tp_contact != NULL)
529     {
530       EmpathyAccountManager *manager;
531       TpConnection *connection;
532
533       /* FIXME: This assume the account manager already exists */
534       manager = empathy_account_manager_dup_singleton ();
535       connection = tp_contact_get_connection (priv->tp_contact);
536       priv->account = empathy_account_manager_get_account (manager, connection);
537       g_object_unref (manager);
538
539       return g_object_ref (priv->account);
540     }
541
542   return NULL;
543 }
544
545 TpConnection *
546 empathy_contact_get_connection (EmpathyContact *contact)
547 {
548   EmpathyContactPriv *priv;
549
550   g_return_val_if_fail (EMPATHY_IS_CONTACT (contact), NULL);
551
552   priv = GET_PRIV (contact);
553
554   if (priv->tp_contact != NULL)
555     return tp_contact_get_connection (priv->tp_contact);
556
557   return NULL;
558 }
559
560 static McPresence
561 presence_type_to_mc_presence (TpConnectionPresenceType type)
562 {
563   switch (type)
564     {
565       case TP_CONNECTION_PRESENCE_TYPE_UNSET:
566       case TP_CONNECTION_PRESENCE_TYPE_UNKNOWN:
567       case TP_CONNECTION_PRESENCE_TYPE_ERROR:
568         return MC_PRESENCE_UNSET;
569       case TP_CONNECTION_PRESENCE_TYPE_OFFLINE:
570         return MC_PRESENCE_OFFLINE;
571       case TP_CONNECTION_PRESENCE_TYPE_AVAILABLE:
572         return MC_PRESENCE_AVAILABLE;
573       case TP_CONNECTION_PRESENCE_TYPE_AWAY:
574         return MC_PRESENCE_AWAY;
575       case TP_CONNECTION_PRESENCE_TYPE_EXTENDED_AWAY:
576         return MC_PRESENCE_EXTENDED_AWAY;
577       case TP_CONNECTION_PRESENCE_TYPE_HIDDEN:
578         return MC_PRESENCE_HIDDEN;
579       case TP_CONNECTION_PRESENCE_TYPE_BUSY:
580         return MC_PRESENCE_DO_NOT_DISTURB;
581     }
582
583   return MC_PRESENCE_UNSET;
584 }
585
586 McPresence
587 empathy_contact_get_presence (EmpathyContact *contact)
588 {
589   EmpathyContactPriv *priv;
590
591   g_return_val_if_fail (EMPATHY_IS_CONTACT (contact), MC_PRESENCE_UNSET);
592
593   priv = GET_PRIV (contact);
594
595   if (priv->tp_contact != NULL)
596     return presence_type_to_mc_presence (tp_contact_get_presence_type (
597         priv->tp_contact));
598
599   return priv->presence;
600 }
601
602 void
603 empathy_contact_set_presence (EmpathyContact *contact,
604                               McPresence presence)
605 {
606   EmpathyContactPriv *priv;
607   McPresence old_presence;
608
609   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
610
611   priv = GET_PRIV (contact);
612
613   if (presence == priv->presence)
614     return;
615
616   old_presence = priv->presence;
617   priv->presence = presence;
618
619   g_signal_emit (contact, signals[PRESENCE_CHANGED], 0, presence, old_presence);
620
621   g_object_notify (G_OBJECT (contact), "presence");
622 }
623
624 const gchar *
625 empathy_contact_get_presence_message (EmpathyContact *contact)
626 {
627   EmpathyContactPriv *priv;
628
629   g_return_val_if_fail (EMPATHY_IS_CONTACT (contact), NULL);
630
631   priv = GET_PRIV (contact);
632
633   if (priv->tp_contact != NULL)
634     return tp_contact_get_presence_message (priv->tp_contact);
635
636   return priv->presence_message;
637 }
638
639 void
640 empathy_contact_set_presence_message (EmpathyContact *contact,
641                                       const gchar *message)
642 {
643   EmpathyContactPriv *priv = GET_PRIV (contact);
644
645   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
646
647   if (!tp_strdiff (message, priv->presence_message))
648     return;
649
650   g_free (priv->presence_message);
651   priv->presence_message = g_strdup (message);
652
653   g_object_notify (G_OBJECT (contact), "presence-message");
654 }
655
656 guint
657 empathy_contact_get_handle (EmpathyContact *contact)
658 {
659   EmpathyContactPriv *priv;
660
661   g_return_val_if_fail (EMPATHY_IS_CONTACT (contact), 0);
662
663   priv = GET_PRIV (contact);
664
665   if (priv->tp_contact != NULL)
666     return tp_contact_get_handle (priv->tp_contact);
667
668   return priv->handle;
669 }
670
671 void
672 empathy_contact_set_handle (EmpathyContact *contact,
673                             guint handle)
674 {
675   EmpathyContactPriv *priv;
676
677   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
678
679   priv = GET_PRIV (contact);
680
681   g_object_ref (contact);
682   if (handle != priv->handle)
683     {
684       priv->handle = handle;
685       g_object_notify (G_OBJECT (contact), "handle");
686     }
687   g_object_unref (contact);
688 }
689
690 EmpathyCapabilities
691 empathy_contact_get_capabilities (EmpathyContact *contact)
692 {
693   EmpathyContactPriv *priv;
694
695   g_return_val_if_fail (EMPATHY_IS_CONTACT (contact), 0);
696
697   priv = GET_PRIV (contact);
698
699   return priv->capabilities;
700 }
701
702 void
703 empathy_contact_set_capabilities (EmpathyContact *contact,
704                                   EmpathyCapabilities capabilities)
705 {
706   EmpathyContactPriv *priv;
707
708   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
709
710   priv = GET_PRIV (contact);
711
712   if (priv->capabilities == capabilities)
713     return;
714
715   priv->capabilities = capabilities;
716
717   g_object_notify (G_OBJECT (contact), "capabilities");
718 }
719
720 gboolean
721 empathy_contact_is_user (EmpathyContact *contact)
722 {
723   EmpathyContactPriv *priv;
724
725   g_return_val_if_fail (EMPATHY_IS_CONTACT (contact), FALSE);
726
727   priv = GET_PRIV (contact);
728
729   return priv->is_user;
730 }
731
732 void
733 empathy_contact_set_is_user (EmpathyContact *contact,
734                              gboolean is_user)
735 {
736   EmpathyContactPriv *priv;
737
738   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
739
740   priv = GET_PRIV (contact);
741
742   if (priv->is_user == is_user)
743     return;
744
745   priv->is_user = is_user;
746
747   g_object_notify (G_OBJECT (contact), "is-user");
748 }
749
750 gboolean
751 empathy_contact_is_online (EmpathyContact *contact)
752 {
753   g_return_val_if_fail (EMPATHY_IS_CONTACT (contact), FALSE);
754
755   return (empathy_contact_get_presence (contact) > MC_PRESENCE_OFFLINE);
756 }
757
758 const gchar *
759 empathy_contact_get_status (EmpathyContact *contact)
760 {
761   const gchar *message;
762
763   g_return_val_if_fail (EMPATHY_IS_CONTACT (contact), "");
764
765   message = empathy_contact_get_presence_message (contact);
766   if (message)
767     return message;
768
769   return empathy_presence_get_default_message (
770       empathy_contact_get_presence (contact));
771 }
772
773 gboolean
774 empathy_contact_can_voip (EmpathyContact *contact)
775 {
776   EmpathyContactPriv *priv;
777
778   g_return_val_if_fail (EMPATHY_IS_CONTACT (contact), FALSE);
779
780   priv = GET_PRIV (contact);
781
782   return priv->capabilities & (EMPATHY_CAPABILITIES_AUDIO |
783       EMPATHY_CAPABILITIES_VIDEO);
784 }
785
786 gboolean
787 empathy_contact_can_send_files (EmpathyContact *contact)
788 {
789   EmpathyContactPriv *priv;
790
791   g_return_val_if_fail (EMPATHY_IS_CONTACT (contact), FALSE);
792
793   priv = GET_PRIV (contact);
794
795   return priv->capabilities & EMPATHY_CAPABILITIES_FT;
796 }
797
798 static gchar *
799 contact_get_avatar_filename (EmpathyContact *contact,
800                              const gchar *token)
801 {
802   EmpathyContactPriv *priv = GET_PRIV (contact);
803   McAccount *account;
804   gchar *avatar_path;
805   gchar *avatar_file;
806   gchar *token_escaped;
807   gchar *contact_escaped;
808
809   if (EMP_STR_EMPTY (priv->id))
810     return NULL;
811
812   contact_escaped = tp_escape_as_identifier (priv->id);
813   token_escaped = tp_escape_as_identifier (token);
814   account = empathy_contact_get_account (contact);
815
816   /* FIXME: Do not use the account, but proto/cm instead */
817   avatar_path = g_build_filename (g_get_user_cache_dir (),
818       PACKAGE_NAME,
819       "avatars",
820       mc_account_get_unique_name (account),
821       contact_escaped,
822       NULL);
823   g_mkdir_with_parents (avatar_path, 0700);
824
825   avatar_file = g_build_filename (avatar_path, token_escaped, NULL);
826
827   g_free (contact_escaped);
828   g_free (token_escaped);
829   g_free (avatar_path);
830
831   return avatar_file;
832 }
833
834 void
835 empathy_contact_load_avatar_data (EmpathyContact *contact,
836                                   const guchar  *data,
837                                   const gsize len,
838                                   const gchar *format,
839                                   const gchar *token)
840 {
841   EmpathyAvatar *avatar;
842   gchar *filename;
843   GError *error = NULL;
844
845   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
846   g_return_if_fail (data != NULL);
847   g_return_if_fail (len > 0);
848   g_return_if_fail (format != NULL);
849   g_return_if_fail (!EMP_STR_EMPTY (token));
850
851   /* Load and set the avatar */
852   avatar = empathy_avatar_new (g_memdup (data, len), len, g_strdup (format),
853       g_strdup (token));
854   empathy_contact_set_avatar (contact, avatar);
855   empathy_avatar_unref (avatar);
856
857   /* Save to cache if not yet in it */
858   filename = contact_get_avatar_filename (contact, token);
859   if (filename && !g_file_test (filename, G_FILE_TEST_EXISTS))
860     {
861       if (!empathy_avatar_save_to_file (avatar, filename, &error))
862         {
863           DEBUG ("Failed to save avatar in cache: %s",
864             error ? error->message : "No error given");
865           g_clear_error (&error);
866         }
867       else
868           DEBUG ("Avatar saved to %s", filename);
869     }
870   g_free (filename);
871 }
872
873 gboolean
874 empathy_contact_load_avatar_cache (EmpathyContact *contact,
875                                    const gchar *token)
876 {
877   EmpathyAvatar *avatar = NULL;
878   gchar *filename;
879   gchar *data = NULL;
880   gsize len;
881   GError *error = NULL;
882
883   g_return_val_if_fail (EMPATHY_IS_CONTACT (contact), FALSE);
884   g_return_val_if_fail (!EMP_STR_EMPTY (token), FALSE);
885
886   /* Load the avatar from file if it exists */
887   filename = contact_get_avatar_filename (contact, token);
888   if (filename && g_file_test (filename, G_FILE_TEST_EXISTS))
889     {
890       if (!g_file_get_contents (filename, &data, &len, &error))
891         {
892           DEBUG ("Failed to load avatar from cache: %s",
893             error ? error->message : "No error given");
894           g_clear_error (&error);
895         }
896     }
897
898   if (data)
899     {
900       DEBUG ("Avatar loaded from %s", filename);
901       avatar = empathy_avatar_new (data, len, NULL, g_strdup (token));
902       empathy_contact_set_avatar (contact, avatar);
903       empathy_avatar_unref (avatar);
904     }
905
906   g_free (filename);
907
908   return data != NULL;
909 }
910
911 GType
912 empathy_avatar_get_type (void)
913 {
914   static GType type_id = 0;
915
916   if (!type_id)
917     {
918       type_id = g_boxed_type_register_static ("EmpathyAvatar",
919           (GBoxedCopyFunc) empathy_avatar_ref,
920           (GBoxedFreeFunc) empathy_avatar_unref);
921     }
922
923   return type_id;
924 }
925
926 EmpathyAvatar *
927 empathy_avatar_new (guchar *data,
928                     gsize len,
929                     gchar *format,
930                     gchar *token)
931 {
932   EmpathyAvatar *avatar;
933
934   avatar = g_slice_new0 (EmpathyAvatar);
935   avatar->data = data;
936   avatar->len = len;
937   avatar->format = format;
938   avatar->token = token;
939   avatar->refcount = 1;
940
941   return avatar;
942 }
943
944 void
945 empathy_avatar_unref (EmpathyAvatar *avatar)
946 {
947   g_return_if_fail (avatar != NULL);
948
949   avatar->refcount--;
950   if (avatar->refcount == 0)
951     {
952       g_free (avatar->data);
953       g_free (avatar->format);
954       g_free (avatar->token);
955       g_slice_free (EmpathyAvatar, avatar);
956     }
957 }
958
959 EmpathyAvatar *
960 empathy_avatar_ref (EmpathyAvatar *avatar)
961 {
962   g_return_val_if_fail (avatar != NULL, NULL);
963
964   avatar->refcount++;
965
966   return avatar;
967 }
968
969 /**
970  * empathy_avatar_save_to_file:
971  * @avatar: the avatar
972  * @filename: name of a file to write avatar to
973  * @error: return location for a GError, or NULL
974  *
975  * Save the avatar to a file named filename
976  *
977  * Returns: %TRUE on success, %FALSE if an error occurred 
978  */
979 gboolean
980 empathy_avatar_save_to_file (EmpathyAvatar *self,
981                              const gchar *filename,
982                              GError **error)
983 {
984   return g_file_set_contents (filename, self->data, self->len, error);
985 }
986