bt-api/bt-device.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 "bluetooth-api.h"
  19 #include "bt-internal-types.h"
  20
  21 #include "bt-common.h"
  22 #include "bt-request-sender.h"
  23 #include "bt-event-handler.h"
  24 #include "bt-dpm.h"
  25
  26 BT_EXPORT_API int bluetooth_disconnect_device(const bluetooth_device_address_t *remote_address)
  27 {
  28         int result;
  29
  30         BT_CHECK_PARAMETER(remote_address, return);
  31         BT_CHECK_ENABLED(return);
  32
  33         BT_INIT_PARAMS();
  34         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
  35
  36         g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
  37
  38         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DISCONNECT_DEVICE,
  39                 in_param1, in_param2, in_param3, in_param4, &out_param);
  40
  41         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
  42
  43         return result;
  44 }
  45
  46 BT_EXPORT_API int bluetooth_bond_device(const bluetooth_device_address_t *device_address)
  47 {
  48         int result;
  49         bt_user_info_t *user_info;
  50
  51         BT_CHECK_PARAMETER(device_address, return);
  52         BT_CHECK_ENABLED(return);
  53
  54         if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_BOND_DEVICE)
  55              == BLUETOOTH_ERROR_PERMISSION_DEINED) {
  56                 BT_ERR("Don't have a privilege to use this API");
  57                 return BLUETOOTH_ERROR_PERMISSION_DEINED;
  58         }
  59
  60         if (_bt_check_dpm(BT_DPM_PAIRING, NULL) == BT_DPM_RESTRICTED) {
  61                         BT_ERR("Not allow to pair the device");
  62                         return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
  63         }
  64
  65         if (_bt_check_dpm(BT_DPM_ADDRESS, (void *)device_address) == BT_DPM_RESTRICTED) {
  66                 BT_ERR("Blacklist device");
  67                 return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
  68         }
  69
  70         user_info = _bt_get_user_data(BT_COMMON);
  71         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
  72
  73         BT_INIT_PARAMS();
  74         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
  75
  76         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
  77
  78         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_BOND_DEVICE,
  79                 in_param1, in_param2, in_param3, in_param4,
  80                 user_info->cb, user_info->user_data);
  81
  82         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
  83
  84         return result;
  85 }
  86
  87 BT_EXPORT_API int bluetooth_bond_device_by_type(
  88         const bluetooth_device_address_t *device_address,
  89         bluetooth_conn_type_t conn_type)
  90 {
  91         int result;
  92         bt_user_info_t *user_info;
  93
  94         BT_CHECK_PARAMETER(device_address, return);
  95         BT_CHECK_ENABLED(return);
  96
  97         if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_BOND_DEVICE_BY_TYPE)
  98              == BLUETOOTH_ERROR_PERMISSION_DEINED) {
  99                 BT_ERR("Don't have a privilege to use this API");
 100                 return BLUETOOTH_ERROR_PERMISSION_DEINED;
 101         }
 102
 103         BT_INIT_PARAMS();
 104         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 105
 106         user_info = _bt_get_user_data(BT_COMMON);
 107         retv_if(user_info == NULL, BLUETOOTH_ERROR_INTERNAL);
 108
 109         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 110         g_array_append_vals(in_param2, &conn_type, sizeof(unsigned short));
 111
 112         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_BOND_DEVICE_BY_TYPE,
 113                 in_param1, in_param2, in_param3, in_param4,
 114                 user_info->cb, user_info->user_data);
 115
 116         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 117
 118         return result;
 119 }
 120
 121 BT_EXPORT_API int bluetooth_cancel_bonding(void)
 122 {
 123         int result;
 124
 125         BT_CHECK_ENABLED(return);
 126
 127         BT_INIT_PARAMS();
 128         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 129
 130         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_CANCEL_BONDING,
 131                 in_param1, in_param2, in_param3, in_param4, &out_param);
 132
 133         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 134
 135         return result;
 136 }
 137
 138 BT_EXPORT_API int bluetooth_unbond_device(const bluetooth_device_address_t *device_address)
 139 {
 140         int result;
 141         bt_user_info_t *user_info;
 142
 143         BT_CHECK_PARAMETER(device_address, return);
 144         BT_CHECK_ENABLED(return);
 145
 146         if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_UNBOND_DEVICE)
 147              == BLUETOOTH_ERROR_PERMISSION_DEINED) {
 148                 BT_ERR("Don't have a privilege to use this API");
 149                 return BLUETOOTH_ERROR_PERMISSION_DEINED;
 150         }
 151
 152         user_info = _bt_get_user_data(BT_COMMON);
 153         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
 154
 155         BT_INIT_PARAMS();
 156         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 157
 158         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 159
 160         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_UNBOND_DEVICE,
 161                 in_param1, in_param2, in_param3, in_param4,
 162                 user_info->cb, user_info->user_data);
 163
 164         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 165
 166         return result;
 167 }
 168
 169 BT_EXPORT_API int bluetooth_get_bonded_device(const bluetooth_device_address_t *device_address,
 170                                               bluetooth_device_info_t *dev_info)
 171 {
 172         int result;
 173
 174         BT_CHECK_PARAMETER(device_address, return);
 175         BT_CHECK_PARAMETER(dev_info, return);
 176         BT_CHECK_ENABLED(return);
 177
 178         BT_INIT_PARAMS();
 179         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 180
 181         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 182
 183         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_BONDED_DEVICE,
 184                 in_param1, in_param2, in_param3, in_param4, &out_param);
 185
 186         if (result == BLUETOOTH_ERROR_NONE) {
 187                 if (out_param->len > 0) {
 188                         *dev_info = g_array_index(out_param,
 189                                         bluetooth_device_info_t, 0);
 190                 } else {
 191                         BT_ERR("out_param length is 0!!");
 192                 }
 193         }
 194
 195         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 196
 197         return result;
 198 }
 199
 200 BT_EXPORT_API int bluetooth_get_is_alias_set(const bluetooth_device_address_t *device_address,
 201                                 gboolean *is_alias_set)
 202 {
 203         int result;
 204
 205         BT_CHECK_PARAMETER(device_address, return);
 206         BT_CHECK_PARAMETER(is_alias_set, return);
 207         BT_CHECK_ENABLED(return);
 208
 209         BT_INIT_PARAMS();
 210         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 211
 212         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 213
 214         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_IS_ALIAS_SET,
 215                 in_param1, in_param2, in_param3, in_param4, &out_param);
 216
 217         if (result == BLUETOOTH_ERROR_NONE)
 218                 *is_alias_set = g_array_index(out_param, gboolean, 0);
 219
 220         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 221
 222         return result;
 223 }
 224
 225 BT_EXPORT_API int bluetooth_get_remote_device(const bluetooth_device_address_t *device_address)
 226 {
 227         return BLUETOOTH_ERROR_NONE;
 228 }
 229
 230 BT_EXPORT_API int bluetooth_search_service(const bluetooth_device_address_t *device_address)
 231 {
 232         int result;
 233         bt_user_info_t *user_info;
 234
 235         BT_CHECK_PARAMETER(device_address, return);
 236         BT_CHECK_ENABLED(return);
 237
 238         if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_SEARCH_SERVICE)
 239              == BLUETOOTH_ERROR_PERMISSION_DEINED) {
 240                 BT_ERR("Don't have a privilege to use this API");
 241                 return BLUETOOTH_ERROR_PERMISSION_DEINED;
 242         }
 243
 244         user_info = _bt_get_user_data(BT_COMMON);
 245         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
 246
 247         BT_INIT_PARAMS();
 248         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 249
 250         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 251
 252         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_SEARCH_SERVICE,
 253                 in_param1, in_param2, in_param3, in_param4,
 254                 user_info->cb, user_info->user_data);
 255
 256         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 257
 258         return result;
 259 }
 260
 261 BT_EXPORT_API int bluetooth_cancel_service_search(void)
 262 {
 263         int result;
 264
 265         BT_CHECK_ENABLED(return);
 266
 267         BT_INIT_PARAMS();
 268         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 269
 270         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_CANCEL_SEARCH_SERVICE,
 271                 in_param1, in_param2, in_param3, in_param4, &out_param);
 272
 273         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 274
 275         return result;
 276 }
 277
 278 BT_EXPORT_API int bluetooth_set_alias(const bluetooth_device_address_t *device_address,
 279                                       const char *alias)
 280 {
 281         int result;
 282         char alias_name[BLUETOOTH_DEVICE_NAME_LENGTH_MAX];
 283
 284         BT_CHECK_PARAMETER(device_address, return);
 285         BT_CHECK_PARAMETER(alias, return);
 286         BT_CHECK_ENABLED(return);
 287
 288         BT_INIT_PARAMS();
 289         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 290
 291         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 292         g_strlcpy(alias_name, alias, sizeof(alias_name));
 293         g_array_append_vals(in_param2, alias_name, BLUETOOTH_DEVICE_NAME_LENGTH_MAX);
 294
 295         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_ALIAS,
 296                 in_param1, in_param2, in_param3, in_param4, &out_param);
 297
 298         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 299
 300         return result;
 301 }
 302
 303 BT_EXPORT_API int bluetooth_authorize_device(const bluetooth_device_address_t *device_address,
 304                                              gboolean authorized)
 305 {
 306         int result;
 307
 308         BT_CHECK_PARAMETER(device_address, return);
 309         BT_CHECK_ENABLED(return);
 310
 311         BT_INIT_PARAMS();
 312         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 313
 314         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 315         g_array_append_vals(in_param2, &authorized, sizeof(gboolean));
 316
 317         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_AUTHORIZATION,
 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_is_device_connected(const bluetooth_device_address_t *device_address,
 326                                 bluetooth_service_type_t type,
 327                                 gboolean *is_connected)
 328 {
 329         int result;
 330
 331         BT_CHECK_PARAMETER(device_address, return);
 332         BT_CHECK_PARAMETER(is_connected, return);
 333         BT_CHECK_ENABLED(return);
 334
 335 #ifdef TIZEN_FEATURE_BT_RFCOMM_DIRECT
 336         if (type & BLUETOOTH_RFCOMM_SERVICE) {
 337                 result = bluetooth_rfcomm_client_is_connected(device_address, is_connected);
 338                 if (*is_connected == FALSE)
 339                         result = bluetooth_rfcomm_server_is_connected(device_address, is_connected);
 340
 341                 return result;
 342         }
 343 #endif
 344
 345         BT_INIT_PARAMS();
 346         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 347
 348         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 349         g_array_append_vals(in_param2, &type, sizeof(int));
 350
 351         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_IS_DEVICE_CONNECTED,
 352                 in_param1, in_param2, in_param3, in_param4, &out_param);
 353
 354         if (result == BLUETOOTH_ERROR_NONE)
 355                 *is_connected = g_array_index(out_param, gboolean, 0);
 356
 357         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 358
 359         return result;
 360 }
 361
 362 BT_EXPORT_API int bluetooth_connect_le(const bluetooth_device_address_t *device_address,
 363                                         gboolean auto_connect, int client_id)
 364 {
 365         int result;
 366         bt_user_info_t *user_info;
 367
 368         BT_CHECK_PARAMETER(device_address, return);
 369         BT_CHECK_ENABLED_ANY(return);
 370
 371         if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_CONNECT_LE)
 372                         == BLUETOOTH_ERROR_PERMISSION_DEINED) {
 373                 BT_ERR("Don't have a privilege to use this API");
 374                 return BLUETOOTH_ERROR_PERMISSION_DEINED;
 375         }
 376
 377         BT_INIT_PARAMS();
 378         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 379
 380         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 381         g_array_append_vals(in_param2, &auto_connect, sizeof(gboolean));
 382         g_array_append_vals(in_param3, &client_id, sizeof(int));
 383
 384         user_info = _bt_get_user_data(BT_COMMON);
 385         retv_if(user_info == NULL, BLUETOOTH_ERROR_INTERNAL);
 386
 387         BT_INFO_C("### Connect LE");
 388         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_CONNECT_LE,
 389                 in_param1, in_param2, in_param3, in_param4,
 390                 user_info->cb, user_info->user_data);
 391
 392         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 393
 394         return result;
 395 }
 396
 397 BT_EXPORT_API int bluetooth_disconnect_le(const bluetooth_device_address_t *device_address,
 398                 int client_id)
 399 {
 400         int result;
 401         bt_user_info_t *user_info;
 402
 403         BT_CHECK_PARAMETER(device_address, return);
 404         BT_CHECK_ENABLED_ANY(return);
 405
 406         if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_DISCONNECT_LE)
 407                         == BLUETOOTH_ERROR_PERMISSION_DEINED) {
 408                 BT_ERR("Don't have a privilege to use this API");
 409                 return BLUETOOTH_ERROR_PERMISSION_DEINED;
 410         }
 411
 412         BT_INIT_PARAMS();
 413         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 414
 415         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 416         g_array_append_vals(in_param2, &client_id, sizeof(int));
 417
 418         BT_DBG("Send GATT disconnect using Client Interface [%d]", client_id);
 419
 420         user_info = _bt_get_user_data(BT_COMMON);
 421         retv_if(user_info == NULL, BLUETOOTH_ERROR_INTERNAL);
 422
 423         BT_INFO_C("### Disconnect LE");
 424         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_DISCONNECT_LE,
 425                 in_param1, in_param2, in_param3, in_param4,
 426                 user_info->cb, user_info->user_data);
 427
 428         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 429
 430         return result;
 431 }
 432
 433 BT_EXPORT_API int bluetooth_get_gatt_data_batching_available_packets(
 434         int *available_packets)
 435 {
 436         int result;
 437         int available;
 438
 439         BT_CHECK_PARAMETER(available_packets, return);
 440         BT_CHECK_ENABLED_ANY(return);
 441
 442         BT_INIT_PARAMS();
 443         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 444
 445         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_GATT_DATA_BATCHING_AVAILABLE_PACKETS,
 446                 in_param1, in_param2, in_param3, in_param4, &out_param);
 447
 448         if (result == BLUETOOTH_ERROR_NONE) {
 449                 available = g_array_index(out_param, guint, 0);
 450                 BT_DBG("available_packets: %d", available);
 451                 *available_packets = available;
 452         }
 453
 454         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 455
 456         return result;
 457 }
 458
 459 BT_EXPORT_API int bluetooth_enable_gatt_data_batching(
 460         const bluetooth_device_address_t *device_address, int packet_threshold, int timeout)
 461 {
 462         int result;
 463
 464         BT_CHECK_PARAMETER(device_address, return);
 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         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 471         g_array_append_vals(in_param2, &packet_threshold, sizeof(int));
 472         g_array_append_vals(in_param3, &timeout, sizeof(int));
 473
 474         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_ENABLE_GATT_DATA_BATCHING,
 475                 in_param1, in_param2, in_param3, in_param4, &out_param);
 476
 477         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 478
 479         return result;
 480 }
 481
 482 BT_EXPORT_API int bluetooth_disable_gatt_data_batching(
 483         const bluetooth_device_address_t *device_address)
 484 {
 485         int result;
 486
 487         BT_CHECK_PARAMETER(device_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, device_address, sizeof(bluetooth_device_address_t));
 494
 495         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DISABLE_GATT_DATA_BATCHING,
 496                 in_param1, in_param2, in_param3, in_param4, &out_param);
 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_enable_rssi(const bluetooth_device_address_t *remote_address,
 504                 int link_type, bt_rssi_threshold_t *rssi_threshold)
 505 {
 506 #ifdef __BROADCOM_PATCH__
 507         int result;
 508
 509         BT_CHECK_ENABLED(return);
 510
 511         BT_INIT_PARAMS();
 512         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 513         g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
 514         g_array_append_vals(in_param2, &link_type, sizeof(int));
 515         g_array_append_vals(in_param3, rssi_threshold, sizeof(bt_rssi_threshold_t));
 516
 517         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_ENABLE_RSSI,
 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 #else
 524         BT_ERR("Current chipset does not support this function.");
 525         return BLUETOOTH_ERROR_NOT_SUPPORT;
 526 #endif
 527 }
 528
 529 BT_EXPORT_API int bluetooth_get_rssi_strength(const bluetooth_device_address_t *remote_address, int link_type)
 530 {
 531 #ifdef __BROADCOM_PATCH__
 532         int result;
 533
 534         BT_CHECK_ENABLED(return);
 535
 536         BT_INIT_PARAMS();
 537         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 538         g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
 539         g_array_append_vals(in_param2, &link_type, sizeof(int));
 540
 541         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_RSSI,
 542                 in_param1, in_param2, in_param3, in_param4, &out_param);
 543
 544         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 545
 546         return result;
 547 #else
 548         BT_ERR("Current chipset does not support this function.");
 549         return BLUETOOTH_ERROR_NOT_SUPPORT;
 550 #endif
 551 }
 552
 553 BT_EXPORT_API int bluetooth_le_conn_update(const bluetooth_device_address_t *address,
 554                                         const bluetooth_le_connection_param_t *parameters)
 555 {
 556         int result;
 557
 558         BT_CHECK_ENABLED(return);
 559         BT_CHECK_PARAMETER(address, return);
 560         BT_CHECK_PARAMETER(parameters, return);
 561
 562         BT_INIT_PARAMS();
 563         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 564
 565         g_array_append_vals(in_param1, address,
 566                         sizeof(bluetooth_device_address_t));
 567         g_array_append_vals(in_param2, parameters,
 568                         sizeof(bluetooth_le_connection_param_t));
 569
 570         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_LE_CONN_UPDATE,
 571                         in_param1, in_param2, in_param3, in_param4, &out_param);
 572
 573         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 574
 575         return result;
 576 }
 577
 578 BT_EXPORT_API int bluetooth_get_connected_link_type(
 579                 const bluetooth_device_address_t *device_address,
 580                 bluetooth_connected_link_t *connected)
 581 {
 582         int result;
 583
 584         BT_CHECK_PARAMETER(device_address, return);
 585         BT_CHECK_ENABLED(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, device_address, sizeof(bluetooth_device_address_t));
 591
 592         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_CONNECTED_LINK_TYPE,
 593                         in_param1, in_param2, in_param3, in_param4, &out_param);
 594
 595         if (result == BLUETOOTH_ERROR_NONE)
 596                 *connected = g_array_index(out_param, guint, 0);
 597
 598         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 599
 600         return result;
 601 }
 602
 603 BT_EXPORT_API int bluetooth_set_pin_code(
 604                 const bluetooth_device_address_t *device_address,
 605                 const bluetooth_device_pin_code_t *pin_code)
 606 {
 607         int result;
 608
 609         BT_CHECK_PARAMETER(device_address, return);
 610         BT_CHECK_PARAMETER(pin_code, return);
 611         BT_CHECK_ENABLED(return);
 612
 613         BT_INIT_PARAMS();
 614         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 615
 616         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 617         g_array_append_vals(in_param2, pin_code, sizeof(bluetooth_device_pin_code_t));
 618
 619         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_PIN_CODE,
 620                 in_param1, in_param2, in_param3, in_param4, &out_param);
 621
 622         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 623
 624         return result;
 625 }
 626
 627 BT_EXPORT_API int bluetooth_unset_pin_code(
 628                 const bluetooth_device_address_t *device_address)
 629 {
 630         int result;
 631
 632         BT_CHECK_PARAMETER(device_address, return);
 633         BT_CHECK_ENABLED(return);
 634
 635         BT_INIT_PARAMS();
 636         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 637
 638         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 639
 640         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_UNSET_PIN_CODE,
 641                 in_param1, in_param2, in_param3, in_param4, &out_param);
 642
 643         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 644
 645         return result;
 646 }
 647
 648 BT_EXPORT_API int bluetooth_update_le_connection_mode(const bluetooth_device_address_t *address,
 649                 const bluetooth_le_connection_mode_t mode)
 650 {
 651         int result;
 652
 653         BT_CHECK_ENABLED(return);
 654         BT_CHECK_PARAMETER(address, return);
 655
 656         BT_INIT_PARAMS();
 657         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 658
 659         g_array_append_vals(in_param1, address,
 660                         sizeof(bluetooth_device_address_t));
 661         g_array_append_vals(in_param2, &mode,
 662                         sizeof(bluetooth_le_connection_mode_t));
 663
 664         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_UPDATE_LE_CONNECTION_MODE,
 665                         in_param1, in_param2, in_param3, in_param4, &out_param);
 666
 667         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 668
 669         return result;
 670 }
 671
 672 BT_EXPORT_API int bluetooth_request_att_mtu(const bluetooth_device_address_t *device_address, unsigned int mtu)
 673 {
 674         int result;
 675         bt_user_info_t *user_info;
 676
 677         BT_CHECK_PARAMETER(device_address, return);
 678         BT_CHECK_ENABLED_ANY(return);
 679
 680         if (mtu > BLUETOOTH_MAX_ATT_MTU)
 681                 return BLUETOOTH_ERROR_INVALID_PARAM;
 682
 683         if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_REQ_ATT_MTU)
 684              == BLUETOOTH_ERROR_PERMISSION_DEINED) {
 685                 BT_ERR("Don't have a privilege to use this API");
 686                 return BLUETOOTH_ERROR_PERMISSION_DEINED;
 687         }
 688
 689         BT_INIT_PARAMS();
 690         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 691
 692         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 693         g_array_append_vals(in_param2, &mtu, sizeof(unsigned int));
 694
 695         user_info = _bt_get_user_data(BT_COMMON);
 696         retv_if(user_info == NULL, BLUETOOTH_ERROR_INTERNAL);
 697
 698         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_REQ_ATT_MTU,
 699                 in_param1, in_param2, in_param3, in_param4,
 700                 user_info->cb, user_info->user_data);
 701
 702         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 703
 704         return result;
 705 }
 706
 707 BT_EXPORT_API int bluetooth_get_att_mtu(const bluetooth_device_address_t *device_address,
 708                                 unsigned int *mtu)
 709 {
 710         int result;
 711
 712         BT_CHECK_PARAMETER(device_address, return);
 713         BT_CHECK_PARAMETER(mtu, return);
 714         BT_CHECK_ENABLED(return);
 715
 716         BT_INIT_PARAMS();
 717         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 718
 719         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 720
 721         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_ATT_MTU,
 722                 in_param1, in_param2, in_param3, in_param4, &out_param);
 723
 724         if (result == BLUETOOTH_ERROR_NONE)
 725                 *mtu = g_array_index(out_param, unsigned int, 0);
 726
 727         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 728
 729         return result;
 730 }
 731
 732 BT_EXPORT_API int bluetooth_get_device_ida(const bluetooth_device_address_t *device_rpa,
 733         bluetooth_device_address_t *id_address)
 734 {
 735         int result;
 736
 737         BT_CHECK_PARAMETER(device_rpa, return);
 738         BT_CHECK_PARAMETER(id_address, return);
 739         BT_CHECK_ENABLED_ANY(return);
 740
 741         BT_INIT_PARAMS();
 742         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 743
 744         g_array_append_vals(in_param1, device_rpa, sizeof(bluetooth_device_address_t));
 745
 746         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_DEVICE_IDA,
 747                 in_param1, in_param2, in_param3, in_param4, &out_param);
 748
 749         if (result == BLUETOOTH_ERROR_NONE) {
 750                 *id_address = g_array_index(out_param,
 751                         bluetooth_device_address_t, 0);
 752         }
 753
 754         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 755
 756         return result;
 757 }
 758
 759 BT_EXPORT_API int bluetooth_force_hcidump(int timeout)
 760 {
 761         int result;
 762
 763         BT_CHECK_ENABLED_ANY(return);
 764
 765         BT_INIT_PARAMS();
 766         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 767
 768         g_array_append_vals(in_param1, &timeout, sizeof(int));
 769
 770         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_ENABLE_FORCE_HCI_DUMP,
 771                 in_param1, in_param2, in_param3, in_param4, &out_param);
 772
 773         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 774
 775         return result;
 776 }
 777
 778 BT_EXPORT_API int bluetooth_set_profile_trusted(
 779                 const bluetooth_device_address_t *device_address,
 780                 int profile, int trust)
 781 {
 782         int result;
 783
 784         BT_CHECK_PARAMETER(device_address, return);
 785         BT_CHECK_ENABLED(return);
 786
 787         BT_INIT_PARAMS();
 788         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 789
 790         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 791         g_array_append_vals(in_param2, &profile, sizeof(int));
 792         g_array_append_vals(in_param3, &trust, sizeof(int));
 793
 794         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_PROFILE_TRUSTED,
 795                         in_param1, in_param2, in_param3, in_param4, &out_param);
 796
 797         if (result == BLUETOOTH_ERROR_NONE)
 798                 BT_DBG("SUCCESSFUL");
 799
 800         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 801
 802         return result;
 803 }
 804
 805 BT_EXPORT_API int bluetooth_get_profile_trusted(
 806                 const bluetooth_device_address_t *device_address,
 807                 int profile, int *trust)
 808 {
 809         int result;
 810         int trust_profile = 0;
 811         BT_CHECK_PARAMETER(device_address, return);
 812         BT_CHECK_ENABLED(return);
 813
 814         BT_INIT_PARAMS();
 815         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 816
 817         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 818         g_array_append_vals(in_param2, &profile, sizeof(int));
 819
 820         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_PROFILE_TRUSTED,
 821                         in_param1, in_param2, in_param3, in_param4, &out_param);
 822
 823         if (result == BLUETOOTH_ERROR_NONE) {
 824                 trust_profile = g_array_index(out_param, guint, 0);
 825                 BT_DBG("SUCCESSFUL");
 826         }
 827         BT_DBG("TRUST %d", trust_profile);
 828         *trust = trust_profile;
 829         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 830
 831         return result;
 832 }
 833
 834 BT_EXPORT_API int bluetooth_passkey_reply(char *passkey, gboolean reply)
 835 {
 836         int result;
 837
 838         char str_passkey[BLUETOOTH_DEVICE_PASSKEY_LENGTH_MAX];
 839
 840         BT_CHECK_PARAMETER(passkey, return);
 841         BT_CHECK_ENABLED(return);
 842
 843         BT_INIT_PARAMS();
 844         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 845
 846         g_strlcpy(str_passkey, passkey, sizeof(str_passkey));
 847         g_array_append_vals(in_param1, str_passkey, BLUETOOTH_DEVICE_PASSKEY_LENGTH_MAX);
 848         g_array_append_vals(in_param2, &reply, sizeof(gboolean));
 849
 850         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_PASSKEY_REPLY,
 851                 in_param1, in_param2, in_param3, in_param4, &out_param);
 852
 853         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 854
 855         return result;
 856 }
 857
 858 BT_EXPORT_API int bluetooth_passkey_confirmation_reply(gboolean reply)
 859 {
 860         int result;
 861
 862         BT_CHECK_ENABLED(return);
 863         BT_INIT_PARAMS();
 864
 865         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 866         g_array_append_vals(in_param1, &reply, sizeof(gboolean));
 867         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_PASSKEY_CONFIRMATION_REPLY,
 868                         in_param1, in_param2, in_param3, in_param4, &out_param);
 869         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 870
 871         return result;
 872 }