bt-service/bt-service-pbap.c

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