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_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_remote_device(const bluetooth_device_address_t *device_address)
 186 {
 187         return BLUETOOTH_ERROR_NONE;
 188 }
 189
 190 BT_EXPORT_API int bluetooth_search_service(const bluetooth_device_address_t *device_address)
 191 {
 192         int result;
 193         bt_user_info_t *user_info;
 194
 195         BT_CHECK_PARAMETER(device_address, return);
 196         BT_CHECK_ENABLED(return);
 197
 198         if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_SEARCH_SERVICE)
 199              == BLUETOOTH_ERROR_PERMISSION_DEINED) {
 200                 BT_ERR("Don't have a privilege to use this API");
 201                 return BLUETOOTH_ERROR_PERMISSION_DEINED;
 202         }
 203
 204         user_info = _bt_get_user_data(BT_COMMON);
 205         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
 206
 207         BT_INIT_PARAMS();
 208         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 209
 210         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 211
 212         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_SEARCH_SERVICE,
 213                 in_param1, in_param2, in_param3, in_param4,
 214                 user_info->cb, user_info->user_data);
 215
 216         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 217
 218         return result;
 219 }
 220
 221 BT_EXPORT_API int bluetooth_cancel_service_search(void)
 222 {
 223         int result;
 224
 225         BT_CHECK_ENABLED(return);
 226
 227         BT_INIT_PARAMS();
 228         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 229
 230         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_CANCEL_SEARCH_SERVICE,
 231                 in_param1, in_param2, in_param3, in_param4, &out_param);
 232
 233         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 234
 235         return result;
 236 }
 237
 238 BT_EXPORT_API int bluetooth_set_alias(const bluetooth_device_address_t *device_address,
 239                                       const char *alias)
 240 {
 241         int result;
 242         char alias_name[BLUETOOTH_DEVICE_NAME_LENGTH_MAX];
 243
 244         BT_CHECK_PARAMETER(device_address, return);
 245         BT_CHECK_PARAMETER(alias, return);
 246         BT_CHECK_ENABLED(return);
 247
 248         BT_INIT_PARAMS();
 249         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 250
 251         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 252         g_strlcpy(alias_name, alias, sizeof(alias_name));
 253         g_array_append_vals(in_param2, alias_name, BLUETOOTH_DEVICE_NAME_LENGTH_MAX);
 254
 255         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_ALIAS,
 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_authorize_device(const bluetooth_device_address_t *device_address,
 264                                              gboolean authorized)
 265 {
 266         int result;
 267
 268         BT_CHECK_PARAMETER(device_address, return);
 269         BT_CHECK_ENABLED(return);
 270
 271         BT_INIT_PARAMS();
 272         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 273
 274         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 275         g_array_append_vals(in_param2, &authorized, sizeof(gboolean));
 276
 277         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_AUTHORIZATION,
 278                 in_param1, in_param2, in_param3, in_param4, &out_param);
 279
 280         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 281
 282         return result;
 283 }
 284
 285 BT_EXPORT_API int bluetooth_is_device_connected(const bluetooth_device_address_t *device_address,
 286                                 bluetooth_service_type_t type,
 287                                 gboolean *is_connected)
 288 {
 289         int result;
 290
 291         BT_CHECK_PARAMETER(device_address, return);
 292         BT_CHECK_PARAMETER(is_connected, return);
 293         BT_CHECK_ENABLED(return);
 294
 295 #ifdef RFCOMM_DIRECT
 296         if (type & BLUETOOTH_RFCOMM_SERVICE) {
 297                 result = bluetooth_rfcomm_client_is_connected(device_address, is_connected);
 298                 if (*is_connected == FALSE)
 299                         result = bluetooth_rfcomm_server_is_connected(device_address, is_connected);
 300
 301                 return result;
 302         }
 303 #endif
 304
 305         BT_INIT_PARAMS();
 306         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 307
 308         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 309         g_array_append_vals(in_param2, &type, sizeof(int));
 310
 311         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_IS_DEVICE_CONNECTED,
 312                 in_param1, in_param2, in_param3, in_param4, &out_param);
 313
 314         if (result == BLUETOOTH_ERROR_NONE) {
 315                 *is_connected = g_array_index(out_param, gboolean, 0);
 316         }
 317
 318         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 319
 320         return result;
 321 }
 322
 323 BT_EXPORT_API int bluetooth_connect_le(const bluetooth_device_address_t *device_address, gboolean auto_connect)
 324 {
 325         int result;
 326         bt_user_info_t *user_info;
 327
 328         BT_CHECK_PARAMETER(device_address, return);
 329         BT_CHECK_ENABLED_ANY(return);
 330
 331         if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_CONNECT_LE)
 332                         == BLUETOOTH_ERROR_PERMISSION_DEINED) {
 333                 BT_ERR("Don't have a privilege to use this API");
 334                 return BLUETOOTH_ERROR_PERMISSION_DEINED;
 335         }
 336
 337         BT_INIT_PARAMS();
 338         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 339
 340         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 341         g_array_append_vals(in_param2, &auto_connect, sizeof(gboolean));
 342
 343         user_info = _bt_get_user_data(BT_COMMON);
 344         retv_if(user_info == NULL, BLUETOOTH_ERROR_INTERNAL);
 345
 346         BT_INFO_C("### Connect LE");
 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         if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_DISCONNECT_LE)
 365              == BLUETOOTH_ERROR_PERMISSION_DEINED) {
 366                 BT_ERR("Don't have a privilege to use this API");
 367                 return BLUETOOTH_ERROR_PERMISSION_DEINED;
 368         }
 369
 370         BT_INIT_PARAMS();
 371         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 372
 373         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 374         user_info = _bt_get_user_data(BT_COMMON);
 375         retv_if(user_info == NULL, BLUETOOTH_ERROR_INTERNAL);
 376
 377         BT_INFO_C("### Disconnect LE");
 378         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_DISCONNECT_LE,
 379                 in_param1, in_param2, in_param3, in_param4,
 380                 user_info->cb, user_info->user_data);
 381
 382         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 383
 384         return result;
 385 }
 386
 387 BT_EXPORT_API int bluetooth_enable_rssi(const bluetooth_device_address_t *remote_address,
 388                 int link_type, bt_rssi_threshold_t *rssi_threshold)
 389 {
 390 #ifdef __BROADCOM_PATCH__
 391         int result;
 392
 393         BT_CHECK_ENABLED(return);
 394
 395         BT_INIT_PARAMS();
 396         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 397         g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
 398         g_array_append_vals(in_param2, &link_type, sizeof(int));
 399         g_array_append_vals(in_param3, rssi_threshold, sizeof(bt_rssi_threshold_t));
 400
 401         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_ENABLE_RSSI,
 402                 in_param1, in_param2, in_param3, in_param4, &out_param);
 403
 404         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 405
 406         return result;
 407 #else
 408         BT_ERR("Current chipset does not support this function.");
 409         return BLUETOOTH_ERROR_NOT_SUPPORT;
 410 #endif
 411 }
 412
 413 BT_EXPORT_API int bluetooth_get_rssi_strength(const bluetooth_device_address_t *remote_address, int link_type)
 414 {
 415 #ifdef __BROADCOM_PATCH__
 416         int result;
 417
 418         BT_CHECK_ENABLED(return);
 419
 420         BT_INIT_PARAMS();
 421         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 422         g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
 423         g_array_append_vals(in_param2, &link_type, sizeof(int));
 424
 425         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_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_le_conn_update(const bluetooth_device_address_t *address,
 438                                         const bluetooth_le_connection_param_t *parameters)
 439 {
 440         int result;
 441
 442         BT_CHECK_ENABLED(return);
 443         BT_CHECK_PARAMETER(address, return);
 444         BT_CHECK_PARAMETER(parameters, return);
 445
 446         BT_INIT_PARAMS();
 447         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 448
 449         g_array_append_vals(in_param1, address,
 450                         sizeof(bluetooth_device_address_t));
 451         g_array_append_vals(in_param2, parameters,
 452                         sizeof(bluetooth_le_connection_param_t));
 453
 454         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_LE_CONN_UPDATE,
 455                         in_param1, in_param2, in_param3, in_param4, &out_param);
 456
 457         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 458
 459         return result;
 460 }
 461
 462 BT_EXPORT_API int bluetooth_get_connected_link_type(
 463                 const bluetooth_device_address_t *device_address,
 464                 bluetooth_connected_link_t *connected)
 465 {
 466         int result;
 467
 468         BT_CHECK_PARAMETER(device_address, return);
 469         BT_CHECK_ENABLED(return);
 470
 471         BT_INIT_PARAMS();
 472         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 473
 474         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 475
 476         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_CONNECTED_LINK_TYPE,
 477                         in_param1, in_param2, in_param3, in_param4, &out_param);
 478
 479         if (result == BLUETOOTH_ERROR_NONE) {
 480                 *connected = g_array_index(out_param, guint, 0);
 481         }
 482
 483         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 484
 485         return result;
 486 }
 487
 488 BT_EXPORT_API int bluetooth_set_pin_code(
 489                 const bluetooth_device_address_t *device_address,
 490                 const bluetooth_device_pin_code_t *pin_code)
 491 {
 492         int result;
 493
 494         BT_CHECK_PARAMETER(device_address, return);
 495         BT_CHECK_PARAMETER(pin_code, return);
 496         BT_CHECK_ENABLED(return);
 497
 498         BT_INIT_PARAMS();
 499         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 500
 501         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 502         g_array_append_vals(in_param2, pin_code, sizeof(bluetooth_device_pin_code_t));
 503
 504         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_PIN_CODE,
 505                 in_param1, in_param2, in_param3, in_param4, &out_param);
 506
 507         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 508
 509         return result;
 510 }
 511
 512 BT_EXPORT_API int bluetooth_unset_pin_code(
 513                 const bluetooth_device_address_t *device_address)
 514 {
 515         int result;
 516
 517         BT_CHECK_PARAMETER(device_address, return);
 518         BT_CHECK_ENABLED(return);
 519
 520         BT_INIT_PARAMS();
 521         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 522
 523         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 524
 525         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_UNSET_PIN_CODE,
 526                 in_param1, in_param2, in_param3, in_param4, &out_param);
 527
 528         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 529
 530         return result;
 531 }
 532
 533 BT_EXPORT_API int bluetooth_update_le_connection_mode(const bluetooth_device_address_t *address,
 534                 const bluetooth_le_connection_mode_t mode)
 535 {
 536         int result;
 537
 538         BT_CHECK_ENABLED(return);
 539         BT_CHECK_PARAMETER(address, return);
 540
 541         BT_INIT_PARAMS();
 542         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 543
 544         g_array_append_vals(in_param1, address,
 545                         sizeof(bluetooth_device_address_t));
 546         g_array_append_vals(in_param2, &mode,
 547                         sizeof(bluetooth_le_connection_mode_t));
 548
 549         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_UPDATE_LE_CONNECTION_MODE,
 550                         in_param1, in_param2, in_param3, in_param4, &out_param);
 551
 552         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 553
 554         return result;
 555 }
 556
 557 BT_EXPORT_API int bluetooth_request_att_mtu(const bluetooth_device_address_t *device_address, unsigned int mtu)
 558 {
 559         int result;
 560         bt_user_info_t *user_info;
 561
 562         BT_CHECK_PARAMETER(device_address, return);
 563         BT_CHECK_ENABLED_ANY(return);
 564
 565         if (mtu > BLUETOOTH_MAX_ATT_MTU)
 566                 return BLUETOOTH_ERROR_INVALID_PARAM;
 567
 568         if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_REQ_ATT_MTU)
 569              == BLUETOOTH_ERROR_PERMISSION_DEINED) {
 570                 BT_ERR("Don't have a privilege to use this API");
 571                 return BLUETOOTH_ERROR_PERMISSION_DEINED;
 572         }
 573
 574         BT_INIT_PARAMS();
 575         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 576
 577         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 578         g_array_append_vals(in_param2, &mtu, sizeof(unsigned int));
 579
 580         user_info = _bt_get_user_data(BT_COMMON);
 581         retv_if(user_info == NULL, BLUETOOTH_ERROR_INTERNAL);
 582
 583         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_REQ_ATT_MTU,
 584                 in_param1, in_param2, in_param3, in_param4,
 585                 user_info->cb, user_info->user_data);
 586
 587         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 588
 589         return result;
 590 }
 591
 592 BT_EXPORT_API int bluetooth_get_att_mtu(const bluetooth_device_address_t *device_address,
 593                                 unsigned int *mtu)
 594 {
 595         int result;
 596
 597         BT_CHECK_PARAMETER(device_address, return);
 598         BT_CHECK_PARAMETER(mtu, return);
 599         BT_CHECK_ENABLED(return);
 600
 601         BT_INIT_PARAMS();
 602         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 603
 604         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 605
 606         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_ATT_MTU,
 607                 in_param1, in_param2, in_param3, in_param4, &out_param);
 608
 609         if (result == BLUETOOTH_ERROR_NONE) {
 610                 *mtu = g_array_index(out_param, unsigned int, 0);
 611         }
 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_get_device_ida(const bluetooth_device_address_t *device_rpa,
 619         bluetooth_device_address_t *id_address)
 620 {
 621         int result;
 622
 623         BT_CHECK_PARAMETER(device_rpa, return);
 624         BT_CHECK_PARAMETER(id_address, return);
 625         BT_CHECK_ENABLED_ANY(return);
 626
 627         BT_INIT_PARAMS();
 628         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 629
 630         g_array_append_vals(in_param1, device_rpa, sizeof(bluetooth_device_address_t));
 631
 632         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_DEVICE_IDA,
 633                 in_param1, in_param2, in_param3, in_param4, &out_param);
 634
 635         if (result == BLUETOOTH_ERROR_NONE) {
 636                 *id_address = g_array_index(out_param,
 637                         bluetooth_device_address_t, 0);
 638         }
 639
 640         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 641
 642         return result;
 643 }
 644
 645 BT_EXPORT_API int bluetooth_force_hcidump(int timeout)
 646 {
 647         int result;
 648
 649         BT_CHECK_ENABLED_ANY(return);
 650
 651         BT_INIT_PARAMS();
 652         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 653
 654         g_array_append_vals(in_param1, &timeout, sizeof(int));
 655
 656         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_ENABLE_FORCE_HCI_DUMP,
 657                 in_param1, in_param2, in_param3, in_param4, &out_param);
 658
 659         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 660
 661         return result;
 662 }
 663
 664 BT_EXPORT_API int bluetooth_set_profile_trusted(
 665                 const bluetooth_device_address_t *device_address,
 666                 int profile, int trust)
 667 {
 668         int result;
 669
 670         BT_CHECK_PARAMETER(device_address, return);
 671         BT_CHECK_ENABLED(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, device_address, sizeof(bluetooth_device_address_t));
 677         g_array_append_vals(in_param2, &profile, sizeof(int));
 678         g_array_append_vals(in_param3, &trust, sizeof(int));
 679
 680         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_PROFILE_TRUSTED,
 681                         in_param1, in_param2, in_param3, in_param4, &out_param);
 682
 683         if (result == BLUETOOTH_ERROR_NONE) {
 684                 BT_DBG("SUCCESSFUL");
 685         }
 686
 687         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 688
 689         return result;
 690 }
 691
 692 BT_EXPORT_API int bluetooth_get_profile_trusted(
 693                 const bluetooth_device_address_t *device_address,
 694                 int profile, int *trust)
 695 {
 696         int result;
 697         int trust_profile = 0;
 698         BT_CHECK_PARAMETER(device_address, return);
 699         BT_CHECK_ENABLED(return);
 700
 701         BT_INIT_PARAMS();
 702         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 703
 704         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 705         g_array_append_vals(in_param2, &profile, sizeof(int));
 706
 707         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_PROFILE_TRUSTED,
 708                         in_param1, in_param2, in_param3, in_param4, &out_param);
 709
 710         if (result == BLUETOOTH_ERROR_NONE) {
 711                 trust_profile = g_array_index(out_param, guint, 0);
 712                 BT_DBG("SUCCESSFUL");
 713         }
 714         BT_DBG("TRUST %d", trust_profile);
 715         *trust = trust_profile;
 716         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 717
 718         return result;
 719 }
 720
 721 BT_EXPORT_API int bluetooth_set_profile_restricted(
 722                 const bluetooth_device_address_t *device_address,
 723                 int profile, int restricted)
 724 {
 725         int result;
 726
 727         BT_CHECK_PARAMETER(device_address, return);
 728         BT_CHECK_ENABLED(return);
 729
 730         BT_INIT_PARAMS();
 731         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 732
 733         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 734         g_array_append_vals(in_param2, &profile, sizeof(int));
 735         g_array_append_vals(in_param3, &restricted, sizeof(int));
 736
 737         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_PROFILE_RESTRICTED,
 738                         in_param1, in_param2, in_param3, in_param4, &out_param);
 739
 740         if (result == BLUETOOTH_ERROR_NONE) {
 741                 BT_DBG("SUCCESSFUL");
 742         }
 743
 744         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 745
 746         return result;
 747 }
 748
 749 BT_EXPORT_API int bluetooth_get_profile_restricted(
 750                 const bluetooth_device_address_t *device_address,
 751                 int profile, int *restricted)
 752 {
 753         int result;
 754         int restrict_profile = 0;
 755         BT_CHECK_PARAMETER(device_address, return);
 756         BT_CHECK_ENABLED(return);
 757
 758         BT_INIT_PARAMS();
 759         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 760
 761         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 762         g_array_append_vals(in_param2, &profile, sizeof(int));
 763
 764         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_PROFILE_RESTRICTED,
 765                         in_param1, in_param2, in_param3, in_param4, &out_param);
 766
 767         if (result == BLUETOOTH_ERROR_NONE) {
 768                 restrict_profile = g_array_index(out_param, guint, 0);
 769                 BT_DBG("SUCCESSFUL");
 770         }
 771         BT_DBG("Restricted %d", restrict_profile);
 772         *restricted = restrict_profile;
 773         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 774
 775         return result;
 776 }
 777
 778 BT_EXPORT_API int bluetooth_passkey_reply(char *passkey, gboolean reply)
 779 {
 780         int result;
 781
 782         char str_passkey[BLUETOOTH_DEVICE_PASSKEY_LENGTH_MAX];
 783
 784         BT_CHECK_PARAMETER(passkey, return);
 785         BT_CHECK_ENABLED(return);
 786
 787         BT_INIT_PARAMS();
 788         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 789
 790         g_strlcpy(str_passkey, passkey, sizeof(str_passkey));
 791         g_array_append_vals(in_param1, str_passkey, BLUETOOTH_DEVICE_PASSKEY_LENGTH_MAX);
 792         g_array_append_vals(in_param2, &reply, sizeof(gboolean));
 793
 794         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_PASSKEY_REPLY,
 795                 in_param1, in_param2, in_param3, in_param4, &out_param);
 796
 797         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 798
 799         return result;
 800 }
 801
 802 BT_EXPORT_API int bluetooth_passkey_confirmation_reply(gboolean reply)
 803 {
 804         int result;
 805
 806         BT_CHECK_ENABLED(return);
 807         BT_INIT_PARAMS();
 808
 809         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 810         g_array_append_vals(in_param1, &reply, sizeof(gboolean));
 811         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_PASSKEY_CONFIRMATION_REPLY,
 812                         in_param1, in_param2, in_param3, in_param4, &out_param);
 813         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 814
 815         return result;
 816 }