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