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