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