bt-service/bt-service-pbap.c

   1 /*
   2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *              http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 #include <unistd.h>
  19 #include <fcntl.h>
  20 #include <string.h>
  21 #include <malloc.h>
  22 #include <stacktrim.h>
  23 #if !defined(LIBNOTIFY_SUPPORT) && !defined(LIBNOTIFICATION_SUPPORT)
  24 #include <syspopup_caller.h>
  25 #endif
  26 #include <vconf.h>
  27 #include <storage.h>
  28
  29 #include "bt-internal-types.h"
  30 #include "bt-service-common.h"
  31 #include "bt-service-event.h"
  32 #include "bt-service-pbap.h"
  33 #include <glib.h>
  34 #include <gio/gio.h>
  35
  36 #define  PBAP_UUID "0000112f-0000-1000-8000-00805f9b34fb"
  37 #define  PBAP_OBEX_CLIENT_SERVICE "org.bluez.obex"
  38 #define  PBAP_OBEX_CLIENT_PATH "/org/bluez/obex"
  39 #define  PBAP_OBEX_CLIENT_INTERFACE "org.bluez.obex.Client1"
  40
  41 #define  PBAP_SESSION_SERVICE   "org.bluez.obex"
  42 #define  PBAP_SESSION_INTERFACE "org.bluez.obex.PhonebookAccess1"
  43 #define PBAP_VCARDLIST_MAXLENGTH 256
  44
  45 #define PBAP_NUM_OF_FIELDS_ENTRY 29
  46 #define PBAP_FIELD_ALL (0xFFFFFFFFFFFFFFFFULL)
  47
  48 #define PBAP_DEFAULT_DOWNLAOD_PATH "/opt/usr/media/Downloads/"
  49 #define PBAP_DEFAULT_FILE_NAME "pb.vcf"
  50
  51 char *FIELDS[] = {
  52                 "VERSION",
  53                 "FN",
  54                 "N",
  55                 "PHOTO",
  56                 "BDAY",
  57                 "ADR",
  58                 "LABEL",
  59                 "TEL",
  60                 "EMAIL",
  61                 "MAILER",
  62                 "TZ",
  63                 "GEO",
  64                 "TITLE",
  65                 "ROLE",
  66                 "LOGO",
  67                 "AGENT",
  68                 "ORG",
  69                 "NOTE",
  70                 "REV",
  71                 "SOUND",
  72                 "URL",
  73                 "UID",
  74                 "KEY",
  75                 "NICKNAME",
  76                 "CATEGORIES",
  77                 "PROID",
  78                 "CLASS",
  79                 "SORT-STRING",
  80                 "X-IRMC-CALL-DATETIME", /* 29 */
  81 };
  82
  83 char *SOURCE[] = {
  84                 "int",  //Phone memory
  85                 "sim"   // SIM memory
  86 };
  87
  88 char *TYPE[] = {
  89                 "pb",   //Phonebook for the saved contacts
  90                 "ich",  //Incoming call history
  91                 "och",  //Outgoing call history
  92                 "mch",  //Missed call history
  93                 "cch",  //Combined Call History cch = ich + och + mch
  94 };
  95
  96 char *FORMAT[] = {
  97                 "vcard21",      // vCard Format 2.1 (Default)
  98                 "vcard30",      // vCard Format 3.0
  99 };
 100
 101 char *ORDER[] = {
 102                 "indexed",              // Index (default)
 103                 "alphanumeric", // Alphanumeric
 104                 "phonetic",             // Phonetic
 105 };
 106
 107 char *SEARCH_FIELD[] = {
 108                 "name",         // Search by Name(default)
 109                 "number",       // Search by Phone Number
 110                 "sound",        // Search by phonetic sound
 111 };
 112
 113 static char *g_pbap_session_path = NULL;
 114 static char *g_pbap_server_address = NULL;
 115 static GDBusConnection *dbus_connection = NULL;
 116 static GDBusProxy *g_pbap_proxy = NULL;
 117
 118 static struct {
 119         int type;
 120         int folder;
 121 } selected_path = { -1, -1};
 122
 123 typedef enum  {
 124         PBAP_NONE,
 125         GET_SIZE,
 126         PULL_ALL,
 127         GET_LIST,
 128         GET_VCARD,
 129         PB_SEARCH,
 130 } bt_pbap_operation_e;
 131
 132 typedef struct  {
 133         bt_pbap_operation_e operation;
 134         void *data;
 135         void *app_param;
 136 } bt_pbap_data_t;
 137
 138 typedef struct {
 139         char *path;
 140         char *filename;
 141         char *remote_device;
 142         bt_pbap_operation_e operation;
 143 } bt_pbap_transfer_info_t;
 144
 145 static GSList *transfers;
 146
 147 int __bt_pbap_call_get_phonebook_size(GDBusProxy *proxy, bt_pbap_data_t *pbap_data);
 148 int __bt_pbap_call_get_phonebook(GDBusProxy *proxy, bt_pbap_data_t *pbap_data);
 149 int __bt_pbap_call_get_vcards_list(GDBusProxy *proxy, bt_pbap_data_t *pbap_data);
 150 int __bt_pbap_call_get_vcard(GDBusProxy *proxy, bt_pbap_data_t *pbap_data);
 151 int __bt_pbap_call_search_phonebook(GDBusProxy *proxy, bt_pbap_data_t *pbap_data);
 152
 153 static void __bt_pbap_free_data(bt_pbap_data_t *pbap_data)
 154 {
 155         g_free(pbap_data->app_param);
 156         g_free(pbap_data->data);
 157         g_free(pbap_data);
 158 }
 159
 160 static bt_pbap_transfer_info_t *__bt_find_transfer_by_path(const char *transfer_path)
 161 {
 162         GSList *l;
 163         bt_pbap_transfer_info_t *transfer;
 164
 165         retv_if(transfer_path == NULL, NULL);
 166
 167         for (l = transfers; l != NULL; l = l->next) {
 168                 transfer = l->data;
 169
 170                 if (transfer == NULL)
 171                         continue;
 172
 173                 if (g_strcmp0(transfer->path, transfer_path) == 0)
 174                         return transfer;
 175         }
 176
 177         return NULL;
 178 }
 179
 180 static void __bt_free_transfer_info(bt_pbap_transfer_info_t *transfer_info)
 181 {
 182         ret_if(transfer_info == NULL);
 183
 184         g_free(transfer_info->path);
 185         g_free(transfer_info->filename);
 186         g_free(transfer_info->remote_device);
 187         g_free(transfer_info);
 188 }
 189
 190 void _bt_pbap_obex_transfer_completed(const char *transfer_path, gboolean transfer_status)
 191 {
 192         bt_pbap_transfer_info_t *transfer_info;
 193         int result = 0;
 194         int success = transfer_status;
 195         GVariant *signal = NULL;
 196         BT_DBG("Transfer [%s] Success [%d] \n", transfer_path, success);
 197
 198         result = (success == TRUE) ? BLUETOOTH_ERROR_NONE
 199                                 : BLUETOOTH_ERROR_INTERNAL;
 200
 201         transfer_info = __bt_find_transfer_by_path(transfer_path);
 202         ret_if(transfer_info == NULL);
 203
 204         BT_DBG("Remote Device [%s] FileName: [%s] Operation[%d]",
 205                         transfer_info->remote_device, transfer_info->filename,
 206                         transfer_info->operation);
 207
 208         signal = g_variant_new("(issi)", result,
 209                         transfer_info->remote_device,
 210                         transfer_info->filename, success);
 211         switch (transfer_info->operation) {
 212         case PULL_ALL: {
 213                 _bt_send_event(BT_PBAP_CLIENT_EVENT,
 214                                         BLUETOOTH_PBAP_PHONEBOOK_PULL,
 215                                         signal);
 216                 break;
 217                 }
 218         case GET_VCARD: {
 219                 _bt_send_event(BT_PBAP_CLIENT_EVENT,
 220                                         BLUETOOTH_PBAP_VCARD_PULL,
 221                                         signal);
 222                 break;
 223                 }
 224         default:
 225                 BT_INFO("Case not handled");
 226                 break;
 227
 228         }
 229
 230         transfers = g_slist_remove(transfers, transfer_info);
 231         __bt_free_transfer_info(transfer_info);
 232 }
 233
 234 void _bt_obex_pbap_client_disconnect(char *path)
 235 {
 236         if (g_strcmp0(g_pbap_session_path, path) == 0) {
 237                 int result = BLUETOOTH_ERROR_NONE;
 238                 GVariant *signal = g_variant_new("(is)", result,
 239                                 g_pbap_server_address);
 240
 241                 _bt_send_event(BT_PBAP_CLIENT_EVENT,
 242                                         BLUETOOTH_PBAP_DISCONNECTED,
 243                                         signal);
 244
 245                 g_free(g_pbap_session_path);
 246                 g_pbap_session_path = NULL;
 247
 248                 g_free(g_pbap_server_address);
 249                 g_pbap_server_address = NULL;
 250
 251                 g_object_unref(g_pbap_proxy);
 252                 g_pbap_proxy = NULL;
 253
 254                 selected_path.folder = -1;
 255                 selected_path.type = -1;
 256         }
 257         BT_DBG("-");
 258 }
 259
 260 void __bt_pbap_connect_cb(GDBusProxy *proxy,
 261                 GAsyncResult *res, gpointer user_data)
 262 {
 263         char *session_path = NULL;
 264         char *address_string = user_data;
 265         GError *error = NULL;
 266         GVariant *value;
 267         GVariant *signal = NULL;
 268         int result = BLUETOOTH_ERROR_INTERNAL;
 269
 270         value = g_dbus_proxy_call_finish(proxy, res, &error);
 271         BT_DBG("Address = %s", address_string);
 272
 273         if (value == NULL) {
 274                 BT_ERR("g_dbus_proxy_call_finish failed");
 275                 if (error) {
 276                         BT_ERR("errCode[%x], message[%s]\n",
 277                                         error->code, error->message);
 278                         g_clear_error(&error);
 279                 }
 280                 g_object_unref(g_pbap_proxy);
 281                 g_pbap_proxy = NULL;
 282         } else {
 283                 g_variant_get(value, "(&o)", &session_path);
 284
 285                 g_pbap_session_path = g_strdup(session_path);
 286                 BT_DBG("Session Path = %s\n", g_pbap_session_path);
 287                 result = BLUETOOTH_ERROR_NONE;
 288                 g_pbap_server_address = g_strdup(address_string);
 289         }
 290
 291         signal = g_variant_new("(is)", result, address_string);
 292
 293         _bt_send_event(BT_PBAP_CLIENT_EVENT,
 294                                 BLUETOOTH_PBAP_CONNECTED,
 295                                 signal);
 296
 297         g_free(address_string);
 298         BT_DBG("-");
 299 }
 300
 301 int _bt_pbap_connect(const bluetooth_device_address_t *address)
 302 {
 303         BT_DBG("+");
 304         GError *error = NULL;
 305         char address_string[18] = { 0, };
 306         char *ptr = NULL;
 307         GVariantBuilder builder;
 308         GVariant *args;
 309
 310         BT_CHECK_PARAMETER(address, return);
 311
 312         /* check if already connected */
 313         if (g_pbap_session_path)
 314                 return BLUETOOTH_ERROR_ALREADY_CONNECT;
 315
 316         BT_DBG("BD Address [%2.2X %2.2X %2.2X %2.2X %2.2X %2.2X]",
 317                         address->addr[0], address->addr[1],
 318                         address->addr[2], address->addr[3],
 319                         address->addr[4], address->addr[5]);
 320
 321         _bt_convert_addr_type_to_string(address_string, (unsigned char *)address->addr);
 322         BT_DBG("Address String: %s", address_string);
 323         dbus_connection = _bt_get_session_gconn();
 324         if (dbus_connection == NULL) {
 325                         BT_ERR("Couldn't connect to system bus");
 326                         return EXIT_FAILURE;
 327         }
 328
 329         g_pbap_proxy =  g_dbus_proxy_new_sync(dbus_connection,
 330                         G_DBUS_PROXY_FLAGS_NONE, NULL,
 331                         PBAP_OBEX_CLIENT_SERVICE, PBAP_OBEX_CLIENT_PATH,
 332                         PBAP_OBEX_CLIENT_INTERFACE, NULL, &error);
 333         if (!g_pbap_proxy) {
 334                 BT_ERR("Failed to get a proxy for D-Bus\n");
 335                 if (error) {
 336                         ERR("Unable to create proxy: %s", error->message);
 337                         g_clear_error(&error);
 338                 }
 339                 return -1;
 340         }
 341
 342         /* Create Hash*/
 343         g_variant_builder_init(&builder, G_VARIANT_TYPE_ARRAY);
 344         g_variant_builder_add(&builder, "{sv}", "Target",
 345                                         g_variant_new("s", "pbap"));
 346         args = g_variant_builder_end(&builder);
 347
 348         ptr = g_strdup(address_string);
 349
 350         GVariant *temp = g_variant_new("(s@a{sv})", ptr, args);
 351
 352         g_dbus_proxy_call(g_pbap_proxy, "CreateSession",
 353                         temp,
 354                         G_DBUS_CALL_FLAGS_NONE, -1, NULL,
 355                         (GAsyncReadyCallback)__bt_pbap_connect_cb, ptr);
 356
 357         BT_DBG("-");
 358         return 0;
 359 }
 360
 361 void __bt_pbap_disconnect_cb(GDBusProxy *proxy,
 362                 GAsyncResult *res, gpointer user_data)
 363 {
 364         char *address_string = user_data;
 365         GError *error = NULL;
 366         GVariant *value;
 367
 368         BT_DBG("Address = %s", address_string);
 369
 370         value = g_dbus_proxy_call_finish(proxy, res, &error);
 371         BT_DBG("Address = %s", address_string);
 372
 373         if (value == NULL) {
 374                 BT_ERR("g_dbus_proxy_call_finish failed");
 375                 if (error) {
 376                         BT_ERR("errCode[%x], message[%s]\n",
 377                                         error->code, error->message);
 378                         g_clear_error(&error);
 379                 }
 380         } else {
 381                 g_object_unref(g_pbap_proxy);
 382                 g_pbap_proxy = NULL;
 383
 384                 g_free(g_pbap_session_path);
 385                 g_pbap_session_path = NULL;
 386
 387                 g_free(g_pbap_server_address);
 388                 g_pbap_server_address = NULL;
 389
 390                 selected_path.folder = -1;
 391                 selected_path.type = -1;
 392         }
 393
 394         /* PBAP disconnected event will be sent in event reciever */
 395
 396         g_free(address_string);
 397         BT_DBG("-");
 398 }
 399
 400 int _bt_pbap_disconnect(const bluetooth_device_address_t *address)
 401 {
 402         BT_DBG("+");
 403         char address_string[18] = { 0, };
 404         char *ptr = NULL;
 405         BT_CHECK_PARAMETER(address, return);
 406
 407         /* check if connected */
 408         if (g_pbap_session_path == NULL)
 409                 return BLUETOOTH_ERROR_NOT_CONNECTED;
 410
 411         BT_DBG("BD Address [%2.2X %2.2X %2.2X %2.2X %2.2X %2.2X]",
 412                         address->addr[0], address->addr[1],
 413                         address->addr[2], address->addr[3],
 414                         address->addr[4], address->addr[5]);
 415
 416         _bt_convert_addr_type_to_string(address_string, (unsigned char *)address->addr);
 417         BT_DBG("Address String: %s", address_string);
 418         BT_DBG("Session Path: %s", g_pbap_session_path);
 419
 420         ptr = g_strdup(address_string);
 421
 422         g_dbus_proxy_call(g_pbap_proxy, "RemoveSession",
 423                         g_variant_new("(o)", g_pbap_session_path),
 424                         G_DBUS_CALL_FLAGS_NONE, -1, NULL,
 425                         (GAsyncReadyCallback)__bt_pbap_disconnect_cb, ptr);
 426
 427         return 0;
 428 }
 429
 430 void __bt_pbap_select_cb(GDBusProxy *proxy,
 431                 GAsyncResult *res, gpointer user_data)
 432 {
 433         BT_DBG("+");
 434         GError *error = NULL;
 435         GVariant *value;
 436         bt_pbap_data_t *pbap_data = user_data;
 437         char *address_string = pbap_data->data;
 438
 439         BT_DBG("Address = %s", address_string);
 440
 441         value = g_dbus_proxy_call_finish(proxy, res, &error);
 442         if (value == NULL) {
 443                 BT_ERR("g_dbus_proxy_call_finish failed");
 444                 if (error) {
 445                         BT_ERR("errCode[%x], message[%s]\n",
 446                                         error->code, error->message);
 447                         g_clear_error(&error);
 448                 }
 449
 450                 selected_path.folder = -1;
 451                 selected_path.type = -1;
 452
 453                 g_object_unref(proxy);
 454                 __bt_pbap_free_data(pbap_data);
 455                 return;
 456         }
 457
 458         switch (pbap_data->operation) {
 459         case GET_SIZE: {
 460                 __bt_pbap_call_get_phonebook_size(proxy, pbap_data);
 461                 break;
 462         }
 463         case PULL_ALL: {
 464                 __bt_pbap_call_get_phonebook(proxy, pbap_data);
 465                 break;
 466         }
 467         case GET_LIST: {
 468                 __bt_pbap_call_get_vcards_list(proxy, pbap_data);
 469                 break;
 470         }
 471         case GET_VCARD: {
 472                 __bt_pbap_call_get_vcard(proxy, pbap_data);
 473                 break;
 474         }
 475         case PB_SEARCH: {
 476                 __bt_pbap_call_search_phonebook(proxy, pbap_data);
 477                 break;
 478         }
 479         default: {
 480                 selected_path.folder = -1;
 481                 selected_path.type = -1;
 482                 g_object_unref(proxy);
 483                 __bt_pbap_free_data(pbap_data);
 484         }
 485         } // End of Case
 486
 487         g_variant_unref(value);
 488         BT_DBG("-");
 489 }
 490
 491
 492 void __bt_pbap_get_phonebook_size_cb(GDBusProxy *proxy,
 493                 GAsyncResult *res, gpointer user_data)
 494 {
 495         BT_DBG("+");
 496         GError *error = NULL;
 497         int result = BLUETOOTH_ERROR_INTERNAL;
 498         bt_pbap_data_t *pbap_data = user_data;
 499         char *address_string = pbap_data->data;
 500         unsigned short int size = 0;
 501         GVariant *value;
 502         GVariant *signal = NULL;
 503
 504         BT_DBG("Address = %s", address_string);
 505         value = g_dbus_proxy_call_finish(proxy, res, &error);
 506
 507         if (value == NULL) {
 508                 BT_ERR("g_dbus_proxy_call_finish failed");
 509                 if (error) {
 510                         BT_ERR("errCode[%x], message[%s]\n",
 511                                         error->code, error->message);
 512                         g_clear_error(&error);
 513                 }
 514         } else {
 515                 g_variant_get(value, "(q)", &size);
 516                 result = BLUETOOTH_ERROR_NONE;
 517         }
 518
 519         BT_DBG("Size of Phonebook: %d", size);
 520
 521         signal = g_variant_new("(isi)", result, address_string, size);
 522         _bt_send_event(BT_PBAP_CLIENT_EVENT,
 523                                 BLUETOOTH_PBAP_PHONEBOOK_SIZE,
 524                                 signal);
 525
 526         g_variant_unref(value);
 527         g_object_unref(proxy);
 528         __bt_pbap_free_data(pbap_data);
 529         BT_DBG("-");
 530 }
 531
 532 void __bt_pbap_get_phonebook_cb(GDBusProxy *proxy,
 533                 GAsyncResult *res, gpointer user_data)
 534 {
 535         BT_DBG("+");
 536         GError *error = NULL;
 537         bt_pbap_data_t *pbap_data = user_data;
 538         char *address_string = pbap_data->data;
 539         bt_pbap_transfer_info_t *transfer_info;
 540         char *transfer = NULL;
 541         const gchar *filename =  NULL;
 542         GVariant *value;
 543         GVariant *properties;
 544
 545         BT_DBG("Address = %s", address_string);
 546         value = g_dbus_proxy_call_finish(proxy, res, &error);
 547         if (value == NULL) {
 548                 BT_ERR("g_dbus_proxy_call_finish failed");
 549                 if (error) {
 550                         BT_ERR("errCode[%x], message[%s]\n",
 551                                         error->code, error->message);
 552                         g_clear_error(&error);
 553                 }
 554         } else {
 555                 g_variant_get(value, "(o@a{sv})", &transfer, &properties);
 556
 557                 if (g_variant_lookup(properties, "Filename", "s", &filename) == FALSE)
 558                         filename = NULL;
 559
 560                 BT_DBG("Transfer Path: %s", transfer);
 561                 BT_DBG("File Name: %s", filename);
 562                 transfer_info = g_new0(bt_pbap_transfer_info_t, 1);
 563                 transfer_info->path = transfer;
 564                 transfer_info->remote_device = g_strdup(address_string);
 565                 transfer_info->filename = (char *)filename;
 566                 transfer_info->operation = PULL_ALL;
 567                 transfers = g_slist_append(transfers, transfer_info);
 568         }
 569
 570         g_object_unref(proxy);
 571         __bt_pbap_free_data(pbap_data);
 572         BT_DBG("-");
 573 }
 574
 575 void __bt_pbap_get_vcard_list_cb(GDBusProxy *proxy,
 576                 GAsyncResult *res, gpointer user_data)
 577 {
 578         BT_DBG("+");
 579         GError *error = NULL;
 580         int i;
 581         int result = BLUETOOTH_ERROR_INTERNAL;
 582         bt_pbap_data_t *pbap_data = user_data;
 583         char *address_string = pbap_data->data;
 584         char **vcard_list = NULL;
 585         char list_entry[PBAP_VCARDLIST_MAXLENGTH] = { 0, };
 586         int length = 0;
 587         GVariant *value;
 588         GVariant *signal = NULL;
 589
 590         value = g_dbus_proxy_call_finish(proxy, res, &error);
 591         if (value == NULL) {
 592                 BT_ERR("g_dbus_proxy_call_finish failed");
 593                 if (error) {
 594                         BT_ERR("errCode[%x], message[%s]\n",
 595                                         error->code, error->message);
 596                         g_clear_error(&error);
 597                 }
 598         } else {
 599                 result = BLUETOOTH_ERROR_NONE;
 600                 gchar *elname, *elval;
 601
 602                 GVariantIter iter;
 603                 GVariant *child = NULL;
 604                 GVariant *value1 = NULL;
 605
 606                 g_variant_get(value, "(@a(ss))", &value1); /* Format for value1 a(ss)*/
 607                 gsize items = g_variant_iter_init(&iter, value1);
 608                 vcard_list = g_new0(char *, items + 1);
 609
 610                 for (i = 0; (child = g_variant_iter_next_value(&iter)) != NULL; i++) {
 611                         g_variant_get(child, "(&s&s)", &elname, &elval);
 612
 613                         memset(list_entry, 0, PBAP_VCARDLIST_MAXLENGTH);
 614 #if 0
 615                         g_snprintf(list_entry, PBAP_VCARDLIST_MAXLENGTH - 1,
 616                                         "<card handle = \"%s\" name = \"%s\"/>", elname, elval);
 617 #else
 618                         g_snprintf(list_entry, PBAP_VCARDLIST_MAXLENGTH - 1,
 619                                         "%s", elval);
 620 #endif
 621                         //If possible send as Array of <STRING, STRING>
 622                         BT_DBG("%s", list_entry);
 623                         vcard_list[i] = g_strdup(list_entry);
 624                         g_variant_unref(child);
 625                 }
 626
 627                 length = i;
 628                 g_variant_unref(value1);
 629                 g_variant_unref(value);
 630         }
 631
 632         BT_DBG("Address = %s", address_string);
 633         GVariant *temp = g_variant_new_strv((const gchar*)vcard_list, length);
 634         signal = g_variant_new("(isv)", result, address_string, temp);
 635
 636         _bt_send_event(BT_PBAP_CLIENT_EVENT,
 637                         BLUETOOTH_PBAP_VCARD_LIST,
 638                         signal);
 639
 640         for (i = 0; i < length; i++)
 641                 g_free(vcard_list[i]);
 642
 643         g_free(vcard_list);
 644         g_object_unref(proxy);
 645         __bt_pbap_free_data(pbap_data);
 646         BT_DBG("-");
 647 }
 648
 649 void __bt_pbap_get_vcard_cb(GDBusProxy *proxy,
 650                 GAsyncResult *res, gpointer user_data)
 651 {
 652         BT_DBG("+");
 653         GError *error = NULL;
 654         bt_pbap_data_t *pbap_data = user_data;
 655         char *address_string = pbap_data->data;
 656         bt_pbap_transfer_info_t *transfer_info;
 657         char *transfer = NULL;
 658         const gchar *filename =  NULL;
 659         GVariant *value;
 660         GVariant *properties;
 661
 662         BT_DBG("Address = %s", address_string);
 663         value = g_dbus_proxy_call_finish(proxy, res, &error);
 664         if (value == NULL) {
 665                 BT_ERR("g_dbus_proxy_call_finish failed");
 666                 if (error) {
 667                         BT_ERR("errCode[%x], message[%s]\n",
 668                                         error->code, error->message);
 669                         g_clear_error(&error);
 670                 }
 671         } else {
 672                 g_variant_get(value, "(o@a{sv})", &transfer, &properties);
 673
 674                 if (g_variant_lookup(properties, "Filename", "s", &filename) == FALSE)
 675                         filename = NULL;
 676
 677                 BT_DBG("Transfer Path: %s", transfer);
 678                 BT_DBG("File Name: %s", filename);
 679                 transfer_info = g_new0(bt_pbap_transfer_info_t, 1);
 680                 transfer_info->path = transfer;
 681                 transfer_info->remote_device = g_strdup(address_string);
 682                 transfer_info->filename = (char *)filename;
 683                 transfer_info->operation = GET_VCARD;
 684                 transfers = g_slist_append(transfers, transfer_info);
 685
 686                 g_variant_unref(properties);
 687                 g_variant_unref(value);
 688         }
 689
 690         g_object_unref(proxy);
 691         __bt_pbap_free_data(pbap_data);
 692         BT_DBG("-");
 693 }
 694
 695 void __bt_pbap_search_phonebook_cb(GDBusProxy *proxy,
 696                 GAsyncResult *res, gpointer user_data)
 697 {
 698         BT_DBG("+");
 699         GError *error = NULL;
 700         int i;
 701         bt_pbap_data_t *pbap_data = user_data;
 702         char *address_string = pbap_data->data;
 703         char **vcard_list = NULL;
 704         char list_entry[PBAP_VCARDLIST_MAXLENGTH] = { 0, };
 705         int length = 0;
 706         int result = BLUETOOTH_ERROR_INTERNAL;
 707         GVariant *value;
 708         GVariant *signal = NULL;
 709
 710         value = g_dbus_proxy_call_finish(proxy, res, &error);
 711         if (value == NULL) {
 712                 BT_ERR("g_dbus_proxy_call_finish failed");
 713                 if (error) {
 714                         BT_ERR("errCode[%x], message[%s]\n",
 715                                         error->code, error->message);
 716                         g_clear_error(&error);
 717                 }
 718         } else {
 719                 result = BLUETOOTH_ERROR_NONE;
 720                 gchar *elname, *elval;
 721
 722                 GVariantIter iter;
 723                 GVariant *child = NULL;
 724                 GVariant *value1 = NULL;
 725
 726                 g_variant_get(value, "(@a(ss))", &value1);
 727                 gsize items = g_variant_iter_init(&iter, value1);
 728                 vcard_list = g_new0(char *, items + 1);
 729
 730                 for (i = 0; (child = g_variant_iter_next_value(&iter)) != NULL; i++) {
 731                         g_variant_get(child, "(&s&s)", &elname, &elval);
 732
 733                         memset(list_entry, 0, PBAP_VCARDLIST_MAXLENGTH);
 734                         g_snprintf(list_entry, PBAP_VCARDLIST_MAXLENGTH - 1,
 735                                         "<card handle = \"%s\" name = \"%s\"/>", elname, elval);
 736                         //If possible send as Array of <STRING, STRING>
 737                         BT_DBG("%s", list_entry);
 738                         vcard_list[i] = g_strdup(list_entry);
 739
 740                         g_variant_unref(child);
 741                 }
 742                 length = i;
 743                 g_variant_unref(value1);
 744                 g_variant_unref(value);
 745         }
 746
 747         BT_DBG("Address = %s", address_string);
 748
 749         signal = g_variant_new("(is@as)", result, address_string,
 750                         g_variant_new_strv((const gchar *)vcard_list, length));
 751
 752         _bt_send_event(BT_PBAP_CLIENT_EVENT,
 753                                 BLUETOOTH_PBAP_PHONEBOOK_SEARCH,
 754                                 signal);
 755
 756         for (i = 0; i < length; i++)
 757                 g_free(vcard_list[i]);
 758
 759         g_free(vcard_list);
 760         g_object_unref(proxy);
 761         __bt_pbap_free_data(pbap_data);
 762         BT_DBG("-");
 763 }
 764
 765 int __bt_pbap_call_get_phonebook_size(GDBusProxy *proxy, bt_pbap_data_t *pbap_data)
 766 {
 767         BT_DBG("+");
 768
 769         g_dbus_proxy_call(proxy, "GetSize",
 770                         NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL,
 771                         (GAsyncReadyCallback)__bt_pbap_get_phonebook_size_cb,
 772                         pbap_data);
 773
 774         BT_DBG("-");
 775         return BLUETOOTH_ERROR_NONE;
 776 }
 777
 778 int __bt_pbap_call_get_phonebook(GDBusProxy *proxy, bt_pbap_data_t *pbap_data)
 779 {
 780         BT_DBG("+");
 781
 782         int i;
 783         int ret;
 784         char *format_str = NULL;
 785         char *fields_str = NULL;
 786         char *order_str = NULL;
 787         char *download_path = NULL;
 788         char *target_file = NULL;
 789         bt_pbap_pull_parameters_t *app_param = pbap_data->app_param;
 790         GVariantBuilder builder;
 791         GVariantBuilder inner_builder;
 792         GVariant *filters;
 793
 794
 795         g_variant_builder_init(&builder, G_VARIANT_TYPE_ARRAY);
 796         g_variant_builder_init(&inner_builder, G_VARIANT_TYPE_ARRAY);
 797
 798         /* Add MaxlistCount*/
 799         g_variant_builder_add(&builder, "{sv}", "MaxCount",
 800                                         g_variant_new("u", app_param->maxlist));
 801
 802         /* Add Order Filter only if other than Indexed (default)*/
 803         if (app_param->order > 0) {
 804                 order_str = g_strdup(ORDER[app_param->order]);
 805                 g_variant_builder_add(&builder, "{sv}", "Order",
 806                                 g_variant_new("s", order_str));
 807         }
 808
 809         /* Add Offset Filter only if other than 0 (default)*/
 810         if (app_param->offset > 0) {
 811                 g_variant_builder_add(&builder, "{sv}", "Offset",
 812                                                 g_variant_new("u", app_param->offset));
 813         }
 814
 815         /* Add Format Filter only if other than vCard 2.1 (default)*/
 816         if (app_param->format > 0) {
 817                 format_str = g_strdup(FORMAT[app_param->format]);
 818                 g_variant_builder_add(&builder, "{sv}", "Format",
 819                                                         g_variant_new("s", format_str));
 820         }
 821
 822         /* Add Filter AttributeMask (64bit) */
 823         if (app_param->fields > 0) {
 824                 if (app_param->fields == PBAP_FIELD_ALL) {
 825                         BT_DBG("** CHECKED ALL **");
 826                         fields_str = g_strdup("ALL");
 827                         g_variant_builder_add(&inner_builder, "s", fields_str);
 828                         g_free(fields_str);
 829                 } else {
 830                         for (i = 0; i < PBAP_NUM_OF_FIELDS_ENTRY; i++) {
 831                                 if (app_param->fields & (1ULL << i)) {
 832                                         BT_DBG("** CHECKED[%d]", i);
 833                                         fields_str = g_strdup(FIELDS[i]);
 834                                         g_variant_builder_add(&inner_builder, "s", fields_str);
 835                                         g_free(fields_str);
 836                                 }
 837                         }
 838                 }
 839
 840                 g_variant_builder_add(&builder, "{sv}", "Fields",
 841                         g_variant_new("as", &inner_builder));
 842         }
 843
 844         filters = g_variant_builder_end(&builder);
 845
 846 //****************************
 847 // Add code for Fields
 848 //
 849 //****************************
 850
 851         ret = storage_get_directory(STORAGE_TYPE_INTERNAL,
 852                         STORAGE_DIRECTORY_DOWNLOADS, &download_path);
 853
 854         if (ret != STORAGE_ERROR_NONE) {
 855                 target_file = g_strdup_printf("%s/%s", PBAP_DEFAULT_DOWNLAOD_PATH,
 856                                                         PBAP_DEFAULT_FILE_NAME);
 857         } else {
 858                 target_file = g_strdup_printf("%s/%s", download_path,
 859                                         PBAP_DEFAULT_FILE_NAME);
 860
 861                 if (download_path)
 862                         free(download_path);
 863         }
 864
 865         DBG_SECURE("Target flie: %s", target_file);
 866
 867         g_dbus_proxy_call(proxy, "PullAll",
 868                         g_variant_new("(s@a{sv})", target_file, filters),
 869                         G_DBUS_CALL_FLAGS_NONE, -1, NULL,
 870                         (GAsyncReadyCallback)__bt_pbap_get_phonebook_cb,
 871                         pbap_data);
 872
 873         g_free(format_str);
 874         g_free(order_str);
 875
 876         BT_DBG("-");
 877         return BLUETOOTH_ERROR_NONE;
 878 }
 879
 880 int __bt_pbap_call_get_vcards_list(GDBusProxy *proxy, bt_pbap_data_t *pbap_data)
 881 {
 882         BT_DBG("+");
 883         char *order_str = NULL;
 884         char *folder = NULL;
 885         GVariantBuilder builder;
 886         GVariant *filters;
 887
 888         bt_pbap_list_parameters_t *app_param = pbap_data->app_param;
 889
 890         g_variant_builder_init(&builder, G_VARIANT_TYPE_ARRAY);
 891
 892         /* Add MaxlistCount*/
 893         g_variant_builder_add(&builder, "{sv}", "MaxCount",
 894                                         g_variant_new("u", app_param->maxlist));
 895
 896         /* Add Order Filter only if other than Indexed (default)*/
 897         if (app_param->order > 0) {
 898                 order_str = g_strdup(ORDER[app_param->order]);
 899                 g_variant_builder_add(&builder, "{sv}", "Order",
 900                                 g_variant_new("s", order_str));
 901         }
 902
 903         /* Add Offset Filter only if other than 0 (default)*/
 904         if (app_param->offset > 0) {
 905                 g_variant_builder_add(&builder, "{sv}", "Offset",
 906                                                 g_variant_new("u", app_param->offset));
 907         }
 908
 909         filters = g_variant_builder_end(&builder);
 910
 911         folder = g_strdup(TYPE[selected_path.type]);
 912         BT_DBG("Folder: %s", folder);
 913
 914
 915         g_dbus_proxy_call(proxy, "List",
 916                         g_variant_new("(s@a{sv})", folder, filters),
 917                         G_DBUS_CALL_FLAGS_NONE, -1, NULL,
 918                         (GAsyncReadyCallback)__bt_pbap_get_vcard_list_cb,
 919                         pbap_data);
 920
 921         g_free(folder);
 922         g_free(order_str);
 923         g_hash_table_unref((GHashTable *)filters);
 924         /* In _bt_pbap_get_list(), path(type) is set to "nil", but current type is not null.
 925              The path should be reset here */
 926         selected_path.type = -1;
 927
 928         BT_DBG("-");
 929         return BLUETOOTH_ERROR_NONE;
 930 }
 931
 932 int __bt_pbap_call_get_vcard(GDBusProxy *proxy, bt_pbap_data_t *pbap_data)
 933 {
 934         BT_DBG("+");
 935
 936         int i;
 937         int ret;
 938         char *format_str = NULL;
 939         char *fields_str = NULL;
 940         char *target_file = NULL;
 941         char *download_path = NULL;
 942         char *vcard_handle = NULL;
 943         char vcard[10] = { 0, };
 944         GVariantBuilder builder;
 945         GVariantBuilder inner_builder;
 946         GVariant *filters;
 947         bt_pbap_pull_vcard_parameters_t *app_param = pbap_data->app_param;
 948
 949         g_variant_builder_init(&builder, G_VARIANT_TYPE_ARRAY);
 950         g_variant_builder_init(&inner_builder, G_VARIANT_TYPE_ARRAY);
 951
 952         /* Add Format Filter only if other than vCard 2.1 (default)*/
 953 //      if (app_param->format > 0) {
 954                 format_str = g_strdup(FORMAT[app_param->format]);
 955                 g_variant_builder_add(&builder, "{sv}", "Format",
 956                                                         g_variant_new("s", format_str));
 957 //      }
 958
 959         /* Add Filter AttributeMask (64bit) */
 960         if (app_param->fields > 0) {
 961                 if (app_param->fields == PBAP_FIELD_ALL) {
 962                         BT_DBG("** CHECKED ALL **");
 963                         fields_str = g_strdup("ALL");
 964                         g_variant_builder_add(&inner_builder, "s", fields_str);
 965                         g_free(fields_str);
 966                 } else {
 967                         for (i = 0; i < PBAP_NUM_OF_FIELDS_ENTRY; i++) {
 968                                 if (app_param->fields & (1ULL << i)) {
 969                                         BT_DBG("** CHECKED[%d]", i);
 970                                         fields_str = g_strdup(FIELDS[i]);
 971                                         g_variant_builder_add(&inner_builder, "s", fields_str);
 972                                         g_free(fields_str);
 973                                 }
 974                         }
 975                 }
 976
 977                 g_variant_builder_add(&builder, "{sv}", "Fields",
 978                         g_variant_new("as", &inner_builder));
 979         }
 980
 981         filters = g_variant_builder_end(&builder);
 982
 983 //****************************
 984 // Add code for Fields
 985 //
 986 //****************************
 987
 988         sprintf(vcard, "%d.vcf", app_param->index);
 989         BT_DBG("Handle: %s", vcard);
 990         vcard_handle = g_strdup(vcard);
 991         BT_DBG("vcard_handle: %s", vcard_handle);
 992
 993         ret = storage_get_directory(STORAGE_TYPE_INTERNAL,
 994                         STORAGE_DIRECTORY_DOWNLOADS, &download_path);
 995
 996         if (ret != STORAGE_ERROR_NONE) {
 997                 target_file = g_strdup_printf("%s/%s", PBAP_DEFAULT_DOWNLAOD_PATH,
 998                                                         PBAP_DEFAULT_FILE_NAME);
 999         } else {
1000                 if (vcard_handle)
1001                         target_file = g_strdup_printf("%s/%s", download_path,
1002                                         vcard_handle);
1003                 else
1004                         target_file = g_strdup_printf("%s/%s", download_path,
1005                                         PBAP_DEFAULT_FILE_NAME);
1006
1007                 if (download_path)
1008                         free(download_path);
1009         }
1010
1011         DBG_SECURE("Target flie: %s", target_file);
1012
1013         GVariant *temp = g_variant_new("(ss@a{sv})", vcard_handle, target_file, filters);
1014
1015         g_dbus_proxy_call(proxy, "Pull",
1016                         temp,
1017                         G_DBUS_CALL_FLAGS_NONE, -1, NULL,
1018                         (GAsyncReadyCallback)__bt_pbap_get_vcard_cb,
1019                         pbap_data);
1020
1021         g_free(format_str);
1022         g_free(vcard_handle);
1023
1024         BT_DBG("-");
1025         return BLUETOOTH_ERROR_NONE;
1026 }
1027
1028 int __bt_pbap_call_search_phonebook(GDBusProxy *proxy, bt_pbap_data_t *pbap_data)
1029 {
1030         BT_DBG("+");
1031
1032         char *order_str = NULL;
1033         char *field = NULL;
1034         char *value = NULL;
1035         bt_pbap_search_parameters_t *app_param = pbap_data->app_param;
1036         GVariantBuilder builder;
1037         GVariant *filters;
1038
1039         g_variant_builder_init(&builder, G_VARIANT_TYPE_ARRAY);
1040
1041         /* Add MaxlistCount*/
1042         g_variant_builder_add(&builder, "{sv}", "MaxCount",
1043                                         g_variant_new("u", app_param->maxlist));
1044
1045         /* Add Order Filter only if other than Indexed (default)*/
1046         if (app_param->order > 0) {
1047                 order_str = g_strdup(ORDER[app_param->order]);
1048                 g_variant_builder_add(&builder, "{sv}", "Order",
1049                                 g_variant_new("s", order_str));
1050         }
1051
1052         /* Add Offset Filter only if other than 0 (default)*/
1053         if (app_param->offset > 0) {
1054                 g_variant_builder_add(&builder, "{sv}", "Offset",
1055                                                 g_variant_new("u", app_param->offset));
1056         }
1057
1058         filters = g_variant_builder_end(&builder);
1059
1060         field = g_strdup(SEARCH_FIELD[app_param->search_attribute]);
1061         value = g_strdup(app_param->search_value);
1062
1063         g_dbus_proxy_call(proxy, "Search",
1064                         g_variant_new("(ss@a{sv})", field, value, filters),
1065                         G_DBUS_CALL_FLAGS_NONE, -1, NULL,
1066                         (GAsyncReadyCallback)__bt_pbap_search_phonebook_cb,
1067                         pbap_data);
1068
1069         g_free(value);
1070         g_free(order_str);
1071         g_free(field);
1072
1073         BT_DBG("-");
1074         return BLUETOOTH_ERROR_NONE;
1075 }
1076
1077 int _bt_pbap_get_phonebook_size(const bluetooth_device_address_t *address,
1078                 int source, int type)
1079 {
1080         BT_DBG("+");
1081         GDBusProxy *g_pbap_session_proxy = NULL;
1082         char address_string[18] = { 0, };
1083         char *source_string = NULL;
1084         char *type_string = NULL;
1085         GError *err = NULL;
1086         bt_pbap_data_t *pbap_data = NULL;
1087
1088         BT_CHECK_PARAMETER(address, return);
1089
1090         /* check if connected */
1091         if (g_pbap_session_path == NULL) {
1092                 BT_ERR("NOT CONNECTED");
1093                 return BLUETOOTH_ERROR_NOT_CONNECTED;
1094         }
1095
1096         BT_DBG("BD Address [%2.2X %2.2X %2.2X %2.2X %2.2X %2.2X]",
1097                         address->addr[0], address->addr[1],
1098                         address->addr[2], address->addr[3],
1099                         address->addr[4], address->addr[5]);
1100
1101         _bt_convert_addr_type_to_string(address_string, (unsigned char *)address->addr);
1102                         BT_DBG("Address String: %s", address_string);
1103         source_string = g_strdup(SOURCE[source]);
1104         type_string = g_strdup(TYPE[type]);
1105
1106         BT_DBG("Address[%s] Source[%s] Type[%s]",
1107                         address_string, source_string, type_string);
1108         BT_DBG("Session Path = %s\n", g_pbap_session_path);
1109         g_pbap_session_proxy =  g_dbus_proxy_new_sync(dbus_connection,
1110                         G_DBUS_PROXY_FLAGS_NONE, NULL,
1111                         PBAP_SESSION_SERVICE, g_pbap_session_path,
1112                         PBAP_SESSION_INTERFACE, NULL, &err);
1113
1114         if (!g_pbap_session_proxy) {
1115                 BT_ERR("Failed to get a proxy for D-Bus\n");
1116                 if (err) {
1117                         ERR("Unable to create proxy: %s", err->message);
1118                         g_clear_error(&err);
1119                 }
1120                 g_free(source_string);
1121                 g_free(type_string);
1122                 return -1;
1123         }
1124
1125         BT_DBG("Prepare PBAP data");
1126         pbap_data = g_new0(bt_pbap_data_t, 1);
1127         pbap_data->operation = GET_SIZE;
1128         pbap_data->data = g_strdup(address_string);
1129
1130         if (source ==  selected_path.folder && type == selected_path.type) {
1131                 BT_DBG("Call get_phonebook_size directly");
1132                 g_free(source_string);
1133                 g_free(type_string);
1134                 return __bt_pbap_call_get_phonebook_size(g_pbap_session_proxy, pbap_data);
1135         }
1136
1137         BT_DBG("Call SELECT");
1138         g_dbus_proxy_call(g_pbap_session_proxy, "Select",
1139                         g_variant_new("(ss)", source_string, type_string),
1140                         G_DBUS_CALL_FLAGS_NONE, -1, NULL,
1141                         (GAsyncReadyCallback)__bt_pbap_select_cb,
1142                         pbap_data);
1143
1144         BT_DBG("Set Folders");
1145         selected_path.folder = source;
1146         selected_path.type = type;
1147
1148         g_free(source_string);
1149         g_free(type_string);
1150         return 0;
1151 }
1152
1153 int _bt_pbap_get_phonebook(const bluetooth_device_address_t *address,
1154                 int source, int type, bt_pbap_pull_parameters_t *app_param)
1155 {
1156         BT_DBG("+");
1157         GDBusProxy *g_pbap_session_proxy = NULL;
1158         char address_string[18] = { 0, };
1159         char *source_string = NULL;
1160         char *type_string = NULL;
1161         GError *err = NULL;
1162
1163         bt_pbap_data_t *pbap_data = NULL;
1164         bt_pbap_pull_parameters_t *param = NULL;
1165
1166         BT_CHECK_PARAMETER(address, return);
1167
1168         /* check if connected */
1169         if (g_pbap_session_path == NULL) {
1170                 BT_ERR("NOT CONNECTED");
1171                 return BLUETOOTH_ERROR_NOT_CONNECTED;
1172         }
1173
1174         BT_DBG("BD Address [%2.2X %2.2X %2.2X %2.2X %2.2X %2.2X]",
1175                         address->addr[0], address->addr[1],
1176                         address->addr[2], address->addr[3],
1177                         address->addr[4], address->addr[5]);
1178
1179         _bt_convert_addr_type_to_string(address_string, (unsigned char *)address->addr);
1180                 BT_DBG("Address String: %s", address_string);
1181
1182         source_string = g_strdup(SOURCE[source]);
1183         type_string = g_strdup(TYPE[type]);
1184
1185         BT_DBG("Address[%s] Source[%s] Type[%s]",
1186                         address_string, source_string, type_string);
1187
1188         BT_DBG("Session Path = %s\n", g_pbap_session_path);
1189         g_pbap_session_proxy =  g_dbus_proxy_new_sync(dbus_connection,
1190                         G_DBUS_PROXY_FLAGS_NONE, NULL,
1191                         PBAP_SESSION_SERVICE, g_pbap_session_path,
1192                         PBAP_SESSION_INTERFACE, NULL, &err);
1193
1194         if (!g_pbap_session_proxy) {
1195                 BT_ERR("Failed to get a proxy for D-Bus\n");
1196                 if (err) {
1197                         ERR("Unable to create proxy: %s", err->message);
1198                         g_clear_error(&err);
1199                 }
1200                 g_free(source_string);
1201                 g_free(type_string);
1202                 return -1;
1203         }
1204
1205         pbap_data = g_new0(bt_pbap_data_t, 1);
1206         pbap_data->operation = PULL_ALL;
1207         pbap_data->data = g_strdup(address_string);
1208         param = g_new0(bt_pbap_pull_parameters_t, 1);
1209         memcpy(param, app_param, sizeof(bt_pbap_pull_parameters_t));
1210         pbap_data->app_param = param;
1211
1212         if (source ==  selected_path.folder && type == selected_path.type) {
1213                 return __bt_pbap_call_get_phonebook(g_pbap_session_proxy, pbap_data);
1214         }
1215
1216         g_dbus_proxy_call(g_pbap_session_proxy, "Select",
1217                         g_variant_new("(ss)", source_string, type_string),
1218                         G_DBUS_CALL_FLAGS_NONE, -1, NULL,
1219                         (GAsyncReadyCallback)__bt_pbap_select_cb,
1220                         pbap_data);
1221
1222         selected_path.folder = source;
1223         selected_path.type = type;
1224         g_free(source_string);
1225         g_free(type_string);
1226
1227         return 0;
1228 }
1229
1230 int _bt_pbap_get_list(const bluetooth_device_address_t *address, int source,
1231                 int type,  bt_pbap_list_parameters_t *app_param)
1232 {
1233         BT_DBG("+");
1234         GDBusProxy *g_pbap_session_proxy = NULL;
1235         char address_string[18] = { 0, };
1236         char *source_string = NULL;
1237         char *type_string = NULL;
1238         GError *err = NULL;
1239
1240         bt_pbap_data_t *pbap_data = NULL;
1241         bt_pbap_list_parameters_t *param = NULL;
1242
1243         BT_CHECK_PARAMETER(address, return);
1244
1245         /* check if connected */
1246         if (g_pbap_session_path == NULL) {
1247                 BT_ERR("NOT CONNECTED");
1248                 return BLUETOOTH_ERROR_NOT_CONNECTED;
1249         }
1250
1251         BT_DBG("BD Address [%2.2X %2.2X %2.2X %2.2X %2.2X %2.2X]",
1252                         address->addr[0], address->addr[1],
1253                         address->addr[2], address->addr[3],
1254                         address->addr[4], address->addr[5]);
1255
1256         _bt_convert_addr_type_to_string(address_string, (unsigned char *)address->addr);
1257                 BT_DBG("Address String: %s", address_string);
1258
1259         source_string = g_strdup(SOURCE[source]);
1260         type_string = g_strdup("nil");
1261
1262         BT_DBG("Address[%s] Source[%s] Type[%s]",
1263                         address_string, source_string, type_string);
1264
1265         BT_DBG("Session Path = %s\n", g_pbap_session_path);
1266         g_pbap_session_proxy =  g_dbus_proxy_new_sync(dbus_connection,
1267                         G_DBUS_PROXY_FLAGS_NONE, NULL,
1268                         PBAP_SESSION_SERVICE, g_pbap_session_path,
1269                         PBAP_SESSION_INTERFACE, NULL, &err);
1270
1271         if (!g_pbap_session_proxy) {
1272                 BT_ERR("Failed to get a proxy for D-Bus\n");
1273                 if (err) {
1274                         ERR("Unable to create proxy: %s", err->message);
1275                         g_clear_error(&err);
1276                 }
1277                 g_free(source_string);
1278                 g_free(type_string);
1279                 return -1;
1280         }
1281
1282         BT_DBG("Set PBAP Data");
1283         pbap_data = g_new0(bt_pbap_data_t, 1);
1284         pbap_data->operation = GET_LIST;
1285         pbap_data->data = g_strdup(address_string);
1286         param = g_new0(bt_pbap_list_parameters_t, 1);
1287         memcpy(param, app_param, sizeof(bt_pbap_list_parameters_t));
1288         pbap_data->app_param = param;
1289
1290         /* Always Call Select for vCardListing
1291         if (source ==  selected_path.folder && type == selected_path.type) {
1292                 BT_DBG("Call Directly");
1293                 return __bt_pbap_call_get_vcards_list(g_pbap_session_proxy, pbap_data);
1294         } */
1295         BT_DBG("Call SELECT");
1296         g_dbus_proxy_call(g_pbap_session_proxy, "Select",
1297                         g_variant_new("(ss)", source_string, type_string),
1298                         G_DBUS_CALL_FLAGS_NONE, -1, NULL,
1299                         (GAsyncReadyCallback)__bt_pbap_select_cb,
1300                         pbap_data);
1301         BT_DBG("Set Folders");
1302         selected_path.folder = source;
1303         selected_path.type = type;
1304         g_free(source_string);
1305         g_free(type_string);
1306
1307         return 0;
1308 }
1309
1310
1311 int _bt_pbap_pull_vcard(const bluetooth_device_address_t *address,
1312                 int source, int type, bt_pbap_pull_vcard_parameters_t *app_param)
1313 {
1314         BT_DBG("+");
1315         GDBusProxy *g_pbap_session_proxy = NULL;
1316         char address_string[18] = { 0, };
1317         char *source_string = NULL;
1318         char *type_string = NULL;
1319         bt_pbap_data_t *pbap_data = NULL;
1320         bt_pbap_pull_vcard_parameters_t *param = NULL;
1321         GError *err = NULL;
1322
1323         BT_CHECK_PARAMETER(address, return);
1324
1325         /* check if connected */
1326         if (g_pbap_session_path == NULL) {
1327                 BT_ERR("NOT CONNECTED");
1328                 return BLUETOOTH_ERROR_NOT_CONNECTED;
1329         }
1330
1331         BT_DBG("BD Address [%2.2X %2.2X %2.2X %2.2X %2.2X %2.2X]",
1332                         address->addr[0], address->addr[1],
1333                         address->addr[2], address->addr[3],
1334                         address->addr[4], address->addr[5]);
1335
1336         _bt_convert_addr_type_to_string(address_string, (unsigned char *)address->addr);
1337                 BT_DBG("Address String: %s", address_string);
1338
1339         source_string = g_strdup(SOURCE[source]);
1340         type_string = g_strdup(TYPE[type]);
1341
1342         BT_DBG("Address[%s] Source[%s] Type[%s]",
1343                         address_string, source_string, type_string);
1344
1345         BT_DBG("Session Path = %s\n", g_pbap_session_path);
1346         g_pbap_session_proxy =  g_dbus_proxy_new_sync(dbus_connection,
1347                         G_DBUS_PROXY_FLAGS_NONE, NULL,
1348                         PBAP_SESSION_SERVICE, g_pbap_session_path,
1349                         PBAP_SESSION_INTERFACE, NULL, &err);
1350
1351         if (!g_pbap_session_proxy) {
1352                 BT_ERR("Failed to get a proxy for D-Bus\n");
1353                 if (err) {
1354                         ERR("Unable to create proxy: %s", err->message);
1355                         g_clear_error(&err);
1356                 }
1357                 return -1;
1358         }
1359
1360         pbap_data = g_new0(bt_pbap_data_t, 1);
1361         pbap_data->operation = GET_VCARD;
1362         pbap_data->data = g_strdup(address_string);
1363         param = g_new0(bt_pbap_pull_vcard_parameters_t, 1);
1364         memcpy(param, app_param, sizeof(bt_pbap_pull_vcard_parameters_t));
1365         pbap_data->app_param = param;
1366
1367         if (source ==  selected_path.folder && type == selected_path.type) {
1368                 return __bt_pbap_call_get_vcard(g_pbap_session_proxy, pbap_data);
1369         }
1370
1371         g_dbus_proxy_call(g_pbap_session_proxy, "Select",
1372                         g_variant_new("(ss)", source_string, type_string),
1373                         G_DBUS_CALL_FLAGS_NONE, -1, NULL,
1374                         (GAsyncReadyCallback)__bt_pbap_select_cb,
1375                         pbap_data);
1376
1377         selected_path.folder = source;
1378         selected_path.type = type;
1379         g_free(source_string);
1380         g_free(type_string);
1381
1382         return 0;
1383 }
1384
1385 int _bt_pbap_phonebook_search(const bluetooth_device_address_t *address,
1386                 int source, int type, bt_pbap_search_parameters_t *app_param)
1387 {
1388         BT_DBG("+");
1389         GDBusProxy *g_pbap_session_proxy = NULL;
1390         char address_string[18] = { 0, };
1391         char *source_string = NULL;
1392         char *type_string = NULL;
1393         bt_pbap_data_t *pbap_data = NULL;
1394         bt_pbap_search_parameters_t *param = NULL;
1395         GError *err = NULL;
1396
1397         BT_CHECK_PARAMETER(address, return);
1398
1399         /* check if connected */
1400         if (g_pbap_session_path == NULL) {
1401                 BT_ERR("NOT CONNECTED");
1402                 return BLUETOOTH_ERROR_NOT_CONNECTED;
1403         }
1404
1405         BT_DBG("BD Address [%2.2X %2.2X %2.2X %2.2X %2.2X %2.2X]",
1406                         address->addr[0], address->addr[1],
1407                         address->addr[2], address->addr[3],
1408                         address->addr[4], address->addr[5]);
1409
1410         _bt_convert_addr_type_to_string(address_string, (unsigned char *)address->addr);
1411                 BT_DBG("Address String: %s", address_string);
1412
1413         source_string = g_strdup(SOURCE[source]);
1414         type_string = g_strdup(TYPE[type]);
1415
1416         BT_DBG("Address[%s] Source[%s] Type[%s]",
1417                         address_string, source_string, type_string);
1418
1419         BT_DBG("Session Path = %s\n", g_pbap_session_path);
1420
1421         g_pbap_session_proxy =  g_dbus_proxy_new_sync(dbus_connection,
1422                         G_DBUS_PROXY_FLAGS_NONE, NULL,
1423                         PBAP_SESSION_SERVICE, g_pbap_session_path,
1424                         PBAP_SESSION_INTERFACE, NULL, &err);
1425
1426         if (!g_pbap_session_proxy) {
1427                 BT_ERR("Failed to get a proxy for D-Bus\n");
1428                 if (err) {
1429                         ERR("Unable to create proxy: %s", err->message);
1430                         g_clear_error(&err);
1431                 }
1432                 g_free(source_string);
1433                 g_free(type_string);
1434                 return -1;
1435         }
1436
1437         pbap_data = g_new0(bt_pbap_data_t, 1);
1438         pbap_data->operation = PB_SEARCH;
1439         pbap_data->data = g_strdup(address_string);
1440         param = g_new0(bt_pbap_search_parameters_t, 1);
1441         memcpy(param, app_param, sizeof(bt_pbap_search_parameters_t));
1442         pbap_data->app_param = param;
1443
1444         /* Call Select for vCardListing
1445         if (source ==  selected_path.folder && type == selected_path.type) {
1446                 return __bt_pbap_call_search_phonebook(g_pbap_session_proxy, pbap_data);
1447         }*/
1448
1449         g_dbus_proxy_call(g_pbap_session_proxy, "Select",
1450                         g_variant_new("(ss)", source_string, type_string),
1451                         G_DBUS_CALL_FLAGS_NONE, -1, NULL,
1452                         (GAsyncReadyCallback)__bt_pbap_select_cb,
1453                         pbap_data);
1454
1455         selected_path.folder = source;
1456         selected_path.type = type;
1457
1458         g_free(source_string);
1459         g_free(type_string);
1460
1461         return 0;
1462 }
1463