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