src/telepathy/telepathy-buddy.c

   1 /**
   2  * @file telepathy-buddy.c
   3  *
   4  * pidgin-sipe
   5  *
   6  * Copyright (C) 2012 SIPE Project <http://sipe.sourceforge.net/>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  */
  22
  23 #include <string.h>
  24
  25 #include <glib-object.h>
  26 #include <glib/gstdio.h>
  27 #include <telepathy-glib/base-connection.h>
  28 #include <telepathy-glib/base-contact-list.h>
  29 #include <telepathy-glib/telepathy-glib.h>
  30
  31 #include "sipe-backend.h"
  32 #include "sipe-common.h"
  33 #include "sipe-core.h"
  34
  35 #include "telepathy-private.h"
  36
  37 #define SIPE_INFO_FIELD_MAX (SIPE_BUDDY_INFO_CUSTOM1_PHONE_DISPLAY + 1)
  38
  39 struct telepathy_buddy {
  40         const gchar *uri;   /* borrowed from contact_list->buddies key */
  41         GHashTable *groups; /* key: group name, value: buddy_entry */
  42                             /* keys are borrowed from contact_list->groups */
  43         TpHandle handle;
  44         /* includes alias as stored on the server */
  45         gchar *info[SIPE_INFO_FIELD_MAX];
  46         gchar *hash;        /* photo hash */
  47         guint activity;
  48 };
  49
  50 struct telepathy_buddy_entry {
  51         struct telepathy_buddy *buddy; /* pointer to parent */
  52         const gchar *group;            /* borrowed from contact_list->groups key */
  53 };
  54
  55 G_BEGIN_DECLS
  56 /*
  57  * Contact List class - data structures
  58  */
  59 typedef struct _SipeContactListClass {
  60         TpBaseContactListClass parent_class;
  61 } SipeContactListClass;
  62
  63 typedef struct _SipeContactList {
  64         TpBaseContactList parent;
  65
  66         TpBaseConnection *connection;
  67         TpHandleRepoIface *contact_repo;
  68         TpHandleSet *contacts;
  69
  70         GHashTable *buddies;       /* key: SIP URI,    value: buddy */
  71         GHashTable *buddy_handles; /* key: TpHandle,   value: buddy */
  72         GHashTable *groups;        /* key: group name, value: buddy */
  73
  74         gboolean initial_received;
  75 } SipeContactList;
  76
  77 /*
  78  * Contact List class - type macros
  79  */
  80 static GType sipe_contact_list_get_type(void) G_GNUC_CONST;
  81 #define SIPE_TYPE_CONTACT_LIST \
  82         (sipe_contact_list_get_type())
  83 #define SIPE_CONTACT_LIST(obj) \
  84         (G_TYPE_CHECK_INSTANCE_CAST((obj), SIPE_TYPE_CONTACT_LIST, \
  85                                     SipeContactList))
  86 G_END_DECLS
  87
  88 /*
  89  * Contact List class - type definition
  90  */
  91 static void contact_group_list_iface_init(TpContactGroupListInterface *);
  92 G_DEFINE_TYPE_WITH_CODE(SipeContactList,
  93                         sipe_contact_list,
  94                         TP_TYPE_BASE_CONTACT_LIST,
  95                         G_IMPLEMENT_INTERFACE (TP_TYPE_CONTACT_GROUP_LIST,
  96                                                contact_group_list_iface_init);
  97 )
  98
  99
 100 /*
 101  * Contact List class - instance methods
 102  */
 103 static TpHandleSet *dup_contacts(TpBaseContactList *contact_list)
 104 {
 105         SipeContactList *self = SIPE_CONTACT_LIST(contact_list);
 106         return(tp_handle_set_copy(self->contacts));
 107 }
 108
 109 static void dup_states(SIPE_UNUSED_PARAMETER TpBaseContactList *contact_list,
 110                        SIPE_UNUSED_PARAMETER TpHandle contact,
 111                        TpSubscriptionState *subscribe,
 112                        TpSubscriptionState *publish,
 113                        gchar **publish_request)
 114 {
 115         /* @TODO */
 116         SIPE_DEBUG_INFO_NOFORMAT("SipeContactList::dup_states - NOT IMPLEMENTED");
 117
 118         if (subscribe)
 119                 *subscribe = TP_SUBSCRIPTION_STATE_YES;
 120         if (publish)
 121                 *publish = TP_SUBSCRIPTION_STATE_YES;
 122         if (publish_request)
 123                 *publish_request = g_strdup("");
 124 }
 125
 126 static void sipe_contact_list_constructed(GObject *object)
 127 {
 128         SipeContactList *self = SIPE_CONTACT_LIST(object);
 129         void (*chain_up)(GObject *) = G_OBJECT_CLASS(sipe_contact_list_parent_class)->constructed;
 130
 131         if (chain_up)
 132                 chain_up(object);
 133
 134         g_object_get(self, "connection", &self->connection, NULL);
 135         self->contact_repo = tp_base_connection_get_handles(self->connection,
 136                                                             TP_HANDLE_TYPE_CONTACT);
 137         self->contacts     = tp_handle_set_new(self->contact_repo);
 138 }
 139
 140 static void sipe_contact_list_dispose(GObject *object)
 141 {
 142         SipeContactList *self = SIPE_CONTACT_LIST(object);
 143         void (*chain_up)(GObject *) = G_OBJECT_CLASS(sipe_contact_list_parent_class)->dispose;
 144
 145         SIPE_DEBUG_INFO_NOFORMAT("SipeContactList::dispose");
 146
 147         tp_clear_pointer(&self->contacts, tp_handle_set_destroy);
 148         tp_clear_object(&self->connection);
 149         /* NOTE: the order is important due to borrowing of keys! */
 150         tp_clear_pointer(&self->buddy_handles, g_hash_table_unref);
 151         tp_clear_pointer(&self->buddies, g_hash_table_unref);
 152         tp_clear_pointer(&self->groups, g_hash_table_unref);
 153
 154         if (chain_up)
 155                 chain_up(object);
 156 }
 157
 158 /*
 159  * Contact List class - type implementation
 160  */
 161 static void sipe_contact_list_class_init(SipeContactListClass *klass)
 162 {
 163         GObjectClass *object_class         = G_OBJECT_CLASS(klass);
 164         TpBaseContactListClass *base_class = TP_BASE_CONTACT_LIST_CLASS(klass);
 165
 166         SIPE_DEBUG_INFO_NOFORMAT("SipeContactList::class_init");
 167
 168         object_class->constructed = sipe_contact_list_constructed;
 169         object_class->dispose     = sipe_contact_list_dispose;
 170
 171         base_class->dup_contacts = dup_contacts;
 172         base_class->dup_states   = dup_states;
 173 }
 174
 175 static void buddy_free(gpointer data);
 176 static void sipe_contact_list_init(SIPE_UNUSED_PARAMETER SipeContactList *self)
 177 {
 178         SIPE_DEBUG_INFO_NOFORMAT("SipeContactList::init");
 179
 180         self->buddies       = g_hash_table_new_full(g_str_hash, g_str_equal,
 181                                                     g_free, buddy_free);
 182         self->buddy_handles = g_hash_table_new(g_direct_hash, g_direct_equal);
 183         self->groups        = g_hash_table_new_full(g_str_hash, g_str_equal,
 184                                                     g_free, NULL);
 185
 186         self->initial_received = FALSE;
 187 }
 188
 189 /*
 190  * Contact List class - interface implementation
 191  *
 192  * Contact groups
 193  */
 194 static GStrv dup_groups(TpBaseContactList *contact_list)
 195 {
 196         SipeContactList *self = SIPE_CONTACT_LIST(contact_list);
 197         GPtrArray *groups     = g_ptr_array_sized_new(
 198                 g_hash_table_size(self->groups) + 1);
 199         GHashTableIter iter;
 200         gpointer name;
 201
 202         SIPE_DEBUG_INFO_NOFORMAT("SipeContactList::dup_groups called");
 203
 204         g_hash_table_iter_init(&iter, self->groups);
 205         while (g_hash_table_iter_next(&iter, &name, NULL))
 206                 g_ptr_array_add(groups, g_strdup(name));
 207         g_ptr_array_add(groups, NULL);
 208
 209         return((GStrv) g_ptr_array_free(groups, FALSE));
 210 }
 211
 212 static TpHandleSet *dup_group_members(TpBaseContactList *contact_list,
 213                                       const gchar *group_name)
 214 {
 215         SipeContactList *self = SIPE_CONTACT_LIST(contact_list);
 216         TpHandleSet *members  = tp_handle_set_new(self->contact_repo);
 217         GHashTableIter iter;
 218         struct telepathy_buddy *buddy;
 219
 220         SIPE_DEBUG_INFO_NOFORMAT("SipeContactList::dup_group_members called");
 221
 222         g_hash_table_iter_init(&iter, self->buddies);
 223         while (g_hash_table_iter_next(&iter, NULL, (gpointer) &buddy))
 224                 if (g_hash_table_lookup(buddy->groups, group_name))
 225                         tp_handle_set_add(members, buddy->handle);
 226
 227         return(members);
 228 }
 229
 230 static GStrv dup_contact_groups(TpBaseContactList *contact_list,
 231                                 TpHandle contact)
 232 {
 233         SipeContactList *self         = SIPE_CONTACT_LIST(contact_list);
 234         GPtrArray *groups             = g_ptr_array_sized_new(
 235                 g_hash_table_size(self->groups) + 1);
 236         struct telepathy_buddy *buddy = g_hash_table_lookup(self->buddy_handles,
 237                                                             GUINT_TO_POINTER(contact));
 238
 239         SIPE_DEBUG_INFO_NOFORMAT("SipeContactList::dup_contact_groups called");
 240
 241         if (buddy) {
 242                 GHashTableIter iter;
 243                 const gchar *group_name;
 244
 245                 g_hash_table_iter_init(&iter, buddy->groups);
 246                 while (g_hash_table_iter_next(&iter,
 247                                               (gpointer) &group_name,
 248                                               NULL))
 249                         g_ptr_array_add(groups, g_strdup(group_name));
 250         }
 251         g_ptr_array_add(groups, NULL);
 252
 253         return((GStrv) g_ptr_array_free(groups, FALSE));
 254 }
 255
 256 static void contact_group_list_iface_init(TpContactGroupListInterface *iface)
 257 {
 258 #define IMPLEMENT(x) iface->x = x
 259         IMPLEMENT(dup_groups);
 260         IMPLEMENT(dup_group_members);
 261         IMPLEMENT(dup_contact_groups);
 262 #undef IMPLEMENT
 263 }
 264
 265 /* create new contact list object */
 266 SipeContactList *sipe_telepathy_contact_list_new(TpBaseConnection *connection)
 267 {
 268         return(g_object_new(SIPE_TYPE_CONTACT_LIST,
 269                             "connection", connection,
 270                             NULL));
 271 }
 272
 273 /* get & set alias for a contact  */
 274 const gchar *sipe_telepathy_buddy_get_alias(SipeContactList *contact_list,
 275                                             TpHandle contact)
 276 {
 277         struct telepathy_buddy *buddy = g_hash_table_lookup(contact_list->buddy_handles,
 278                                                             GUINT_TO_POINTER(contact));
 279         if (!buddy)
 280                 return(NULL);
 281         return(buddy->info[SIPE_BUDDY_INFO_DISPLAY_NAME]);
 282 }
 283
 284 static void update_alias(struct telepathy_buddy *buddy,
 285                          const gchar *alias)
 286 {
 287         if (buddy) {
 288                 g_free(buddy->info[SIPE_BUDDY_INFO_DISPLAY_NAME]);
 289                 buddy->info[SIPE_BUDDY_INFO_DISPLAY_NAME] = g_strdup(alias);
 290         }
 291 }
 292
 293 void sipe_telepathy_buddy_set_alias(SipeContactList *contact_list,
 294                                     const guint contact,
 295                                     const gchar *alias)
 296 {
 297         struct telepathy_buddy *buddy = g_hash_table_lookup(contact_list->buddy_handles,
 298                                                             GUINT_TO_POINTER(contact));
 299         update_alias(buddy, alias);
 300
 301         /* tell core about the alias change */
 302         if (buddy) {
 303                 struct sipe_backend_private *telepathy_private = sipe_telepathy_connection_private(G_OBJECT(contact_list->connection));
 304                 sipe_core_group_set_alias(telepathy_private->public,
 305                                           buddy->uri,
 306                                           alias);
 307         }
 308 }
 309
 310 /* get photo hash for a contact */
 311 const gchar *sipe_telepathy_buddy_get_hash(struct _SipeContactList *contact_list,
 312                                            const guint contact)
 313 {
 314         struct telepathy_buddy *buddy = g_hash_table_lookup(contact_list->buddy_handles,
 315                                                             GUINT_TO_POINTER(contact));
 316         if (!buddy)
 317                 return(NULL);
 318         return(buddy->hash);
 319 }
 320
 321 /* get presence status for a contact */
 322 guint sipe_telepathy_buddy_get_presence(SipeContactList *contact_list,
 323                                         const TpHandle contact)
 324 {
 325         struct telepathy_buddy *buddy = g_hash_table_lookup(contact_list->buddy_handles,
 326                                                             GUINT_TO_POINTER(contact));
 327         if (!buddy)
 328                 return(SIPE_ACTIVITY_UNSET);
 329         return(buddy->activity);
 330 }
 331
 332 /* @TODO: are other MIME types supported by OCS? */
 333 static const char * mimetypes[] = {
 334         "image/jpeg",
 335         NULL
 336 };
 337
 338 /* @TODO: are these correct or even needed? */
 339 #define AVATAR_MIN_PX       16
 340 #define AVATAR_MAX_PX      256
 341 #define AVATAR_MAX_BYTES 32768
 342
 343 static void get_avatar_requirements(TpSvcConnectionInterfaceAvatars *iface,
 344                                     DBusGMethodInvocation *context)
 345 {
 346         TP_BASE_CONNECTION_ERROR_IF_NOT_CONNECTED(TP_BASE_CONNECTION(iface),
 347                                                   context);
 348
 349         tp_svc_connection_interface_avatars_return_from_get_avatar_requirements(
 350                 context,
 351                 mimetypes,
 352                 AVATAR_MIN_PX, AVATAR_MIN_PX,
 353                 AVATAR_MAX_PX, AVATAR_MAX_PX,
 354                 AVATAR_MAX_BYTES);
 355 }
 356
 357 void sipe_telepathy_avatars_iface_init(gpointer g_iface,
 358                                        SIPE_UNUSED_PARAMETER gpointer iface_data)
 359 {
 360         TpSvcConnectionInterfaceAvatarsClass *klass = g_iface;
 361
 362 #define IMPLEMENT(x) tp_svc_connection_interface_avatars_implement_##x( \
 363                 klass, x)
 364         IMPLEMENT(get_avatar_requirements);
 365         /* Information is provided by server: can't implement
 366            IMPLEMENT(get_avatar_tokens);
 367            IMPLEMENT(get_known_avatar_tokens);
 368            IMPLEMENT(request_avatar);
 369            IMPLEMENT(request_avatars);
 370            IMPLEMENT(set_avatar);
 371            IMPLEMENT(clear_avatar); */
 372 #undef IMPLEMENT
 373 }
 374
 375 static const gchar *const sipe_to_vcard_field[SIPE_INFO_FIELD_MAX] = {
 376 /* SIPE_BUDDY_INFO_DISPLAY_NAME          */ "fn",
 377 /* SIPE_BUDDY_INFO_JOB_TITLE             */ "title",
 378 /* SIPE_BUDDY_INFO_CITY                  */ NULL,
 379 /* SIPE_BUDDY_INFO_STATE                 */ NULL,
 380 /* SIPE_BUDDY_INFO_OFFICE                */ NULL,
 381 /* SIPE_BUDDY_INFO_DEPARTMENT            */ NULL,
 382 /* SIPE_BUDDY_INFO_COUNTRY               */ NULL,
 383 /* SIPE_BUDDY_INFO_WORK_PHONE            */ "tel",
 384 /* SIPE_BUDDY_INFO_WORK_PHONE_DISPLAY    */ NULL,
 385 /* SIPE_BUDDY_INFO_COMPANY               */ "org",
 386 /* SIPE_BUDDY_INFO_EMAIL                 */ "email",
 387 /* SIPE_BUDDY_INFO_SITE                  */ NULL,
 388 /* SIPE_BUDDY_INFO_ZIPCODE               */ NULL,
 389 /* SIPE_BUDDY_INFO_STREET                */ NULL,
 390 /* SIPE_BUDDY_INFO_MOBILE_PHONE          */ NULL,
 391 /* SIPE_BUDDY_INFO_MOBILE_PHONE_DISPLAY  */ NULL,
 392 /* SIPE_BUDDY_INFO_HOME_PHONE            */ NULL,
 393 /* SIPE_BUDDY_INFO_HOME_PHONE_DISPLAY    */ NULL,
 394 /* SIPE_BUDDY_INFO_OTHER_PHONE           */ NULL,
 395 /* SIPE_BUDDY_INFO_OTHER_PHONE_DISPLAY   */ NULL,
 396 /* SIPE_BUDDY_INFO_CUSTOM1_PHONE         */ NULL,
 397 /* SIPE_BUDDY_INFO_CUSTOM1_PHONE_DISPLAY */ NULL,
 398 };
 399
 400 static GPtrArray *convert_contact_info(struct telepathy_buddy *buddy)
 401 {
 402         GPtrArray *info = NULL;
 403
 404         if (buddy) {
 405                 guint i;
 406
 407                 info = dbus_g_type_specialized_construct(
 408                         TP_ARRAY_TYPE_CONTACT_INFO_FIELD_LIST);
 409
 410                 for (i = 0; i < SIPE_INFO_FIELD_MAX; i++) {
 411                         const gchar *name  = sipe_to_vcard_field[i];
 412                         const gchar *value = buddy->info[i];
 413
 414                         if (name && value) {
 415                                 const gchar *const field_values[2] = { value, NULL };
 416
 417                                 SIPE_DEBUG_INFO("SipeContactInfo::convert_contact_info: %s: (%2d)%s = '%s'",
 418                                                 buddy->uri, i, name, value);
 419
 420                                 g_ptr_array_add(info,
 421                                                 tp_value_array_build(3,
 422                                                                      G_TYPE_STRING, name,
 423                                                                      G_TYPE_STRV,   NULL,
 424                                                                      G_TYPE_STRV,   field_values,
 425                                                                      G_TYPE_INVALID));
 426                         }
 427                 }
 428         }
 429
 430         return(info);
 431 }
 432
 433 static void get_contact_info(TpSvcConnectionInterfaceContactInfo *iface,
 434                              const GArray *contacts,
 435                              DBusGMethodInvocation *context)
 436 {
 437         struct sipe_backend_private *telepathy_private = sipe_telepathy_connection_private(G_OBJECT(iface));
 438         GHashTable *buddies     = telepathy_private->contact_list->buddy_handles;
 439         TpBaseConnection *base  = TP_BASE_CONNECTION(iface);
 440         TpHandleRepoIface *repo = tp_base_connection_get_handles(base,
 441                                                                  TP_HANDLE_TYPE_CONTACT);
 442         GError *error           = NULL;
 443         GHashTable *infos;
 444         guint i;
 445
 446         TP_BASE_CONNECTION_ERROR_IF_NOT_CONNECTED(base, context);
 447
 448         SIPE_DEBUG_INFO_NOFORMAT("SipeContactInfo::get_contact_info called");
 449
 450         if (!tp_handles_are_valid(repo, contacts, FALSE, &error)) {
 451                 dbus_g_method_return_error(context, error);
 452                 g_error_free(error);
 453                 return;
 454         }
 455
 456         infos = dbus_g_type_specialized_construct(TP_HASH_TYPE_CONTACT_INFO_MAP);
 457
 458         for (i = 0; i < contacts->len; i++) {
 459                 TpHandle contact = g_array_index(contacts, TpHandle, i);
 460                 struct telepathy_buddy *buddy = g_hash_table_lookup(buddies,
 461                                                                     GUINT_TO_POINTER(contact));
 462                 GPtrArray *info  = convert_contact_info(buddy);
 463
 464                 if (info)
 465                         g_hash_table_insert(infos,
 466                                             GUINT_TO_POINTER(contact),
 467                                             info);
 468         }
 469
 470         tp_svc_connection_interface_contact_info_return_from_get_contact_info(context,
 471                                                                               infos);
 472         g_boxed_free(TP_HASH_TYPE_CONTACT_INFO_MAP, infos);
 473 }
 474
 475 static void request_contact_info(TpSvcConnectionInterfaceContactInfo *iface,
 476                                  guint contact,
 477                                  DBusGMethodInvocation *context)
 478 {
 479         struct sipe_backend_private *telepathy_private = sipe_telepathy_connection_private(G_OBJECT(iface));
 480         struct telepathy_buddy *buddy = g_hash_table_lookup(telepathy_private->contact_list->buddy_handles,
 481                                                             GUINT_TO_POINTER(contact));
 482         TpBaseConnection *base  = TP_BASE_CONNECTION(iface);
 483         TpHandleRepoIface *repo = tp_base_connection_get_handles(base,
 484                                                                  TP_HANDLE_TYPE_CONTACT);
 485         GError *error           = NULL;
 486         GPtrArray *info;
 487
 488         TP_BASE_CONNECTION_ERROR_IF_NOT_CONNECTED(base, context);
 489
 490         SIPE_DEBUG_INFO_NOFORMAT("SipeContactInfo::request_contact_info called");
 491
 492         if (!tp_handle_is_valid(repo, contact, &error)) {
 493                 dbus_g_method_return_error(context, error);
 494                 g_error_free(error);
 495                 return;
 496         }
 497
 498         info  = convert_contact_info(buddy);
 499         if (!info) {
 500                 dbus_g_method_return_error(context, error);
 501                 g_error_free(error);
 502                 return;
 503         }
 504
 505         tp_svc_connection_interface_contact_info_return_from_request_contact_info(context,
 506                                                                                   info);
 507         g_boxed_free(TP_ARRAY_TYPE_CONTACT_INFO_FIELD_LIST, info);
 508 }
 509
 510 void sipe_telepathy_contact_info_iface_init(gpointer g_iface,
 511                                             SIPE_UNUSED_PARAMETER gpointer iface_data)
 512 {
 513         TpSvcConnectionInterfaceContactInfoClass *klass = g_iface;
 514
 515 #define IMPLEMENT(x) tp_svc_connection_interface_contact_info_implement_##x( \
 516                 klass, x)
 517         IMPLEMENT(get_contact_info);
 518         /* Information is provided by the server: can't implement
 519            IMPLEMENT(refresh_contact_info); */
 520         IMPLEMENT(request_contact_info);
 521         /* Information is provided by the server: can't implement
 522            IMPLEMENT(set_contact_info); */
 523 #undef IMPLEMENT
 524 }
 525
 526 GPtrArray *sipe_telepathy_contact_info_fields(void)
 527 {
 528         GPtrArray *fields = dbus_g_type_specialized_construct(TP_ARRAY_TYPE_FIELD_SPECS);
 529         guint i;
 530
 531         SIPE_DEBUG_INFO_NOFORMAT("SipeContactInfo::contact_info_fields called");
 532
 533         for (i = 0; i <= SIPE_BUDDY_INFO_CUSTOM1_PHONE_DISPLAY; i++) {
 534                 const gchar *vcard_name       = sipe_to_vcard_field[i];
 535                 GValueArray *va;
 536
 537                 /* unsupported field */
 538                 if (!vcard_name)
 539                         continue;
 540
 541                 va = tp_value_array_build(4,
 542                                           G_TYPE_STRING, vcard_name,
 543                                           G_TYPE_STRV,   NULL,
 544                                           G_TYPE_UINT,   0, /* tp_flags  */
 545                                           G_TYPE_UINT,   1, /* max_times */
 546                                           G_TYPE_INVALID);
 547                 g_ptr_array_add (fields, va);
 548         }
 549
 550         return(fields);
 551 }
 552
 553 /* TpDBusPropertiesMixinPropImpl is a broken typedef */
 554 gpointer sipe_telepathy_contact_info_props(void)
 555 {
 556         static TpDBusPropertiesMixinPropImpl props[] = {
 557                 {
 558                         .name        = "ContactInfoFlags",
 559                         .getter_data = GUINT_TO_POINTER(0),
 560                         /* @TODO .getter_data = GUINT_TO_POINTER(TP_CONTACT_INFO_FLAG_CAN_SET), */
 561                         .setter_data = NULL,
 562                 },
 563                 {
 564                         .name        = "SupportedFields",
 565                         .getter_data = NULL,
 566                         .setter_data = NULL,
 567                 },
 568                 {
 569                         .name        = NULL
 570                 }
 571         };
 572         return(props);
 573 }
 574
 575 /*
 576  * Backend adaptor functions
 577  */
 578 sipe_backend_buddy sipe_backend_buddy_find(struct sipe_core_public *sipe_public,
 579                                            const gchar *buddy_name,
 580                                            const gchar *group_name)
 581 {
 582         struct sipe_backend_private *telepathy_private = sipe_public->backend_private;
 583         struct telepathy_buddy *buddy                  = g_hash_table_lookup(telepathy_private->contact_list->buddies,
 584                                                                              buddy_name);
 585         if (!buddy)
 586                 return(NULL);
 587
 588         if (group_name) {
 589                 return(g_hash_table_lookup(buddy->groups, group_name));
 590         } else {
 591                 /* just return the first entry */
 592                 GHashTableIter iter;
 593                 gpointer value = NULL;
 594                 g_hash_table_iter_init(&iter, buddy->groups);
 595                 /* make Coverity happy: as buddy != NULL this can't fail */
 596                 (void) g_hash_table_iter_next(&iter, NULL, &value);
 597                 return(value);
 598         }
 599 }
 600
 601 static GSList *buddy_add_all(struct telepathy_buddy *buddy, GSList *list)
 602 {
 603         GHashTableIter iter;
 604         struct telepathy_buddy_entry *buddy_entry;
 605
 606         if (!buddy)
 607                 return(list);
 608
 609         g_hash_table_iter_init(&iter, buddy->groups);
 610         while (g_hash_table_iter_next(&iter, NULL, (gpointer) &buddy_entry))
 611                 list = g_slist_prepend(list, buddy_entry);
 612
 613         return(list);
 614 }
 615
 616 GSList *sipe_backend_buddy_find_all(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public,
 617                                     const gchar *buddy_name,
 618                                     const gchar *group_name)
 619 {
 620         GSList *result = NULL;
 621
 622         /* NOTE: group_name != NULL not implemented in purple either */
 623         if (!group_name) {
 624                 struct sipe_backend_private *telepathy_private = sipe_public->backend_private;
 625                 GHashTable *buddies                            = telepathy_private->contact_list->buddies;
 626
 627                 if (buddy_name) {
 628                         result = buddy_add_all(g_hash_table_lookup(buddies,
 629                                                                    buddy_name),
 630                                                result);
 631                 } else {
 632                         GHashTableIter biter;
 633                         struct telepathy_buddy *buddy;
 634
 635                         g_hash_table_iter_init(&biter, telepathy_private->contact_list->buddies);
 636                         while (g_hash_table_iter_next(&biter, NULL, (gpointer) &buddy))
 637                                 result = buddy_add_all(buddy, result);
 638                 }
 639         }
 640
 641         return(result);
 642 }
 643
 644 gchar *sipe_backend_buddy_get_name(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public,
 645                                    const sipe_backend_buddy who)
 646 {
 647         return(g_strdup(((struct telepathy_buddy_entry *) who)->buddy->uri));
 648 }
 649
 650 gchar *sipe_backend_buddy_get_alias(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public,
 651                                     const sipe_backend_buddy who)
 652 {
 653         return(g_strdup(((struct telepathy_buddy_entry *) who)->buddy->info[SIPE_BUDDY_INFO_DISPLAY_NAME]));
 654 }
 655
 656 gchar *sipe_backend_buddy_get_server_alias(struct sipe_core_public *sipe_public,
 657                                            const sipe_backend_buddy who)
 658 {
 659         /* server alias is the same as alias */
 660         return(sipe_backend_buddy_get_alias(sipe_public, who));
 661 }
 662
 663 gchar *sipe_backend_buddy_get_local_alias(struct sipe_core_public *sipe_public,
 664                                           const sipe_backend_buddy who)
 665 {
 666         /* server alias is the same as alias */
 667         return(sipe_backend_buddy_get_alias(sipe_public, who));
 668 }
 669
 670 gchar *sipe_backend_buddy_get_group_name(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public,
 671                                          const sipe_backend_buddy who)
 672 {
 673         return(g_strdup(((struct telepathy_buddy_entry *) who)->group));
 674 }
 675
 676 gchar *sipe_backend_buddy_get_string(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public,
 677                                      sipe_backend_buddy who,
 678                                      const sipe_buddy_info_fields key)
 679 {
 680         struct telepathy_buddy_entry *buddy_entry = who;
 681         struct telepathy_buddy *buddy             = buddy_entry->buddy;
 682
 683         if (key >= SIPE_INFO_FIELD_MAX)
 684                 return(NULL);
 685         return(g_strdup(buddy->info[key]));
 686 }
 687
 688 void sipe_backend_buddy_set_string(struct sipe_core_public *sipe_public,
 689                                    sipe_backend_buddy who,
 690                                    const sipe_buddy_info_fields key,
 691                                    const gchar *val)
 692 {
 693         struct sipe_backend_private *telepathy_private = sipe_public->backend_private;
 694         SipeContactList *contact_list                  = telepathy_private->contact_list;
 695         struct telepathy_buddy_entry *buddy_entry      = who;
 696         struct telepathy_buddy *buddy                  = buddy_entry->buddy;
 697
 698         if (key >= SIPE_INFO_FIELD_MAX)
 699                 return;
 700
 701         SIPE_DEBUG_INFO("sipe_backend_buddy_set_string: %s replacing info %d: %s -> %s",
 702                         buddy->uri, key,
 703                         buddy->info[key] ? buddy->info[key]: "<UNDEFINED>",
 704                         val);
 705
 706         g_free(buddy->info[key]);
 707         buddy->info[key] = g_strdup(val);
 708
 709         if (contact_list->initial_received) {
 710                 /* @TODO: emit signal? */
 711         }
 712 }
 713
 714 void sipe_backend_buddy_refresh_properties(struct sipe_core_public *sipe_public,
 715                                            const gchar *uri)
 716 {
 717         struct sipe_backend_private *telepathy_private = sipe_public->backend_private;
 718         struct telepathy_buddy *buddy                  = g_hash_table_lookup(telepathy_private->contact_list->buddies,
 719                                                                              uri);
 720         GPtrArray *info                                = convert_contact_info(buddy);
 721
 722         if (info) {
 723                 tp_svc_connection_interface_contact_info_emit_contact_info_changed(telepathy_private->connection,
 724                                                                                    buddy->handle,
 725                                                                                    info);
 726                 g_boxed_free(TP_ARRAY_TYPE_CONTACT_INFO_FIELD_LIST, info);
 727         }
 728 }
 729
 730 guint sipe_backend_buddy_get_status(struct sipe_core_public *sipe_public,
 731                                     const gchar *uri)
 732 {
 733         struct sipe_backend_private *telepathy_private = sipe_public->backend_private;
 734         struct telepathy_buddy *buddy                  = g_hash_table_lookup(telepathy_private->contact_list->buddies,
 735                                                                              uri);
 736
 737         if (!buddy)
 738                 return(SIPE_ACTIVITY_UNSET);
 739         return(buddy->activity);
 740 }
 741
 742 void sipe_backend_buddy_set_alias(struct sipe_core_public *sipe_public,
 743                                   const sipe_backend_buddy who,
 744                                   const gchar *alias)
 745 {
 746         struct sipe_backend_private *telepathy_private = sipe_public->backend_private;
 747         SipeContactList *contact_list                  = telepathy_private->contact_list;
 748         struct telepathy_buddy_entry *buddy_entry      = who;
 749         struct telepathy_buddy *buddy                  = buddy_entry->buddy;
 750
 751         update_alias(buddy, alias);
 752
 753         if (contact_list->initial_received) {
 754                 SIPE_DEBUG_INFO("sipe_backend_buddy_set_alias: %s changed to '%s'",
 755                                 buddy->uri, alias);
 756                 sipe_telepathy_connection_alias_updated(contact_list->connection,
 757                                                         buddy->handle,
 758                                                         alias);
 759         }
 760 }
 761
 762 void sipe_backend_buddy_set_server_alias(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public,
 763                                          SIPE_UNUSED_PARAMETER const sipe_backend_buddy who,
 764                                          SIPE_UNUSED_PARAMETER const gchar *alias)
 765 {
 766         /* server alias is the same as alias. Ignore this */
 767 }
 768
 769 void sipe_backend_buddy_list_processing_finish(struct sipe_core_public *sipe_public)
 770 {
 771         struct sipe_backend_private *telepathy_private = sipe_public->backend_private;
 772         SipeContactList *contact_list                  = telepathy_private->contact_list;
 773
 774         if (!contact_list->initial_received) {
 775                 /* we can only call this once */
 776                 contact_list->initial_received = TRUE;
 777                 SIPE_DEBUG_INFO_NOFORMAT("sipe_backend_buddy_list_processing_finish called");
 778                 tp_base_contact_list_set_list_received(TP_BASE_CONTACT_LIST(contact_list));
 779         }
 780 }
 781
 782 static void buddy_free(gpointer data)
 783 {
 784         struct telepathy_buddy *buddy = data;
 785         guint i;
 786         g_hash_table_destroy(buddy->groups);
 787         for (i = 0; i < SIPE_INFO_FIELD_MAX; i++)
 788                 g_free(buddy->info[i]);
 789         g_free(buddy->hash);
 790         g_free(buddy);
 791 }
 792
 793 sipe_backend_buddy sipe_backend_buddy_add(struct sipe_core_public *sipe_public,
 794                                           const gchar *name,
 795                                           const gchar *alias,
 796                                           const gchar *group_name)
 797 {
 798         struct sipe_backend_private *telepathy_private = sipe_public->backend_private;
 799         SipeContactList *contact_list                  = telepathy_private->contact_list;
 800         const gchar *group                             = g_hash_table_lookup(contact_list->groups,
 801                                                                              group_name);
 802         struct telepathy_buddy *buddy                  = g_hash_table_lookup(contact_list->buddies,
 803                                                                              name);
 804         struct telepathy_buddy_entry *buddy_entry;
 805
 806         if (!group)
 807                 return(NULL);
 808
 809         if (!buddy) {
 810                 buddy           = g_new0(struct telepathy_buddy, 1);
 811                 buddy->uri      = g_strdup(name); /* reused as key */
 812                 buddy->groups   = g_hash_table_new_full(g_str_hash, g_str_equal,
 813                                                         NULL, g_free);
 814                 buddy->info[SIPE_BUDDY_INFO_DISPLAY_NAME] = g_strdup(alias);
 815                 buddy->hash     = NULL;
 816                 buddy->activity = SIPE_ACTIVITY_OFFLINE;
 817                 buddy->handle   = tp_handle_ensure(contact_list->contact_repo,
 818                                                    buddy->uri, NULL, NULL);
 819                 tp_handle_set_add(contact_list->contacts, buddy->handle);
 820                 g_hash_table_insert(contact_list->buddies,
 821                                     (gchar *) buddy->uri, /* owned by hash table */
 822                                     buddy);
 823                 g_hash_table_insert(contact_list->buddy_handles,
 824                                     GUINT_TO_POINTER(buddy->handle),
 825                                     buddy);
 826         }
 827
 828         buddy_entry = g_hash_table_lookup(buddy->groups, group);
 829         if (!buddy_entry) {
 830                 buddy_entry        = g_new0(struct telepathy_buddy_entry, 1);
 831                 buddy_entry->buddy = buddy;
 832                 buddy_entry->group = group;
 833                 g_hash_table_insert(buddy->groups,
 834                                     (gchar *) group, /* key is borrowed */
 835                                     buddy_entry);
 836         }
 837
 838         if (contact_list->initial_received) {
 839                 /* @TODO: emit signal? */
 840         }
 841
 842         return(buddy_entry);
 843 }
 844
 845 void sipe_backend_buddy_remove(struct sipe_core_public *sipe_public,
 846                                const sipe_backend_buddy who)
 847 {
 848         struct sipe_backend_private *telepathy_private = sipe_public->backend_private;
 849         SipeContactList *contact_list                  = telepathy_private->contact_list;
 850         struct telepathy_buddy_entry *remove_entry     = who;
 851         struct telepathy_buddy       *buddy            = remove_entry->buddy;
 852
 853         g_hash_table_remove(buddy->groups,
 854                             remove_entry->group);
 855         /* remove_entry is invalid */
 856
 857         if (g_hash_table_size(buddy->groups) == 0) {
 858                 /* removed from last group -> drop this buddy */
 859                 tp_handle_set_remove(contact_list->contacts,
 860                                      buddy->handle);
 861                 g_hash_table_remove(contact_list->buddy_handles,
 862                                     GUINT_TO_POINTER(buddy->handle));
 863                 g_hash_table_remove(contact_list->buddies,
 864                                     buddy->uri);
 865
 866         }
 867
 868         if (contact_list->initial_received) {
 869                 /* @TODO: emit signal? */
 870         }
 871 }
 872
 873 void sipe_backend_buddy_set_status(struct sipe_core_public *sipe_public,
 874                                    const gchar *uri,
 875                                    guint activity)
 876 {
 877         struct sipe_backend_private *telepathy_private = sipe_public->backend_private;
 878         SipeContactList *contact_list                  = telepathy_private->contact_list;
 879         struct telepathy_buddy *buddy                  = g_hash_table_lookup(contact_list->buddies,
 880                                                                              uri);
 881         TpPresenceStatus *status;
 882
 883         if (!buddy)
 884                 return;
 885         buddy->activity = activity;
 886
 887         SIPE_DEBUG_INFO("sipe_backend_buddy_set_status: %s to %d", uri, activity);
 888
 889         /* emit status update signal */
 890         status = tp_presence_status_new(activity, NULL);
 891         tp_presence_mixin_emit_one_presence_update(G_OBJECT(telepathy_private->connection),
 892                                                    buddy->handle, status);
 893         tp_presence_status_free(status);
 894 }
 895
 896 gboolean sipe_backend_uses_photo(void)
 897 {
 898         return(TRUE);
 899 }
 900
 901 static void buddy_photo_updated(struct sipe_backend_private *telepathy_private,
 902                                 struct telepathy_buddy *buddy,
 903                                 const gchar *photo,
 904                                 gsize photo_len)
 905 {
 906         GArray *array = g_array_new(FALSE, FALSE, sizeof(gchar));
 907
 908         SIPE_DEBUG_INFO("buddy_photo_updated: %s (%" G_GSIZE_FORMAT ")",
 909                         buddy->uri, photo_len);
 910
 911         g_array_append_vals(array, photo, photo_len);
 912
 913         tp_svc_connection_interface_avatars_emit_avatar_updated(telepathy_private->connection,
 914                                                                 buddy->handle,
 915                                                                 buddy->hash);
 916         tp_svc_connection_interface_avatars_emit_avatar_retrieved(telepathy_private->connection,
 917                                                                   buddy->handle,
 918                                                                   buddy->hash,
 919                                                                   array,
 920                                                                   /* @TODO: is this correct? */
 921                                                                   "image/jpeg");
 922         g_array_unref(array);
 923 }
 924
 925 void sipe_backend_buddy_set_photo(struct sipe_core_public *sipe_public,
 926                                   const gchar *uri,
 927                                   gpointer image_data,
 928                                   gsize image_len,
 929                                   const gchar *photo_hash)
 930 {
 931         struct sipe_backend_private *telepathy_private = sipe_public->backend_private;
 932         struct telepathy_buddy *buddy                  = g_hash_table_lookup(telepathy_private->contact_list->buddies,
 933                                                                              uri);
 934
 935         if (buddy) {
 936                 gchar *hash_file = g_build_filename(telepathy_private->cache_dir,
 937                                                     uri,
 938                                                     NULL);
 939
 940                 /* does this buddy already have a photo? -> delete it */
 941                 if (buddy->hash) {
 942                         char *photo_file = g_build_filename(telepathy_private->cache_dir,
 943                                                             buddy->hash,
 944                                                             NULL);
 945                         (void) g_remove(photo_file);
 946                         g_free(photo_file);
 947                         g_free(buddy->hash);
 948                         buddy->hash = NULL;
 949                 }
 950
 951                 /* update hash file */
 952                 if (g_file_set_contents(hash_file,
 953                                         photo_hash,
 954                                         strlen(photo_hash),
 955                                         NULL)) {
 956                         gchar *photo_file = g_build_filename(telepathy_private->cache_dir,
 957                                                              photo_hash,
 958                                                              NULL);
 959                         buddy->hash = g_strdup(photo_hash);
 960                         g_file_set_contents(photo_file,
 961                                             image_data,
 962                                             image_len,
 963                                             NULL);
 964
 965                         buddy_photo_updated(telepathy_private,
 966                                             buddy,
 967                                             image_data,
 968                                             image_len);
 969
 970                         g_free(photo_file);
 971                 }
 972
 973                 g_free(hash_file);
 974         }
 975
 976         g_free(image_data);
 977 }
 978
 979 const gchar *sipe_backend_buddy_get_photo_hash(struct sipe_core_public *sipe_public,
 980                                                const gchar *uri)
 981 {
 982         struct sipe_backend_private *telepathy_private = sipe_public->backend_private;
 983         struct telepathy_buddy *buddy                  = g_hash_table_lookup(telepathy_private->contact_list->buddies,
 984                                                                              uri);
 985
 986         if (!buddy)
 987                 return(NULL);
 988
 989         if (!buddy->hash) {
 990                 gchar *hash_file = g_build_filename(telepathy_private->cache_dir,
 991                                                     uri,
 992                                                     NULL);
 993                 /* returned memory is owned & freed by buddy */
 994                 if (g_file_get_contents(hash_file, &buddy->hash, NULL, NULL)) {
 995                         gchar *photo_file = g_build_filename(telepathy_private->cache_dir,
 996                                                             buddy->hash,
 997                                                             NULL);
 998                         gchar *image_data = NULL;
 999                         gsize image_len;
1000
1001                         if (g_file_get_contents(photo_file,
1002                                                 &image_data,
1003                                                 &image_len,
1004                                                 NULL))
1005                                 buddy_photo_updated(telepathy_private,
1006                                                     buddy,
1007                                                     image_data,
1008                                                     image_len);
1009                         g_free(image_data);
1010                         g_free(photo_file);
1011                 }
1012                 g_free(hash_file);
1013         }
1014
1015         return(buddy->hash);
1016 }
1017
1018 gboolean sipe_backend_buddy_group_add(struct sipe_core_public *sipe_public,
1019                                       const gchar *group_name)
1020 {
1021         struct sipe_backend_private *telepathy_private = sipe_public->backend_private;
1022         SipeContactList *contact_list                  = telepathy_private->contact_list;
1023         gchar *group                                   = g_hash_table_lookup(contact_list->groups,
1024                                                                              group_name);
1025
1026         if (!group) {
1027                 group = g_strdup(group_name);
1028                 g_hash_table_insert(contact_list->groups, group, group);
1029                 tp_base_contact_list_groups_created(TP_BASE_CONTACT_LIST(contact_list),
1030                                                     &group_name,
1031                                                     1);
1032         }
1033
1034         return(group != NULL);
1035 }
1036
1037 void sipe_backend_buddy_group_remove(struct sipe_core_public *sipe_public,
1038                                      const gchar *group_name)
1039 {
1040         struct sipe_backend_private *telepathy_private = sipe_public->backend_private;
1041         SipeContactList *contact_list                  = telepathy_private->contact_list;
1042
1043         g_hash_table_remove(contact_list->groups, group_name);
1044
1045         if (contact_list->initial_received) {
1046                 /* @TODO: emit signal? */
1047         }
1048 }
1049
1050 /*
1051   Local Variables:
1052   mode: c
1053   c-file-style: "bsd"
1054   indent-tabs-mode: t
1055   tab-width: 8
1056   End:
1057 */