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