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