bt-api/bt-adapter.c

   1 /*
   2  * Bluetooth-frwk
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact:  Hocheol Seo <hocheol.seo@samsung.com>
   7  *               Girishashok Joshi <girish.joshi@samsung.com>
   8  *               Chanyeol Park <chanyeol.park@samsung.com>
   9  *
  10  * Licensed under the Apache License, Version 2.0 (the "License");
  11  * you may not use this file except in compliance with the License.
  12  * You may obtain a copy of the License at
  13  *
  14  *              http://www.apache.org/licenses/LICENSE-2.0
  15  *
  16  * Unless required by applicable law or agreed to in writing, software
  17  * distributed under the License is distributed on an "AS IS" BASIS,
  18  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  19  * See the License for the specific language governing permissions and
  20  * limitations under the License.
  21  *
  22  */
  23
  24 #include <vconf.h>
  25
  26 #include "bluetooth-api.h"
  27 #include "bt-internal-types.h"
  28
  29 #include "bt-common.h"
  30 #include "bt-request-sender.h"
  31 #include "bt-event-handler.h"
  32
  33 static int __bt_fill_device_list(GArray *out_param2, GPtrArray **dev_list)
  34 {
  35         int i;
  36         guint size;
  37         bluetooth_device_info_t info;
  38
  39         BT_CHECK_PARAMETER(out_param2, return);
  40         BT_CHECK_PARAMETER(dev_list, return);
  41
  42         size = out_param2->len;
  43
  44         if (size == 0) {
  45                 BT_ERR("No bonded device");
  46                 return BLUETOOTH_ERROR_NONE;
  47         }
  48
  49         size = (out_param2->len) / sizeof(bluetooth_device_info_t);
  50
  51         for (i = 0; i < size; i++) {
  52                 bluetooth_device_info_t *dev_info = NULL;
  53
  54                 info = g_array_index(out_param2,
  55                                 bluetooth_device_info_t, i);
  56
  57                 dev_info = g_memdup(&info, sizeof(bluetooth_device_info_t));
  58
  59                 if (dev_info) {
  60                         g_ptr_array_add(*dev_list, (gpointer)dev_info);
  61                 }
  62         }
  63
  64         return BLUETOOTH_ERROR_NONE;
  65 }
  66
  67 BT_EXPORT_API int bluetooth_check_adapter(void)
  68 {
  69         int ret;
  70         int value;
  71
  72         ret = _bt_get_adapter_path(_bt_gdbus_get_system_gconn(), NULL);
  73
  74         if (ret != BLUETOOTH_ERROR_NONE) {
  75                 return BLUETOOTH_ADAPTER_DISABLED;
  76         }
  77
  78         /* check VCONFKEY_BT_STATUS */
  79         if (vconf_get_int(VCONFKEY_BT_STATUS, &value) != 0) {
  80                 BT_ERR("fail to get vconf key!");
  81                 return BLUETOOTH_ADAPTER_DISABLED;
  82         }
  83
  84         return value == VCONFKEY_BT_STATUS_OFF ? BLUETOOTH_ADAPTER_DISABLED :
  85                                                 BLUETOOTH_ADAPTER_ENABLED;
  86 }
  87
  88 BT_EXPORT_API int bluetooth_enable_adapter(void)
  89 {
  90         int result;
  91
  92         BT_INFO("");
  93         retv_if(bluetooth_check_adapter() == BLUETOOTH_ADAPTER_ENABLED,
  94                                 BLUETOOTH_ERROR_DEVICE_ALREADY_ENABLED);
  95
  96         BT_INIT_PARAMS();
  97         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
  98
  99         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_ENABLE_ADAPTER,
 100                 in_param1, in_param2, in_param3, in_param4, &out_param);
 101
 102         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 103
 104         return result;
 105 }
 106
 107 BT_EXPORT_API int bluetooth_disable_adapter(void)
 108 {
 109         int result;
 110
 111         BT_INFO("");
 112         BT_CHECK_ENABLED(return);
 113
 114         BT_INIT_PARAMS();
 115         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 116
 117         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DISABLE_ADAPTER,
 118                 in_param1, in_param2, in_param3, in_param4, &out_param);
 119
 120         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 121
 122         return result;
 123 }
 124
 125 BT_EXPORT_API int bluetooth_recover_adapter(void)
 126 {
 127         int result;
 128
 129         BT_INFO("");
 130         BT_CHECK_ENABLED(return);
 131
 132         BT_INIT_PARAMS();
 133         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 134
 135         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_RECOVER_ADAPTER,
 136                 in_param1, in_param2, in_param3, in_param4, &out_param);
 137
 138         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 139
 140         return result;
 141 }
 142
 143 BT_EXPORT_API int bluetooth_reset_adapter(void)
 144 {
 145         int result;
 146
 147         BT_INFO("");
 148         BT_INIT_PARAMS();
 149         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 150
 151         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_RESET_ADAPTER,
 152                 in_param1, in_param2, in_param3, in_param4, &out_param);
 153
 154         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 155
 156         return result;
 157 }
 158
 159 BT_EXPORT_API int bluetooth_get_local_address(bluetooth_device_address_t *local_address)
 160 {
 161         int result;
 162
 163         BT_CHECK_PARAMETER(local_address, return);
 164         BT_CHECK_ENABLED_ANY(return);
 165
 166         BT_INIT_PARAMS();
 167         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 168
 169         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_LOCAL_ADDRESS,
 170                 in_param1, in_param2, in_param3, in_param4, &out_param);
 171
 172         if (result == BLUETOOTH_ERROR_NONE) {
 173                 *local_address = g_array_index(out_param,
 174                         bluetooth_device_address_t, 0);
 175         }
 176
 177         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 178
 179         return result;
 180 }
 181
 182 BT_EXPORT_API int bluetooth_get_local_version(bluetooth_version_t *local_version)
 183 {
 184         int result;
 185
 186         BT_CHECK_PARAMETER(local_version, return);
 187         BT_CHECK_ENABLED_ANY(return);
 188
 189         BT_INIT_PARAMS();
 190         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 191
 192         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_LOCAL_VERSION,
 193                 in_param1, in_param2, in_param3, in_param4, &out_param);
 194
 195         if (result == BLUETOOTH_ERROR_NONE) {
 196                 *local_version = g_array_index(out_param, bluetooth_version_t, 0);
 197         }
 198
 199         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 200
 201         return result;
 202 }
 203
 204 BT_EXPORT_API int bluetooth_get_local_name(bluetooth_device_name_t *local_name)
 205 {
 206         int result;
 207
 208         BT_CHECK_PARAMETER(local_name, return);
 209         BT_CHECK_ENABLED_ANY(return);
 210
 211         BT_INIT_PARAMS();
 212         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 213
 214         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_LOCAL_NAME,
 215                 in_param1, in_param2, in_param3, in_param4, &out_param);
 216
 217         if (result == BLUETOOTH_ERROR_NONE) {
 218                 *local_name = g_array_index(out_param,
 219                                 bluetooth_device_name_t, 0);
 220         }
 221
 222         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 223
 224         return result;
 225 }
 226
 227 BT_EXPORT_API int bluetooth_set_local_name(const bluetooth_device_name_t *local_name)
 228 {
 229         int result;
 230
 231         BT_CHECK_PARAMETER(local_name, return);
 232         BT_CHECK_ENABLED_ANY(return);
 233
 234         BT_INIT_PARAMS();
 235         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 236
 237         g_array_append_vals(in_param1, local_name, sizeof(bluetooth_device_name_t));
 238
 239         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_LOCAL_NAME,
 240                 in_param1, in_param2, in_param3, in_param4, &out_param);
 241
 242         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 243
 244         return result;
 245 }
 246
 247 BT_EXPORT_API int bluetooth_is_service_used(const char *service_uuid,
 248                                                 gboolean *used)
 249 {
 250         int result;
 251         char uuid[BLUETOOTH_UUID_STRING_MAX];
 252
 253         BT_CHECK_PARAMETER(service_uuid, return);
 254         BT_CHECK_PARAMETER(used, return);
 255         BT_CHECK_ENABLED(return);
 256
 257         BT_INIT_PARAMS();
 258         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 259
 260         g_strlcpy(uuid, service_uuid, sizeof(uuid));
 261         g_array_append_vals(in_param1, uuid, BLUETOOTH_UUID_STRING_MAX);
 262
 263         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_IS_SERVICE_USED,
 264                 in_param1, in_param2, in_param3, in_param4, &out_param);
 265
 266         if (result == BLUETOOTH_ERROR_NONE) {
 267                 *used = g_array_index(out_param, gboolean, 0);
 268         }
 269
 270         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 271
 272         return result;
 273 }
 274
 275 BT_EXPORT_API int bluetooth_get_discoverable_mode(bluetooth_discoverable_mode_t *
 276                                                   discoverable_mode_ptr)
 277 {
 278         int result;
 279
 280         BT_CHECK_PARAMETER(discoverable_mode_ptr, return);
 281
 282 #ifndef TIZEN_WEARABLE
 283         int timeout = 0;
 284         /* Requirement in OSP */
 285         if (bluetooth_check_adapter() == BLUETOOTH_ADAPTER_DISABLED) {
 286                 if (vconf_get_int(BT_FILE_VISIBLE_TIME, &timeout) != 0) {
 287                         BT_ERR("Fail to get the timeout value");
 288                         return BLUETOOTH_ERROR_INTERNAL;
 289                 }
 290
 291                 if (timeout == -1) {
 292                         *discoverable_mode_ptr = BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE;
 293                 } else {
 294                         *discoverable_mode_ptr = BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE;
 295                 }
 296
 297                 return BLUETOOTH_ERROR_NONE;
 298         }
 299 #endif
 300
 301         BT_INIT_PARAMS();
 302         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 303
 304         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_DISCOVERABLE_MODE,
 305                 in_param1, in_param2, in_param3, in_param4, &out_param);
 306
 307         if (result == BLUETOOTH_ERROR_NONE) {
 308                 *discoverable_mode_ptr = g_array_index(out_param, int, 0);
 309         }
 310
 311         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 312
 313         return result;
 314 }
 315
 316 BT_EXPORT_API int bluetooth_set_discoverable_mode(bluetooth_discoverable_mode_t discoverable_mode,
 317                                                   int timeout)
 318 {
 319         int result;
 320
 321         BT_CHECK_ENABLED(return);
 322
 323         BT_INIT_PARAMS();
 324         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 325
 326         g_array_append_vals(in_param1, &discoverable_mode, sizeof(int));
 327         g_array_append_vals(in_param2, &timeout, sizeof(int));
 328
 329         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_DISCOVERABLE_MODE,
 330                 in_param1, in_param2, in_param3, in_param4, &out_param);
 331
 332         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 333
 334         return result;
 335 }
 336
 337 BT_EXPORT_API int bluetooth_get_timeout_value(int *timeout)
 338 {
 339         int result;
 340
 341         BT_CHECK_PARAMETER(timeout, return);
 342         BT_CHECK_ENABLED(return);
 343
 344         BT_INIT_PARAMS();
 345         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 346
 347         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_DISCOVERABLE_TIME,
 348                 in_param1, in_param2, in_param3, in_param4, &out_param);
 349
 350         if (result == BLUETOOTH_ERROR_NONE) {
 351                 *timeout = g_array_index(out_param, int, 0);
 352         }
 353
 354         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 355
 356         return result;
 357 }
 358
 359 BT_EXPORT_API int bluetooth_start_discovery(unsigned short max_response,
 360                                             unsigned short discovery_duration,
 361                                             unsigned int classOfDeviceMask)
 362 {
 363         int result;
 364
 365         BT_CHECK_ENABLED(return);
 366
 367         BT_INIT_PARAMS();
 368         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 369
 370         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_START_DISCOVERY,
 371                 in_param1, in_param2, in_param3, in_param4, &out_param);
 372
 373         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 374
 375         return result;
 376 }
 377
 378 BT_EXPORT_API int bluetooth_start_custom_discovery(bt_discovery_role_type_t role,
 379                                                 unsigned short max_response,
 380                                                 unsigned short discovery_duration,
 381                                                 unsigned int classOfDeviceMask)
 382 {
 383         int result;
 384
 385         if (role == DISCOVERY_ROLE_LE)
 386                 BT_CHECK_ENABLED_LE(return);
 387         else
 388                 BT_CHECK_ENABLED(return);
 389
 390         BT_INIT_PARAMS();
 391         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 392
 393         g_array_append_vals(in_param1, &role, sizeof(bt_discovery_role_type_t));
 394         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_START_CUSTOM_DISCOVERY,
 395                 in_param1, in_param2, in_param3, in_param4, &out_param);
 396
 397         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 398
 399         return result;
 400 }
 401
 402 BT_EXPORT_API int bluetooth_cancel_discovery(void)
 403 {
 404         int result;
 405
 406         BT_CHECK_ENABLED(return);
 407
 408         BT_INIT_PARAMS();
 409         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 410
 411         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_CANCEL_DISCOVERY,
 412                 in_param1, in_param2, in_param3, in_param4, &out_param);
 413
 414
 415         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 416
 417         return result;
 418 }
 419
 420 BT_EXPORT_API int bluetooth_is_discovering(void)
 421 {
 422         int result;
 423         int is_discovering = FALSE;
 424
 425         BT_CHECK_ENABLED(return);
 426
 427         BT_INIT_PARAMS();
 428         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 429
 430         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_IS_DISCOVERYING,
 431                 in_param1, in_param2, in_param3, in_param4, &out_param);
 432
 433         if (result == BLUETOOTH_ERROR_NONE) {
 434                 is_discovering = g_array_index(out_param,
 435                                 int, 0);
 436         } else {
 437                 BT_ERR("Fail to send request");
 438         }
 439
 440         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 441
 442         return is_discovering;
 443 }
 444
 445 BT_EXPORT_API int bluetooth_is_connectable(gboolean *is_connectable)
 446 {
 447         int result;
 448
 449         BT_CHECK_ENABLED_ANY(return);
 450
 451         BT_INIT_PARAMS();
 452         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 453
 454         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_IS_CONNECTABLE,
 455                 in_param1, in_param2, in_param3, in_param4, &out_param);
 456
 457         if (result == BLUETOOTH_ERROR_NONE) {
 458                 *is_connectable = g_array_index(out_param, int, 0);
 459         } else {
 460                 BT_ERR("Fail to send request");
 461         }
 462
 463         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 464
 465         return result;
 466 }
 467
 468 BT_EXPORT_API int bluetooth_set_connectable(gboolean is_connectable)
 469 {
 470         int result;
 471
 472         BT_CHECK_ENABLED_ANY(return);
 473
 474         BT_INIT_PARAMS();
 475         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 476
 477         g_array_append_vals(in_param1, &is_connectable, sizeof(gboolean));
 478
 479         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_CONNECTABLE,
 480                 in_param1, in_param2, in_param3, in_param4, &out_param);
 481
 482         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 483
 484         return result;
 485 }
 486
 487 BT_EXPORT_API int bluetooth_get_bonded_device_list(GPtrArray **dev_list)
 488 {
 489         int result;
 490
 491         BT_CHECK_PARAMETER(dev_list, return);
 492         BT_CHECK_ENABLED(return);
 493
 494         BT_INIT_PARAMS();
 495         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 496
 497         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_BONDED_DEVICES,
 498                 in_param1, in_param2, in_param3, in_param4, &out_param);
 499
 500         if (result == BLUETOOTH_ERROR_NONE)
 501                 result = __bt_fill_device_list(out_param, dev_list);
 502
 503         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 504
 505         return result;
 506 }
 507
 508 BT_EXPORT_API int bluetooth_set_manufacturer_data(const bluetooth_manufacturer_data_t *value)
 509 {
 510         int result;
 511
 512         BT_CHECK_PARAMETER(value, return);
 513         BT_CHECK_ENABLED_ANY(return);
 514
 515         if (value->data_len > BLUETOOTH_MANUFACTURER_DATA_LENGTH_MAX)
 516                 return BLUETOOTH_ERROR_INVALID_PARAM;
 517
 518         BT_INIT_PARAMS();
 519         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 520
 521         g_array_append_vals(in_param1, value, sizeof(bluetooth_manufacturer_data_t));
 522
 523         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_MANUFACTURER_DATA,
 524                 in_param1, in_param2, in_param3, in_param4, &out_param);
 525
 526         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 527
 528         return result;
 529 }