bt-service/bt-service-pbap.c

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