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.",
 924                                                              G_TYPE_STRV,
 925                                                              G_PARAM_READABLE |
 926                                                              G_PARAM_STATIC_STRINGS));
 927         g_object_class_install_property (object_class,
 928                                          PROP_MIN_WIDTH,
 929                                          g_param_spec_uint ("avatar-min-width",
 930                                                             "Minimum width for avatars",
 931                                                             "Minimum width of avatar that may be set.",
 932                                                             0,
 933                                                             G_MAXUINT,
 934                                                             0,
 935                                                             G_PARAM_READABLE |
 936                                                             G_PARAM_STATIC_STRINGS));
 937         g_object_class_install_property (object_class,
 938                                          PROP_MIN_HEIGHT,
 939                                          g_param_spec_uint ("avatar-min-height",
 940                                                             "Minimum height for avatars",
 941                                                             "Minimum height of avatar that may be set.",
 942                                                             0,
 943                                                             G_MAXUINT,
 944                                                             0,
 945                                                             G_PARAM_READABLE |
 946                                                             G_PARAM_STATIC_STRINGS));
 947         g_object_class_install_property (object_class,
 948                                          PROP_MAX_WIDTH,
 949                                          g_param_spec_uint ("avatar-max-width",
 950                                                             "Maximum width for avatars",
 951                                                             "Maximum width of avatar that may be set "
 952                                                             "or 0 if there is no maximum.",
 953                                                             0,
 954                                                             G_MAXUINT,
 955                                                             0,
 956                                                             G_PARAM_READABLE |
 957                                                             G_PARAM_STATIC_STRINGS));
 958         g_object_class_install_property (object_class,
 959                                          PROP_MAX_HEIGHT,
 960                                          g_param_spec_uint ("avatar-max-height",
 961                                                             "Maximum height for avatars",
 962                                                             "Maximum height of avatar that may be set "
 963                                                             "or 0 if there is no maximum.",
 964                                                             0,
 965                                                             G_MAXUINT,
 966                                                             0,
 967                                                             G_PARAM_READABLE |
 968                                                             G_PARAM_STATIC_STRINGS));
 969         g_object_class_install_property (object_class,
 970                                          PROP_MAX_SIZE,
 971                                          g_param_spec_uint ("avatar-max-size",
 972                                                             "Maximum size for avatars in bytes",
 973                                                             "Maximum file size of avatar that may be "
 974                                                             "set or 0 if there is no maximum.",
 975                                                             0,
 976                                                             G_MAXUINT,
 977                                                             0,
 978                                                             G_PARAM_READABLE |
 979                                                             G_PARAM_STATIC_STRINGS));
 980
 981
 982         g_type_class_add_private (object_class, sizeof (EmpathyTpContactFactoryPriv));
 983 }
 984
 985 static void
 986 empathy_tp_contact_factory_init (EmpathyTpContactFactory *tp_factory)
 987 {
 988         EmpathyTpContactFactoryPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (tp_factory,
 989                 EMPATHY_TYPE_TP_CONTACT_FACTORY, EmpathyTpContactFactoryPriv);
 990
 991         tp_factory->priv = priv;
 992         priv->can_request_ft = FALSE;
 993 }
 994
 995 static GHashTable *factories = NULL;
 996
 997 static void
 998 tp_contact_factory_connection_invalidated_cb (TpProxy *connection,
 999                                               guint    domain,
1000                                               gint     code,
1001                                               gchar   *message,
1002                                               gpointer user_data)
1003 {
1004         DEBUG ("Message: %s", message);
1005         g_hash_table_remove (factories, connection);
1006 }
1007
1008 static void
1009 tp_contact_factory_connection_weak_notify_cb (gpointer connection,
1010                                               GObject *where_the_object_was)
1011 {
1012         g_hash_table_remove (factories, connection);
1013 }
1014
1015 static void
1016 tp_contact_factory_remove_connection (gpointer connection)
1017 {
1018         g_signal_handlers_disconnect_by_func (connection,
1019                 tp_contact_factory_connection_invalidated_cb, NULL);
1020         g_object_unref (connection);
1021 }
1022
1023 EmpathyTpContactFactory *
1024 empathy_tp_contact_factory_dup_singleton (TpConnection *connection)
1025 {
1026         EmpathyTpContactFactory *tp_factory;
1027
1028         g_return_val_if_fail (TP_IS_CONNECTION (connection), NULL);
1029
1030         if (factories == NULL) {
1031                 factories = g_hash_table_new_full (empathy_proxy_hash,
1032                                                    empathy_proxy_equal,
1033                                                    tp_contact_factory_remove_connection,
1034                                                    NULL);
1035         }
1036
1037         tp_factory = g_hash_table_lookup (factories, connection);
1038         if (tp_factory == NULL) {
1039                 tp_factory = g_object_new (EMPATHY_TYPE_TP_CONTACT_FACTORY,
1040                                            "connection", connection,
1041                                            NULL);
1042                 g_hash_table_insert (factories, g_object_ref (connection),
1043                                      tp_factory);
1044                 g_object_weak_ref (G_OBJECT (tp_factory),
1045                                    tp_contact_factory_connection_weak_notify_cb,
1046                                    connection);
1047                 g_signal_connect (connection, "invalidated",
1048                                   G_CALLBACK (tp_contact_factory_connection_invalidated_cb),
1049                                   NULL);
1050         } else {
1051                 g_object_ref (tp_factory);
1052         }
1053
1054         return tp_factory;
1055 }
1056