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 BT_EXPORT_API int bluetooth_connect_le(const bluetooth_device_address_t *device_address, gboolean auto_connect)
 348 {
 349         int result;
 350         bt_user_info_t *user_info;
 351
 352         BT_CHECK_PARAMETER(device_address, return);
 353         BT_CHECK_ENABLED_ANY(return);
 354
 355         if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_CONNECT_LE)
 356                         == BLUETOOTH_ERROR_PERMISSION_DEINED) {
 357                 BT_ERR("Don't have a privilege to use this API");
 358                 return BLUETOOTH_ERROR_PERMISSION_DEINED;
 359         }
 360
 361         BT_INIT_PARAMS();
 362         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 363
 364         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 365         g_array_append_vals(in_param2, &auto_connect, sizeof(gboolean));
 366
 367         user_info = _bt_get_user_data(BT_COMMON);
 368         retv_if(user_info == NULL, BLUETOOTH_ERROR_INTERNAL);
 369
 370         BT_INFO_C("### Connect LE");
 371         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_CONNECT_LE,
 372                 in_param1, in_param2, in_param3, in_param4,
 373                 user_info->cb, user_info->user_data);
 374
 375         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 376
 377         return result;
 378 }
 379
 380 BT_EXPORT_API int bluetooth_disconnect_le(const bluetooth_device_address_t *device_address)
 381 {
 382         int result;
 383         bt_user_info_t *user_info;
 384
 385         BT_CHECK_PARAMETER(device_address, return);
 386         BT_CHECK_ENABLED_ANY(return);
 387
 388         if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_DISCONNECT_LE)
 389              == BLUETOOTH_ERROR_PERMISSION_DEINED) {
 390                 BT_ERR("Don't have a privilege to use this API");
 391                 return BLUETOOTH_ERROR_PERMISSION_DEINED;
 392         }
 393
 394         BT_INIT_PARAMS();
 395         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 396
 397         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 398         user_info = _bt_get_user_data(BT_COMMON);
 399         retv_if(user_info == NULL, BLUETOOTH_ERROR_INTERNAL);
 400
 401         BT_INFO_C("### Disconnect LE");
 402         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_DISCONNECT_LE,
 403                 in_param1, in_param2, in_param3, in_param4,
 404                 user_info->cb, user_info->user_data);
 405
 406         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 407
 408         return result;
 409 }
 410
 411 BT_EXPORT_API int bluetooth_enable_rssi(const bluetooth_device_address_t *remote_address,
 412                 int link_type, bt_rssi_threshold_t *rssi_threshold)
 413 {
 414 #ifdef __BROADCOM_PATCH__
 415         int result;
 416
 417         BT_CHECK_ENABLED(return);
 418
 419         BT_INIT_PARAMS();
 420         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 421         g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
 422         g_array_append_vals(in_param2, &link_type, sizeof(int));
 423         g_array_append_vals(in_param3, rssi_threshold, sizeof(bt_rssi_threshold_t));
 424
 425         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_ENABLE_RSSI,
 426                 in_param1, in_param2, in_param3, in_param4, &out_param);
 427
 428         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 429
 430         return result;
 431 #else
 432         BT_ERR("Current chipset does not support this function.");
 433         return BLUETOOTH_ERROR_NOT_SUPPORT;
 434 #endif
 435 }
 436
 437 BT_EXPORT_API int bluetooth_get_rssi_strength(const bluetooth_device_address_t *remote_address, int link_type)
 438 {
 439 #ifdef __BROADCOM_PATCH__
 440         int result;
 441
 442         BT_CHECK_ENABLED(return);
 443
 444         BT_INIT_PARAMS();
 445         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 446         g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
 447         g_array_append_vals(in_param2, &link_type, sizeof(int));
 448
 449         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_RSSI,
 450                 in_param1, in_param2, in_param3, in_param4, &out_param);
 451
 452         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 453
 454         return result;
 455 #else
 456         BT_ERR("Current chipset does not support this function.");
 457         return BLUETOOTH_ERROR_NOT_SUPPORT;
 458 #endif
 459 }
 460
 461 BT_EXPORT_API int bluetooth_le_conn_update(const bluetooth_device_address_t *address,
 462                                         const bluetooth_le_connection_param_t *parameters)
 463 {
 464         int result;
 465
 466         BT_CHECK_ENABLED(return);
 467         BT_CHECK_PARAMETER(address, return);
 468         BT_CHECK_PARAMETER(parameters, return);
 469
 470         BT_INIT_PARAMS();
 471         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 472
 473         g_array_append_vals(in_param1, address,
 474                         sizeof(bluetooth_device_address_t));
 475         g_array_append_vals(in_param2, parameters,
 476                         sizeof(bluetooth_le_connection_param_t));
 477
 478         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_LE_CONN_UPDATE,
 479                         in_param1, in_param2, in_param3, in_param4, &out_param);
 480
 481         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 482
 483         return result;
 484 }
 485
 486 BT_EXPORT_API int bluetooth_get_connected_link_type(
 487                 const bluetooth_device_address_t *device_address,
 488                 bluetooth_connected_link_t *connected)
 489 {
 490         int result;
 491
 492         BT_CHECK_PARAMETER(device_address, return);
 493         BT_CHECK_ENABLED(return);
 494
 495         BT_INIT_PARAMS();
 496         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 497
 498         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 499
 500         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_CONNECTED_LINK_TYPE,
 501                         in_param1, in_param2, in_param3, in_param4, &out_param);
 502
 503         if (result == BLUETOOTH_ERROR_NONE)
 504                 *connected = g_array_index(out_param, guint, 0);
 505
 506         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 507
 508         return result;
 509 }
 510
 511 BT_EXPORT_API int bluetooth_set_pin_code(
 512                 const bluetooth_device_address_t *device_address,
 513                 const bluetooth_device_pin_code_t *pin_code)
 514 {
 515         int result;
 516
 517         BT_CHECK_PARAMETER(device_address, return);
 518         BT_CHECK_PARAMETER(pin_code, return);
 519         BT_CHECK_ENABLED(return);
 520
 521         BT_INIT_PARAMS();
 522         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 523
 524         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 525         g_array_append_vals(in_param2, pin_code, sizeof(bluetooth_device_pin_code_t));
 526
 527         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_PIN_CODE,
 528                 in_param1, in_param2, in_param3, in_param4, &out_param);
 529
 530         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 531
 532         return result;
 533 }
 534
 535 BT_EXPORT_API int bluetooth_unset_pin_code(
 536                 const bluetooth_device_address_t *device_address)
 537 {
 538         int result;
 539
 540         BT_CHECK_PARAMETER(device_address, return);
 541         BT_CHECK_ENABLED(return);
 542
 543         BT_INIT_PARAMS();
 544         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 545
 546         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 547
 548         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_UNSET_PIN_CODE,
 549                 in_param1, in_param2, in_param3, in_param4, &out_param);
 550
 551         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 552
 553         return result;
 554 }
 555
 556 BT_EXPORT_API int bluetooth_update_le_connection_mode(const bluetooth_device_address_t *address,
 557                 const bluetooth_le_connection_mode_t mode)
 558 {
 559         int result;
 560
 561         BT_CHECK_ENABLED(return);
 562         BT_CHECK_PARAMETER(address, return);
 563
 564         BT_INIT_PARAMS();
 565         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 566
 567         g_array_append_vals(in_param1, address,
 568                         sizeof(bluetooth_device_address_t));
 569         g_array_append_vals(in_param2, &mode,
 570                         sizeof(bluetooth_le_connection_mode_t));
 571
 572         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_UPDATE_LE_CONNECTION_MODE,
 573                         in_param1, in_param2, in_param3, in_param4, &out_param);
 574
 575         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 576
 577         return result;
 578 }
 579
 580 BT_EXPORT_API int bluetooth_request_att_mtu(const bluetooth_device_address_t *device_address, unsigned int mtu)
 581 {
 582         int result;
 583         bt_user_info_t *user_info;
 584
 585         BT_CHECK_PARAMETER(device_address, return);
 586         BT_CHECK_ENABLED_ANY(return);
 587
 588         if (mtu > BLUETOOTH_MAX_ATT_MTU)
 589                 return BLUETOOTH_ERROR_INVALID_PARAM;
 590
 591         if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_REQ_ATT_MTU)
 592              == BLUETOOTH_ERROR_PERMISSION_DEINED) {
 593                 BT_ERR("Don't have a privilege to use this API");
 594                 return BLUETOOTH_ERROR_PERMISSION_DEINED;
 595         }
 596
 597         BT_INIT_PARAMS();
 598         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 599
 600         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 601         g_array_append_vals(in_param2, &mtu, sizeof(unsigned int));
 602
 603         user_info = _bt_get_user_data(BT_COMMON);
 604         retv_if(user_info == NULL, BLUETOOTH_ERROR_INTERNAL);
 605
 606         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_REQ_ATT_MTU,
 607                 in_param1, in_param2, in_param3, in_param4,
 608                 user_info->cb, user_info->user_data);
 609
 610         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 611
 612         return result;
 613 }
 614
 615 BT_EXPORT_API int bluetooth_get_att_mtu(const bluetooth_device_address_t *device_address,
 616                                 unsigned int *mtu)
 617 {
 618         int result;
 619
 620         BT_CHECK_PARAMETER(device_address, return);
 621         BT_CHECK_PARAMETER(mtu, return);
 622         BT_CHECK_ENABLED(return);
 623
 624         BT_INIT_PARAMS();
 625         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 626
 627         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 628
 629         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_ATT_MTU,
 630                 in_param1, in_param2, in_param3, in_param4, &out_param);
 631
 632         if (result == BLUETOOTH_ERROR_NONE)
 633                 *mtu = g_array_index(out_param, unsigned int, 0);
 634
 635         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 636
 637         return result;
 638 }
 639
 640 BT_EXPORT_API int bluetooth_get_device_ida(const bluetooth_device_address_t *device_rpa,
 641         bluetooth_device_address_t *id_address)
 642 {
 643         int result;
 644
 645         BT_CHECK_PARAMETER(device_rpa, return);
 646         BT_CHECK_PARAMETER(id_address, return);
 647         BT_CHECK_ENABLED_ANY(return);
 648
 649         BT_INIT_PARAMS();
 650         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 651
 652         g_array_append_vals(in_param1, device_rpa, sizeof(bluetooth_device_address_t));
 653
 654         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_DEVICE_IDA,
 655                 in_param1, in_param2, in_param3, in_param4, &out_param);
 656
 657         if (result == BLUETOOTH_ERROR_NONE) {
 658                 *id_address = g_array_index(out_param,
 659                         bluetooth_device_address_t, 0);
 660         }
 661
 662         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 663
 664         return result;
 665 }
 666
 667 BT_EXPORT_API int bluetooth_force_hcidump(int timeout)
 668 {
 669         int result;
 670
 671         BT_CHECK_ENABLED_ANY(return);
 672
 673         BT_INIT_PARAMS();
 674         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 675
 676         g_array_append_vals(in_param1, &timeout, sizeof(int));
 677
 678         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_ENABLE_FORCE_HCI_DUMP,
 679                 in_param1, in_param2, in_param3, in_param4, &out_param);
 680
 681         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 682
 683         return result;
 684 }
 685
 686 BT_EXPORT_API int bluetooth_set_profile_trusted(
 687                 const bluetooth_device_address_t *device_address,
 688                 int profile, int trust)
 689 {
 690         int result;
 691
 692         BT_CHECK_PARAMETER(device_address, return);
 693         BT_CHECK_ENABLED(return);
 694
 695         BT_INIT_PARAMS();
 696         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 697
 698         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 699         g_array_append_vals(in_param2, &profile, sizeof(int));
 700         g_array_append_vals(in_param3, &trust, sizeof(int));
 701
 702         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_PROFILE_TRUSTED,
 703                         in_param1, in_param2, in_param3, in_param4, &out_param);
 704
 705         if (result == BLUETOOTH_ERROR_NONE)
 706                 BT_DBG("SUCCESSFUL");
 707
 708         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 709
 710         return result;
 711 }
 712
 713 BT_EXPORT_API int bluetooth_get_profile_trusted(
 714                 const bluetooth_device_address_t *device_address,
 715                 int profile, int *trust)
 716 {
 717         int result;
 718         int trust_profile = 0;
 719         BT_CHECK_PARAMETER(device_address, return);
 720         BT_CHECK_ENABLED(return);
 721
 722         BT_INIT_PARAMS();
 723         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 724
 725         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 726         g_array_append_vals(in_param2, &profile, sizeof(int));
 727
 728         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_PROFILE_TRUSTED,
 729                         in_param1, in_param2, in_param3, in_param4, &out_param);
 730
 731         if (result == BLUETOOTH_ERROR_NONE) {
 732                 trust_profile = g_array_index(out_param, guint, 0);
 733                 BT_DBG("SUCCESSFUL");
 734         }
 735         BT_DBG("TRUST %d", trust_profile);
 736         *trust = trust_profile;
 737         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 738
 739         return result;
 740 }
 741
 742 BT_EXPORT_API int bluetooth_passkey_reply(char *passkey, gboolean reply)
 743 {
 744         int result;
 745
 746         char str_passkey[BLUETOOTH_DEVICE_PASSKEY_LENGTH_MAX];
 747
 748         BT_CHECK_PARAMETER(passkey, return);
 749         BT_CHECK_ENABLED(return);
 750
 751         BT_INIT_PARAMS();
 752         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 753
 754         g_strlcpy(str_passkey, passkey, sizeof(str_passkey));
 755         g_array_append_vals(in_param1, str_passkey, BLUETOOTH_DEVICE_PASSKEY_LENGTH_MAX);
 756         g_array_append_vals(in_param2, &reply, sizeof(gboolean));
 757
 758         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_PASSKEY_REPLY,
 759                 in_param1, in_param2, in_param3, in_param4, &out_param);
 760
 761         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 762
 763         return result;
 764 }
 765
 766 BT_EXPORT_API int bluetooth_passkey_confirmation_reply(gboolean reply)
 767 {
 768         int result;
 769
 770         BT_CHECK_ENABLED(return);
 771         BT_INIT_PARAMS();
 772
 773         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 774         g_array_append_vals(in_param1, &reply, sizeof(gboolean));
 775         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_PASSKEY_CONFIRMATION_REPLY,
 776                         in_param1, in_param2, in_param3, in_param4, &out_param);
 777         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 778
 779         return result;
 780 }