bt-api/bt-adapter-le.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 <stdio.h>
  19 #include <vconf.h>
  20
  21 #include "bluetooth-api.h"
  22 #include "bt-internal-types.h"
  23
  24 #include "bt-common.h"
  25 #include "bt-request-sender.h"
  26 #include "bt-event-handler.h"
  27
  28 static gboolean is_le_scanning = FALSE;
  29 static int is_scan_filter_supported = -1;
  30
  31 BT_EXPORT_API int bluetooth_check_adapter_le(void)
  32 {
  33         int ret;
  34         int value;
  35
  36         ret = _bt_get_adapter_path(_bt_gdbus_get_system_gconn(), NULL);
  37
  38         if (ret != BLUETOOTH_ERROR_NONE) {
  39                 return BLUETOOTH_ADAPTER_LE_DISABLED;
  40         }
  41
  42         ret = vconf_get_int(VCONFKEY_BT_LE_STATUS, &value);
  43         if (ret != 0) {
  44                 BT_ERR("fail to get vconf key!");
  45                 return ret;
  46         }
  47
  48         BT_DBG("value : %d", value);
  49         return value == VCONFKEY_BT_LE_STATUS_ON ? BLUETOOTH_ADAPTER_LE_ENABLED :
  50                                                 BLUETOOTH_ADAPTER_LE_DISABLED;
  51 }
  52
  53 BT_EXPORT_API int bluetooth_enable_adapter_le(void)
  54 {
  55         int result;
  56
  57         BT_INIT_PARAMS();
  58         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
  59
  60         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_ENABLE_ADAPTER_LE,
  61                 in_param1, in_param2, in_param3, in_param4, &out_param);
  62
  63         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
  64         return result;
  65 }
  66
  67 BT_EXPORT_API int bluetooth_disable_adapter_le(void)
  68 {
  69         int result;
  70         retv_if(bluetooth_check_adapter_le() == BLUETOOTH_ADAPTER_LE_DISABLED,
  71                                 BLUETOOTH_ERROR_DEVICE_NOT_ENABLED);
  72
  73         BT_INIT_PARAMS();
  74         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
  75
  76         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DISABLE_ADAPTER_LE,
  77                 in_param1, in_param2, in_param3, in_param4, &out_param);
  78
  79         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
  80
  81         return result;
  82 }
  83
  84 void _bt_set_le_scan_status(gboolean mode)
  85 {
  86         BT_DBG("set LE scan mode : %d", mode);
  87         is_le_scanning = mode;
  88 }
  89
  90 BT_EXPORT_API gboolean bluetooth_is_le_scanning(void)
  91 {
  92         return is_le_scanning;
  93 }
  94
  95 BT_EXPORT_API int bluetooth_start_le_discovery(void)
  96 {
  97         int result;
  98
  99         BT_CHECK_ENABLED_ANY(return);
 100
 101         BT_INIT_PARAMS();
 102         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 103
 104         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_START_LE_DISCOVERY,
 105                 in_param1, in_param2, in_param3, in_param4, &out_param);
 106
 107         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 108
 109         if (result == BLUETOOTH_ERROR_NONE)
 110                 _bt_set_le_scan_status(TRUE);
 111
 112         return result;
 113 }
 114
 115 BT_EXPORT_API int bluetooth_stop_le_discovery(void)
 116 {
 117         int result;
 118
 119         BT_CHECK_ENABLED_ANY(return);
 120
 121         BT_INIT_PARAMS();
 122         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 123
 124         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_STOP_LE_DISCOVERY,
 125                 in_param1, in_param2, in_param3, in_param4, &out_param);
 126
 127         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 128
 129         if (result == BLUETOOTH_ERROR_NONE)
 130                 _bt_set_le_scan_status(FALSE);
 131
 132         return result;
 133 }
 134
 135 BT_EXPORT_API int bluetooth_is_le_discovering(void)
 136 {
 137         int result;
 138         int is_discovering = FALSE;
 139
 140         BT_CHECK_ENABLED_ANY(return);
 141
 142         BT_INIT_PARAMS();
 143         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 144
 145         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_IS_LE_DISCOVERYING,
 146                 in_param1, in_param2, in_param3, in_param4, &out_param);
 147
 148         if (result == BLUETOOTH_ERROR_NONE) {
 149                 is_discovering = g_array_index(out_param,
 150                                 int, 0);
 151         } else {
 152                 BT_ERR("Fail to send request");
 153         }
 154
 155         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 156
 157         return is_discovering;
 158 }
 159
 160 BT_EXPORT_API gboolean bluetooth_is_scan_filter_supported(void)
 161 {
 162         int result;
 163
 164         if (is_scan_filter_supported == -1) {
 165                 BT_INIT_PARAMS();
 166                 BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 167
 168                 result = _bt_send_request(BT_BLUEZ_SERVICE, BT_IS_SCAN_FILTER_SUPPORTED,
 169                         in_param1, in_param2, in_param3, in_param4, &out_param);
 170
 171                 if (result == BLUETOOTH_ERROR_NONE) {
 172                         is_scan_filter_supported = g_array_index(out_param, int, 0);
 173                 } else {
 174                         BT_ERR("Fail to send request");
 175                 }
 176
 177                 BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 178         }
 179
 180         if (is_scan_filter_supported == 1) {
 181                 return TRUE;
 182         }
 183
 184         return FALSE;
 185 }
 186
 187 BT_EXPORT_API int bluetooth_register_scan_filter(bluetooth_le_scan_filter_t *filter, int *slot_id)
 188 {
 189         int result;
 190
 191         BT_CHECK_ENABLED_ANY(return);
 192
 193         BT_INIT_PARAMS();
 194         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 195
 196         g_array_append_vals(in_param1, filter, sizeof(bluetooth_le_scan_filter_t));
 197
 198         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_REGISTER_SCAN_FILTER,
 199                 in_param1, in_param2, in_param3, in_param4, &out_param);
 200
 201         if (result == BLUETOOTH_ERROR_NONE) {
 202                 *slot_id = g_array_index(out_param, int, 0);
 203         } else {
 204                 BT_ERR("Fail to send request");
 205         }
 206
 207         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 208
 209         return result;
 210 }
 211
 212 BT_EXPORT_API int bluetooth_unregister_scan_filter(int slot_id)
 213 {
 214         int result;
 215
 216         BT_CHECK_ENABLED_ANY(return);
 217
 218         BT_INIT_PARAMS();
 219         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 220
 221         g_array_append_vals(in_param1, &slot_id, sizeof(int));
 222
 223         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_UNREGISTER_SCAN_FILTER,
 224                 in_param1, in_param2, in_param3, in_param4, &out_param);
 225
 226         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 227
 228         return result;
 229 }
 230
 231 BT_EXPORT_API int bluetooth_unregister_all_scan_filters(void)
 232 {
 233         int result;
 234
 235         BT_CHECK_ENABLED_ANY(return);
 236
 237         BT_INIT_PARAMS();
 238         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 239
 240         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_UNREGISTER_ALL_SCAN_FILTERS,
 241                 in_param1, in_param2, in_param3, in_param4, &out_param);
 242
 243         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 244
 245         return result;
 246 }
 247
 248 #ifdef TIZEN_WEARABLE
 249 gboolean __bluetooth_is_privileged_process(void)
 250 {
 251         FILE *fp = NULL;
 252         char path[30] = {0, };
 253         char buf[256] = {0, };
 254
 255         snprintf(path, sizeof(path), "/proc/%d/cmdline", getpid());
 256         fp = fopen(path, "r");
 257         if (fp == NULL)
 258                 return FALSE;
 259
 260         if (fgets(buf, 256, fp) != NULL) {
 261                 if (strstr(buf, "weconnd") != NULL) {
 262                         fclose(fp);
 263                         return TRUE;
 264                 }
 265         }
 266
 267         fclose(fp);
 268         return FALSE;
 269 }
 270 #endif
 271
 272 BT_EXPORT_API int bluetooth_set_advertising(int handle, gboolean enable)
 273 {
 274         int result;
 275         gboolean use_reserved_slot = FALSE;
 276
 277         BT_CHECK_ENABLED_ANY(return);
 278
 279 #ifdef TIZEN_WEARABLE
 280         use_reserved_slot = __bluetooth_is_privileged_process();
 281 #endif
 282
 283         BT_INIT_PARAMS();
 284         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 285
 286         g_array_append_vals(in_param1, &handle, sizeof(int));
 287         g_array_append_vals(in_param2, &enable, sizeof(gboolean));
 288         g_array_append_vals(in_param3, &use_reserved_slot, sizeof(gboolean));
 289
 290         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_ADVERTISING,
 291                 in_param1, in_param2, in_param3, in_param4, &out_param);
 292
 293         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 294
 295         return result;
 296 }
 297
 298 BT_EXPORT_API int bluetooth_set_custom_advertising(int handle, gboolean enable,
 299                                                 bluetooth_advertising_params_t *params)
 300 {
 301         int result;
 302         gboolean use_reserved_slot = FALSE;
 303
 304         BT_CHECK_ENABLED_ANY(return);
 305
 306 #ifdef TIZEN_WEARABLE
 307         use_reserved_slot = __bluetooth_is_privileged_process();
 308 #endif
 309
 310         BT_INIT_PARAMS();
 311         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 312
 313         g_array_append_vals(in_param1, &handle, sizeof(int));
 314         g_array_append_vals(in_param2, &enable, sizeof(gboolean));
 315         g_array_append_vals(in_param3, params, sizeof(bluetooth_advertising_params_t));
 316         g_array_append_vals(in_param4, &use_reserved_slot, sizeof(gboolean));
 317
 318         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_CUSTOM_ADVERTISING,
 319                 in_param1, in_param2, in_param3, in_param4, &out_param);
 320
 321         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 322
 323         return result;
 324 }
 325
 326 BT_EXPORT_API int bluetooth_get_advertising_data(bluetooth_advertising_data_t *adv_data, int *length)
 327 {
 328         int result;
 329         guint8 *data;
 330
 331         BT_CHECK_PARAMETER(adv_data, return);
 332         BT_CHECK_PARAMETER(length, return);
 333         BT_CHECK_ENABLED_ANY(return);
 334
 335         BT_INIT_PARAMS();
 336         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 337
 338         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_ADVERTISING_DATA,
 339                 in_param1, in_param2, in_param3, in_param4, &out_param);
 340
 341         if (result == BLUETOOTH_ERROR_NONE) {
 342                 data = &g_array_index(out_param, guint8, 0);
 343                 *length = out_param->len;
 344
 345                 memset(adv_data, 0x00, sizeof(bluetooth_advertising_data_t));
 346                 memcpy(adv_data->data, data, *length);
 347         }
 348
 349         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 350
 351         return result;
 352 }
 353
 354 BT_EXPORT_API int bluetooth_set_advertising_data(int handle, const bluetooth_advertising_data_t *value, int length)
 355 {
 356         int result;
 357         gboolean use_reserved_slot = FALSE;
 358
 359         BT_CHECK_PARAMETER(value, return);
 360         BT_CHECK_ENABLED_ANY(return);
 361
 362         if (length > BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX - 3)
 363                 return BLUETOOTH_ERROR_INVALID_PARAM;
 364
 365 #ifdef TIZEN_WEARABLE
 366         use_reserved_slot = __bluetooth_is_privileged_process();
 367 #endif
 368
 369         BT_INIT_PARAMS();
 370         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 371
 372         g_array_append_vals(in_param1, &handle, sizeof(int));
 373         g_array_append_vals(in_param2, value, sizeof(bluetooth_advertising_data_t));
 374         g_array_append_vals(in_param3, &length, sizeof(int));
 375         g_array_append_vals(in_param4, &use_reserved_slot, sizeof(gboolean));
 376
 377         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_ADVERTISING_DATA,
 378                 in_param1, in_param2, in_param3, in_param4, &out_param);
 379
 380         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 381
 382         return result;
 383 }
 384
 385 BT_EXPORT_API int bluetooth_get_scan_response_data(bluetooth_scan_resp_data_t *value, int *length)
 386 {
 387         int result;
 388         guint8 *data;
 389
 390         BT_CHECK_PARAMETER(value, return);
 391         BT_CHECK_PARAMETER(length, return);
 392         BT_CHECK_ENABLED_ANY(return);
 393
 394         BT_INIT_PARAMS();
 395         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 396
 397         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_SCAN_RESPONSE_DATA,
 398                 in_param1, in_param2, in_param3, in_param4, &out_param);
 399
 400         if (result == BLUETOOTH_ERROR_NONE) {
 401                 data = &g_array_index(out_param, guint8, 0);
 402                 *length = out_param->len;
 403
 404                 memset(value, 0x00, sizeof(bluetooth_scan_resp_data_t));
 405                 memcpy(value->data, data, *length);
 406         }
 407
 408         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 409
 410         return result;
 411 }
 412
 413 BT_EXPORT_API int bluetooth_set_scan_response_data(int handle,
 414                         const bluetooth_scan_resp_data_t *value, int length)
 415 {
 416         int result;
 417         gboolean use_reserved_slot = FALSE;
 418
 419         BT_CHECK_PARAMETER(value, return);
 420         BT_CHECK_ENABLED_ANY(return);
 421
 422         if (length > BLUETOOTH_SCAN_RESP_DATA_LENGTH_MAX)
 423                 return BLUETOOTH_ERROR_INVALID_PARAM;
 424
 425 #ifdef TIZEN_WEARABLE
 426         use_reserved_slot = __bluetooth_is_privileged_process();
 427 #endif
 428
 429         BT_INIT_PARAMS();
 430         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 431
 432         g_array_append_vals(in_param1, &handle, sizeof(int));
 433         g_array_append_vals(in_param2, value, length);
 434         g_array_append_vals(in_param3, &length, sizeof(int));
 435         g_array_append_vals(in_param4, &use_reserved_slot, sizeof(gboolean));
 436
 437         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_SCAN_RESPONSE_DATA,
 438                 in_param1, in_param2, in_param3, in_param4, &out_param);
 439
 440         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 441
 442         return result;
 443 }
 444
 445 BT_EXPORT_API int bluetooth_set_scan_parameters(bluetooth_le_scan_params_t *params)
 446 {
 447         int result;
 448
 449         BT_CHECK_ENABLED_ANY(return);
 450
 451         BT_INIT_PARAMS();
 452         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 453
 454         g_array_append_vals(in_param1, params, sizeof(bluetooth_le_scan_params_t));
 455
 456         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_SCAN_PARAMETERS,
 457                 in_param1, in_param2, in_param3, in_param4, &out_param);
 458
 459         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 460
 461         return result;
 462 }
 463
 464 BT_EXPORT_API int bluetooth_is_advertising(gboolean *is_advertising)
 465 {
 466         int result;
 467
 468         BT_CHECK_ENABLED_ANY(return);
 469
 470         BT_INIT_PARAMS();
 471         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 472
 473         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_IS_ADVERTISING,
 474                 in_param1, in_param2, in_param3, in_param4, &out_param);
 475
 476         if (result == BLUETOOTH_ERROR_NONE) {
 477                 *is_advertising = g_array_index(out_param, int, 0);
 478         } else {
 479                 BT_ERR("Fail to send request");
 480         }
 481
 482         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 483
 484         return result;
 485 }
 486
 487 BT_EXPORT_API int bluetooth_add_white_list(bluetooth_device_address_t *address, bluetooth_device_address_type_t address_type)
 488 {
 489         int result;
 490
 491         BT_CHECK_PARAMETER(address, return);
 492         BT_CHECK_ENABLED_ANY(return);
 493
 494         BT_INIT_PARAMS();
 495         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 496
 497         g_array_append_vals(in_param1, address, sizeof(bluetooth_device_address_t));
 498         g_array_append_vals(in_param2, &address_type, sizeof(int));
 499
 500         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_ADD_WHITE_LIST,
 501                 in_param1, in_param2, in_param3, in_param4, &out_param);
 502
 503         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 504
 505         return result;
 506 }
 507
 508 BT_EXPORT_API int bluetooth_remove_white_list(bluetooth_device_address_t *address, bluetooth_device_address_type_t address_type)
 509 {
 510         int result;
 511
 512         BT_CHECK_PARAMETER(address, return);
 513         BT_CHECK_ENABLED_ANY(return);
 514
 515         BT_INIT_PARAMS();
 516         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 517
 518         g_array_append_vals(in_param1, address, sizeof(bluetooth_device_address_t));
 519         g_array_append_vals(in_param2, &address_type, sizeof(int));
 520
 521         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_REMOVE_WHITE_LIST,
 522                 in_param1, in_param2, in_param3, in_param4, &out_param);
 523
 524         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 525
 526         return result;
 527 }
 528
 529 BT_EXPORT_API int bluetooth_clear_white_list(void)
 530 {
 531         int result;
 532
 533         BT_CHECK_ENABLED_ANY(return);
 534
 535         BT_INIT_PARAMS();
 536         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 537
 538         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_CLEAR_WHITE_LIST,
 539                 in_param1, in_param2, in_param3, in_param4, &out_param);
 540
 541         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 542
 543         return result;
 544 }
 545
 546 BT_EXPORT_API int bluetooth_enable_le_privacy(gboolean enable_privacy)
 547 {
 548         int result;
 549
 550         BT_CHECK_ENABLED_ANY(return);
 551
 552         BT_INIT_PARAMS();
 553         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 554
 555         g_array_append_vals(in_param1, &enable_privacy, sizeof(gboolean));
 556
 557         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_LE_PRIVACY,
 558                 in_param1, in_param2, in_param3, in_param4, &out_param);
 559
 560         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 561
 562         return result;
 563 }
 564
 565 BT_EXPORT_API int bluetooth_set_le_static_random_address(gboolean enable)
 566 {
 567         int result;
 568
 569         BT_CHECK_ENABLED_ANY(return);
 570
 571         BT_INIT_PARAMS();
 572         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 573
 574         g_array_append_vals(in_param1, &enable, sizeof(gboolean));
 575
 576         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_LE_STATIC_RANDOM_ADDRESS,
 577                 in_param1, in_param2, in_param3, in_param4, &out_param);
 578
 579         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 580
 581         return result;
 582 }
 583
 584 BT_EXPORT_API int bluetooth_check_privilege_advertising_parameter(void)
 585 {
 586         if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_SET_ADVERTISING_PARAMETERS)
 587                      == BLUETOOTH_ERROR_PERMISSION_DEINED) {
 588                 BT_ERR("Don't have a privilege to use this API");
 589                 return BLUETOOTH_ERROR_PERMISSION_DEINED;
 590         }
 591
 592         return BLUETOOTH_ERROR_NONE;
 593 }
 594
 595 BT_EXPORT_API int bluetooth_le_register_callback(bluetooth_cb_func_ptr callback_ptr, void *user_data)
 596 {
 597         int ret;
 598
 599         ret = _bt_register_event(BT_LE_ADAPTER_EVENT, (void *)callback_ptr, user_data);
 600         if (ret != BLUETOOTH_ERROR_NONE &&
 601             ret != BLUETOOTH_ERROR_ALREADY_INITIALIZED) {
 602                 BT_ERR("Fail to register BT_LE_ADAPTER_EVENT event : %d", ret);
 603                 return ret;
 604         }
 605
 606         return BLUETOOTH_ERROR_NONE;
 607 }
 608
 609 BT_EXPORT_API int bluetooth_le_unregister_callback(void)
 610 {
 611         _bt_unregister_event(BT_LE_ADAPTER_EVENT);
 612
 613         return BLUETOOTH_ERROR_NONE;
 614 }
 615
 616 BT_EXPORT_API int bluetooth_le_read_maximum_data_length(
 617                         bluetooth_le_read_maximum_data_length_t *max_le_datalength)
 618 {
 619         BT_CHECK_ENABLED_ANY(return);
 620         BT_INIT_PARAMS();
 621         int result;
 622         bluetooth_le_read_maximum_data_length_t *datalength = NULL;
 623
 624         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 625
 626         result = _bt_send_request(BT_BLUEZ_SERVICE,
 627                 BT_LE_READ_MAXIMUM_DATA_LENGTH,
 628                 in_param1, in_param2, in_param3, in_param4, &out_param);
 629
 630         if (result == BLUETOOTH_ERROR_NONE) {
 631                 datalength = &g_array_index(out_param,
 632                         bluetooth_le_read_maximum_data_length_t, 0);
 633                 max_le_datalength->max_tx_octets  = datalength->max_tx_octets;
 634                 max_le_datalength->max_tx_time = datalength->max_tx_time;
 635                 max_le_datalength->max_rx_octets = datalength->max_rx_octets;
 636                 max_le_datalength->max_rx_time = datalength->max_rx_time;
 637         }
 638
 639         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 640
 641         return result;
 642 }
 643
 644 BT_EXPORT_API int bluetooth_le_write_host_suggested_default_data_length(
 645         const unsigned int def_tx_Octets, const unsigned int def_tx_Time)
 646 {
 647         BT_CHECK_ENABLED_ANY(return);
 648         BT_INIT_PARAMS();
 649
 650         int result;
 651
 652         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 653
 654         g_array_append_vals(in_param1, &def_tx_Octets, sizeof(guint));
 655         g_array_append_vals(in_param2, &def_tx_Time, sizeof(guint));
 656
 657         result = _bt_send_request(BT_BLUEZ_SERVICE,
 658                 BT_LE_WRITE_HOST_SUGGESTED_DATA_LENGTH,
 659                 in_param1, in_param2, in_param3, in_param4, &out_param);
 660
 661         if (result != BLUETOOTH_ERROR_NONE) {
 662                 BT_ERR("Failed to Write the host suggested default data length values : %d", result);
 663         }
 664
 665         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 666
 667         return result;
 668 }
 669
 670 BT_EXPORT_API int bluetooth_le_read_suggested_default_data_length(
 671         bluetooth_le_read_host_suggested_data_length_t *le_data_length)
 672 {
 673         BT_CHECK_ENABLED_ANY(return);
 674         BT_INIT_PARAMS();
 675
 676         int result;
 677         bluetooth_le_read_host_suggested_data_length_t *data_values = NULL;
 678         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 679
 680         result = _bt_send_request(BT_BLUEZ_SERVICE,
 681                 BT_LE_READ_HOST_SUGGESTED_DATA_LENGTH,
 682                 in_param1, in_param2, in_param3, in_param4, &out_param);
 683
 684         if (result == BLUETOOTH_ERROR_NONE) {
 685                 data_values = &g_array_index(out_param,
 686                         bluetooth_le_read_host_suggested_data_length_t, 0);
 687
 688                 le_data_length->def_tx_octets = data_values->def_tx_octets;
 689                 le_data_length->def_tx_time = data_values->def_tx_time;
 690         }
 691
 692         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 693
 694         return result;
 695 }
 696
 697 BT_EXPORT_API int bluetooth_le_set_data_length(bluetooth_device_address_t *address,
 698         const unsigned int max_tx_octets, const unsigned int max_tx_time)
 699 {
 700         BT_CHECK_ENABLED_ANY(return);
 701         BT_INIT_PARAMS();
 702
 703         int result;
 704
 705         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 706
 707         g_array_append_vals(in_param1, address, sizeof(bluetooth_device_address_t));
 708         g_array_append_vals(in_param2, &max_tx_octets, sizeof(guint));
 709         g_array_append_vals(in_param3, &max_tx_time, sizeof(guint));
 710
 711         result = _bt_send_request(BT_BLUEZ_SERVICE,
 712                 BT_LE_SET_DATA_LENGTH,
 713                 in_param1, in_param2, in_param3, in_param4, &out_param);
 714
 715         if (result != BLUETOOTH_ERROR_NONE) {
 716                 BT_ERR("Failed to Set data length values : %d", result);
 717         }
 718
 719         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 720
 721         return result;
 722 }