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