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