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 #ifdef TIZEN_PROFILE_WEARABLE
 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 #endif
 269
 270 BT_EXPORT_API int bluetooth_set_advertising(int handle, gboolean enable)
 271 {
 272         int result;
 273         gboolean use_reserved_slot = FALSE;
 274
 275         BT_CHECK_ENABLED_ANY(return);
 276
 277 #ifdef TIZEN_PROFILE_WEARABLE
 278         use_reserved_slot = __bluetooth_is_privileged_process();
 279 #endif
 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 = FALSE;
 301
 302         BT_CHECK_ENABLED_ANY(return);
 303
 304 #ifdef TIZEN_PROFILE_WEARABLE
 305         use_reserved_slot = __bluetooth_is_privileged_process();
 306 #endif
 307
 308         BT_INIT_PARAMS();
 309         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 310
 311         g_array_append_vals(in_param1, &handle, sizeof(int));
 312         g_array_append_vals(in_param2, &enable, sizeof(gboolean));
 313         g_array_append_vals(in_param3, params, sizeof(bluetooth_advertising_params_t));
 314         g_array_append_vals(in_param4, &use_reserved_slot, sizeof(gboolean));
 315
 316         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_CUSTOM_ADVERTISING,
 317                 in_param1, in_param2, in_param3, in_param4, &out_param);
 318
 319         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 320
 321         return result;
 322 }
 323
 324 BT_EXPORT_API int bluetooth_get_advertising_data(bluetooth_advertising_data_t *adv_data, int *length)
 325 {
 326         int result;
 327         guint8 *data;
 328
 329         BT_CHECK_PARAMETER(adv_data, return);
 330         BT_CHECK_PARAMETER(length, return);
 331         BT_CHECK_ENABLED_ANY(return);
 332
 333         BT_INIT_PARAMS();
 334         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 335
 336         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_ADVERTISING_DATA,
 337                 in_param1, in_param2, in_param3, in_param4, &out_param);
 338
 339         if (result == BLUETOOTH_ERROR_NONE) {
 340                 data = &g_array_index(out_param, guint8, 0);
 341                 *length = out_param->len;
 342
 343                 memset(adv_data, 0x00, sizeof(bluetooth_advertising_data_t));
 344                 memcpy(adv_data->data, data, *length);
 345         }
 346
 347         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 348
 349         return result;
 350 }
 351
 352 BT_EXPORT_API int bluetooth_set_advertising_data(int handle, const bluetooth_advertising_data_t *value, int length)
 353 {
 354         int result;
 355         gboolean use_reserved_slot = FALSE;
 356
 357         BT_CHECK_PARAMETER(value, return);
 358         BT_CHECK_ENABLED_ANY(return);
 359
 360         if (length > BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX - 3)
 361                 return BLUETOOTH_ERROR_INVALID_PARAM;
 362
 363 #ifdef TIZEN_PROFILE_WEARABLE
 364         use_reserved_slot = __bluetooth_is_privileged_process();
 365 #endif
 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 = FALSE;
 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 #ifdef TIZEN_PROFILE_WEARABLE
 424         use_reserved_slot = __bluetooth_is_privileged_process();
 425 #endif
 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_is_advertising(gboolean *is_advertising)
 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         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_IS_ADVERTISING,
 472                 in_param1, in_param2, in_param3, in_param4, &out_param);
 473
 474         if (result == BLUETOOTH_ERROR_NONE)
 475                 *is_advertising = g_array_index(out_param, int, 0);
 476         else
 477                 BT_ERR("Fail to send request");
 478
 479         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 480
 481         return result;
 482 }
 483
 484 BT_EXPORT_API int bluetooth_add_white_list(bluetooth_device_address_t *address, bluetooth_device_address_type_t address_type)
 485 {
 486         int result;
 487
 488         BT_CHECK_PARAMETER(address, return);
 489         BT_CHECK_ENABLED_ANY(return);
 490
 491         BT_INIT_PARAMS();
 492         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 493
 494         g_array_append_vals(in_param1, address, sizeof(bluetooth_device_address_t));
 495         g_array_append_vals(in_param2, &address_type, sizeof(int));
 496
 497         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_ADD_WHITE_LIST,
 498                 in_param1, in_param2, in_param3, in_param4, &out_param);
 499
 500         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 501
 502         return result;
 503 }
 504
 505 BT_EXPORT_API int bluetooth_remove_white_list(bluetooth_device_address_t *address, bluetooth_device_address_type_t address_type)
 506 {
 507         int result;
 508
 509         BT_CHECK_PARAMETER(address, return);
 510         BT_CHECK_ENABLED_ANY(return);
 511
 512         BT_INIT_PARAMS();
 513         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 514
 515         g_array_append_vals(in_param1, address, sizeof(bluetooth_device_address_t));
 516         g_array_append_vals(in_param2, &address_type, sizeof(int));
 517
 518         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_REMOVE_WHITE_LIST,
 519                 in_param1, in_param2, in_param3, in_param4, &out_param);
 520
 521         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 522
 523         return result;
 524 }
 525
 526 BT_EXPORT_API int bluetooth_clear_white_list(void)
 527 {
 528         int result;
 529
 530         BT_CHECK_ENABLED_ANY(return);
 531
 532         BT_INIT_PARAMS();
 533         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 534
 535         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_CLEAR_WHITE_LIST,
 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_enable_le_privacy(gboolean enable_privacy)
 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_privacy, sizeof(gboolean));
 553
 554         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_LE_PRIVACY,
 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_set_le_static_random_address(gboolean enable)
 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, sizeof(gboolean));
 572
 573         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_LE_STATIC_RANDOM_ADDRESS,
 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_check_privilege_advertising_parameter(void)
 582 {
 583         if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_SET_ADVERTISING_PARAMETERS)
 584                      == BLUETOOTH_ERROR_PERMISSION_DEINED) {
 585                 BT_ERR("Don't have a privilege to use this API");
 586                 return BLUETOOTH_ERROR_PERMISSION_DEINED;
 587         }
 588
 589         return BLUETOOTH_ERROR_NONE;
 590 }
 591
 592 BT_EXPORT_API int bluetooth_le_register_callback(bluetooth_cb_func_ptr callback_ptr, void *user_data)
 593 {
 594         int ret;
 595
 596         ret = _bt_register_event(BT_LE_ADAPTER_EVENT, (void *)callback_ptr, user_data);
 597         if (ret != BLUETOOTH_ERROR_NONE &&
 598             ret != BLUETOOTH_ERROR_ALREADY_INITIALIZED) {
 599                 BT_ERR("Fail to register BT_LE_ADAPTER_EVENT event : %d", ret);
 600                 return ret;
 601         }
 602
 603         return BLUETOOTH_ERROR_NONE;
 604 }
 605
 606 BT_EXPORT_API int bluetooth_le_unregister_callback(void)
 607 {
 608         _bt_unregister_event(BT_LE_ADAPTER_EVENT);
 609
 610         return BLUETOOTH_ERROR_NONE;
 611 }
 612
 613 BT_EXPORT_API int bluetooth_le_read_maximum_data_length(
 614                         bluetooth_le_read_maximum_data_length_t *max_le_datalength)
 615 {
 616         BT_CHECK_ENABLED_ANY(return);
 617         BT_INIT_PARAMS();
 618         int result;
 619         bluetooth_le_read_maximum_data_length_t *datalength = NULL;
 620
 621         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 622
 623         result = _bt_send_request(BT_BLUEZ_SERVICE,
 624                 BT_LE_READ_MAXIMUM_DATA_LENGTH,
 625                 in_param1, in_param2, in_param3, in_param4, &out_param);
 626
 627         if (result == BLUETOOTH_ERROR_NONE) {
 628                 datalength = &g_array_index(out_param,
 629                         bluetooth_le_read_maximum_data_length_t, 0);
 630                 max_le_datalength->max_tx_octets  = datalength->max_tx_octets;
 631                 max_le_datalength->max_tx_time = datalength->max_tx_time;
 632                 max_le_datalength->max_rx_octets = datalength->max_rx_octets;
 633                 max_le_datalength->max_rx_time = datalength->max_rx_time;
 634         }
 635
 636         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 637
 638         return result;
 639 }
 640
 641 BT_EXPORT_API int bluetooth_le_write_host_suggested_default_data_length(
 642         const unsigned int def_tx_Octets, const unsigned int def_tx_Time)
 643 {
 644         BT_CHECK_ENABLED_ANY(return);
 645         BT_INIT_PARAMS();
 646
 647         int result;
 648
 649         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 650
 651         g_array_append_vals(in_param1, &def_tx_Octets, sizeof(guint));
 652         g_array_append_vals(in_param2, &def_tx_Time, sizeof(guint));
 653
 654         result = _bt_send_request(BT_BLUEZ_SERVICE,
 655                 BT_LE_WRITE_HOST_SUGGESTED_DATA_LENGTH,
 656                 in_param1, in_param2, in_param3, in_param4, &out_param);
 657
 658         if (result != BLUETOOTH_ERROR_NONE)
 659                 BT_ERR("Failed to Write the host suggested default data length values : %d", result);
 660
 661         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 662
 663         return result;
 664 }
 665
 666 BT_EXPORT_API int bluetooth_le_read_suggested_default_data_length(
 667         bluetooth_le_read_host_suggested_data_length_t *le_data_length)
 668 {
 669         BT_CHECK_ENABLED_ANY(return);
 670         BT_INIT_PARAMS();
 671
 672         int result;
 673         bluetooth_le_read_host_suggested_data_length_t *data_values = NULL;
 674         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 675
 676         result = _bt_send_request(BT_BLUEZ_SERVICE,
 677                 BT_LE_READ_HOST_SUGGESTED_DATA_LENGTH,
 678                 in_param1, in_param2, in_param3, in_param4, &out_param);
 679
 680         if (result == BLUETOOTH_ERROR_NONE) {
 681                 data_values = &g_array_index(out_param,
 682                         bluetooth_le_read_host_suggested_data_length_t, 0);
 683
 684                 le_data_length->def_tx_octets = data_values->def_tx_octets;
 685                 le_data_length->def_tx_time = data_values->def_tx_time;
 686         }
 687
 688         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 689
 690         return result;
 691 }
 692
 693 BT_EXPORT_API int bluetooth_le_set_data_length(bluetooth_device_address_t *address,
 694         const unsigned int max_tx_octets, const unsigned int max_tx_time)
 695 {
 696         BT_CHECK_ENABLED_ANY(return);
 697         BT_INIT_PARAMS();
 698
 699         int result;
 700
 701         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 702
 703         g_array_append_vals(in_param1, address, sizeof(bluetooth_device_address_t));
 704         g_array_append_vals(in_param2, &max_tx_octets, sizeof(guint));
 705         g_array_append_vals(in_param3, &max_tx_time, sizeof(guint));
 706
 707         result = _bt_send_request(BT_BLUEZ_SERVICE,
 708                 BT_LE_SET_DATA_LENGTH,
 709                 in_param1, in_param2, in_param3, in_param4, &out_param);
 710
 711         if (result != BLUETOOTH_ERROR_NONE)
 712                 BT_ERR("Failed to Set data length values : %d", result);
 713
 714         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 715
 716         return result;
 717 }