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_DPM_ENABLE
  26 #include "bt-dpm.h"
  27 #endif
  28
  29 BT_EXPORT_API int bluetooth_bond_device(const bluetooth_device_address_t *device_address)
  30 {
  31         int result;
  32         bt_user_info_t *user_info;
  33
  34         BT_CHECK_PARAMETER(device_address, return);
  35         BT_CHECK_ENABLED(return);
  36
  37         if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_BOND_DEVICE)
  38              == BLUETOOTH_ERROR_PERMISSION_DEINED) {
  39                 BT_ERR("Don't have a privilege to use this API");
  40                 return BLUETOOTH_ERROR_PERMISSION_DEINED;
  41         }
  42
  43 #ifdef TIZEN_DPM_ENABLE
  44         if (_bt_check_dpm(BT_DPM_PAIRING, NULL) == BT_DPM_RESTRICTED) {
  45                         BT_ERR("Not allow to pair the device");
  46                         return BLUETOOTH_ERROR_ACCESS_DENIED;
  47         }
  48
  49         if (_bt_check_dpm(BT_DPM_ADDRESS, (void *)device_address) == BT_DPM_RESTRICTED) {
  50                 BT_ERR("Blacklist device");
  51                 return BLUETOOTH_ERROR_ACCESS_DENIED;
  52         }
  53 #endif
  54
  55         user_info = _bt_get_user_data(BT_COMMON);
  56         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
  57
  58         BT_INIT_PARAMS();
  59         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
  60
  61         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
  62
  63         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_BOND_DEVICE,
  64                 in_param1, in_param2, in_param3, in_param4,
  65                 user_info->cb, user_info->user_data);
  66
  67         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
  68
  69         return result;
  70 }
  71
  72 BT_EXPORT_API int bluetooth_bond_device_by_type(
  73         const bluetooth_device_address_t *device_address,
  74         bluetooth_conn_type_t conn_type)
  75 {
  76         int result;
  77         bt_user_info_t *user_info;
  78
  79         BT_CHECK_PARAMETER(device_address, return);
  80         if(conn_type == BLUETOOTH_DEV_CONN_BREDR)
  81                 BT_CHECK_ENABLED(return);
  82         else if(conn_type == BLUETOOTH_DEV_CONN_LE)
  83                 BT_CHECK_ENABLED_LE(return);
  84         else if(conn_type == BLUETOOTH_DEV_CONN_DEFAULT) {
  85                 BT_CHECK_ENABLED(return);
  86                 BT_CHECK_ENABLED_LE(return);
  87         }
  88
  89         if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_BOND_DEVICE_BY_TYPE)
  90              == BLUETOOTH_ERROR_PERMISSION_DEINED) {
  91                 BT_ERR("Don't have a privilege to use this API");
  92                 return BLUETOOTH_ERROR_PERMISSION_DEINED;
  93         }
  94
  95         BT_INIT_PARAMS();
  96         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
  97
  98         user_info = _bt_get_user_data(BT_COMMON);
  99         retv_if(user_info == NULL, BLUETOOTH_ERROR_INTERNAL);
 100
 101         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 102         g_array_append_vals(in_param2, &conn_type, sizeof(unsigned short));
 103
 104         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_BOND_DEVICE_BY_TYPE,
 105                 in_param1, in_param2, in_param3, in_param4,
 106                 user_info->cb, user_info->user_data);
 107
 108         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 109
 110         return result;
 111 }
 112
 113 BT_EXPORT_API int bluetooth_cancel_bonding(void)
 114 {
 115         int result;
 116
 117         BT_CHECK_ENABLED_ANY(return);
 118
 119         BT_INIT_PARAMS();
 120         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 121
 122         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_CANCEL_BONDING,
 123                 in_param1, in_param2, in_param3, in_param4, &out_param);
 124
 125         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 126
 127         return result;
 128 }
 129
 130 BT_EXPORT_API int bluetooth_unbond_device(const bluetooth_device_address_t *device_address)
 131 {
 132         int result;
 133         bt_user_info_t *user_info;
 134
 135         BT_CHECK_PARAMETER(device_address, return);
 136         BT_CHECK_ENABLED_ANY(return);
 137
 138         if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_UNBOND_DEVICE)
 139              == BLUETOOTH_ERROR_PERMISSION_DEINED) {
 140                 BT_ERR("Don't have a privilege to use this API");
 141                 return BLUETOOTH_ERROR_PERMISSION_DEINED;
 142         }
 143
 144         user_info = _bt_get_user_data(BT_COMMON);
 145         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
 146
 147         BT_INIT_PARAMS();
 148         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 149
 150         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 151
 152         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_UNBOND_DEVICE,
 153                 in_param1, in_param2, in_param3, in_param4,
 154                 user_info->cb, user_info->user_data);
 155
 156         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 157
 158         return result;
 159 }
 160
 161 BT_EXPORT_API int bluetooth_get_bonded_device(const bluetooth_device_address_t *device_address,
 162                                               bluetooth_device_info_t *dev_info)
 163 {
 164         int result;
 165
 166         BT_CHECK_PARAMETER(device_address, return);
 167         BT_CHECK_PARAMETER(dev_info, return);
 168         BT_CHECK_ENABLED_ANY(return);
 169
 170         BT_INIT_PARAMS();
 171         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 172
 173         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 174
 175         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_BONDED_DEVICE,
 176                 in_param1, in_param2, in_param3, in_param4, &out_param);
 177
 178         if (result == BLUETOOTH_ERROR_NONE) {
 179                 if (out_param->len > 0) {
 180                         *dev_info = g_array_index(out_param,
 181                                         bluetooth_device_info_t, 0);
 182                 } else {
 183                         BT_ERR("out_param length is 0!!");
 184                 }
 185         }
 186
 187         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 188
 189         return result;
 190 }
 191
 192 BT_EXPORT_API int bluetooth_get_remote_device(const bluetooth_device_address_t *device_address)
 193 {
 194         return BLUETOOTH_ERROR_NONE;
 195 }
 196
 197 BT_EXPORT_API int bluetooth_search_service(const bluetooth_device_address_t *device_address)
 198 {
 199         int result;
 200         bt_user_info_t *user_info;
 201
 202         BT_CHECK_PARAMETER(device_address, return);
 203         BT_CHECK_ENABLED_ANY(return);
 204
 205         if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_SEARCH_SERVICE)
 206              == BLUETOOTH_ERROR_PERMISSION_DEINED) {
 207                 BT_ERR("Don't have a privilege to use this API");
 208                 return BLUETOOTH_ERROR_PERMISSION_DEINED;
 209         }
 210
 211         user_info = _bt_get_user_data(BT_COMMON);
 212         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
 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_async(BT_BLUEZ_SERVICE, BT_SEARCH_SERVICE,
 220                 in_param1, in_param2, in_param3, in_param4,
 221                 user_info->cb, user_info->user_data);
 222
 223         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 224
 225         return result;
 226 }
 227
 228 BT_EXPORT_API int bluetooth_cancel_service_search(void)
 229 {
 230         int result;
 231
 232         BT_CHECK_ENABLED_ANY(return);
 233
 234         BT_INIT_PARAMS();
 235         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 236
 237         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_CANCEL_SEARCH_SERVICE,
 238                 in_param1, in_param2, in_param3, in_param4, &out_param);
 239
 240         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 241
 242         return result;
 243 }
 244
 245 BT_EXPORT_API int bluetooth_set_alias(const bluetooth_device_address_t *device_address,
 246                                       const char *alias)
 247 {
 248         int result;
 249         char alias_name[BLUETOOTH_DEVICE_NAME_LENGTH_MAX];
 250
 251         BT_CHECK_PARAMETER(device_address, return);
 252         BT_CHECK_PARAMETER(alias, return);
 253         BT_CHECK_ENABLED_ANY(return);
 254
 255         BT_INIT_PARAMS();
 256         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 257
 258         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 259         g_strlcpy(alias_name, alias, sizeof(alias_name));
 260         g_array_append_vals(in_param2, alias_name, BLUETOOTH_DEVICE_NAME_LENGTH_MAX);
 261
 262         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_ALIAS,
 263                 in_param1, in_param2, in_param3, in_param4, &out_param);
 264
 265         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 266
 267         return result;
 268 }
 269
 270 BT_EXPORT_API int bluetooth_authorize_device(const bluetooth_device_address_t *device_address,
 271                                              gboolean authorized)
 272 {
 273         int result;
 274
 275         BT_CHECK_PARAMETER(device_address, return);
 276         BT_CHECK_ENABLED_ANY(return);
 277
 278         BT_INIT_PARAMS();
 279         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 280
 281         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 282         g_array_append_vals(in_param2, &authorized, sizeof(gboolean));
 283
 284         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_AUTHORIZATION,
 285                 in_param1, in_param2, in_param3, in_param4, &out_param);
 286
 287         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 288
 289         return result;
 290 }
 291
 292 BT_EXPORT_API int bluetooth_is_device_connected(const bluetooth_device_address_t *device_address,
 293                                 bluetooth_service_type_t type,
 294                                 gboolean *is_connected)
 295 {
 296         int result;
 297
 298         BT_CHECK_PARAMETER(device_address, return);
 299         BT_CHECK_PARAMETER(is_connected, return);
 300         BT_CHECK_ENABLED_ANY(return);
 301
 302 #ifdef RFCOMM_DIRECT
 303         if (type & BLUETOOTH_RFCOMM_SERVICE) {
 304                 result = bluetooth_rfcomm_client_is_connected(device_address, is_connected);
 305                 if (*is_connected == FALSE)
 306                         result = bluetooth_rfcomm_server_is_connected(device_address, is_connected);
 307
 308                 return result;
 309         }
 310 #endif
 311
 312         BT_INIT_PARAMS();
 313         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 314
 315         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 316         g_array_append_vals(in_param2, &type, sizeof(int));
 317
 318         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_IS_DEVICE_CONNECTED,
 319                 in_param1, in_param2, in_param3, in_param4, &out_param);
 320
 321         if (result == BLUETOOTH_ERROR_NONE) {
 322                 *is_connected = g_array_index(out_param, gboolean, 0);
 323         }
 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_connect_le(const bluetooth_device_address_t *device_address, gboolean auto_connect)
 331 {
 332         int result;
 333         bt_user_info_t *user_info;
 334
 335         BT_CHECK_PARAMETER(device_address, return);
 336         BT_CHECK_ENABLED_ANY(return);
 337
 338         BT_INIT_PARAMS();
 339         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 340
 341         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 342         g_array_append_vals(in_param2, &auto_connect, sizeof(gboolean));
 343
 344         user_info = _bt_get_user_data(BT_COMMON);
 345         retv_if(user_info == NULL, BLUETOOTH_ERROR_INTERNAL);
 346
 347         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_CONNECT_LE,
 348                 in_param1, in_param2, in_param3, in_param4,
 349                 user_info->cb, user_info->user_data);
 350
 351         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 352
 353         return result;
 354 }
 355
 356 BT_EXPORT_API int bluetooth_disconnect_le(const bluetooth_device_address_t *device_address)
 357 {
 358         int result;
 359         bt_user_info_t *user_info;
 360
 361         BT_CHECK_PARAMETER(device_address, return);
 362         BT_CHECK_ENABLED_ANY(return);
 363
 364         BT_INIT_PARAMS();
 365         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 366
 367         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 368
 369         user_info = _bt_get_user_data(BT_COMMON);
 370         retv_if(user_info == NULL, BLUETOOTH_ERROR_INTERNAL);
 371
 372         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_DISCONNECT_LE,
 373                 in_param1, in_param2, in_param3, in_param4,
 374                 user_info->cb, user_info->user_data);
 375
 376         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 377
 378         return result;
 379 }
 380
 381 BT_EXPORT_API int bluetooth_enable_rssi(const bluetooth_device_address_t *remote_address,
 382                 int link_type, bt_rssi_threshold_t *rssi_threshold)
 383 {
 384         int result;
 385
 386         BT_CHECK_ENABLED_ANY(return);
 387
 388         BT_INIT_PARAMS();
 389         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 390         g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
 391         g_array_append_vals(in_param2, &link_type, sizeof(int));
 392         g_array_append_vals(in_param3, rssi_threshold, sizeof(bt_rssi_threshold_t));
 393
 394         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_ENABLE_RSSI,
 395                 in_param1, in_param2, in_param3, in_param4, &out_param);
 396
 397         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 398
 399         return result;
 400 }
 401
 402 BT_EXPORT_API int bluetooth_get_rssi_strength(const bluetooth_device_address_t *remote_address, int link_type)
 403 {
 404         int result;
 405
 406         BT_CHECK_ENABLED_ANY(return);
 407
 408         BT_INIT_PARAMS();
 409         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 410         g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
 411         g_array_append_vals(in_param2, &link_type, sizeof(int));
 412
 413         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_RSSI,
 414                 in_param1, in_param2, in_param3, in_param4, &out_param);
 415
 416         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 417
 418         return result;
 419 }
 420
 421 BT_EXPORT_API int bluetooth_le_conn_update(const bluetooth_device_address_t *address,
 422                                         const bluetooth_le_connection_param_t *parameters)
 423 {
 424         int result;
 425
 426         BT_CHECK_ENABLED_ANY(return);
 427         BT_CHECK_PARAMETER(address, return);
 428         BT_CHECK_PARAMETER(parameters, return);
 429
 430         BT_INIT_PARAMS();
 431         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 432
 433         g_array_append_vals(in_param1, address,
 434                         sizeof(bluetooth_device_address_t));
 435         g_array_append_vals(in_param2, parameters,
 436                         sizeof(bluetooth_le_connection_param_t));
 437
 438         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_LE_CONN_UPDATE,
 439                         in_param1, in_param2, in_param3, in_param4, &out_param);
 440
 441         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 442
 443         return result;
 444 }
 445
 446 BT_EXPORT_API int bluetooth_get_connected_link_type(
 447                 const bluetooth_device_address_t *device_address,
 448                 bluetooth_connected_link_t *connected)
 449 {
 450         int result;
 451
 452         BT_CHECK_PARAMETER(device_address, return);
 453         BT_CHECK_ENABLED_ANY(return);
 454
 455         BT_INIT_PARAMS();
 456         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 457
 458         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 459
 460         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_CONNECTED_LINK_TYPE,
 461                         in_param1, in_param2, in_param3, in_param4, &out_param);
 462
 463         if (result == BLUETOOTH_ERROR_NONE) {
 464                 *connected = g_array_index(out_param, guint, 0);
 465         }
 466
 467         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 468
 469         return result;
 470 }
 471
 472 BT_EXPORT_API int bluetooth_set_pin_code(
 473                 const bluetooth_device_address_t *device_address,
 474                 const bluetooth_device_pin_code_t *pin_code)
 475 {
 476         int result;
 477
 478         BT_CHECK_PARAMETER(device_address, return);
 479         BT_CHECK_PARAMETER(pin_code, return);
 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
 485         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 486         g_array_append_vals(in_param2, pin_code, sizeof(bluetooth_device_pin_code_t));
 487
 488         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_PIN_CODE,
 489                 in_param1, in_param2, in_param3, in_param4, &out_param);
 490
 491         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 492
 493         return result;
 494 }
 495
 496 BT_EXPORT_API int bluetooth_unset_pin_code(
 497                 const bluetooth_device_address_t *device_address)
 498 {
 499         int result;
 500
 501         BT_CHECK_PARAMETER(device_address, return);
 502         BT_CHECK_ENABLED(return);
 503
 504         BT_INIT_PARAMS();
 505         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 506
 507         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 508
 509         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_UNSET_PIN_CODE,
 510                 in_param1, in_param2, in_param3, in_param4, &out_param);
 511
 512         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 513
 514         return result;
 515 }
 516
 517 BT_EXPORT_API int bluetooth_update_le_connection_mode(const bluetooth_device_address_t *address,
 518                 const bluetooth_le_connection_mode_t mode)
 519 {
 520         int result;
 521
 522         BT_CHECK_ENABLED(return);
 523         BT_CHECK_PARAMETER(address, return);
 524
 525         BT_INIT_PARAMS();
 526         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 527
 528         g_array_append_vals(in_param1, address,
 529                         sizeof(bluetooth_device_address_t));
 530         g_array_append_vals(in_param2, &mode,
 531                         sizeof(bluetooth_le_connection_mode_t));
 532
 533         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_UPDATE_LE_CONNECTION_MODE,
 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 }
 540
 541 BT_EXPORT_API int bluetooth_passkey_reply(char *passkey, gboolean reply)
 542 {
 543         int result;
 544
 545         char str_passkey[BLUETOOTH_DEVICE_PASSKEY_LENGTH_MAX];
 546
 547         BT_CHECK_PARAMETER(passkey, return);
 548         BT_CHECK_ENABLED(return);
 549
 550         BT_INIT_PARAMS();
 551         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 552
 553         g_strlcpy(str_passkey, passkey, sizeof(str_passkey));
 554         g_array_append_vals(in_param1, str_passkey, BLUETOOTH_DEVICE_PASSKEY_LENGTH_MAX);
 555         g_array_append_vals(in_param2, &reply, sizeof(gboolean));
 556
 557         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_PASSKEY_REPLY,
 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 }
 564
 565 BT_EXPORT_API int bluetooth_passkey_confirmation_reply(gboolean reply)
 566 {
 567         int result;
 568
 569         BT_CHECK_ENABLED(return);
 570         BT_INIT_PARAMS();
 571
 572         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 573         g_array_append_vals(in_param1, &reply, sizeof(gboolean));
 574         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_PASSKEY_CONFIRMATION_REPLY,
 575                         in_param1, in_param2, in_param3, in_param4, &out_param);
 576         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 577
 578         return result;
 579 }