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_INFO("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_enable_rssi(const bluetooth_device_address_t *remote_address,
 450                 int link_type, bt_rssi_threshold_t *rssi_threshold)
 451 {
 452 #ifdef __BROADCOM_PATCH__
 453         int result;
 454
 455         BT_CHECK_ENABLED(return);
 456
 457         BT_INIT_PARAMS();
 458         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 459         g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
 460         g_array_append_vals(in_param2, &link_type, sizeof(int));
 461         g_array_append_vals(in_param3, rssi_threshold, sizeof(bt_rssi_threshold_t));
 462
 463         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_ENABLE_RSSI,
 464                 in_param1, in_param2, in_param3, in_param4, &out_param);
 465
 466         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 467
 468         return result;
 469 #else
 470         BT_ERR("Current chipset does not support this function.");
 471         return BLUETOOTH_ERROR_NOT_SUPPORT;
 472 #endif
 473 }
 474
 475 BT_EXPORT_API int bluetooth_get_rssi_strength(const bluetooth_device_address_t *remote_address, int link_type)
 476 {
 477 #ifdef __BROADCOM_PATCH__
 478         int result;
 479
 480         BT_CHECK_ENABLED(return);
 481
 482         BT_INIT_PARAMS();
 483         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 484         g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
 485         g_array_append_vals(in_param2, &link_type, sizeof(int));
 486
 487         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_RSSI,
 488                 in_param1, in_param2, in_param3, in_param4, &out_param);
 489
 490         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 491
 492         return result;
 493 #else
 494         BT_ERR("Current chipset does not support this function.");
 495         return BLUETOOTH_ERROR_NOT_SUPPORT;
 496 #endif
 497 }
 498
 499 BT_EXPORT_API int bluetooth_le_conn_update(const bluetooth_device_address_t *address,
 500                                         const bluetooth_le_connection_param_t *parameters)
 501 {
 502         int result;
 503
 504         BT_CHECK_ENABLED(return);
 505         BT_CHECK_PARAMETER(address, return);
 506         BT_CHECK_PARAMETER(parameters, return);
 507
 508         BT_INIT_PARAMS();
 509         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 510
 511         g_array_append_vals(in_param1, address,
 512                         sizeof(bluetooth_device_address_t));
 513         g_array_append_vals(in_param2, parameters,
 514                         sizeof(bluetooth_le_connection_param_t));
 515
 516         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_LE_CONN_UPDATE,
 517                         in_param1, in_param2, in_param3, in_param4, &out_param);
 518
 519         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 520
 521         return result;
 522 }
 523
 524 BT_EXPORT_API int bluetooth_get_connected_link_type(
 525                 const bluetooth_device_address_t *device_address,
 526                 bluetooth_connected_link_t *connected)
 527 {
 528         int result;
 529
 530         BT_CHECK_PARAMETER(device_address, return);
 531         BT_CHECK_ENABLED(return);
 532
 533         BT_INIT_PARAMS();
 534         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 535
 536         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 537
 538         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_CONNECTED_LINK_TYPE,
 539                         in_param1, in_param2, in_param3, in_param4, &out_param);
 540
 541         if (result == BLUETOOTH_ERROR_NONE)
 542                 *connected = g_array_index(out_param, guint, 0);
 543
 544         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 545
 546         return result;
 547 }
 548
 549 BT_EXPORT_API int bluetooth_set_pin_code(
 550                 const bluetooth_device_address_t *device_address,
 551                 const bluetooth_device_pin_code_t *pin_code)
 552 {
 553         int result;
 554
 555         BT_CHECK_PARAMETER(device_address, return);
 556         BT_CHECK_PARAMETER(pin_code, return);
 557         BT_CHECK_ENABLED(return);
 558
 559         BT_INIT_PARAMS();
 560         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 561
 562         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 563         g_array_append_vals(in_param2, pin_code, sizeof(bluetooth_device_pin_code_t));
 564
 565         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_PIN_CODE,
 566                 in_param1, in_param2, in_param3, in_param4, &out_param);
 567
 568         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 569
 570         return result;
 571 }
 572
 573 BT_EXPORT_API int bluetooth_unset_pin_code(
 574                 const bluetooth_device_address_t *device_address)
 575 {
 576         int result;
 577
 578         BT_CHECK_PARAMETER(device_address, return);
 579         BT_CHECK_ENABLED(return);
 580
 581         BT_INIT_PARAMS();
 582         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 583
 584         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 585
 586         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_UNSET_PIN_CODE,
 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_update_le_connection_mode(const bluetooth_device_address_t *address,
 595                 const bluetooth_le_connection_mode_t mode)
 596 {
 597         int result;
 598
 599         BT_CHECK_ENABLED(return);
 600         BT_CHECK_PARAMETER(address, return);
 601
 602         BT_INIT_PARAMS();
 603         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 604
 605         g_array_append_vals(in_param1, address,
 606                         sizeof(bluetooth_device_address_t));
 607         g_array_append_vals(in_param2, &mode,
 608                         sizeof(bluetooth_le_connection_mode_t));
 609
 610         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_UPDATE_LE_CONNECTION_MODE,
 611                         in_param1, in_param2, in_param3, in_param4, &out_param);
 612
 613         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 614
 615         return result;
 616 }
 617
 618 BT_EXPORT_API int bluetooth_request_att_mtu(const bluetooth_device_address_t *device_address, unsigned int mtu)
 619 {
 620         int result;
 621         bt_user_info_t *user_info;
 622
 623         BT_CHECK_PARAMETER(device_address, return);
 624         BT_CHECK_ENABLED_ANY(return);
 625
 626         if (mtu > BLUETOOTH_MAX_ATT_MTU)
 627                 return BLUETOOTH_ERROR_INVALID_PARAM;
 628
 629         if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_REQ_ATT_MTU)
 630              == BLUETOOTH_ERROR_PERMISSION_DEINED) {
 631                 BT_ERR("Don't have a privilege to use this API");
 632                 return BLUETOOTH_ERROR_PERMISSION_DEINED;
 633         }
 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         g_array_append_vals(in_param2, &mtu, sizeof(unsigned int));
 640
 641         user_info = _bt_get_user_data(BT_COMMON);
 642         retv_if(user_info == NULL, BLUETOOTH_ERROR_INTERNAL);
 643
 644         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_REQ_ATT_MTU,
 645                 in_param1, in_param2, in_param3, in_param4,
 646                 user_info->cb, user_info->user_data);
 647
 648         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 649
 650         return result;
 651 }
 652
 653 BT_EXPORT_API int bluetooth_get_att_mtu(const bluetooth_device_address_t *device_address,
 654                                 unsigned int *mtu)
 655 {
 656         int result;
 657
 658         BT_CHECK_PARAMETER(device_address, return);
 659         BT_CHECK_PARAMETER(mtu, return);
 660         BT_CHECK_ENABLED(return);
 661
 662         BT_INIT_PARAMS();
 663         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 664
 665         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 666
 667         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_ATT_MTU,
 668                 in_param1, in_param2, in_param3, in_param4, &out_param);
 669
 670         if (result == BLUETOOTH_ERROR_NONE)
 671                 *mtu = g_array_index(out_param, unsigned int, 0);
 672
 673         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 674
 675         return result;
 676 }
 677
 678 BT_EXPORT_API int bluetooth_get_device_ida(const bluetooth_device_address_t *device_rpa,
 679         bluetooth_device_address_t *id_address)
 680 {
 681         int result;
 682
 683         BT_CHECK_PARAMETER(device_rpa, return);
 684         BT_CHECK_PARAMETER(id_address, return);
 685         BT_CHECK_ENABLED_ANY(return);
 686
 687         BT_INIT_PARAMS();
 688         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 689
 690         g_array_append_vals(in_param1, device_rpa, sizeof(bluetooth_device_address_t));
 691
 692         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_DEVICE_IDA,
 693                 in_param1, in_param2, in_param3, in_param4, &out_param);
 694
 695         if (result == BLUETOOTH_ERROR_NONE) {
 696                 *id_address = g_array_index(out_param,
 697                         bluetooth_device_address_t, 0);
 698         }
 699
 700         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 701
 702         return result;
 703 }
 704
 705 BT_EXPORT_API int bluetooth_force_hcidump(int timeout)
 706 {
 707         int result;
 708
 709         BT_CHECK_ENABLED_ANY(return);
 710
 711         BT_INIT_PARAMS();
 712         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 713
 714         g_array_append_vals(in_param1, &timeout, sizeof(int));
 715
 716         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_ENABLE_FORCE_HCI_DUMP,
 717                 in_param1, in_param2, in_param3, in_param4, &out_param);
 718
 719         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 720
 721         return result;
 722 }
 723
 724 BT_EXPORT_API int bluetooth_set_profile_trusted(
 725                 const bluetooth_device_address_t *device_address,
 726                 int profile, int trust)
 727 {
 728         int result;
 729
 730         BT_CHECK_PARAMETER(device_address, return);
 731         BT_CHECK_ENABLED(return);
 732
 733         BT_INIT_PARAMS();
 734         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 735
 736         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 737         g_array_append_vals(in_param2, &profile, sizeof(int));
 738         g_array_append_vals(in_param3, &trust, sizeof(int));
 739
 740         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_PROFILE_TRUSTED,
 741                         in_param1, in_param2, in_param3, in_param4, &out_param);
 742
 743         if (result == BLUETOOTH_ERROR_NONE)
 744                 BT_DBG("SUCCESSFUL");
 745
 746         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 747
 748         return result;
 749 }
 750
 751 BT_EXPORT_API int bluetooth_get_profile_trusted(
 752                 const bluetooth_device_address_t *device_address,
 753                 int profile, int *trust)
 754 {
 755         int result;
 756         int trust_profile = 0;
 757         BT_CHECK_PARAMETER(device_address, return);
 758         BT_CHECK_ENABLED(return);
 759
 760         BT_INIT_PARAMS();
 761         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 762
 763         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 764         g_array_append_vals(in_param2, &profile, sizeof(int));
 765
 766         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_PROFILE_TRUSTED,
 767                         in_param1, in_param2, in_param3, in_param4, &out_param);
 768
 769         if (result == BLUETOOTH_ERROR_NONE) {
 770                 trust_profile = g_array_index(out_param, guint, 0);
 771                 BT_DBG("SUCCESSFUL");
 772         }
 773         BT_DBG("TRUST %d", trust_profile);
 774         *trust = trust_profile;
 775         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 776
 777         return result;
 778 }
 779
 780 BT_EXPORT_API int bluetooth_passkey_reply(char *passkey, gboolean reply)
 781 {
 782         int result;
 783
 784         char str_passkey[BLUETOOTH_DEVICE_PASSKEY_LENGTH_MAX];
 785
 786         BT_CHECK_PARAMETER(passkey, return);
 787         BT_CHECK_ENABLED(return);
 788
 789         BT_INIT_PARAMS();
 790         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 791
 792         g_strlcpy(str_passkey, passkey, sizeof(str_passkey));
 793         g_array_append_vals(in_param1, str_passkey, BLUETOOTH_DEVICE_PASSKEY_LENGTH_MAX);
 794         g_array_append_vals(in_param2, &reply, sizeof(gboolean));
 795
 796         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_PASSKEY_REPLY,
 797                 in_param1, in_param2, in_param3, in_param4, &out_param);
 798
 799         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 800
 801         return result;
 802 }
 803
 804 BT_EXPORT_API int bluetooth_passkey_confirmation_reply(gboolean reply)
 805 {
 806         int result;
 807
 808         BT_CHECK_ENABLED(return);
 809         BT_INIT_PARAMS();
 810
 811         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 812         g_array_append_vals(in_param1, &reply, sizeof(gboolean));
 813         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_PASSKEY_CONFIRMATION_REPLY,
 814                         in_param1, in_param2, in_param3, in_param4, &out_param);
 815         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 816
 817         return result;
 818 }