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 union {
 558         EmpathyTpContactFactoryContactsByIdCb ids_cb;
 559         EmpathyTpContactFactoryContactsByHandleCb handles_cb;
 560         EmpathyTpContactFactoryContactCb contact_cb;
 561 } GetContactsCb;
 562
 563 typedef struct {
 564         EmpathyTpContactFactory *tp_factory;
 565         GetContactsCb callback;
 566         gpointer user_data;
 567         GDestroyNotify destroy;
 568 } GetContactsData;
 569
 570 static void
 571 get_contacts_data_free (gpointer user_data)
 572 {
 573         GetContactsData *data = user_data;
 574
 575         if (data->destroy) {
 576                 data->destroy (data->user_data);
 577         }
 578         g_object_unref (data->tp_factory);
 579
 580         g_slice_free (GetContactsData, data);
 581 }
 582
 583 static EmpathyContact *
 584 dup_contact_for_tp_contact (EmpathyTpContactFactory *tp_factory,
 585                             TpContact               *tp_contact)
 586 {
 587         EmpathyContact *contact;
 588
 589         contact = tp_contact_factory_find_by_tp_contact (tp_factory,
 590                                                          tp_contact);
 591
 592         if (contact != NULL) {
 593                 g_object_ref (contact);
 594         } else {
 595                 contact = empathy_contact_new (tp_contact);
 596                 tp_contact_factory_add_contact (tp_factory, contact);
 597         }
 598
 599         return contact;
 600 }
 601
 602 static EmpathyContact **
 603 contacts_array_new (EmpathyTpContactFactory *tp_factory,
 604                     guint                    n_contacts,
 605                     TpContact * const *      contacts)
 606 {
 607         EmpathyContact **ret;
 608         guint            i;
 609
 610         ret = g_new0 (EmpathyContact *, n_contacts);
 611         for (i = 0; i < n_contacts; i++) {
 612                 ret[i] = dup_contact_for_tp_contact (tp_factory, contacts[i]);
 613         }
 614
 615         return ret;
 616 }
 617
 618 static void
 619 contacts_array_free (guint            n_contacts,
 620                      EmpathyContact **contacts)
 621 {
 622         guint i;
 623
 624         for (i = 0; i < n_contacts; i++) {
 625                 g_object_unref (contacts[i]);
 626         }
 627         g_free (contacts);
 628 }
 629
 630 static void
 631 get_contacts_by_id_cb (TpConnection *connection,
 632                        guint n_contacts,
 633                        TpContact * const *contacts,
 634                        const gchar * const *requested_ids,
 635                        GHashTable *failed_id_errors,
 636                        const GError *error,
 637                        gpointer user_data,
 638                        GObject *weak_object)
 639 {
 640         GetContactsData *data = user_data;
 641         EmpathyContact **empathy_contacts;
 642
 643         empathy_contacts = contacts_array_new (data->tp_factory,
 644                                                n_contacts, contacts);
 645         if (data->callback.ids_cb) {
 646                 data->callback.ids_cb (data->tp_factory,
 647                                        n_contacts, empathy_contacts,
 648                                        requested_ids,
 649                                        failed_id_errors,
 650                                        error,
 651                                        data->user_data, weak_object);
 652         }
 653
 654         contacts_array_free (n_contacts, empathy_contacts);
 655 }
 656
 657 void
 658 empathy_tp_contact_factory_get_from_ids (EmpathyTpContactFactory *tp_factory,
 659                                          guint                    n_ids,
 660                                          const gchar * const     *ids,
 661                                          EmpathyTpContactFactoryContactsByIdCb callback,
 662                                          gpointer                 user_data,
 663                                          GDestroyNotify           destroy,
 664                                          GObject                 *weak_object)
 665 {
 666         EmpathyTpContactFactoryPriv *priv = GET_PRIV (tp_factory);
 667         GetContactsData *data;
 668
 669         g_return_if_fail (EMPATHY_IS_TP_CONTACT_FACTORY (tp_factory));
 670         g_return_if_fail (ids != NULL);
 671
 672         data = g_slice_new (GetContactsData);
 673         data->callback.ids_cb = callback;
 674         data->user_data = user_data;
 675         data->destroy = destroy;
 676         data->tp_factory = g_object_ref (tp_factory);
 677         tp_connection_get_contacts_by_id (priv->connection,
 678                                           n_ids, ids,
 679                                           G_N_ELEMENTS (contact_features),
 680                                           contact_features,
 681                                           get_contacts_by_id_cb,
 682                                           data,
 683                                           (GDestroyNotify) get_contacts_data_free,
 684                                           weak_object);
 685 }
 686
 687 static void
 688 get_contact_by_id_cb (TpConnection *connection,
 689                       guint n_contacts,
 690                       TpContact * const *contacts,
 691                       const gchar * const *requested_ids,
 692                       GHashTable *failed_id_errors,
 693                       const GError *error,
 694                       gpointer user_data,
 695                       GObject *weak_object)
 696 {
 697         GetContactsData *data = user_data;
 698         EmpathyContact  *contact = NULL;
 699
 700         if (n_contacts == 1) {
 701                 contact = dup_contact_for_tp_contact (data->tp_factory,
 702                                                       contacts[0]);
 703         }
 704         else if (error == NULL) {
 705                 GHashTableIter iter;
 706                 gpointer       value;
 707
 708                 g_hash_table_iter_init (&iter, failed_id_errors);
 709                 while (g_hash_table_iter_next (&iter, NULL, &value)) {
 710                         if (value) {
 711                                 error = value;
 712                                 break;
 713                         }
 714                 }
 715         }
 716
 717         if (data->callback.contact_cb) {
 718                 data->callback.contact_cb (data->tp_factory,
 719                                            contact,
 720                                            error,
 721                                            data->user_data, weak_object);
 722         }
 723 }
 724
 725 void
 726 empathy_tp_contact_factory_get_from_id (EmpathyTpContactFactory *tp_factory,
 727                                         const gchar             *id,
 728                                         EmpathyTpContactFactoryContactCb callback,
 729                                         gpointer                 user_data,
 730                                         GDestroyNotify           destroy,
 731                                         GObject                 *weak_object)
 732 {
 733         EmpathyTpContactFactoryPriv *priv = GET_PRIV (tp_factory);
 734         GetContactsData *data;
 735
 736         g_return_if_fail (EMPATHY_IS_TP_CONTACT_FACTORY (tp_factory));
 737         g_return_if_fail (id != NULL);
 738
 739         data = g_slice_new (GetContactsData);
 740         data->callback.contact_cb = callback;
 741         data->user_data = user_data;
 742         data->destroy = destroy;
 743         data->tp_factory = g_object_ref (tp_factory);
 744         tp_connection_get_contacts_by_id (priv->connection,
 745                                           1, &id,
 746                                           G_N_ELEMENTS (contact_features),
 747                                           contact_features,
 748                                           get_contact_by_id_cb,
 749                                           data,
 750                                           (GDestroyNotify) get_contacts_data_free,
 751                                           weak_object);
 752 }
 753
 754 static void
 755 get_contacts_by_handle_cb (TpConnection *connection,
 756                            guint n_contacts,
 757                            TpContact * const *contacts,
 758                            guint n_failed,
 759                            const TpHandle *failed,
 760                            const GError *error,
 761                            gpointer user_data,
 762                            GObject *weak_object)
 763 {
 764         GetContactsData *data = user_data;
 765         EmpathyContact **empathy_contacts;
 766
 767         empathy_contacts = contacts_array_new (data->tp_factory,
 768                                                n_contacts, contacts);
 769         if (data->callback.handles_cb) {
 770                 data->callback.handles_cb (data->tp_factory,
 771                                            n_contacts, empathy_contacts,
 772                                            n_failed, failed,
 773                                            error,
 774                                            data->user_data, weak_object);
 775         }
 776
 777         contacts_array_free (n_contacts, empathy_contacts);
 778 }
 779
 780 void
 781 empathy_tp_contact_factory_get_from_handles (EmpathyTpContactFactory *tp_factory,
 782                                              guint n_handles,
 783                                              const TpHandle *handles,
 784                                              EmpathyTpContactFactoryContactsByHandleCb callback,
 785                                              gpointer                 user_data,
 786                                              GDestroyNotify           destroy,
 787                                              GObject                 *weak_object)
 788 {
 789         EmpathyTpContactFactoryPriv *priv = GET_PRIV (tp_factory);
 790         GetContactsData *data;
 791
 792         g_return_if_fail (EMPATHY_IS_TP_CONTACT_FACTORY (tp_factory));
 793         g_return_if_fail (handles != NULL);
 794
 795         data = g_slice_new (GetContactsData);
 796         data->callback.handles_cb = callback;
 797         data->user_data = user_data;
 798         data->destroy = destroy;
 799         data->tp_factory = g_object_ref (tp_factory);
 800         tp_connection_get_contacts_by_handle (priv->connection,
 801                                               n_handles, handles,
 802                                               G_N_ELEMENTS (contact_features),
 803                                               contact_features,
 804                                               get_contacts_by_handle_cb,
 805                                               data,
 806                                               (GDestroyNotify) get_contacts_data_free,
 807                                               weak_object);
 808 }
 809
 810 static void
 811 get_contact_by_handle_cb (TpConnection *connection,
 812                           guint n_contacts,
 813                           TpContact * const *contacts,
 814                           guint n_failed,
 815                           const TpHandle *failed,
 816                           const GError *error,
 817                           gpointer user_data,
 818                           GObject *weak_object)
 819 {
 820         GetContactsData *data = user_data;
 821         EmpathyContact  *contact = NULL;
 822
 823         if (n_contacts == 1) {
 824                 contact = dup_contact_for_tp_contact (data->tp_factory,
 825                                                       contacts[0]);
 826         }
 827
 828         if (data->callback.contact_cb) {
 829                 data->callback.contact_cb (data->tp_factory,
 830                                            contact,
 831                                            error,
 832                                            data->user_data, weak_object);
 833         }
 834 }
 835
 836 void
 837 empathy_tp_contact_factory_get_from_handle (EmpathyTpContactFactory *tp_factory,
 838                                             TpHandle                 handle,
 839                                             EmpathyTpContactFactoryContactCb callback,
 840                                             gpointer                 user_data,
 841                                             GDestroyNotify           destroy,
 842                                             GObject                 *weak_object)
 843 {
 844         EmpathyTpContactFactoryPriv *priv = GET_PRIV (tp_factory);
 845         GetContactsData *data;
 846
 847         g_return_if_fail (EMPATHY_IS_TP_CONTACT_FACTORY (tp_factory));
 848
 849         data = g_slice_new (GetContactsData);
 850         data->callback.contact_cb = callback;
 851         data->user_data = user_data;
 852         data->destroy = destroy;
 853         data->tp_factory = g_object_ref (tp_factory);
 854         tp_connection_get_contacts_by_handle (priv->connection,
 855                                               1, &handle,
 856                                               G_N_ELEMENTS (contact_features),
 857                                               contact_features,
 858                                               get_contact_by_handle_cb,
 859                                               data,
 860                                               (GDestroyNotify) get_contacts_data_free,
 861                                               weak_object);
 862 }
 863
 864 void
 865 empathy_tp_contact_factory_set_alias (EmpathyTpContactFactory *tp_factory,
 866                                       EmpathyContact          *contact,
 867                                       const gchar             *alias)
 868 {
 869         EmpathyTpContactFactoryPriv *priv = GET_PRIV (tp_factory);
 870         GHashTable                  *new_alias;
 871         guint                        handle;
 872
 873         g_return_if_fail (EMPATHY_IS_TP_CONTACT_FACTORY (tp_factory));
 874         g_return_if_fail (EMPATHY_IS_CONTACT (contact));
 875
 876         handle = empathy_contact_get_handle (contact);
 877
 878         DEBUG ("Setting alias for contact %s (%d) to %s",
 879                 empathy_contact_get_id (contact),
 880                 handle, alias);
 881
 882         new_alias = g_hash_table_new_full (g_direct_hash,
 883                                            g_direct_equal,
 884                                            NULL,
 885                                            g_free);
 886
 887         g_hash_table_insert (new_alias,
 888                              GUINT_TO_POINTER (handle),
 889                              g_strdup (alias));
 890
 891         tp_cli_connection_interface_aliasing_call_set_aliases (priv->connection,
 892                                                                -1,
 893                                                                new_alias,
 894                                                                tp_contact_factory_set_aliases_cb,
 895                                                                NULL, NULL,
 896                                                                G_OBJECT (tp_factory));
 897
 898         g_hash_table_destroy (new_alias);
 899 }
 900
 901 void
 902 empathy_tp_contact_factory_set_avatar (EmpathyTpContactFactory *tp_factory,
 903                                        const gchar             *data,
 904                                        gsize                    size,
 905                                        const gchar             *mime_type)
 906 {
 907         EmpathyTpContactFactoryPriv *priv = GET_PRIV (tp_factory);
 908
 909         g_return_if_fail (EMPATHY_IS_TP_CONTACT_FACTORY (tp_factory));
 910
 911         if (data && size > 0 && size < G_MAXUINT) {
 912                 GArray avatar;
 913
 914                 avatar.data = (gchar*) data;
 915                 avatar.len = size;
 916
 917                 DEBUG ("Setting avatar on connection %s",
 918                         tp_proxy_get_object_path (TP_PROXY (priv->connection)));
 919
 920                 tp_cli_connection_interface_avatars_call_set_avatar (priv->connection,
 921                                                                      -1,
 922                                                                      &avatar,
 923                                                                      mime_type,
 924                                                                      tp_contact_factory_set_avatar_cb,
 925                                                                      NULL, NULL,
 926                                                                      G_OBJECT (tp_factory));
 927         } else {
 928                 DEBUG ("Clearing avatar on connection %s",
 929                         tp_proxy_get_object_path (TP_PROXY (priv->connection)));
 930
 931                 tp_cli_connection_interface_avatars_call_clear_avatar (priv->connection,
 932                                                                        -1,
 933                                                                        tp_contact_factory_clear_avatar_cb,
 934                                                                        NULL, NULL,
 935                                                                        G_OBJECT (tp_factory));
 936         }
 937 }
 938
 939 static void
 940 tp_contact_factory_get_property (GObject    *object,
 941                                  guint       param_id,
 942                                  GValue     *value,
 943                                  GParamSpec *pspec)
 944 {
 945         EmpathyTpContactFactoryPriv *priv = GET_PRIV (object);
 946
 947         switch (param_id) {
 948         case PROP_CONNECTION:
 949                 g_value_set_object (value, priv->connection);
 950                 break;
 951         case PROP_MIME_TYPES:
 952                 g_value_set_boxed (value, priv->avatar_mime_types);
 953                 break;
 954         case PROP_MIN_WIDTH:
 955                 g_value_set_uint (value, priv->avatar_min_width);
 956                 break;
 957         case PROP_MIN_HEIGHT:
 958                 g_value_set_uint (value, priv->avatar_min_height);
 959                 break;
 960         case PROP_MAX_WIDTH:
 961                 g_value_set_uint (value, priv->avatar_max_width);
 962                 break;
 963         case PROP_MAX_HEIGHT:
 964                 g_value_set_uint (value, priv->avatar_max_height);
 965                 break;
 966         case PROP_MAX_SIZE:
 967                 g_value_set_uint (value, priv->avatar_max_size);
 968                 break;
 969         default:
 970                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
 971                 break;
 972         };
 973 }
 974
 975 static void
 976 tp_contact_factory_set_property (GObject      *object,
 977                                  guint         param_id,
 978                                  const GValue *value,
 979                                  GParamSpec   *pspec)
 980 {
 981         EmpathyTpContactFactoryPriv *priv = GET_PRIV (object);
 982
 983         switch (param_id) {
 984         case PROP_CONNECTION:
 985                 priv->connection = g_value_dup_object (value);
 986                 break;
 987         default:
 988                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
 989                 break;
 990         };
 991 }
 992
 993 static void
 994 tp_contact_factory_finalize (GObject *object)
 995 {
 996         EmpathyTpContactFactoryPriv *priv = GET_PRIV (object);
 997         GList                       *l;
 998
 999         DEBUG ("Finalized: %p", object);
1000
1001         for (l = priv->contacts; l; l = l->next) {
1002                 g_object_weak_unref (G_OBJECT (l->data),
1003                                      tp_contact_factory_weak_notify,
1004                                      object);
1005         }
1006
1007         g_list_free (priv->contacts);
1008
1009         g_object_unref (priv->connection);
1010
1011         g_strfreev (priv->avatar_mime_types);
1012
1013         G_OBJECT_CLASS (empathy_tp_contact_factory_parent_class)->finalize (object);
1014 }
1015
1016 static GObject *
1017 tp_contact_factory_constructor (GType                  type,
1018                                 guint                  n_props,
1019                                 GObjectConstructParam *props)
1020 {
1021         GObject *tp_factory;
1022         EmpathyTpContactFactoryPriv *priv;
1023
1024         tp_factory = G_OBJECT_CLASS (empathy_tp_contact_factory_parent_class)->constructor (type, n_props, props);
1025         priv = GET_PRIV (tp_factory);
1026
1027         /* FIXME: This should be moved to TpContact */
1028         tp_cli_connection_interface_avatars_connect_to_avatar_updated (priv->connection,
1029                                                                        tp_contact_factory_avatar_updated_cb,
1030                                                                        NULL, NULL,
1031                                                                        tp_factory,
1032                                                                        NULL);
1033         tp_cli_connection_interface_avatars_connect_to_avatar_retrieved (priv->connection,
1034                                                                          tp_contact_factory_avatar_retrieved_cb,
1035                                                                          NULL, NULL,
1036                                                                          tp_factory,
1037                                                                          NULL);
1038         tp_cli_connection_interface_capabilities_connect_to_capabilities_changed (priv->connection,
1039                                                                                   tp_contact_factory_capabilities_changed_cb,
1040                                                                                   NULL, NULL,
1041                                                                                   tp_factory,
1042                                                                                   NULL);
1043
1044
1045         /* FIXME: This should be moved to TpConnection */
1046         tp_cli_connection_interface_avatars_call_get_avatar_requirements (priv->connection,
1047                                                                           -1,
1048                                                                           tp_contact_factory_got_avatar_requirements_cb,
1049                                                                           NULL, NULL,
1050                                                                           tp_factory);
1051         tp_cli_dbus_properties_call_get (priv->connection, -1,
1052                 TP_IFACE_CONNECTION_INTERFACE_REQUESTS,
1053                 "RequestableChannelClasses",
1054                 get_requestable_channel_classes_cb, NULL, NULL,
1055                 G_OBJECT (tp_factory));
1056
1057         return tp_factory;
1058 }
1059
1060 static void
1061 empathy_tp_contact_factory_class_init (EmpathyTpContactFactoryClass *klass)
1062 {
1063         GObjectClass *object_class = G_OBJECT_CLASS (klass);
1064
1065         object_class->finalize = tp_contact_factory_finalize;
1066         object_class->constructor = tp_contact_factory_constructor;
1067         object_class->get_property = tp_contact_factory_get_property;
1068         object_class->set_property = tp_contact_factory_set_property;
1069
1070         g_object_class_install_property (object_class,
1071                                          PROP_CONNECTION,
1072                                          g_param_spec_object ("connection",
1073                                                               "Factory's Connection",
1074                                                               "The connection associated with the factory",
1075                                                               TP_TYPE_CONNECTION,
1076                                                               G_PARAM_READWRITE |
1077                                                               G_PARAM_CONSTRUCT_ONLY |
1078                                                               G_PARAM_STATIC_STRINGS));
1079         g_object_class_install_property (object_class,
1080                                          PROP_MIME_TYPES,
1081                                          g_param_spec_boxed ("avatar-mime-types",
1082                                                              "Supported MIME types for avatars",
1083                                                              "Types of images that may be set as "
1084                                                              "avatars on this connection.",
1085                                                              G_TYPE_STRV,
1086                                                              G_PARAM_READABLE |
1087                                                              G_PARAM_STATIC_STRINGS));
1088         g_object_class_install_property (object_class,
1089                                          PROP_MIN_WIDTH,
1090                                          g_param_spec_uint ("avatar-min-width",
1091                                                             "Minimum width for avatars",
1092                                                             "Minimum width of avatar that may be set.",
1093                                                             0,
1094                                                             G_MAXUINT,
1095                                                             0,
1096                                                             G_PARAM_READABLE |
1097                                                             G_PARAM_STATIC_STRINGS));
1098         g_object_class_install_property (object_class,
1099                                          PROP_MIN_HEIGHT,
1100                                          g_param_spec_uint ("avatar-min-height",
1101                                                             "Minimum height for avatars",
1102                                                             "Minimum height of avatar that may be set.",
1103                                                             0,
1104                                                             G_MAXUINT,
1105                                                             0,
1106                                                             G_PARAM_READABLE |
1107                                                             G_PARAM_STATIC_STRINGS));
1108         g_object_class_install_property (object_class,
1109                                          PROP_MAX_WIDTH,
1110                                          g_param_spec_uint ("avatar-max-width",
1111                                                             "Maximum width for avatars",
1112                                                             "Maximum width of avatar that may be set "
1113                                                             "or 0 if there is no maximum.",
1114                                                             0,
1115                                                             G_MAXUINT,
1116                                                             0,
1117                                                             G_PARAM_READABLE |
1118                                                             G_PARAM_STATIC_STRINGS));
1119         g_object_class_install_property (object_class,
1120                                          PROP_MAX_HEIGHT,
1121                                          g_param_spec_uint ("avatar-max-height",
1122                                                             "Maximum height for avatars",
1123                                                             "Maximum height of avatar that may be set "
1124                                                             "or 0 if there is no maximum.",
1125                                                             0,
1126                                                             G_MAXUINT,
1127                                                             0,
1128                                                             G_PARAM_READABLE |
1129                                                             G_PARAM_STATIC_STRINGS));
1130         g_object_class_install_property (object_class,
1131                                          PROP_MAX_SIZE,
1132                                          g_param_spec_uint ("avatar-max-size",
1133                                                             "Maximum size for avatars in bytes",
1134                                                             "Maximum file size of avatar that may be "
1135                                                             "set or 0 if there is no maximum.",
1136                                                             0,
1137                                                             G_MAXUINT,
1138                                                             0,
1139                                                             G_PARAM_READABLE |
1140                                                             G_PARAM_STATIC_STRINGS));
1141
1142
1143         g_type_class_add_private (object_class, sizeof (EmpathyTpContactFactoryPriv));
1144 }
1145
1146 static void
1147 empathy_tp_contact_factory_init (EmpathyTpContactFactory *tp_factory)
1148 {
1149         EmpathyTpContactFactoryPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (tp_factory,
1150                 EMPATHY_TYPE_TP_CONTACT_FACTORY, EmpathyTpContactFactoryPriv);
1151
1152         tp_factory->priv = priv;
1153         priv->can_request_ft = FALSE;
1154 }
1155
1156 static GHashTable *factories = NULL;
1157
1158 static void
1159 tp_contact_factory_connection_invalidated_cb (TpProxy *connection,
1160                                               guint    domain,
1161                                               gint     code,
1162                                               gchar   *message,
1163                                               gpointer user_data)
1164 {
1165         DEBUG ("Message: %s", message);
1166         g_hash_table_remove (factories, connection);
1167 }
1168
1169 static void
1170 tp_contact_factory_connection_weak_notify_cb (gpointer connection,
1171                                               GObject *where_the_object_was)
1172 {
1173         g_hash_table_remove (factories, connection);
1174 }
1175
1176 static void
1177 tp_contact_factory_remove_connection (gpointer connection)
1178 {
1179         g_signal_handlers_disconnect_by_func (connection,
1180                 tp_contact_factory_connection_invalidated_cb, NULL);
1181         g_object_unref (connection);
1182 }
1183
1184 EmpathyTpContactFactory *
1185 empathy_tp_contact_factory_dup_singleton (TpConnection *connection)
1186 {
1187         EmpathyTpContactFactory *tp_factory;
1188
1189         g_return_val_if_fail (TP_IS_CONNECTION (connection), NULL);
1190
1191         if (factories == NULL) {
1192                 factories = g_hash_table_new_full (empathy_proxy_hash,
1193                                                    empathy_proxy_equal,
1194                                                    tp_contact_factory_remove_connection,
1195                                                    NULL);
1196         }
1197
1198         tp_factory = g_hash_table_lookup (factories, connection);
1199         if (tp_factory == NULL) {
1200                 tp_factory = g_object_new (EMPATHY_TYPE_TP_CONTACT_FACTORY,
1201                                            "connection", connection,
1202                                            NULL);
1203                 g_hash_table_insert (factories, g_object_ref (connection),
1204                                      tp_factory);
1205                 g_object_weak_ref (G_OBJECT (tp_factory),
1206                                    tp_contact_factory_connection_weak_notify_cb,
1207                                    connection);
1208                 g_signal_connect (connection, "invalidated",
1209                                   G_CALLBACK (tp_contact_factory_connection_invalidated_cb),
1210                                   NULL);
1211         } else {
1212                 g_object_ref (tp_factory);
1213         }
1214
1215         return tp_factory;
1216 }
1217