CONSTRUCT_ONLY properties must be writable
[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_READWRITE));
151
152   g_object_class_install_property (object_class,
153       PROP_ACCOUNT,
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_READWRITE));
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   g_return_val_if_fail (TP_IS_CONTACT (tp_contact), NULL);
383
384   return g_object_new (EMPATHY_TYPE_CONTACT,
385       "tp-contact", tp_contact,
386       NULL);
387 }
388
389 TpContact *
390 empathy_contact_get_tp_contact (EmpathyContact *contact)
391 {
392   EmpathyContactPriv *priv;
393
394   g_return_val_if_fail (EMPATHY_IS_CONTACT (contact), NULL);
395
396   priv = GET_PRIV (contact);
397
398   return priv->tp_contact;
399 }
400
401 const gchar *
402 empathy_contact_get_id (EmpathyContact *contact)
403 {
404   EmpathyContactPriv *priv;
405
406   g_return_val_if_fail (EMPATHY_IS_CONTACT (contact), NULL);
407
408   priv = GET_PRIV (contact);
409
410   if (priv->tp_contact != NULL)
411     return tp_contact_get_identifier (priv->tp_contact);
412
413   return priv->id;
414 }
415
416 void
417 empathy_contact_set_id (EmpathyContact *contact,
418                         const gchar *id)
419 {
420   EmpathyContactPriv *priv;
421
422   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
423   g_return_if_fail (id != NULL);
424
425   priv = GET_PRIV (contact);
426
427   /* We temporally ref the contact because it could be destroyed
428    * during the signal emition */
429   g_object_ref (contact);
430   if (tp_strdiff (id, priv->id))
431     {
432       g_free (priv->id);
433       priv->id = g_strdup (id);
434
435       g_object_notify (G_OBJECT (contact), "id");
436       if (EMP_STR_EMPTY (priv->name))
437           g_object_notify (G_OBJECT (contact), "name");
438     }
439
440   g_object_unref (contact);
441 }
442
443 const gchar *
444 empathy_contact_get_name (EmpathyContact *contact)
445 {
446   EmpathyContactPriv *priv;
447
448   g_return_val_if_fail (EMPATHY_IS_CONTACT (contact), NULL);
449
450   priv = GET_PRIV (contact);
451
452   if (priv->tp_contact != NULL)
453     return tp_contact_get_alias (priv->tp_contact);
454
455   if (EMP_STR_EMPTY (priv->name))
456       return empathy_contact_get_id (contact);
457
458   return priv->name;
459 }
460
461 void
462 empathy_contact_set_name (EmpathyContact *contact,
463                           const gchar *name)
464 {
465   EmpathyContactPriv *priv;
466
467   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
468
469   priv = GET_PRIV (contact);
470
471   g_object_ref (contact);
472   if (tp_strdiff (name, priv->name))
473     {
474       g_free (priv->name);
475       priv->name = g_strdup (name);
476       g_object_notify (G_OBJECT (contact), "name");
477     }
478   g_object_unref (contact);
479 }
480
481 EmpathyAvatar *
482 empathy_contact_get_avatar (EmpathyContact *contact)
483 {
484   EmpathyContactPriv *priv;
485
486   g_return_val_if_fail (EMPATHY_IS_CONTACT (contact), NULL);
487
488   priv = GET_PRIV (contact);
489
490   return priv->avatar;
491 }
492
493 void
494 empathy_contact_set_avatar (EmpathyContact *contact,
495                             EmpathyAvatar *avatar)
496 {
497   EmpathyContactPriv *priv;
498
499   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
500
501   priv = GET_PRIV (contact);
502
503   if (priv->avatar == avatar)
504     return;
505
506   if (priv->avatar)
507     {
508       empathy_avatar_unref (priv->avatar);
509       priv->avatar = NULL;
510     }
511
512   if (avatar)
513       priv->avatar = empathy_avatar_ref (avatar);
514
515   g_object_notify (G_OBJECT (contact), "avatar");
516 }
517
518 McAccount *
519 empathy_contact_get_account (EmpathyContact *contact)
520 {
521   EmpathyContactPriv *priv;
522
523   g_return_val_if_fail (EMPATHY_IS_CONTACT (contact), NULL);
524
525   priv = GET_PRIV (contact);
526
527   if (priv->account != NULL)
528     return priv->account;
529
530   if (priv->tp_contact != NULL)
531     {
532       EmpathyAccountManager *manager;
533       TpConnection *connection;
534
535       /* FIXME: This assume the account manager already exists */
536       manager = empathy_account_manager_dup_singleton ();
537       connection = tp_contact_get_connection (priv->tp_contact);
538       priv->account = empathy_account_manager_get_account (manager, connection);
539       g_object_unref (manager);
540
541       return g_object_ref (priv->account);
542     }
543
544   return NULL;
545 }
546
547 TpConnection *
548 empathy_contact_get_connection (EmpathyContact *contact)
549 {
550   EmpathyContactPriv *priv;
551
552   g_return_val_if_fail (EMPATHY_IS_CONTACT (contact), NULL);
553
554   priv = GET_PRIV (contact);
555
556   if (priv->tp_contact != NULL)
557     return tp_contact_get_connection (priv->tp_contact);
558
559   return NULL;
560 }
561
562 static McPresence
563 presence_type_to_mc_presence (TpConnectionPresenceType type)
564 {
565   switch (type)
566     {
567       case TP_CONNECTION_PRESENCE_TYPE_UNSET:
568       case TP_CONNECTION_PRESENCE_TYPE_UNKNOWN:
569       case TP_CONNECTION_PRESENCE_TYPE_ERROR:
570         return MC_PRESENCE_UNSET;
571       case TP_CONNECTION_PRESENCE_TYPE_OFFLINE:
572         return MC_PRESENCE_OFFLINE;
573       case TP_CONNECTION_PRESENCE_TYPE_AVAILABLE:
574         return MC_PRESENCE_AVAILABLE;
575       case TP_CONNECTION_PRESENCE_TYPE_AWAY:
576         return MC_PRESENCE_AWAY;
577       case TP_CONNECTION_PRESENCE_TYPE_EXTENDED_AWAY:
578         return MC_PRESENCE_EXTENDED_AWAY;
579       case TP_CONNECTION_PRESENCE_TYPE_HIDDEN:
580         return MC_PRESENCE_HIDDEN;
581       case TP_CONNECTION_PRESENCE_TYPE_BUSY:
582         return MC_PRESENCE_DO_NOT_DISTURB;
583     }
584
585   return MC_PRESENCE_UNSET;
586 }
587
588 McPresence
589 empathy_contact_get_presence (EmpathyContact *contact)
590 {
591   EmpathyContactPriv *priv;
592
593   g_return_val_if_fail (EMPATHY_IS_CONTACT (contact), MC_PRESENCE_UNSET);
594
595   priv = GET_PRIV (contact);
596
597   if (priv->tp_contact != NULL)
598     return presence_type_to_mc_presence (tp_contact_get_presence_type (
599         priv->tp_contact));
600
601   return priv->presence;
602 }
603
604 void
605 empathy_contact_set_presence (EmpathyContact *contact,
606                               McPresence presence)
607 {
608   EmpathyContactPriv *priv;
609   McPresence old_presence;
610
611   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
612
613   priv = GET_PRIV (contact);
614
615   if (presence == priv->presence)
616     return;
617
618   old_presence = priv->presence;
619   priv->presence = presence;
620
621   g_signal_emit (contact, signals[PRESENCE_CHANGED], 0, presence, old_presence);
622
623   g_object_notify (G_OBJECT (contact), "presence");
624 }
625
626 const gchar *
627 empathy_contact_get_presence_message (EmpathyContact *contact)
628 {
629   EmpathyContactPriv *priv;
630
631   g_return_val_if_fail (EMPATHY_IS_CONTACT (contact), NULL);
632
633   priv = GET_PRIV (contact);
634
635   if (priv->tp_contact != NULL)
636     return tp_contact_get_presence_message (priv->tp_contact);
637
638   return priv->presence_message;
639 }
640
641 void
642 empathy_contact_set_presence_message (EmpathyContact *contact,
643                                       const gchar *message)
644 {
645   EmpathyContactPriv *priv = GET_PRIV (contact);
646
647   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
648
649   if (!tp_strdiff (message, priv->presence_message))
650     return;
651
652   g_free (priv->presence_message);
653   priv->presence_message = g_strdup (message);
654
655   g_object_notify (G_OBJECT (contact), "presence-message");
656 }
657
658 guint
659 empathy_contact_get_handle (EmpathyContact *contact)
660 {
661   EmpathyContactPriv *priv;
662
663   g_return_val_if_fail (EMPATHY_IS_CONTACT (contact), 0);
664
665   priv = GET_PRIV (contact);
666
667   if (priv->tp_contact != NULL)
668     return tp_contact_get_handle (priv->tp_contact);
669
670   return priv->handle;
671 }
672
673 void
674 empathy_contact_set_handle (EmpathyContact *contact,
675                             guint handle)
676 {
677   EmpathyContactPriv *priv;
678
679   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
680
681   priv = GET_PRIV (contact);
682
683   g_object_ref (contact);
684   if (handle != priv->handle)
685     {
686       priv->handle = handle;
687       g_object_notify (G_OBJECT (contact), "handle");
688     }
689   g_object_unref (contact);
690 }
691
692 EmpathyCapabilities
693 empathy_contact_get_capabilities (EmpathyContact *contact)
694 {
695   EmpathyContactPriv *priv;
696
697   g_return_val_if_fail (EMPATHY_IS_CONTACT (contact), 0);
698
699   priv = GET_PRIV (contact);
700
701   return priv->capabilities;
702 }
703
704 void
705 empathy_contact_set_capabilities (EmpathyContact *contact,
706                                   EmpathyCapabilities capabilities)
707 {
708   EmpathyContactPriv *priv;
709
710   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
711
712   priv = GET_PRIV (contact);
713
714   if (priv->capabilities == capabilities)
715     return;
716
717   priv->capabilities = capabilities;
718
719   g_object_notify (G_OBJECT (contact), "capabilities");
720 }
721
722 gboolean
723 empathy_contact_is_user (EmpathyContact *contact)
724 {
725   EmpathyContactPriv *priv;
726
727   g_return_val_if_fail (EMPATHY_IS_CONTACT (contact), FALSE);
728
729   priv = GET_PRIV (contact);
730
731   return priv->is_user;
732 }
733
734 void
735 empathy_contact_set_is_user (EmpathyContact *contact,
736                              gboolean is_user)
737 {
738   EmpathyContactPriv *priv;
739
740   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
741
742   priv = GET_PRIV (contact);
743
744   if (priv->is_user == is_user)
745     return;
746
747   priv->is_user = is_user;
748
749   g_object_notify (G_OBJECT (contact), "is-user");
750 }
751
752 gboolean
753 empathy_contact_is_online (EmpathyContact *contact)
754 {
755   g_return_val_if_fail (EMPATHY_IS_CONTACT (contact), FALSE);
756
757   return (empathy_contact_get_presence (contact) > MC_PRESENCE_OFFLINE);
758 }
759
760 const gchar *
761 empathy_contact_get_status (EmpathyContact *contact)
762 {
763   const gchar *message;
764
765   g_return_val_if_fail (EMPATHY_IS_CONTACT (contact), "");
766
767   message = empathy_contact_get_presence_message (contact);
768   if (message)
769     return message;
770
771   return empathy_presence_get_default_message (
772       empathy_contact_get_presence (contact));
773 }
774
775 gboolean
776 empathy_contact_can_voip (EmpathyContact *contact)
777 {
778   EmpathyContactPriv *priv;
779
780   g_return_val_if_fail (EMPATHY_IS_CONTACT (contact), FALSE);
781
782   priv = GET_PRIV (contact);
783
784   return priv->capabilities & (EMPATHY_CAPABILITIES_AUDIO |
785       EMPATHY_CAPABILITIES_VIDEO);
786 }
787
788 gboolean
789 empathy_contact_can_send_files (EmpathyContact *contact)
790 {
791   EmpathyContactPriv *priv;
792
793   g_return_val_if_fail (EMPATHY_IS_CONTACT (contact), FALSE);
794
795   priv = GET_PRIV (contact);
796
797   return priv->capabilities & EMPATHY_CAPABILITIES_FT;
798 }
799
800 static gchar *
801 contact_get_avatar_filename (EmpathyContact *contact,
802                              const gchar *token)
803 {
804   EmpathyContactPriv *priv = GET_PRIV (contact);
805   McAccount *account;
806   gchar *avatar_path;
807   gchar *avatar_file;
808   gchar *token_escaped;
809   gchar *contact_escaped;
810
811   if (EMP_STR_EMPTY (priv->id))
812     return NULL;
813
814   contact_escaped = tp_escape_as_identifier (priv->id);
815   token_escaped = tp_escape_as_identifier (token);
816   account = empathy_contact_get_account (contact);
817
818   /* FIXME: Do not use the account, but proto/cm instead */
819   avatar_path = g_build_filename (g_get_user_cache_dir (),
820       PACKAGE_NAME,
821       "avatars",
822       mc_account_get_unique_name (account),
823       contact_escaped,
824       NULL);
825   g_mkdir_with_parents (avatar_path, 0700);
826
827   avatar_file = g_build_filename (avatar_path, token_escaped, NULL);
828
829   g_free (contact_escaped);
830   g_free (token_escaped);
831   g_free (avatar_path);
832
833   return avatar_file;
834 }
835
836 void
837 empathy_contact_load_avatar_data (EmpathyContact *contact,
838                                   const guchar  *data,
839                                   const gsize len,
840                                   const gchar *format,
841                                   const gchar *token)
842 {
843   EmpathyAvatar *avatar;
844   gchar *filename;
845   GError *error = NULL;
846
847   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
848   g_return_if_fail (data != NULL);
849   g_return_if_fail (len > 0);
850   g_return_if_fail (format != NULL);
851   g_return_if_fail (!EMP_STR_EMPTY (token));
852
853   /* Load and set the avatar */
854   avatar = empathy_avatar_new (g_memdup (data, len), len, g_strdup (format),
855       g_strdup (token));
856   empathy_contact_set_avatar (contact, avatar);
857   empathy_avatar_unref (avatar);
858
859   /* Save to cache if not yet in it */
860   filename = contact_get_avatar_filename (contact, token);
861   if (filename && !g_file_test (filename, G_FILE_TEST_EXISTS))
862     {
863       if (!empathy_avatar_save_to_file (avatar, filename, &error))
864         {
865           DEBUG ("Failed to save avatar in cache: %s",
866             error ? error->message : "No error given");
867           g_clear_error (&error);
868         }
869       else
870           DEBUG ("Avatar saved to %s", filename);
871     }
872   g_free (filename);
873 }
874
875 gboolean
876 empathy_contact_load_avatar_cache (EmpathyContact *contact,
877                                    const gchar *token)
878 {
879   EmpathyAvatar *avatar = NULL;
880   gchar *filename;
881   gchar *data = NULL;
882   gsize len;
883   GError *error = NULL;
884
885   g_return_val_if_fail (EMPATHY_IS_CONTACT (contact), FALSE);
886   g_return_val_if_fail (!EMP_STR_EMPTY (token), FALSE);
887
888   /* Load the avatar from file if it exists */
889   filename = contact_get_avatar_filename (contact, token);
890   if (filename && g_file_test (filename, G_FILE_TEST_EXISTS))
891     {
892       if (!g_file_get_contents (filename, &data, &len, &error))
893         {
894           DEBUG ("Failed to load avatar from cache: %s",
895             error ? error->message : "No error given");
896           g_clear_error (&error);
897         }
898     }
899
900   if (data)
901     {
902       DEBUG ("Avatar loaded from %s", filename);
903       avatar = empathy_avatar_new (data, len, NULL, g_strdup (token));
904       empathy_contact_set_avatar (contact, avatar);
905       empathy_avatar_unref (avatar);
906     }
907
908   g_free (filename);
909
910   return data != NULL;
911 }
912
913 GType
914 empathy_avatar_get_type (void)
915 {
916   static GType type_id = 0;
917
918   if (!type_id)
919     {
920       type_id = g_boxed_type_register_static ("EmpathyAvatar",
921           (GBoxedCopyFunc) empathy_avatar_ref,
922           (GBoxedFreeFunc) empathy_avatar_unref);
923     }
924
925   return type_id;
926 }
927
928 EmpathyAvatar *
929 empathy_avatar_new (guchar *data,
930                     gsize len,
931                     gchar *format,
932                     gchar *token)
933 {
934   EmpathyAvatar *avatar;
935
936   avatar = g_slice_new0 (EmpathyAvatar);
937   avatar->data = data;
938   avatar->len = len;
939   avatar->format = format;
940   avatar->token = token;
941   avatar->refcount = 1;
942
943   return avatar;
944 }
945
946 void
947 empathy_avatar_unref (EmpathyAvatar *avatar)
948 {
949   g_return_if_fail (avatar != NULL);
950
951   avatar->refcount--;
952   if (avatar->refcount == 0)
953     {
954       g_free (avatar->data);
955       g_free (avatar->format);
956       g_free (avatar->token);
957       g_slice_free (EmpathyAvatar, avatar);
958     }
959 }
960
961 EmpathyAvatar *
962 empathy_avatar_ref (EmpathyAvatar *avatar)
963 {
964   g_return_val_if_fail (avatar != NULL, NULL);
965
966   avatar->refcount++;
967
968   return avatar;
969 }
970
971 /**
972  * empathy_avatar_save_to_file:
973  * @avatar: the avatar
974  * @filename: name of a file to write avatar to
975  * @error: return location for a GError, or NULL
976  *
977  * Save the avatar to a file named filename
978  *
979  * Returns: %TRUE on success, %FALSE if an error occurred 
980  */
981 gboolean
982 empathy_avatar_save_to_file (EmpathyAvatar *self,
983                              const gchar *filename,
984                              GError **error)
985 {
986   return g_file_set_contents (filename, self->data, self->len, error);
987 }
988