bt-api/bt-gatt-client.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 <gio/gio.h>
  19 #include <glib.h>
  20 #include <glib/gprintf.h>
  21 #include <stdlib.h>
  22 #include <unistd.h>
  23 #include <stdint.h>
  24
  25 #include "bt-common.h"
  26 #include "bt-event-handler.h"
  27 #include "bt-gatt-client.h"
  28 #include "bt-internal-types.h"
  29 #include "bt-request-sender.h"
  30
  31 #define GATT_DEFAULT_TIMEOUT  (6 * 1000) // Dependent on supervision timeout 6 sec
  32
  33 typedef enum {
  34         TYPE_NONE,
  35         USER_DESC,
  36         CLIENT_CONF,
  37         SERVER_CONF,
  38         CHAR_FORMAT
  39 } char_descriptor_type_t;
  40
  41 static GSList *service_monitor_list = NULL;
  42
  43 BT_EXPORT_API int bluetooth_gatt_free_service_property(bt_gatt_service_property_t *svc_pty)
  44 {
  45         BT_CHECK_PARAMETER(svc_pty, return);
  46
  47         g_free(svc_pty->uuid);
  48         g_free(svc_pty->handle);
  49         g_strfreev(svc_pty->include_handles.handle);
  50         g_strfreev(svc_pty->char_handle.handle);
  51
  52         memset(svc_pty, 0, sizeof(bt_gatt_service_property_t));
  53
  54         return BLUETOOTH_ERROR_NONE;
  55 }
  56
  57 BT_EXPORT_API int bluetooth_gatt_free_char_property(bt_gatt_char_property_t *char_pty)
  58 {
  59         BT_CHECK_PARAMETER(char_pty, return);
  60
  61         g_free(char_pty->uuid);
  62         g_free(char_pty->name);
  63         g_free(char_pty->description);
  64         g_free(char_pty->val);
  65         g_free(char_pty->handle);
  66         g_strfreev(char_pty->char_desc_handle.handle);
  67
  68         memset(char_pty, 0, sizeof(bt_gatt_char_property_t));
  69
  70         return BLUETOOTH_ERROR_NONE;
  71 }
  72
  73 BT_EXPORT_API int bluetooth_gatt_free_desc_property(bt_gatt_char_descriptor_property_t *desc_pty)
  74 {
  75         BT_CHECK_PARAMETER(desc_pty, return);
  76
  77         g_free(desc_pty->uuid);
  78         g_free(desc_pty->val);
  79         g_free(desc_pty->handle);
  80
  81         memset(desc_pty, 0, sizeof(bt_gatt_char_descriptor_property_t));
  82
  83         return BLUETOOTH_ERROR_NONE;
  84 }
  85
  86 static char **__get_string_array_from_gptr_array(GPtrArray *gp)
  87 {
  88         gchar *gp_path = NULL;
  89         char **path = NULL;
  90         int i;
  91
  92         if (gp->len == 0)
  93                 return NULL;
  94
  95         path = g_malloc0((gp->len + 1) * sizeof(char *));
  96
  97         for (i = 0; i < gp->len; i++) {
  98                 gp_path = g_ptr_array_index(gp, i);
  99                 path[i] = g_strdup(gp_path);
 100         //      BT_DBG("path[%d] : [%s]", i, path[i]);
 101         }
 102
 103         return path;
 104 }
 105
 106 gboolean _bluetooth_gatt_check_service_change_watcher_address(
 107                 const bluetooth_device_address_t *device_addr)
 108 {
 109         GSList *l;
 110
 111         for (l = service_monitor_list; l != NULL; l = l->next) {
 112                 bluetooth_device_address_t *addr = l->data;
 113
 114                 if (!memcmp(device_addr, addr,
 115                             sizeof(bluetooth_device_address_t)))
 116                         return TRUE;
 117         }
 118
 119         return FALSE;
 120 }
 121
 122 BT_EXPORT_API int bluetooth_gatt_set_service_change_watcher(
 123                 const bluetooth_device_address_t *address, gboolean enable)
 124 {
 125         GSList *l;
 126         bluetooth_device_address_t *addr = NULL;
 127         char secure_address[BT_ADDRESS_STRING_SIZE] = { 0 };
 128
 129         _bt_convert_addr_type_to_secure_string(secure_address, (unsigned char *)address->addr);
 130         BT_INFO("Set watcher for %s with %d", secure_address, enable);
 131
 132         if (enable == TRUE) {
 133                 if (_bluetooth_gatt_check_service_change_watcher_address(address)
 134                                 == TRUE) {
 135                         BT_INFO("The watcher is already set");
 136                         return BLUETOOTH_ERROR_NONE;
 137                 }
 138
 139                 if (service_monitor_list == NULL)
 140                         _bt_register_manager_subscribe_signal(TRUE);
 141
 142                 addr = g_malloc0(sizeof(bluetooth_device_address_t));
 143                 memcpy(addr, address, sizeof(bluetooth_device_address_t));
 144
 145                 service_monitor_list =
 146                         g_slist_append(service_monitor_list, addr);
 147         } else {
 148                 for (l = service_monitor_list; l != NULL; l = l->next) {
 149                         addr = l->data;
 150
 151                         if (!memcmp(address, addr,
 152                                     sizeof(bluetooth_device_address_t))) {
 153                                 service_monitor_list =
 154                                         g_slist_remove(service_monitor_list, addr);
 155                                 g_free(addr);
 156                                 break;
 157                         }
 158                 }
 159
 160                 if (service_monitor_list == NULL)
 161                         _bt_register_manager_subscribe_signal(FALSE);
 162         }
 163
 164         return BLUETOOTH_ERROR_NONE;
 165 }
 166
 167 BT_EXPORT_API int bluetooth_gatt_get_service_property(const char *service_handle,
 168                                                 bt_gatt_service_property_t *service)
 169 {
 170         GDBusProxy *properties_proxy = NULL;
 171         GError *error = NULL;
 172         GVariant *result = NULL;
 173         GDBusConnection *g_conn;
 174         gsize len;
 175         char *char_handle = NULL;
 176         GPtrArray *gp_array  = NULL ;
 177         GVariantIter *property_iter, *char_iter = NULL;
 178         const gchar *key;
 179         GVariant *value;
 180
 181         BT_CHECK_PARAMETER(service_handle, return);
 182         BT_CHECK_PARAMETER(service, return);
 183         BT_CHECK_ENABLED(return);
 184
 185         g_conn = _bt_gdbus_get_system_gconn();
 186         retv_if(g_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
 187
 188         properties_proxy = g_dbus_proxy_new_sync(g_conn,
 189                         G_DBUS_PROXY_FLAGS_NONE, NULL,
 190                         BT_BLUEZ_NAME,
 191                         service_handle,
 192                         BT_PROPERTIES_INTERFACE,
 193                         NULL, &error);
 194
 195         retv_if(properties_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
 196
 197         result = g_dbus_proxy_call_sync(properties_proxy,
 198                                 "GetAll",
 199                                 g_variant_new("(s)", GATT_SERV_INTERFACE),
 200                                 G_DBUS_CALL_FLAGS_NONE,
 201                                 -1,
 202                                 NULL,
 203                                 &error);
 204
 205         if (!result) {
 206                 if (error != NULL) {
 207                         BT_ERR("Fail to get properties (Error: %s)", error->message);
 208                         g_clear_error(&error);
 209                 } else
 210                         BT_ERR("Fail to get properties");
 211                 g_object_unref(properties_proxy);
 212                 return BLUETOOTH_ERROR_INTERNAL;
 213         }
 214
 215         g_variant_get(result, "(a{sv})", &property_iter);
 216
 217         memset(service, 0, sizeof(bt_gatt_service_property_t));
 218
 219         while (g_variant_iter_loop(property_iter, "{sv}", &key, &value)) {
 220                 if (!g_strcmp0(key, "UUID")) {
 221                         char *name = NULL;
 222                         service->uuid = g_variant_dup_string(value, &len);
 223                         bluetooth_get_uuid_name(service->uuid, &name);
 224                         BT_INFO("%s %s [%s]", service_handle + 37, service->uuid, name);
 225                         g_free(name);
 226                 } else if (!g_strcmp0(key, "Primary")) {
 227                         service->primary = g_variant_get_boolean(value);
 228
 229                 } else if (!g_strcmp0(key, "Includes")) {
 230                         g_variant_get(value, "ao", &char_iter);
 231                         if (char_iter != NULL) {
 232                                 gp_array = g_ptr_array_new();
 233                                 while (g_variant_iter_loop(char_iter, "&o", &char_handle))
 234                                         g_ptr_array_add(gp_array, (gpointer)char_handle);
 235
 236                                 if (gp_array->len != 0) {
 237                                         service->include_handles.count = gp_array->len;
 238                                         service->include_handles.handle =
 239                                                         __get_string_array_from_gptr_array(gp_array);
 240                                 }
 241                                 g_ptr_array_free(gp_array, TRUE);
 242                                 g_variant_iter_free(char_iter);
 243                         }
 244                 } else if (!g_strcmp0(key, "Characteristics")) {
 245                         g_variant_get(value, "ao", &char_iter);
 246                         if (char_iter != NULL) {
 247                                 gp_array = g_ptr_array_new();
 248                                 while (g_variant_iter_loop(char_iter, "&o", &char_handle))
 249                                         g_ptr_array_add(gp_array, (gpointer)char_handle);
 250
 251                                 if (gp_array->len != 0) {
 252                                         service->char_handle.count = gp_array->len;
 253                                         service->char_handle.handle =
 254                                                         __get_string_array_from_gptr_array(gp_array);
 255                                 }
 256                                 g_ptr_array_free(gp_array, TRUE);
 257                                 g_variant_iter_free(char_iter);
 258                         }
 259                         BT_DBG("Characteristics count : %d", service->char_handle.count);
 260                 }
 261         }
 262
 263         service->handle = g_strdup(service_handle);
 264
 265         g_variant_iter_free(property_iter);
 266         g_variant_unref(result);
 267         g_object_unref(properties_proxy);
 268
 269         return BLUETOOTH_ERROR_NONE;
 270 }
 271
 272 BT_EXPORT_API int bluetooth_gatt_get_primary_services(
 273                 const bluetooth_device_address_t *address,
 274                 bt_gatt_handle_info_t *prim_svc)
 275 {
 276         GVariant *result = NULL;
 277         GVariantIter *iter;
 278         GVariantIter *svc_iter;
 279         GVariantIter *interface_iter;
 280         char *object_path = NULL;
 281         char *interface_str = NULL;
 282         const gchar *key = NULL;
 283         GVariant *value = NULL;
 284         GPtrArray *gp_array  = NULL;
 285         char device_address[BT_ADDRESS_STRING_SIZE] = { 0 };
 286         char temp_address[BT_ADDRESS_STRING_SIZE] = { 0 };
 287         int ret = BLUETOOTH_ERROR_INTERNAL;
 288         int idx = 0;
 289
 290         BT_DBG("+");
 291         BT_CHECK_PARAMETER(address, return);
 292         BT_CHECK_PARAMETER(prim_svc, return);
 293         BT_CHECK_ENABLED(return);
 294
 295         result = _bt_get_managed_objects();
 296         if (result == NULL)
 297                 return ret;
 298
 299         _bt_convert_addr_type_to_string(device_address,
 300                         (unsigned char *)address->addr);
 301
 302         gp_array = g_ptr_array_new();
 303         g_variant_get(result, "(a{oa{sa{sv}}})", &iter);
 304
 305         while (g_variant_iter_loop(iter, "{&oa{sa{sv}}}", &object_path,
 306                         &interface_iter)) {
 307                 if (object_path == NULL)
 308                         continue;
 309
 310                 _bt_convert_device_path_to_address(object_path, temp_address);
 311
 312                 if (g_strcmp0(temp_address, device_address) != 0)
 313                         continue;
 314
 315                 while (g_variant_iter_loop(interface_iter, "{sa{sv}}",
 316                                 &interface_str, &svc_iter)) {
 317                         if (g_strcmp0(interface_str, GATT_SERV_INTERFACE) != 0)
 318                                 continue;
 319
 320                         BT_DBG("[%d] Object Path : %s", idx++, object_path);
 321                         while (g_variant_iter_loop(svc_iter, "{sv}", &key, &value)) {
 322                                 if (g_strcmp0(key, "Primary") == 0) {
 323                                         if (g_variant_get_boolean(value))
 324                                                 g_ptr_array_add(gp_array, (gpointer)object_path);
 325                                 }
 326                         }
 327                 }
 328         }
 329
 330         if (gp_array->len == 0) {
 331                 BT_ERR("gp_array is NULL");
 332                 ret = BLUETOOTH_ERROR_NOT_FOUND;
 333         } else {
 334                 ret = BLUETOOTH_ERROR_NONE;
 335                 prim_svc->count = gp_array->len;
 336                 prim_svc->handle = __get_string_array_from_gptr_array(gp_array);
 337         }
 338
 339         g_ptr_array_free(gp_array, TRUE);
 340         g_variant_iter_free(iter);
 341         g_variant_unref(result);
 342         BT_DBG("-");
 343         return ret;
 344 }
 345
 346 BT_EXPORT_API int bluetooth_gatt_get_service_from_uuid(bluetooth_device_address_t *address,
 347                         const char *service_uuid,
 348                         bt_gatt_service_property_t *service)
 349 {
 350         GVariant *result = NULL;
 351         GVariantIter *iter;
 352         GVariantIter *svc_iter;
 353         GVariantIter *interface_iter;
 354         char *object_path = NULL;
 355         char *interface_str = NULL;
 356         char device_address[BT_ADDRESS_STRING_SIZE] = { 0 };
 357         char temp_address[BT_ADDRESS_STRING_SIZE] = { 0 };
 358         int ret = BLUETOOTH_ERROR_INTERNAL;
 359
 360         BT_CHECK_PARAMETER(address, return);
 361         BT_CHECK_PARAMETER(service_uuid, return);
 362         BT_CHECK_PARAMETER(service, return);
 363         BT_CHECK_ENABLED(return);
 364
 365         result = _bt_get_managed_objects();
 366         if (result == NULL)
 367                 return ret;
 368
 369         _bt_convert_addr_type_to_string(device_address,
 370                                 (unsigned char *)address->addr);
 371
 372         g_variant_get(result, "(a{oa{sa{sv}}})", &iter);
 373
 374         while (g_variant_iter_loop(iter, "{oa{sa{sv}}}", &object_path,
 375                         &interface_iter)) {
 376                 if (object_path == NULL)
 377                         continue;
 378
 379                 _bt_convert_device_path_to_address(object_path,
 380                                 temp_address);
 381
 382                 if (g_strcmp0(temp_address, device_address) != 0)
 383                         continue;
 384
 385                 while (g_variant_iter_loop(interface_iter, "{sa{sv}}",
 386                                 &interface_str, &svc_iter)) {
 387                         if (g_strcmp0(interface_str, GATT_SERV_INTERFACE) != 0)
 388                                 continue;
 389
 390                         BT_DBG("Object Path: %s", object_path);
 391                         ret = bluetooth_gatt_get_service_property(object_path,
 392                                         service);
 393
 394                         if (ret != BLUETOOTH_ERROR_NONE) {
 395                                 BT_ERR("Get service property failed(0x%08x)", ret);
 396                         } else {
 397                                 if (service->primary == TRUE &&
 398                                                 g_strstr_len(service->uuid, -1,
 399                                                                 service_uuid)) {
 400                                         ret = BLUETOOTH_ERROR_NONE;
 401                                         goto done;
 402                                 }
 403                         }
 404                         bluetooth_gatt_free_service_property(service);
 405                 }
 406         }
 407
 408 done:
 409         g_variant_iter_free(iter);
 410         g_variant_unref(result);
 411
 412         return ret;
 413 }
 414
 415 static void __bluetooth_internal_get_char_cb(GDBusProxy *proxy,
 416                 GAsyncResult *res, gpointer user_data)
 417 {
 418         GVariant *value;
 419         GVariant *char_value;
 420         GVariantIter *char_iter;
 421         GPtrArray *gp_array = NULL;
 422         bt_gatt_discovered_char_t svc_char = { 0, };
 423         char *char_handle;
 424         GError *error = NULL;
 425         bt_user_info_t *user_info;
 426
 427         BT_DBG("+");
 428
 429         user_info = _bt_get_user_data(BT_COMMON);
 430         svc_char.service_handle = user_data;
 431
 432         value = g_dbus_proxy_call_finish(proxy, res, &error);
 433
 434         if (value == NULL) {
 435                 if (error != NULL) {
 436                         BT_ERR("Get service characteristics failed\n errCode[%x],"
 437                                         "message[%s]\n", error->code, error->message);
 438                         g_clear_error(&error);
 439                 } else {
 440                         BT_ERR("Get service characteristics failed\n");
 441                 }
 442                 if (user_info) {
 443                         _bt_common_event_cb(BLUETOOTH_EVENT_GATT_SVC_CHAR_DISCOVERED,
 444                                 BLUETOOTH_ERROR_INTERNAL, NULL,
 445                                 user_info->cb, user_info->user_data);
 446                 }
 447                 g_free(svc_char.service_handle);
 448                 g_object_unref(proxy);
 449                 return;
 450         }
 451
 452         g_variant_get(value, "(v)", &char_value);
 453         g_variant_get(char_value, "ao", &char_iter);
 454
 455         gp_array = g_ptr_array_new();
 456         while (g_variant_iter_loop(char_iter, "&o",  &char_handle))
 457                 g_ptr_array_add(gp_array, (gpointer)char_handle);
 458
 459         if (gp_array->len != 0) {
 460                 svc_char.handle_info.count = gp_array->len;
 461                 svc_char.handle_info.handle =
 462                         __get_string_array_from_gptr_array(gp_array);
 463         }
 464         g_ptr_array_free(gp_array, TRUE);
 465
 466         if (user_info) {
 467                 _bt_common_event_cb(BLUETOOTH_EVENT_GATT_SVC_CHAR_DISCOVERED,
 468                         BLUETOOTH_ERROR_NONE, &svc_char,
 469                         user_info->cb, user_info->user_data);
 470         }
 471
 472         g_strfreev(svc_char.handle_info.handle);
 473         g_free(svc_char.service_handle);
 474         g_variant_iter_free(char_iter);
 475         g_variant_unref(value);
 476         g_object_unref(proxy);
 477 }
 478
 479 BT_EXPORT_API int bluetooth_gatt_discover_service_characteristics(
 480                         const char *service_handle)
 481 {
 482         GDBusProxy *properties_proxy = NULL;
 483         GDBusConnection *g_conn;
 484         GError *error = NULL;
 485         char *handle;
 486
 487         BT_DBG("+");
 488
 489         BT_CHECK_PARAMETER(service_handle, return);
 490         BT_CHECK_ENABLED(return);
 491
 492         g_conn = _bt_gdbus_get_system_gconn();
 493         retv_if(g_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
 494
 495         properties_proxy = g_dbus_proxy_new_sync(g_conn,
 496                         G_DBUS_PROXY_FLAGS_NONE, NULL,
 497                         BT_BLUEZ_NAME,
 498                         service_handle,
 499                         BT_PROPERTIES_INTERFACE,
 500                         NULL, &error);
 501
 502         retv_if(properties_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
 503
 504         handle = g_strdup(service_handle);
 505         g_dbus_proxy_call(properties_proxy,
 506                         "Get",
 507                         g_variant_new("(ss)",
 508                                 GATT_SERV_INTERFACE, "Characteristics"),
 509                         G_DBUS_CALL_FLAGS_NONE,
 510                         -1,
 511                         NULL,
 512                         (GAsyncReadyCallback)__bluetooth_internal_get_char_cb,
 513                         (gpointer)handle);
 514
 515         BT_DBG("-");
 516         return BLUETOOTH_ERROR_NONE;
 517 }
 518
 519
 520 static int __get_permission_flag(char *permission)
 521 {
 522         int ret = 0;
 523
 524         retv_if(permission == NULL, ret);
 525
 526         if (!g_strcmp0(permission, "broadcast"))
 527                 ret = BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_BROADCAST;
 528         else if (!g_strcmp0(permission, "read"))
 529                 ret = BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_READ;
 530         else if (!g_strcmp0(permission, "write-without-response"))
 531                 ret = BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_WRITE_NO_RESPONSE;
 532         else if (!g_strcmp0(permission, "write"))
 533                 ret = BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_WRITE;
 534         else if (!g_strcmp0(permission, "notify"))
 535                 ret = BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_NOTIFY;
 536         else if (!g_strcmp0(permission, "indicate"))
 537                 ret = BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_INDICATE;
 538         else if (!g_strcmp0(permission, "authenticated-signed-writes"))
 539                 ret = BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_SIGNED_WRITE;
 540         else if (!g_strcmp0(permission, "reliable-write"))
 541                 ret = BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_RELIABLE_WRITE;
 542         else if (!g_strcmp0(permission, "writable-auxiliaries"))
 543                 ret = BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_WRITABLE_AUXILIARIES;
 544         else if (!g_strcmp0(permission, "encrypt-read"))
 545                 ret = BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_ENCRYPT_READ;
 546         else if (!g_strcmp0(permission, "encrypt-write"))
 547                 ret = BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_ENCRYPT_WRITE;
 548         else if (!g_strcmp0(permission, "encrypt-authenticated-read"))
 549                 ret = BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_ENCRYPT_AUTHENTICATED_READ;
 550         else if (!g_strcmp0(permission, "encrypt-authenticated-write"))
 551                 ret = BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_ENCRYPT_AUTHENTICATED_WRITE;
 552
 553         return ret;
 554 }
 555
 556 static void __convert_permission_flag_to_str(unsigned int permission)
 557 {
 558         char perm[200] = { 0, };
 559
 560         if (permission & BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_BROADCAST)
 561                 g_strlcat(perm, "broadcast ", sizeof(perm));
 562         if (permission & BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_READ)
 563                 g_strlcat(perm, "read ", sizeof(perm));
 564         if (permission & BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_WRITE_NO_RESPONSE)
 565                 g_strlcat(perm, "write-without-response ", sizeof(perm));
 566         if (permission & BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_WRITE)
 567                 g_strlcat(perm, "write ", sizeof(perm));
 568         if (permission & BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_NOTIFY)
 569                 g_strlcat(perm, "notify ", sizeof(perm));
 570         if (permission & BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_INDICATE)
 571                 g_strlcat(perm, "indicate ", sizeof(perm));
 572         if (permission & BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_SIGNED_WRITE)
 573                 g_strlcat(perm, "authenticated-signed-writes ", sizeof(perm));
 574         if (permission & BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_RELIABLE_WRITE)
 575                 g_strlcat(perm, "reliable-write ", sizeof(perm));
 576         if (permission & BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_WRITABLE_AUXILIARIES)
 577                 g_strlcat(perm, "writable-auxiliaries ", sizeof(perm));
 578         if (permission & BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_ENCRYPT_READ)
 579                 g_strlcat(perm, "encrypt-read ", sizeof(perm));
 580         if (permission & BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_ENCRYPT_WRITE)
 581                 g_strlcat(perm, "encrypt-write ", sizeof(perm));
 582         if (permission & BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_ENCRYPT_AUTHENTICATED_READ)
 583                 g_strlcat(perm, "encrypt-authenticated-read ", sizeof(perm));
 584         if (permission & BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_ENCRYPT_AUTHENTICATED_WRITE)
 585                 g_strlcat(perm, "encrypt-authenticated-write ", sizeof(perm));
 586
 587         BT_INFO("permission [0x%04x] : %s\n", permission, perm);
 588         return;
 589 }
 590
 591 BT_EXPORT_API int bluetooth_gatt_get_characteristics_property(
 592                 const char *char_handle, bt_gatt_char_property_t *characteristic)
 593 {
 594         GDBusProxy *properties_proxy = NULL;
 595         GError *error = NULL;
 596         GVariant *value = NULL;
 597         GVariant *result = NULL;
 598         GByteArray *gb_array = NULL;
 599         GPtrArray *gp_array  = NULL ;
 600         GDBusConnection *g_conn;
 601         guint8 char_value;
 602         const gchar *key;
 603         gchar* permission;
 604         char *char_desc_handle = NULL;
 605         gsize len;
 606         GVariantIter *property_iter;
 607         GVariantIter *char_value_iter;
 608         GVariantIter *char_perm_iter;
 609         GVariantIter *char_desc_iter;
 610
 611         BT_CHECK_PARAMETER(char_handle, return);
 612         BT_CHECK_PARAMETER(characteristic, return);
 613
 614         BT_CHECK_ENABLED(return);
 615
 616         g_conn = _bt_gdbus_get_system_gconn();
 617         retv_if(g_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
 618
 619         properties_proxy = g_dbus_proxy_new_sync(g_conn,
 620                         G_DBUS_PROXY_FLAGS_NONE, NULL,
 621                         BT_BLUEZ_NAME,
 622                         char_handle,
 623                         BT_PROPERTIES_INTERFACE,
 624                         NULL, &error);
 625
 626         retv_if(properties_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
 627
 628         result = g_dbus_proxy_call_sync(properties_proxy,
 629                                 "GetAll",
 630                                         g_variant_new("(s)", GATT_CHAR_INTERFACE),
 631                                 G_DBUS_CALL_FLAGS_NONE,
 632                                 -1,
 633                                 NULL,
 634                                 &error);
 635
 636         if (!result) {
 637                 if (error != NULL) {
 638                         BT_ERR("Fail to get properties (Error: %s)", error->message);
 639                         g_clear_error(&error);
 640                 } else
 641                         BT_ERR("Fail to get properties");
 642                 g_object_unref(properties_proxy);
 643                 return BLUETOOTH_ERROR_INTERNAL;
 644         }
 645
 646         g_variant_get(result, "(a{sv})", &property_iter);
 647
 648         memset(characteristic, 0, sizeof(bt_gatt_char_property_t));
 649         characteristic->handle = g_strdup(char_handle);
 650
 651         while (g_variant_iter_loop(property_iter, "{sv}", &key, &value)) {
 652                 if (!g_strcmp0(key, "UUID")) {
 653                         char *name = NULL;
 654                         characteristic->uuid = g_variant_dup_string(value, &len);
 655                         bluetooth_get_uuid_name(characteristic->uuid, &name);
 656                         BT_INFO("%s %s [%s]", char_handle + 37, characteristic->uuid, name);
 657                         g_free(name);
 658                 } else if (!g_strcmp0(key, "Value")) {
 659                         gb_array = g_byte_array_new();
 660                         g_variant_get(value, "ay", &char_value_iter);
 661                         while (g_variant_iter_loop(char_value_iter, "y",  &char_value)) {
 662                         //      BT_DBG("value of char = %d",char_value);
 663                                 g_byte_array_append(gb_array, &char_value, 1);
 664                         }
 665                         g_variant_iter_free(char_value_iter);
 666
 667                         if (gb_array->len != 0) {
 668                                 characteristic->val = g_malloc0(gb_array->len *
 669                                                                 sizeof(unsigned char));
 670                                 memcpy(characteristic->val, gb_array->data, gb_array->len);
 671                         }
 672                         characteristic->val_len = gb_array->len;
 673                         g_byte_array_free(gb_array, TRUE);
 674                 } else if (!g_strcmp0(key, "Flags")) {
 675                         g_variant_get(value, "as", &char_perm_iter);
 676                         characteristic->permission = 0x00;
 677
 678                         while (g_variant_iter_loop(char_perm_iter, "s", &permission))
 679                                 characteristic->permission |= __get_permission_flag(permission);
 680                         __convert_permission_flag_to_str(characteristic->permission);
 681
 682                         g_variant_iter_free(char_perm_iter);
 683                 } else if (!g_strcmp0(key, "Descriptors")) {
 684                         g_variant_get(value, "ao", &char_desc_iter);
 685                         gp_array = g_ptr_array_new();
 686                         while (g_variant_iter_loop(char_desc_iter, "&o", &char_desc_handle))
 687                                 g_ptr_array_add(gp_array, (gpointer)char_desc_handle);
 688
 689                         g_variant_iter_free(char_desc_iter);
 690                         if (gp_array->len != 0) {
 691                                 characteristic->char_desc_handle.count = gp_array->len;
 692                                 characteristic->char_desc_handle.handle =
 693                                                 __get_string_array_from_gptr_array(gp_array);
 694                         }
 695                         g_ptr_array_free(gp_array, TRUE);
 696                 }
 697         }
 698
 699         g_variant_iter_free(property_iter);
 700         g_variant_unref(result);
 701         g_object_unref(properties_proxy);
 702
 703         return BLUETOOTH_ERROR_NONE;
 704 }
 705
 706 void bluetooth_gatt_get_char_from_uuid_cb(GDBusProxy *proxy,
 707                         GAsyncResult *res, gpointer user_data)
 708 {
 709         GVariant *value;
 710         GVariantIter *char_iter;
 711         char *char_handle;
 712         GError *error = NULL;
 713         bt_user_info_t *user_info;
 714         int ret = BLUETOOTH_ERROR_INTERNAL;
 715         bt_gatt_char_property_t characteristic;
 716
 717         user_info = _bt_get_user_data(BT_COMMON);
 718
 719         value = g_dbus_proxy_call_finish(proxy, res, &error);
 720
 721         if (value == NULL) {
 722                 if (error != NULL) {
 723                         BT_ERR("Get service characteristics failed\n errCode[%x],"
 724                                         "message[%s]\n", error->code, error->message);
 725                         g_clear_error(&error);
 726                 } else {
 727                         BT_ERR("Get service characteristics failed\n");
 728                 }
 729                 if (user_info) {
 730                         _bt_common_event_cb(BLUETOOTH_EVENT_GATT_GET_CHAR_FROM_UUID,
 731                                 BLUETOOTH_ERROR_INTERNAL, NULL,
 732                                 user_info->cb, user_info->user_data);
 733                 }
 734                 g_object_unref(proxy);
 735                 g_free(user_data);
 736                 return;
 737         }
 738
 739         g_variant_get(value, "(ao)", &char_iter);
 740
 741         while (g_variant_iter_loop(char_iter, "&o",  &char_handle)) {
 742                 if (!char_handle)
 743                         continue;
 744                 ret = bluetooth_gatt_get_characteristics_property(char_handle,
 745                                 &characteristic);
 746
 747                 if (ret != BLUETOOTH_ERROR_NONE) {
 748                         BT_ERR("Get characteristic property failed(0x%08x)", ret);
 749                 } else {
 750                         if (g_strstr_len(characteristic.uuid, -1, user_data)) {
 751                                 ret = BLUETOOTH_ERROR_NONE;
 752                                 break;
 753                         }
 754                 }
 755                 bluetooth_gatt_free_char_property(&characteristic);
 756         }
 757
 758         if (user_info) {
 759                 _bt_common_event_cb(BLUETOOTH_EVENT_GATT_GET_CHAR_FROM_UUID, ret,
 760                                 &characteristic, user_info->cb, user_info->user_data);
 761         }
 762
 763         bluetooth_gatt_free_char_property(&characteristic);
 764         g_variant_iter_free(char_iter);
 765         g_variant_unref(value);
 766         g_free(user_data);
 767 }
 768
 769 BT_EXPORT_API int bluetooth_gatt_get_char_from_uuid(const char *service_handle,
 770                                                 const char *char_uuid)
 771 {
 772         GDBusProxy *properties_proxy = NULL;
 773         GDBusConnection *g_conn;
 774         GError *error = NULL;
 775         char *uuid;
 776
 777         BT_CHECK_PARAMETER(service_handle, return);
 778         BT_CHECK_PARAMETER(char_uuid, return);
 779         BT_CHECK_ENABLED(return);
 780
 781         g_conn = _bt_gdbus_get_system_gconn();
 782         retv_if(g_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
 783
 784         properties_proxy = g_dbus_proxy_new_sync(g_conn,
 785                         G_DBUS_PROXY_FLAGS_NONE, NULL,
 786                         BT_BLUEZ_NAME,
 787                         service_handle,
 788                         BT_PROPERTIES_INTERFACE,
 789                         NULL, &error);
 790
 791         retv_if(properties_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
 792
 793         uuid = g_strdup(char_uuid);
 794         g_dbus_proxy_call(properties_proxy,
 795                         "Get",
 796                         g_variant_new("(ss)",
 797                                 GATT_SERV_INTERFACE, "Characteristics"),
 798                         G_DBUS_CALL_FLAGS_NONE,
 799                         -1,
 800                         NULL,
 801                         (GAsyncReadyCallback)bluetooth_gatt_get_char_from_uuid_cb,
 802                         (gpointer)uuid);
 803
 804         return BLUETOOTH_ERROR_NONE;
 805 }
 806
 807 BT_EXPORT_API int bluetooth_gatt_get_char_descriptor_property(
 808                 const char *descriptor_handle, bt_gatt_char_descriptor_property_t *descriptor)
 809 {
 810         GDBusProxy *properties_proxy = NULL;
 811         GError *error = NULL;
 812         GDBusConnection *g_conn;
 813         GVariant *result = NULL;
 814         GVariantIter *property_iter;
 815         const gchar *key;
 816         guint8 char_value;
 817         gsize len;
 818         GVariant *value = NULL;
 819         GByteArray *gb_array = NULL;
 820         GVariantIter *desc_value_iter;
 821
 822         BT_CHECK_PARAMETER(descriptor_handle, return);
 823         BT_CHECK_PARAMETER(descriptor, return);
 824
 825         BT_CHECK_ENABLED(return);
 826
 827         g_conn = _bt_gdbus_get_system_gconn();
 828         retv_if(g_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
 829
 830         properties_proxy = g_dbus_proxy_new_sync(g_conn,
 831                         G_DBUS_PROXY_FLAGS_NONE, NULL,
 832                         BT_BLUEZ_NAME,
 833                         descriptor_handle,
 834                         BT_PROPERTIES_INTERFACE,
 835                         NULL, &error);
 836
 837         retv_if(properties_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
 838
 839         result = g_dbus_proxy_call_sync(properties_proxy,
 840                                 "GetAll",
 841                                         g_variant_new("(s)", GATT_DESC_INTERFACE),
 842                                 G_DBUS_CALL_FLAGS_NONE,
 843                                 -1,
 844                                 NULL,
 845                                 &error);
 846
 847         if (!result) {
 848                 if (error != NULL) {
 849                         BT_ERR("Fail to get properties (Error: %s)", error->message);
 850                         g_clear_error(&error);
 851                 } else
 852                         BT_ERR("Fail to get properties");
 853                 g_object_unref(properties_proxy);
 854                 return BLUETOOTH_ERROR_INTERNAL;
 855         }
 856
 857         g_variant_get(result, "(a{sv})", &property_iter);
 858
 859         memset(descriptor, 0, sizeof(bt_gatt_char_descriptor_property_t));
 860         descriptor->handle = g_strdup(descriptor_handle);
 861
 862         while (g_variant_iter_loop(property_iter, "{sv}", &key, &value)) {
 863                 if (!g_strcmp0(key, "UUID")) {
 864                         char *name = NULL;
 865                         descriptor->uuid = g_variant_dup_string(value, &len);
 866                         bluetooth_get_uuid_name(descriptor->uuid, &name);
 867                         BT_INFO("Descriptor : %s [%s]", descriptor->uuid, name);
 868                         g_free(name);
 869                 } else if (!g_strcmp0(key, "Value")) {
 870                         gb_array = g_byte_array_new();
 871                         g_variant_get(value, "ay", &desc_value_iter);
 872                         while (g_variant_iter_loop(desc_value_iter, "y",  &char_value)) {
 873                                 BT_DBG("value of descriptor = %d", char_value);
 874                                 g_byte_array_append(gb_array, &char_value, 1);
 875                         }
 876                         g_variant_iter_free(desc_value_iter);
 877
 878                         if (gb_array->len != 0) {
 879                                 descriptor->val = g_malloc0(gb_array->len *
 880                                                                 sizeof(unsigned char));
 881                                 memcpy(descriptor->val, gb_array->data, gb_array->len);
 882                         }
 883                         descriptor->val_len = gb_array->len;
 884                         g_byte_array_free(gb_array, TRUE);
 885                 }
 886         }
 887
 888         g_variant_iter_free(property_iter);
 889         g_variant_unref(result);
 890         g_object_unref(properties_proxy);
 891
 892         return BLUETOOTH_ERROR_NONE;
 893 }
 894
 895 static int __bluetooth_get_att_error_code(GError *error)
 896 {
 897         int att_ecode = 0;
 898         int len;
 899         char *str = NULL;
 900
 901         BT_ERR("Error : %s", error->message);
 902         str = g_strrstr(error->message, "ATT error: 0x");
 903         if (str) {
 904                 len = strlen(str);
 905                 att_ecode =  g_ascii_xdigit_value(str[len - 2]) << 4;
 906                 att_ecode += g_ascii_xdigit_value(str[len - 1]);
 907         } else
 908                 return BLUETOOTH_ATT_ERROR_INTERNAL;
 909
 910         switch (att_ecode) {
 911         case BLUETOOTH_ATT_ERROR_READ_NOT_PERMITTED:
 912                 BT_ERR("Read not permitted");
 913                 break;
 914         case BLUETOOTH_ATT_ERROR_WRITE_NOT_PERMITTED:
 915                 BT_ERR("Write not permitted");
 916                 break;
 917         case BLUETOOTH_ATT_ERROR_AUTHENTICATION:
 918         case BLUETOOTH_ATT_ERROR_INSUFFICIENT_ENCRYPTION:
 919         case BLUETOOTH_ATT_ERROR_INSUFFICIENT_ENCRYPTION_KEY_SIZE:
 920                 BT_ERR("Not paired");
 921                 break;
 922         case BLUETOOTH_ATT_ERROR_INVALID_OFFSET:
 923                 BT_ERR("Invalid offset");
 924                 break;
 925         case BLUETOOTH_ATT_ERROR_INVALID_ATTRIBUTE_VALUE_LEN:
 926                 BT_ERR("Invalid Length");
 927                 break;
 928         case BLUETOOTH_ATT_ERROR_AUTHORIZATION:
 929                 BT_ERR("Operation not Authorized");
 930                 break;
 931         }
 932
 933         if (att_ecode >= 0x80 && att_ecode <= 0x9F)
 934                 BT_ERR("Application error");
 935
 936         return att_ecode;
 937 }
 938
 939 static void __bluetooth_internal_read_cb(GObject *source_object,
 940                                          GAsyncResult *res, gpointer user_data)
 941 {
 942         GError *error = NULL;
 943         GDBusConnection *system_gconn = NULL;
 944         GVariant *value;
 945         bt_user_info_t *user_info;
 946         GVariantIter *iter;
 947         GByteArray *gp_byte_array = NULL;
 948         guint8 g_byte;
 949         int att_ecode = 0;
 950         bt_gatt_resp_data_t *resp_data = user_data;
 951
 952         BT_DBG("+");
 953
 954         system_gconn = _bt_gdbus_get_system_gconn();
 955         value = g_dbus_connection_call_finish(system_gconn, res, &error);
 956
 957         user_info = _bt_get_user_data(BT_COMMON);
 958         if (!user_info) {
 959                 g_free(resp_data);
 960                 if (error) {
 961                         BT_ERR("Error : %s", error->message);
 962                         g_clear_error(&error);
 963                         return;
 964                 }
 965                 g_variant_unref(value);
 966                 return;
 967         }
 968
 969         if (error) {
 970                 att_ecode = __bluetooth_get_att_error_code(error);
 971                 g_clear_error(&error);
 972
 973                 _bt_common_event_cb(BLUETOOTH_EVENT_GATT_READ_CHAR,
 974                                     att_ecode, resp_data,
 975                                     user_info->cb, user_info->user_data);
 976                 g_free(resp_data);
 977                 return;
 978         }
 979
 980         gp_byte_array = g_byte_array_new();
 981         g_variant_get(value, "(ay)", &iter);
 982
 983         while (g_variant_iter_loop(iter, "y", &g_byte))
 984                 g_byte_array_append(gp_byte_array, &g_byte, 1);
 985
 986         if (gp_byte_array->len != 0) {
 987                 resp_data->len = gp_byte_array->len;
 988                 resp_data->value = gp_byte_array->data;
 989         }
 990
 991         _bt_common_event_cb(BLUETOOTH_EVENT_GATT_READ_CHAR,
 992                             BLUETOOTH_ATT_ERROR_NONE, resp_data,
 993                             user_info->cb, user_info->user_data);
 994         g_free(resp_data);
 995
 996         g_byte_array_free(gp_byte_array, TRUE);
 997         g_variant_iter_free(iter);
 998         g_variant_unref(value);
 999
1000         BT_DBG("-");
1001 }
1002
1003 BT_EXPORT_API int bluetooth_gatt_read_characteristic_value(const char *chr,
1004                                                            gpointer user_data)
1005 {
1006         GDBusConnection *conn;
1007         bt_gatt_resp_data_t *resp_data;
1008         GVariantBuilder *builder = NULL;
1009         guint16 offset = 0;
1010
1011         BT_CHECK_PARAMETER(chr, return);
1012         BT_CHECK_ENABLED(return);
1013
1014         conn = _bt_gdbus_get_system_gconn();
1015         retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
1016
1017         resp_data = g_malloc0(sizeof(bt_gatt_resp_data_t));
1018         resp_data->user_data = user_data;
1019
1020         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
1021
1022         /*offset*/
1023         g_variant_builder_add(builder, "{sv}", "offset",
1024                 g_variant_new("q", offset));
1025
1026         /* Device Object path*/
1027 //      g_variant_builder_add(builder, "{sv}", "device",
1028 //      g_variant_new_object("o", NULL));
1029
1030         g_dbus_connection_call(conn, BT_BLUEZ_NAME, chr, GATT_CHAR_INTERFACE,
1031                         "ReadValue", g_variant_new("(a{sv})", builder),
1032                         G_VARIANT_TYPE("(ay)"), G_DBUS_CALL_FLAGS_NONE, -1, NULL,
1033                         (GAsyncReadyCallback)__bluetooth_internal_read_cb,
1034                         (gpointer)resp_data);
1035         g_variant_builder_unref(builder);
1036
1037         return BLUETOOTH_ERROR_NONE;
1038 }
1039
1040 static void __bluetooth_internal_write_cb(GObject *source_object,
1041                                           GAsyncResult *res, gpointer user_data)
1042 {
1043         GError *error = NULL;
1044         GDBusConnection *system_gconn = NULL;
1045         bt_user_info_t *user_info;
1046         GVariant *value;
1047         int att_ecode = 0;
1048         bt_gatt_resp_data_t *resp_data = user_data;
1049
1050         system_gconn = _bt_gdbus_get_system_gconn();
1051         value = g_dbus_connection_call_finish(system_gconn, res, &error);
1052
1053         user_info = _bt_get_user_data(BT_COMMON);
1054         if (!user_info) {
1055                 g_free(resp_data);
1056                 if (error) {
1057                         BT_ERR("Error : %s", error->message);
1058                         g_clear_error(&error);
1059                         return;
1060                 }
1061                 g_variant_unref(value);
1062                 return;
1063         }
1064
1065         if (error) {
1066                 att_ecode = __bluetooth_get_att_error_code(error);
1067                 g_clear_error(&error);
1068
1069                 _bt_common_event_cb(BLUETOOTH_EVENT_GATT_WRITE_CHAR,
1070                                 att_ecode, resp_data,
1071                                 user_info->cb, user_info->user_data);
1072                 g_free(resp_data);
1073                 return;
1074         }
1075
1076         _bt_common_event_cb(BLUETOOTH_EVENT_GATT_WRITE_CHAR,
1077                         BLUETOOTH_ATT_ERROR_NONE, resp_data,
1078                         user_info->cb, user_info->user_data);
1079         g_free(resp_data);
1080
1081         g_variant_unref(value);
1082         return;
1083 }
1084
1085 BT_EXPORT_API int bluetooth_gatt_set_characteristics_value(
1086                 const char *char_handle, const guint8 *value, int length)
1087 {
1088         GVariant *val, *options;
1089         GVariantBuilder *builder1;
1090         GVariantBuilder *builder2;
1091         GError *error = NULL;
1092         GDBusConnection *conn;
1093         int i = 0;
1094         guint16 offset = 0;
1095
1096         BT_DBG("+");
1097         BT_CHECK_PARAMETER(char_handle, return);
1098         BT_CHECK_PARAMETER(value, return);
1099         retv_if(length == 0, BLUETOOTH_ERROR_INVALID_PARAM);
1100         BT_CHECK_ENABLED(return);
1101
1102         conn = _bt_gdbus_get_system_gconn();
1103         retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
1104
1105         builder1 = g_variant_builder_new(G_VARIANT_TYPE("ay"));
1106         for (i = 0; i < length; i++)
1107                 g_variant_builder_add(builder1, "y", value[i]);
1108
1109         val = g_variant_new("ay", builder1);
1110
1111         builder2 = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
1112         /*offset*/
1113         g_variant_builder_add(builder2, "{sv}", "offset",
1114                                 g_variant_new_uint16(offset));
1115
1116         /* Device Object path*/
1117 //      g_variant_builder_add(builder2, "{sv}", "device",
1118 //      g_variant_new_object("o", NULL));
1119
1120         options = g_variant_new("a{sv}", builder2);
1121
1122         g_dbus_connection_call(conn,
1123                                 BT_BLUEZ_NAME,
1124                                 char_handle,
1125                                 GATT_CHAR_INTERFACE,
1126                                 "WriteValue",
1127                                 g_variant_new("(@ay@a{sv})",
1128                                 val, options),
1129                                 NULL,
1130                                 G_DBUS_CALL_FLAGS_NONE,
1131                                 -1, NULL,
1132                                 (GAsyncReadyCallback)__bluetooth_internal_write_cb,
1133                                 NULL);
1134
1135
1136         if (error) {
1137                 BT_ERR("Set value Failed: %s", error->message);
1138                 g_clear_error(&error);
1139                 g_variant_builder_unref(builder1);
1140                 return BLUETOOTH_ERROR_INTERNAL;
1141         }
1142         g_variant_builder_unref(builder1);
1143         g_variant_builder_unref(builder2);
1144
1145         BT_DBG("-");
1146         return BLUETOOTH_ERROR_NONE;
1147 }
1148
1149 BT_EXPORT_API int bluetooth_gatt_set_characteristics_value_by_type(
1150                         const char *chr, const guint8 *value, int length,
1151                         guint8 write_type, gpointer user_data)
1152 {
1153         GVariant *val, *options;
1154         GVariantBuilder *builder1;
1155         GVariantBuilder *builder2;
1156         GDBusConnection *conn;
1157         guint16 offset = 0;
1158         int i = 0;
1159         int ret = BLUETOOTH_ERROR_NONE;
1160         bt_gatt_resp_data_t *resp_data;
1161
1162         BT_CHECK_PARAMETER(chr, return);
1163         BT_CHECK_PARAMETER(value, return);
1164         retv_if(length == 0, BLUETOOTH_ERROR_INVALID_PARAM);
1165         BT_CHECK_ENABLED_INTERNAL(return);
1166
1167         conn = _bt_gdbus_get_system_gconn();
1168         retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
1169
1170         builder1 = g_variant_builder_new(G_VARIANT_TYPE("ay"));
1171
1172         for (i = 0; i < length; i++)
1173                 g_variant_builder_add(builder1, "y", value[i]);
1174
1175         val = g_variant_new("ay", builder1);
1176
1177         builder2 = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
1178         /*offset*/
1179         g_variant_builder_add(builder2, "{sv}", "offset",
1180                         g_variant_new_uint16(offset));
1181
1182         /* Device Object path*/
1183 //      g_variant_builder_add(builder2, "{sv}", "device",
1184 //      g_variant_new_object("o", NULL));
1185
1186         options = g_variant_new("a{sv}", builder2);
1187
1188         resp_data = g_malloc0(sizeof(bt_gatt_resp_data_t));
1189         resp_data->user_data = user_data;
1190
1191         g_dbus_connection_call(conn, BT_BLUEZ_NAME, chr, GATT_CHAR_INTERFACE,
1192                         "WriteValuebyType",
1193                         g_variant_new("(y@ay@a{sv})", write_type, val, options),
1194                         NULL,
1195                         G_DBUS_CALL_FLAGS_NONE, -1, NULL,
1196                         (GAsyncReadyCallback)__bluetooth_internal_write_cb,
1197                         (gpointer)resp_data);
1198
1199         g_variant_builder_unref(builder1);
1200         g_variant_builder_unref(builder2);
1201
1202         return ret;
1203 }
1204
1205 BT_EXPORT_API int bluetooth_gatt_set_characteristics_value_request(
1206                         const char *char_handle, const guint8 *value, int length)
1207 {
1208         GVariant *val, *options;
1209         GDBusConnection *conn;
1210         GVariantBuilder *builder1;
1211         GVariantBuilder *builder2;
1212         guint offset = 0;
1213         int i;
1214
1215         BT_DBG("+");
1216         BT_CHECK_PARAMETER(char_handle, return);
1217         BT_CHECK_PARAMETER(value, return);
1218         retv_if(length == 0, BLUETOOTH_ERROR_INVALID_PARAM);
1219         BT_CHECK_ENABLED(return);
1220
1221         conn = _bt_gdbus_get_system_gconn();
1222         retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
1223
1224         builder1 = g_variant_builder_new(G_VARIANT_TYPE("ay"));
1225
1226         for (i = 0; i < length; i++) {
1227                 g_variant_builder_add(builder1, "y", value[i]);
1228                 BT_DBG("value [] = %d", value[i]);
1229         }
1230
1231         val = g_variant_new("ay", builder1);
1232
1233         builder2 = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
1234         /*offset*/
1235         g_variant_builder_add(builder2, "{sv}", "offset",
1236                                 g_variant_new_uint16(offset));
1237
1238         /* Device Object path*/
1239 //      g_variant_builder_add(builder2, "{sv}", "device",
1240 //      g_variant_new_object("o", NULL));
1241
1242         options = g_variant_new("a{sv}", builder2);
1243
1244         g_dbus_connection_call(conn,
1245                                 BT_BLUEZ_NAME,
1246                                 char_handle,
1247                                 GATT_CHAR_INTERFACE,
1248                                 "WriteValue",
1249                                 g_variant_new("(@ay@a{sv})",
1250                                 val, options),
1251                                 NULL,
1252                                 G_DBUS_CALL_FLAGS_NONE,
1253                                 -1, NULL,
1254                                 (GAsyncReadyCallback)__bluetooth_internal_write_cb,
1255                                 NULL);
1256
1257         g_variant_builder_unref(builder1);
1258         g_variant_builder_unref(builder2);
1259
1260         BT_DBG("-");
1261         return BLUETOOTH_ERROR_NONE;
1262 }
1263
1264 static int __bluetooth_gatt_descriptor_iter(const char *char_handle,
1265                         bt_gatt_char_property_t *characteristic)
1266 {
1267         BT_DBG("+");
1268         GDBusProxy *properties_proxy = NULL;
1269         GError *error = NULL;
1270         GVariant *value = NULL;
1271         GVariant *result = NULL;
1272         GDBusConnection *g_conn;
1273         int i, ret = BLUETOOTH_ERROR_NONE;
1274         const char *uuid = NULL;
1275         gsize len = 0;
1276         GVariantIter *desc_value_iter, *property_iter;
1277         const gchar *key;
1278         char_descriptor_type_t desc_type = TYPE_NONE;
1279
1280         g_conn = _bt_gdbus_get_system_gconn();
1281         retv_if(g_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
1282
1283         properties_proxy = g_dbus_proxy_new_sync(g_conn,
1284                         G_DBUS_PROXY_FLAGS_NONE, NULL,
1285                         BT_BLUEZ_NAME,
1286                         char_handle,
1287                         BT_PROPERTIES_INTERFACE,
1288                         NULL, &error);
1289
1290         retv_if(properties_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
1291
1292         result = g_dbus_proxy_call_sync(properties_proxy,
1293                                 "GetAll",
1294                                 g_variant_new("(s)", GATT_DESC_INTERFACE),
1295                                 G_DBUS_CALL_FLAGS_NONE,
1296                                 -1,
1297                                 NULL,
1298                                 &error);
1299
1300         if (!result) {
1301                 if (error != NULL) {
1302                         BT_ERR("Fail to get properties (Error: %s)", error->message);
1303                         g_clear_error(&error);
1304                 } else
1305                         BT_ERR("Fail to get properties");
1306                 g_object_unref(properties_proxy);
1307                 return BLUETOOTH_ERROR_INTERNAL;
1308         }
1309         g_variant_get(result, "(a{sv})", &property_iter);
1310         while (g_variant_iter_loop(property_iter, "{sv}", &key, &value)) {
1311                 if (!g_strcmp0(key, "UUID")) {
1312                         uuid = g_variant_get_string(value, &len);
1313                         if (g_strcmp0(uuid, GATT_USER_DESC_UUID) == 0) {
1314                                 BT_DBG("GATT_USER_DESC_UUID");
1315                                 desc_type = USER_DESC;
1316                         } else if (g_strcmp0(uuid, GATT_CHAR_FORMAT) == 0) {
1317                                 BT_DBG("GATT_CHAR_FORMAT");
1318                                 desc_type = CHAR_FORMAT;
1319                         } else if (g_strcmp0(uuid, GATT_CHAR_CLIENT_CONF) == 0) {
1320                                 BT_DBG("GATT_CHAR_CLIENT_CONF");
1321                                 desc_type = CLIENT_CONF;
1322                         } else if (g_strcmp0(uuid, GATT_CHAR_SERVER_CONF) == 0) {
1323                                 BT_DBG("GATT_CHAR_SERVER_CONF");
1324                                 desc_type = SERVER_CONF;
1325                         } else {
1326                                 BT_DBG("descriptor uuid = %s", uuid);
1327                         }
1328                 } else if (!g_strcmp0(key, "Value")) {
1329                         switch (desc_type) {
1330                         case CHAR_FORMAT:
1331                                 BT_DBG("Format descriptor");
1332                                 g_variant_get(value, "(yyqyq)",
1333                                                 &(characteristic->format.format),
1334                                                 &(characteristic->format.exponent),
1335                                                 &(characteristic->format.unit),
1336                                                 &(characteristic->format.name_space),
1337                                                 &(characteristic->format.description));
1338                                 break;
1339                         case USER_DESC:
1340                                 BT_DBG("User descriptor");
1341                                 g_variant_get(value, "ay", &desc_value_iter);
1342                                 len = g_variant_get_size((GVariant *)desc_value_iter);
1343
1344                                 if (len > 0)
1345                                         characteristic->description = (char *)g_malloc0(len + 1);
1346
1347                                 for (i = 0; i < len; i++) {
1348                                         g_variant_iter_loop(desc_value_iter, "y",
1349                                                 &characteristic->description[i]);
1350                                         BT_DBG("description = %s", characteristic->description);
1351                                 }
1352                                 g_variant_iter_free(desc_value_iter);
1353                                 break;
1354                         case CLIENT_CONF:
1355                                 BT_DBG(" CLIENT_CONF");
1356                                 break;
1357                         case SERVER_CONF:
1358                                 BT_DBG(" SERVER_CONF");
1359                                 break;
1360                         default:
1361                                 break;
1362                         }
1363                 }
1364         }
1365
1366         g_variant_iter_free(property_iter);
1367         g_variant_unref(result);
1368         g_object_unref(properties_proxy);
1369
1370         BT_DBG("-");
1371         return ret;
1372 }
1373
1374
1375 static void bluetooth_gatt_get_char_desc_cb(GDBusProxy *proxy,
1376                         GAsyncResult *res, gpointer user_data)
1377 {
1378         BT_DBG("+");
1379         GVariant *value;
1380         GVariant        *char_value;
1381         GVariantIter *char_iter;
1382         char *char_handle;
1383         GError *error = NULL;
1384         bt_user_info_t *user_info;
1385         bt_gatt_char_property_t characteristic = {0, };
1386         int ret = BLUETOOTH_ERROR_INTERNAL;
1387
1388         user_info = _bt_get_user_data(BT_COMMON);
1389
1390         value = g_dbus_proxy_call_finish(proxy, res, &error);
1391         characteristic.handle = user_data;
1392
1393         if (value == NULL) {
1394                 if (error != NULL) {
1395                         BT_ERR("Get characteristic descriptor failed\n errCode[%x],"
1396                                         "message[%s]\n", error->code, error->message);
1397                         g_clear_error(&error);
1398                 } else {
1399                         BT_ERR("Get characteristic descriptor failed\n");
1400                 }
1401                 if (user_info) {
1402                         _bt_common_event_cb(BLUETOOTH_EVENT_GATT_SVC_CHAR_DESC_DISCOVERED,
1403                                 BLUETOOTH_ERROR_INTERNAL, NULL,
1404                                 user_info->cb, user_info->user_data);
1405                 }
1406                 g_free(characteristic.handle);
1407                 g_object_unref(proxy);
1408                 return;
1409         }
1410
1411         g_variant_get(value, "(v)", &char_value);
1412         g_variant_get(char_value, "ao", &char_iter);
1413
1414         while (g_variant_iter_loop(char_iter, "&o",  &char_handle)) {
1415                 BT_DBG("object path of descriptor = %s", char_handle);
1416                 if (char_handle) {
1417                         ret = __bluetooth_gatt_descriptor_iter(char_handle,
1418                                                 &characteristic);
1419                         BT_DBG("Descriptor read status [%d]", ret);
1420                 }
1421         }
1422
1423         if (user_info) {
1424                 _bt_common_event_cb(BLUETOOTH_EVENT_GATT_SVC_CHAR_DESC_DISCOVERED,
1425                                 ret, &characteristic, user_info->cb, user_info->user_data);
1426         }
1427         bluetooth_gatt_free_char_property(&characteristic);
1428
1429         g_free(characteristic.handle);
1430         g_variant_iter_free(char_iter);
1431         g_variant_unref(value);
1432         BT_DBG("-");
1433 }
1434
1435 BT_EXPORT_API int bluetooth_gatt_discover_characteristic_descriptor(
1436                         const char *characteristic_handle)
1437 {
1438         GDBusProxy *properties_proxy = NULL;
1439         GDBusConnection *g_conn;
1440         char *handle;
1441         GError *error = NULL;
1442
1443         BT_CHECK_PARAMETER(characteristic_handle, return);
1444         BT_CHECK_ENABLED(return);
1445
1446         g_conn = _bt_gdbus_get_system_gconn();
1447         retv_if(g_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
1448
1449         properties_proxy = g_dbus_proxy_new_sync(g_conn,
1450                         G_DBUS_PROXY_FLAGS_NONE, NULL,
1451                         BT_BLUEZ_NAME,
1452                         characteristic_handle,
1453                         BT_PROPERTIES_INTERFACE,
1454                         NULL, &error);
1455
1456         retv_if(properties_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
1457
1458         handle = g_strdup(characteristic_handle);
1459         g_dbus_proxy_call(properties_proxy,
1460                         "Get",
1461                         g_variant_new("(ss)",
1462                                 GATT_CHAR_INTERFACE, "Descriptors"),
1463                         G_DBUS_CALL_FLAGS_NONE,
1464                         -1, NULL,
1465                         (GAsyncReadyCallback)bluetooth_gatt_get_char_desc_cb,
1466                         (gpointer)handle);
1467
1468         return BLUETOOTH_ERROR_NONE;
1469 }
1470
1471 static void __bluetooth_internal_read_desc_cb(GObject *source_object,
1472                         GAsyncResult *res,
1473                         gpointer user_data)
1474 {
1475         GError *error = NULL;
1476         GDBusConnection *system_gconn = NULL;
1477         GVariant *value;
1478         bt_user_info_t *user_info;
1479         GByteArray *gp_byte_array = NULL;
1480         GVariantIter *iter;
1481         guint8 g_byte;
1482         int att_ecode = 0;
1483         bt_gatt_resp_data_t *resp_data = user_data;
1484
1485         BT_DBG("+");
1486
1487         system_gconn = _bt_gdbus_get_system_gconn();
1488         value = g_dbus_connection_call_finish(system_gconn, res, &error);
1489
1490         user_info = _bt_get_user_data(BT_COMMON);
1491         if (!user_info) {
1492                 g_free(resp_data);
1493                 if (error) {
1494                         BT_ERR("Error : %s", error->message);
1495                         g_clear_error(&error);
1496                         return;
1497                 }
1498                 g_variant_unref(value);
1499                 return;
1500         }
1501
1502         if (error) {
1503                 att_ecode = __bluetooth_get_att_error_code(error);
1504                 g_clear_error(&error);
1505
1506                 _bt_common_event_cb(BLUETOOTH_EVENT_GATT_READ_DESC,
1507                                 att_ecode, resp_data,
1508                                 user_info->cb, user_info->user_data);
1509                 g_free(resp_data);
1510                 return;
1511         }
1512
1513         gp_byte_array = g_byte_array_new();
1514         g_variant_get(value, "(ay)", &iter);
1515
1516         while (g_variant_iter_loop(iter, "y", &g_byte))
1517                 g_byte_array_append(gp_byte_array, &g_byte, 1);
1518
1519         if (gp_byte_array->len != 0) {
1520                 resp_data->len = gp_byte_array->len;
1521                 resp_data->value = gp_byte_array->data;
1522         }
1523
1524         _bt_common_event_cb(BLUETOOTH_EVENT_GATT_READ_DESC,
1525                         BLUETOOTH_ATT_ERROR_NONE, resp_data,
1526                         user_info->cb, user_info->user_data);
1527         g_free(resp_data);
1528
1529
1530         g_byte_array_free(gp_byte_array, TRUE);
1531         g_variant_iter_free(iter);
1532         g_variant_unref(value);
1533
1534         BT_DBG("-");
1535 }
1536
1537 BT_EXPORT_API int bluetooth_gatt_read_descriptor_value(const char *desc,
1538                                                        gpointer user_data)
1539 {
1540         GDBusConnection *conn;
1541         GVariantBuilder *builder;
1542         guint offset = 0;
1543         bt_gatt_resp_data_t *resp_data;
1544
1545         BT_DBG("+");
1546
1547         BT_CHECK_PARAMETER(desc, return);
1548         BT_CHECK_ENABLED(return);
1549
1550         conn = _bt_gdbus_get_system_gconn();
1551         retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
1552
1553         resp_data = g_malloc0(sizeof(bt_gatt_resp_data_t));
1554         resp_data->user_data = user_data;
1555
1556         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
1557
1558         /*offset*/
1559         g_variant_builder_add(builder, "{sv}", "offset",
1560                                 g_variant_new("q", offset));
1561         /* Device Object path*/
1562 //  g_variant_builder_add(builder, "{sv}", "device",
1563 //  g_variant_new("o", serv_info->serv_path));
1564
1565         g_dbus_connection_call(conn, BT_BLUEZ_NAME, desc, GATT_DESC_INTERFACE,
1566                         "ReadValue", g_variant_new("(a{sv})", builder),
1567                         G_VARIANT_TYPE("(ay)"),
1568                         G_DBUS_CALL_FLAGS_NONE, -1, NULL,
1569                         (GAsyncReadyCallback)__bluetooth_internal_read_desc_cb,
1570                         (gpointer)resp_data);
1571         g_variant_builder_unref(builder);
1572
1573         BT_DBG("-");
1574         return BLUETOOTH_ERROR_NONE;
1575 }
1576
1577 static void __bluetooth_internal_write_desc_cb(GObject *source_object,
1578                                         GAsyncResult *res, gpointer user_data)
1579 {
1580         GError *error = NULL;
1581         bt_user_info_t *user_info;
1582         GDBusConnection *system_gconn = NULL;
1583         GVariant *value;
1584         int att_ecode = BLUETOOTH_ATT_ERROR_NONE;
1585         bt_gatt_resp_data_t *resp_data = user_data;
1586
1587         BT_DBG("+");
1588
1589         system_gconn = _bt_gdbus_get_system_gconn();
1590         value = g_dbus_connection_call_finish(system_gconn, res, &error);
1591
1592         user_info = _bt_get_user_data(BT_COMMON);
1593         if (!user_info) {
1594                 g_free(resp_data);
1595                 if (error) {
1596                         BT_ERR("Error : %s", error->message);
1597                         g_clear_error(&error);
1598                         return;
1599                 }
1600                 g_variant_unref(value);
1601                 return;
1602         }
1603
1604         if (error) {
1605                 att_ecode = __bluetooth_get_att_error_code(error);
1606                 g_clear_error(&error);
1607
1608                 _bt_common_event_cb(BLUETOOTH_EVENT_GATT_WRITE_DESC,
1609                                 att_ecode, resp_data,
1610                                 user_info->cb, user_info->user_data);
1611                 g_free(resp_data);
1612                 return;
1613         }
1614
1615         _bt_common_event_cb(BLUETOOTH_EVENT_GATT_WRITE_DESC,
1616                                 BLUETOOTH_ATT_ERROR_NONE, resp_data,
1617                         user_info->cb, user_info->user_data);
1618         g_free(resp_data);
1619
1620         g_variant_unref(value);
1621         BT_DBG("-");
1622 }
1623
1624 BT_EXPORT_API int bluetooth_gatt_write_descriptor_value(const char *desc,
1625                         const guint8 *value, int length, gpointer user_data)
1626 {
1627         GVariant *val, *options;
1628         GDBusConnection *conn;
1629         GVariantBuilder *builder1;
1630         GVariantBuilder *builder2;
1631         guint offset = 0;
1632         int i;
1633         bt_gatt_resp_data_t *resp_data;
1634
1635         BT_DBG("+");
1636
1637         BT_CHECK_PARAMETER(desc, return);
1638         BT_CHECK_PARAMETER(value, return);
1639         retv_if(length == 0, BLUETOOTH_ERROR_INVALID_PARAM);
1640         BT_CHECK_ENABLED(return);
1641
1642         conn = _bt_gdbus_get_system_gconn();
1643         retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
1644
1645         builder1 = g_variant_builder_new(G_VARIANT_TYPE("ay"));
1646
1647         for (i = 0; i < length; i++)
1648                 g_variant_builder_add(builder1, "y", value[i]);
1649
1650         val = g_variant_new("ay", builder1);
1651
1652         builder2 = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
1653         /*offset*/
1654         g_variant_builder_add(builder2, "{sv}", "offset",
1655                                 g_variant_new_uint16(offset));
1656
1657         /* Device Object path*/
1658 //      g_variant_builder_add(builder2, "{sv}", "device",
1659 //      g_variant_new_object("o", NULL));
1660
1661         options = g_variant_new("a{sv}", builder2);
1662
1663         resp_data = g_malloc0(sizeof(bt_gatt_resp_data_t));
1664         resp_data->user_data = user_data;
1665
1666         g_dbus_connection_call(conn, BT_BLUEZ_NAME, desc, GATT_DESC_INTERFACE,
1667                         "WriteValue", g_variant_new("(@ay@a{sv})",
1668                         val, options), NULL,
1669                         G_DBUS_CALL_FLAGS_NONE, -1, NULL,
1670                         (GAsyncReadyCallback)__bluetooth_internal_write_desc_cb,
1671                         (gpointer)resp_data);
1672
1673         g_variant_builder_unref(builder1);
1674         g_variant_builder_unref(builder2);
1675
1676         BT_DBG("-");
1677         return BLUETOOTH_ERROR_NONE;
1678 }
1679
1680 BT_EXPORT_API int bluetooth_gatt_watch_characteristics(const char *char_handle, const char *svc_name)
1681 {
1682         GDBusConnection *conn;
1683         GError *error = NULL;
1684         int ret = BLUETOOTH_ERROR_NONE;
1685
1686         BT_CHECK_PARAMETER(char_handle, return);
1687         BT_CHECK_ENABLED(return);
1688
1689         BT_INFO_C("### Enable CCCD : %s [%s]", char_handle + 15, svc_name);
1690
1691         conn = _bt_gdbus_get_system_gconn();
1692         retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
1693
1694         g_dbus_connection_call_sync(conn,
1695                         BT_BLUEZ_NAME,
1696                         char_handle,
1697                         GATT_CHAR_INTERFACE,
1698                         "StartNotify",
1699                         NULL,
1700                         NULL,
1701                         G_DBUS_CALL_FLAGS_NONE,
1702                         GATT_DEFAULT_TIMEOUT, NULL, &error);
1703
1704         if (error) {
1705                 g_dbus_error_strip_remote_error(error);
1706                 BT_ERR_C("### Watch Failed: %s", error->message);
1707                 if (g_strrstr(error->message, "Already notifying"))
1708                         ret = BLUETOOTH_ERROR_NONE;
1709                 else if (g_strrstr(error->message, "In Progress"))
1710                         ret = BLUETOOTH_ERROR_IN_PROGRESS;
1711                 else if (g_strrstr(error->message, "Operation is not supported"))
1712                         ret = BLUETOOTH_ERROR_NOT_SUPPORT;
1713 /*failed because of either Insufficient Authorization or Write Not Permitted */
1714                 else if (g_strrstr(error->message, "Write not permitted") ||
1715                                 g_strrstr(error->message, "Operation Not Authorized"))
1716                         ret = BLUETOOTH_ERROR_PERMISSION_DEINED;
1717 /* failed because of either Insufficient Authentication,
1718         Insufficient Encryption Key Size, or Insufficient Encryption. */
1719                 else if (g_strrstr(error->message, "Not paired"))
1720                         ret = BLUETOOTH_ERROR_NOT_PAIRED;
1721                 else
1722                         ret = BLUETOOTH_ERROR_INTERNAL;
1723
1724                 g_clear_error(&error);
1725         }
1726
1727         return ret;
1728 }
1729
1730 BT_EXPORT_API int bluetooth_gatt_unwatch_characteristics(const char *char_handle)
1731 {
1732
1733         GDBusConnection *conn;
1734         GError *error = NULL;
1735         int ret = BLUETOOTH_ERROR_NONE;
1736         BT_CHECK_PARAMETER(char_handle, return);
1737
1738         BT_CHECK_ENABLED(return);
1739
1740         BT_INFO("Disable CCCD : %s", char_handle);
1741
1742         conn = _bt_gdbus_get_system_gconn();
1743         retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
1744
1745         g_dbus_connection_call_sync(conn,
1746                         BT_BLUEZ_NAME,
1747                         char_handle,
1748                         GATT_CHAR_INTERFACE,
1749                         "StopNotify",
1750                         NULL,
1751                         NULL,
1752                         G_DBUS_CALL_FLAGS_NONE,
1753                         GATT_DEFAULT_TIMEOUT, NULL, &error);
1754
1755         if (error) {
1756                 BT_ERR("Watch Failed: %s", error->message);
1757                 g_clear_error(&error);
1758                 ret =  BLUETOOTH_ERROR_INTERNAL;
1759         }
1760
1761         return ret;
1762 }