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