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