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_get_system_private_conn(), 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 -> %d", is_le_scanning, 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         _bt_print_api_caller_name();
 105         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_START_LE_DISCOVERY,
 106                 in_param1, in_param2, in_param3, in_param4, &out_param);
 107
 108         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 109
 110         if (result == BLUETOOTH_ERROR_NONE)
 111                 _bt_set_le_scan_status(TRUE);
 112
 113         return result;
 114 }
 115
 116 BT_EXPORT_API int bluetooth_stop_le_discovery(void)
 117 {
 118         int result;
 119
 120         BT_CHECK_ENABLED_ANY(return);
 121
 122         BT_INIT_PARAMS();
 123         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 124
 125         BT_INFO_C("### Stop LE scan");
 126         _bt_print_api_caller_name();
 127         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_STOP_LE_DISCOVERY,
 128                 in_param1, in_param2, in_param3, in_param4, &out_param);
 129
 130         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 131
 132         if (result == BLUETOOTH_ERROR_NONE)
 133                 _bt_set_le_scan_status(FALSE);
 134
 135         return result;
 136 }
 137
 138 BT_EXPORT_API int bluetooth_is_le_discovering(void)
 139 {
 140         int result;
 141         int is_discovering = FALSE;
 142
 143         BT_CHECK_ENABLED_ANY(return);
 144
 145         BT_INIT_PARAMS();
 146         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 147
 148         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_IS_LE_DISCOVERYING,
 149                 in_param1, in_param2, in_param3, in_param4, &out_param);
 150
 151         if (result == BLUETOOTH_ERROR_NONE) {
 152                 is_discovering = g_array_index(out_param,
 153                                 int, 0);
 154         } else {
 155                 BT_ERR("Fail to send request");
 156         }
 157
 158         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 159
 160         return is_discovering;
 161 }
 162
 163 BT_EXPORT_API gboolean bluetooth_is_scan_filter_supported(void)
 164 {
 165         int result;
 166
 167         if (is_scan_filter_supported == -1) {
 168                 BT_INIT_PARAMS();
 169                 BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 170
 171                 result = _bt_send_request(BT_BLUEZ_SERVICE, BT_IS_SCAN_FILTER_SUPPORTED,
 172                         in_param1, in_param2, in_param3, in_param4, &out_param);
 173
 174                 if (result == BLUETOOTH_ERROR_NONE)
 175                         is_scan_filter_supported = g_array_index(out_param, int, 0);
 176                 else
 177                         BT_ERR("Fail to send request");
 178
 179                 BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 180         }
 181
 182         if (is_scan_filter_supported == 1)
 183                 return TRUE;
 184
 185         return FALSE;
 186 }
 187
 188 BT_EXPORT_API int bluetooth_register_scan_filter(bluetooth_le_scan_filter_t *filter, int *slot_id)
 189 {
 190         int result;
 191
 192         BT_CHECK_ENABLED_ANY(return);
 193
 194         BT_INIT_PARAMS();
 195         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 196
 197         g_array_append_vals(in_param1, filter, sizeof(bluetooth_le_scan_filter_t));
 198
 199         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_REGISTER_SCAN_FILTER,
 200                 in_param1, in_param2, in_param3, in_param4, &out_param);
 201
 202         if (result == BLUETOOTH_ERROR_NONE)
 203                 *slot_id = g_array_index(out_param, int, 0);
 204         else
 205                 BT_ERR("Fail to send request");
 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 gboolean __bluetooth_is_privileged_process(void)
 249 {
 250         FILE *fp = NULL;
 251         char path[30] = {0, };
 252         char buf[256] = {0, };
 253
 254         snprintf(path, sizeof(path), "/proc/%d/cmdline", getpid());
 255         fp = fopen(path, "r");
 256         if (fp == NULL)
 257                 return FALSE;
 258
 259         if (fgets(buf, 256, fp) != NULL) {
 260                 if (strstr(buf, "weconnd") != NULL) {
 261                         fclose(fp);
 262                         return TRUE;
 263                 }
 264         }
 265
 266         fclose(fp);
 267         return FALSE;
 268 }
 269
 270 BT_EXPORT_API int bluetooth_set_advertising(int handle, gboolean enable)
 271 {
 272         int result;
 273         gboolean use_reserved_slot = TRUE;
 274
 275         BT_CHECK_ENABLED_ANY(return);
 276
 277         if (TIZEN_PROFILE_WEARABLE)
 278                 use_reserved_slot = __bluetooth_is_privileged_process();
 279
 280         _bt_print_api_caller_name();
 281
 282         BT_INIT_PARAMS();
 283         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 284
 285         g_array_append_vals(in_param1, &handle, sizeof(int));
 286         g_array_append_vals(in_param2, &enable, sizeof(gboolean));
 287         g_array_append_vals(in_param3, &use_reserved_slot, sizeof(gboolean));
 288
 289         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_ADVERTISING,
 290                 in_param1, in_param2, in_param3, in_param4, &out_param);
 291
 292         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 293
 294         return result;
 295 }
 296
 297 BT_EXPORT_API int bluetooth_set_custom_advertising(int handle, gboolean enable,
 298                                                 bluetooth_advertising_params_t *params)
 299 {
 300         int result;
 301         gboolean use_reserved_slot = TRUE;
 302
 303         BT_CHECK_ENABLED_ANY(return);
 304
 305         if (TIZEN_PROFILE_WEARABLE)
 306         use_reserved_slot = __bluetooth_is_privileged_process();
 307
 308         _bt_print_api_caller_name();
 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 = TRUE;
 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         if (TIZEN_PROFILE_WEARABLE)
 366                 use_reserved_slot = __bluetooth_is_privileged_process();
 367
 368         BT_INIT_PARAMS();
 369         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 370
 371         g_array_append_vals(in_param1, &handle, sizeof(int));
 372         g_array_append_vals(in_param2, value, sizeof(bluetooth_advertising_data_t));
 373         g_array_append_vals(in_param3, &length, sizeof(int));
 374         g_array_append_vals(in_param4, &use_reserved_slot, sizeof(gboolean));
 375
 376         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_ADVERTISING_DATA,
 377                 in_param1, in_param2, in_param3, in_param4, &out_param);
 378
 379         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 380
 381         return result;
 382 }
 383
 384 BT_EXPORT_API int bluetooth_get_scan_response_data(bluetooth_scan_resp_data_t *value, int *length)
 385 {
 386         int result;
 387         guint8 *data;
 388
 389         BT_CHECK_PARAMETER(value, return);
 390         BT_CHECK_PARAMETER(length, return);
 391         BT_CHECK_ENABLED_ANY(return);
 392
 393         BT_INIT_PARAMS();
 394         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 395
 396         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_SCAN_RESPONSE_DATA,
 397                 in_param1, in_param2, in_param3, in_param4, &out_param);
 398
 399         if (result == BLUETOOTH_ERROR_NONE) {
 400                 data = &g_array_index(out_param, guint8, 0);
 401                 *length = out_param->len;
 402
 403                 memset(value, 0x00, sizeof(bluetooth_scan_resp_data_t));
 404                 memcpy(value->data, data, *length);
 405         }
 406
 407         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 408
 409         return result;
 410 }
 411
 412 BT_EXPORT_API int bluetooth_set_scan_response_data(int handle,
 413                         const bluetooth_scan_resp_data_t *value, int length)
 414 {
 415         int result;
 416         gboolean use_reserved_slot = TRUE;
 417
 418         BT_CHECK_PARAMETER(value, return);
 419         BT_CHECK_ENABLED_ANY(return);
 420
 421         if (length > BLUETOOTH_SCAN_RESP_DATA_LENGTH_MAX)
 422                 return BLUETOOTH_ERROR_INVALID_PARAM;
 423
 424         if (TIZEN_PROFILE_WEARABLE)
 425                 use_reserved_slot = __bluetooth_is_privileged_process();
 426
 427         BT_INIT_PARAMS();
 428         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 429
 430         g_array_append_vals(in_param1, &handle, sizeof(int));
 431         g_array_append_vals(in_param2, value, length);
 432         g_array_append_vals(in_param3, &length, sizeof(int));
 433         g_array_append_vals(in_param4, &use_reserved_slot, sizeof(gboolean));
 434
 435         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_SCAN_RESPONSE_DATA,
 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_set_scan_parameters(bluetooth_le_scan_params_t *params)
 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         g_array_append_vals(in_param1, params, sizeof(bluetooth_le_scan_params_t));
 453
 454         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_SCAN_PARAMETERS,
 455                 in_param1, in_param2, in_param3, in_param4, &out_param);
 456
 457         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 458
 459         return result;
 460 }
 461
 462 BT_EXPORT_API int bluetooth_set_scan_type(bluetooth_le_scan_type_t scan_type)
 463 {
 464         int result;
 465
 466         BT_CHECK_ENABLED_ANY(return);
 467
 468         BT_INIT_PARAMS();
 469         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 470
 471         g_array_append_vals(in_param1, &scan_type, sizeof(int));
 472
 473         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_SCAN_TYPE,
 474                 in_param1, in_param2, in_param3, in_param4, &out_param);
 475
 476         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 477
 478         return result;
 479 }
 480
 481 BT_EXPORT_API int bluetooth_is_advertising(gboolean *is_advertising)
 482 {
 483         int result;
 484
 485         BT_CHECK_ENABLED_ANY(return);
 486
 487         BT_INIT_PARAMS();
 488         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 489
 490         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_IS_ADVERTISING,
 491                 in_param1, in_param2, in_param3, in_param4, &out_param);
 492
 493         if (result == BLUETOOTH_ERROR_NONE)
 494                 *is_advertising = g_array_index(out_param, int, 0);
 495         else
 496                 BT_ERR("Fail to send request");
 497
 498         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 499
 500         return result;
 501 }
 502
 503 BT_EXPORT_API int bluetooth_add_white_list(bluetooth_device_address_t *address, bluetooth_device_address_type_t address_type)
 504 {
 505         int result;
 506
 507         BT_CHECK_PARAMETER(address, return);
 508         BT_CHECK_ENABLED_ANY(return);
 509
 510         BT_INIT_PARAMS();
 511         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 512
 513         g_array_append_vals(in_param1, address, sizeof(bluetooth_device_address_t));
 514         g_array_append_vals(in_param2, &address_type, sizeof(int));
 515
 516         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_ADD_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_remove_white_list(bluetooth_device_address_t *address, bluetooth_device_address_type_t address_type)
 525 {
 526         int result;
 527
 528         BT_CHECK_PARAMETER(address, return);
 529         BT_CHECK_ENABLED_ANY(return);
 530
 531         BT_INIT_PARAMS();
 532         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 533
 534         g_array_append_vals(in_param1, address, sizeof(bluetooth_device_address_t));
 535         g_array_append_vals(in_param2, &address_type, sizeof(int));
 536
 537         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_REMOVE_WHITE_LIST,
 538                 in_param1, in_param2, in_param3, in_param4, &out_param);
 539
 540         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 541
 542         return result;
 543 }
 544
 545 BT_EXPORT_API int bluetooth_clear_white_list(void)
 546 {
 547         int result;
 548
 549         BT_CHECK_ENABLED_ANY(return);
 550
 551         BT_INIT_PARAMS();
 552         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 553
 554         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_CLEAR_WHITE_LIST,
 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_enable_le_privacy(gboolean enable_privacy)
 563 {
 564         int result;
 565
 566         BT_CHECK_ENABLED_ANY(return);
 567
 568         BT_INIT_PARAMS();
 569         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 570
 571         g_array_append_vals(in_param1, &enable_privacy, sizeof(gboolean));
 572
 573         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_LE_PRIVACY,
 574                 in_param1, in_param2, in_param3, in_param4, &out_param);
 575
 576         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 577
 578         return result;
 579 }
 580
 581 BT_EXPORT_API int bluetooth_set_le_static_random_address(gboolean enable)
 582 {
 583         int result;
 584
 585         BT_CHECK_ENABLED_ANY(return);
 586
 587         BT_INIT_PARAMS();
 588         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 589
 590         g_array_append_vals(in_param1, &enable, sizeof(gboolean));
 591
 592         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_LE_STATIC_RANDOM_ADDRESS,
 593                 in_param1, in_param2, in_param3, in_param4, &out_param);
 594
 595         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 596
 597         return result;
 598 }
 599
 600 BT_EXPORT_API int bluetooth_check_privilege_advertising_parameter(void)
 601 {
 602         if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_SET_ADVERTISING_PARAMETERS)
 603                      == BLUETOOTH_ERROR_PERMISSION_DEINED) {
 604                 BT_ERR("Don't have a privilege to use this API");
 605                 return BLUETOOTH_ERROR_PERMISSION_DEINED;
 606         }
 607
 608         return BLUETOOTH_ERROR_NONE;
 609 }
 610
 611 BT_EXPORT_API int bluetooth_le_register_callback(bluetooth_cb_func_ptr callback_ptr, void *user_data)
 612 {
 613         int ret;
 614
 615         ret = _bt_register_event(BT_LE_ADAPTER_EVENT, (void *)callback_ptr, user_data);
 616         if (ret != BLUETOOTH_ERROR_NONE &&
 617             ret != BLUETOOTH_ERROR_ALREADY_INITIALIZED) {
 618                 BT_ERR("Fail to register BT_LE_ADAPTER_EVENT event : %d", ret);
 619                 return ret;
 620         }
 621
 622         return BLUETOOTH_ERROR_NONE;
 623 }
 624
 625 BT_EXPORT_API int bluetooth_le_unregister_callback(void)
 626 {
 627         _bt_unregister_event(BT_LE_ADAPTER_EVENT);
 628
 629         return BLUETOOTH_ERROR_NONE;
 630 }
 631
 632 BT_EXPORT_API int bluetooth_le_read_maximum_data_length(
 633                         bluetooth_le_read_maximum_data_length_t *max_le_datalength)
 634 {
 635         BT_CHECK_ENABLED_ANY(return);
 636         BT_INIT_PARAMS();
 637         int result;
 638         bluetooth_le_read_maximum_data_length_t *datalength = NULL;
 639
 640         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 641
 642         result = _bt_send_request(BT_BLUEZ_SERVICE,
 643                 BT_LE_READ_MAXIMUM_DATA_LENGTH,
 644                 in_param1, in_param2, in_param3, in_param4, &out_param);
 645
 646         if (result == BLUETOOTH_ERROR_NONE) {
 647                 datalength = &g_array_index(out_param,
 648                         bluetooth_le_read_maximum_data_length_t, 0);
 649                 max_le_datalength->max_tx_octets  = datalength->max_tx_octets;
 650                 max_le_datalength->max_tx_time = datalength->max_tx_time;
 651                 max_le_datalength->max_rx_octets = datalength->max_rx_octets;
 652                 max_le_datalength->max_rx_time = datalength->max_rx_time;
 653         }
 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_write_host_suggested_default_data_length(
 661         const unsigned int def_tx_Octets, const unsigned int def_tx_Time)
 662 {
 663         BT_CHECK_ENABLED_ANY(return);
 664         BT_INIT_PARAMS();
 665
 666         int result;
 667
 668         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 669
 670         g_array_append_vals(in_param1, &def_tx_Octets, sizeof(guint));
 671         g_array_append_vals(in_param2, &def_tx_Time, sizeof(guint));
 672
 673         result = _bt_send_request(BT_BLUEZ_SERVICE,
 674                 BT_LE_WRITE_HOST_SUGGESTED_DATA_LENGTH,
 675                 in_param1, in_param2, in_param3, in_param4, &out_param);
 676
 677         if (result != BLUETOOTH_ERROR_NONE)
 678                 BT_ERR("Failed to Write the host suggested default data length values : %d", result);
 679
 680         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 681
 682         return result;
 683 }
 684
 685 BT_EXPORT_API int bluetooth_le_read_suggested_default_data_length(
 686         bluetooth_le_read_host_suggested_data_length_t *le_data_length)
 687 {
 688         BT_CHECK_ENABLED_ANY(return);
 689         BT_INIT_PARAMS();
 690
 691         int result;
 692         bluetooth_le_read_host_suggested_data_length_t *data_values = NULL;
 693         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 694
 695         result = _bt_send_request(BT_BLUEZ_SERVICE,
 696                 BT_LE_READ_HOST_SUGGESTED_DATA_LENGTH,
 697                 in_param1, in_param2, in_param3, in_param4, &out_param);
 698
 699         if (result == BLUETOOTH_ERROR_NONE) {
 700                 data_values = &g_array_index(out_param,
 701                         bluetooth_le_read_host_suggested_data_length_t, 0);
 702
 703                 le_data_length->def_tx_octets = data_values->def_tx_octets;
 704                 le_data_length->def_tx_time = data_values->def_tx_time;
 705         }
 706
 707         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 708
 709         return result;
 710 }
 711
 712 BT_EXPORT_API int bluetooth_le_set_data_length(bluetooth_device_address_t *address,
 713         const unsigned int max_tx_octets, const unsigned int max_tx_time)
 714 {
 715         BT_CHECK_ENABLED_ANY(return);
 716         BT_INIT_PARAMS();
 717
 718         int result;
 719
 720         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 721
 722         g_array_append_vals(in_param1, address, sizeof(bluetooth_device_address_t));
 723         g_array_append_vals(in_param2, &max_tx_octets, sizeof(guint));
 724         g_array_append_vals(in_param3, &max_tx_time, sizeof(guint));
 725
 726         result = _bt_send_request(BT_BLUEZ_SERVICE,
 727                 BT_LE_SET_DATA_LENGTH,
 728                 in_param1, in_param2, in_param3, in_param4, &out_param);
 729
 730         if (result != BLUETOOTH_ERROR_NONE)
 731                 BT_ERR("Failed to Set data length values : %d", result);
 732
 733         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 734
 735         return result;
 736 }
 737
 738 BT_EXPORT_API int bluetooth_is_le_2m_phy_supported(gboolean *is_supported)
 739 {
 740         int result;
 741
 742         BT_CHECK_PARAMETER(is_supported, return);
 743         BT_CHECK_ENABLED_ANY(return);
 744
 745         BT_INIT_PARAMS();
 746         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 747
 748         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_IS_LE_2M_PHY_SUPPORTED,
 749                         in_param1, in_param2, in_param3, in_param4, &out_param);
 750
 751         if (result == BLUETOOTH_ERROR_NONE) {
 752                 *is_supported = g_array_index(out_param, int, 0);
 753         } else {
 754                 BT_ERR("Fail to send request");
 755         }
 756
 757         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 758
 759         BT_INFO("LE 2M PHY Support[%s]", *is_supported ? "TRUE" : "FALSE");
 760         return result;
 761 }
 762
 763 BT_EXPORT_API int bluetooth_is_le_coded_phy_supported(gboolean *is_supported)
 764 {
 765         int result;
 766
 767         BT_CHECK_PARAMETER(is_supported, return);
 768         BT_CHECK_ENABLED_ANY(return);
 769
 770         BT_INIT_PARAMS();
 771         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 772
 773         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_IS_LE_CODED_PHY_SUPPORTED,
 774                         in_param1, in_param2, in_param3, in_param4, &out_param);
 775
 776         if (result == BLUETOOTH_ERROR_NONE) {
 777                 *is_supported = g_array_index(out_param, int, 0);
 778         } else {
 779                 BT_ERR("Fail to send request");
 780         }
 781
 782         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 783
 784         BT_INFO("LE CODED PHY Support[%s]", *is_supported ? "TRUE" : "FALSE");
 785         return result;
 786 }