mobile/src/bluetooth-adapter.c

   1 /*
   2  * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
   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 #include <glib.h>
  18 #include <string.h>
  19 #include <stdlib.h>
  20 #include <ctype.h>
  21 #include <dlog.h>
  22 #include <stdio.h>
  23 #include <stdbool.h>
  24 #include <bluetooth-api.h>
  25
  26 #include "bluetooth.h"
  27 #include "bluetooth_private.h"
  28
  29 int bt_adapter_enable(void)
  30 {
  31         int error_code = BT_ERROR_NONE;
  32
  33         BT_CHECK_INIT_STATUS();
  34         error_code = _bt_get_error_code(bluetooth_enable_adapter());
  35         if (error_code != BT_ERROR_NONE) {
  36                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code);
  37         }
  38         return error_code;
  39 }
  40
  41 int bt_adapter_disable(void)
  42 {
  43         int error_code = BT_ERROR_NONE;
  44
  45         BT_CHECK_INIT_STATUS();
  46         error_code = _bt_get_error_code(bluetooth_disable_adapter());
  47         if (error_code != BT_ERROR_NONE) {
  48                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code);
  49         }
  50         return error_code;
  51 }
  52
  53 int bt_adapter_reset(void)
  54 {
  55         int error_code = BT_ERROR_NONE;
  56
  57         BT_CHECK_INIT_STATUS();
  58         error_code = _bt_get_error_code(bluetooth_reset_adapter());
  59         if (error_code != BT_ERROR_NONE) {
  60                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code);
  61         }
  62         return error_code;
  63 }
  64
  65 int bt_adapter_get_state(bt_adapter_state_e *adapter_state)
  66 {
  67         BT_CHECK_INIT_STATUS();
  68         BT_CHECK_INPUT_PARAMETER(adapter_state);
  69
  70         *adapter_state = bluetooth_check_adapter();
  71         return BT_ERROR_NONE;
  72 }
  73
  74 int bt_adapter_get_address(char **address)
  75 {
  76         bluetooth_device_address_t loc_address = { {0} };
  77         int error_code = BT_ERROR_NONE;
  78
  79         BT_CHECK_INIT_STATUS();
  80         BT_CHECK_INPUT_PARAMETER(address);
  81
  82         error_code = _bt_get_error_code(bluetooth_get_local_address(&loc_address));
  83         if (error_code != BT_ERROR_NONE) {
  84                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code);
  85                 return error_code;
  86         }
  87
  88         error_code = _bt_convert_address_to_string(address, &loc_address);
  89         if (error_code != BT_ERROR_NONE) {
  90                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code);
  91                 return error_code;
  92         }
  93
  94         return BT_ERROR_NONE;
  95 }
  96
  97 int bt_adapter_get_name(char **name)
  98 {
  99         int ret = BT_ERROR_NONE;
 100         bluetooth_device_name_t loc_name = { {0} };
 101
 102         BT_CHECK_INIT_STATUS();
 103         BT_CHECK_INPUT_PARAMETER(name);
 104
 105         ret = _bt_get_error_code(bluetooth_get_local_name(&loc_name));
 106         if (ret != BT_ERROR_NONE) {
 107                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
 108                 return ret;
 109         }
 110
 111         *name = strdup(loc_name.name);
 112         if (*name == NULL) {
 113                 BT_ERR("OUT_OF_MEMORY(0x%08x)", BT_ERROR_OUT_OF_MEMORY);
 114                 return BT_ERROR_OUT_OF_MEMORY;
 115         }
 116
 117         return BT_ERROR_NONE;
 118 }
 119
 120 int bt_adapter_set_name(const char *name)
 121 {
 122         bluetooth_device_name_t loc_name = { {0} };
 123         int ret = BT_ERROR_NONE;
 124
 125         BT_CHECK_INIT_STATUS();
 126         BT_CHECK_INPUT_PARAMETER(name);
 127
 128         strncpy(loc_name.name, name, BLUETOOTH_DEVICE_NAME_LENGTH_MAX);
 129         loc_name.name[BLUETOOTH_DEVICE_NAME_LENGTH_MAX] = '\0';
 130
 131         ret = _bt_get_error_code(bluetooth_set_local_name(&loc_name));
 132         if (ret != BT_ERROR_NONE) {
 133                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
 134         }
 135
 136         return ret;
 137 }
 138
 139 int bt_adapter_get_visibility(bt_adapter_visibility_mode_e *mode, int *duration)
 140 {
 141         bluetooth_discoverable_mode_t discoverable_mode = BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE;
 142         int ret = BT_ERROR_NONE;
 143
 144         BT_CHECK_INIT_STATUS();
 145         BT_CHECK_INPUT_PARAMETER(mode);
 146
 147         ret = _bt_get_error_code(bluetooth_get_discoverable_mode(&discoverable_mode));
 148         if (ret != BT_ERROR_NONE) {
 149                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
 150                 return ret;
 151         }
 152
 153         *mode = _bt_get_bt_visibility_mode_e(discoverable_mode);
 154
 155         if (duration)
 156                 *duration = 0;
 157
 158         if (discoverable_mode == BLUETOOTH_DISCOVERABLE_MODE_TIME_LIMITED_DISCOVERABLE) {
 159                 if (duration == NULL)
 160                         return BT_ERROR_NONE;
 161                 ret = bluetooth_get_timeout_value(duration);
 162                 if (ret != BT_ERROR_NONE) {
 163                         BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
 164                 }
 165         }
 166
 167         return BT_ERROR_NONE;
 168 }
 169
 170 int bt_adapter_set_visibility(bt_adapter_visibility_mode_e visibility_mode, int timeout_sec)
 171 {
 172         bluetooth_discoverable_mode_t discoverable_mode = BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE;
 173         int error_code = BT_ERROR_NONE;
 174
 175         BT_CHECK_INIT_STATUS();
 176         switch (visibility_mode) {
 177         case BT_ADAPTER_VISIBILITY_MODE_LIMITED_DISCOVERABLE:
 178                 discoverable_mode = BLUETOOTH_DISCOVERABLE_MODE_TIME_LIMITED_DISCOVERABLE;
 179                 break;
 180         case BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE:
 181                 discoverable_mode = BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE;
 182                 timeout_sec = 0;
 183                 break;
 184         case BT_ADAPTER_VISIBILITY_MODE_GENERAL_DISCOVERABLE:
 185                 discoverable_mode = BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE;
 186                 timeout_sec = 0;
 187                 break;
 188         default:
 189                 BT_ERR("INVALID_PARAMETER(0x%08x)", BT_ERROR_INVALID_PARAMETER);
 190                 return BT_ERROR_INVALID_PARAMETER;
 191         }
 192
 193         error_code = _bt_get_error_code(bluetooth_set_discoverable_mode(discoverable_mode, timeout_sec));
 194         if (error_code != BT_ERROR_NONE) {
 195                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code);
 196         }
 197
 198         return error_code;
 199 }
 200
 201 int bt_adapter_foreach_bonded_device(bt_adapter_bonded_device_cb foreach_cb, void *user_data)
 202 {
 203         GPtrArray *dev_list = NULL;
 204         bt_device_info_s *dev_info = NULL;
 205         bluetooth_device_info_t *ptr = NULL;
 206         int ret = BT_ERROR_NONE;
 207         int i = 0;
 208
 209         BT_CHECK_INIT_STATUS();
 210         BT_CHECK_INPUT_PARAMETER(foreach_cb);
 211
 212         dev_list = g_ptr_array_new();
 213         if (dev_list == NULL) {
 214                 BT_ERR("OUT_OF_MEMORY(0x%08x)", BT_ERROR_OUT_OF_MEMORY);
 215                 return BT_ERROR_OUT_OF_MEMORY;
 216         }
 217
 218         ret = _bt_get_error_code(bluetooth_get_bonded_device_list(&dev_list));
 219         if (ret != BT_ERROR_NONE) {
 220                 BT_ERR("%s(0x%08x) : Failed to get bonded device list", _bt_convert_error_to_string(ret), ret);
 221                 return ret;
 222         }
 223
 224         for (i = 0; i < dev_list->len; i++) {
 225                 ptr = g_ptr_array_index(dev_list, i);
 226                 if (ptr != NULL) {
 227                         ret = _bt_get_bt_device_info_s(&dev_info, (bluetooth_device_info_t *)ptr);
 228                         if (ret != BT_ERROR_NONE) {
 229                                 BT_ERR("%s(0x%08x) : Failed to get device info", _bt_convert_error_to_string(ret), ret);
 230                                 break;
 231                         }
 232
 233                         if (!foreach_cb(dev_info, user_data)) {
 234                                 _bt_free_bt_device_info_s(dev_info);
 235                                 break;
 236                         }
 237                         _bt_free_bt_device_info_s(dev_info);
 238                 } else {
 239                         BT_ERR("OPERATION_FAILED(0x%08x)", BT_ERROR_OPERATION_FAILED);
 240                         ret = BT_ERROR_OPERATION_FAILED;
 241                         break;
 242                 }
 243         }
 244
 245         if (dev_list != NULL) {
 246                 g_ptr_array_foreach(dev_list, (GFunc)g_free, NULL);
 247                 g_ptr_array_free(dev_list, TRUE);
 248         }
 249
 250         return ret;
 251 }
 252
 253 int bt_adapter_get_bonded_device_info(const char *remote_address, bt_device_info_s **device_info)
 254 {
 255         int ret;
 256         bluetooth_device_address_t addr_hex = { {0,} };
 257         bluetooth_device_info_t *info;
 258
 259         BT_CHECK_INIT_STATUS();
 260         BT_CHECK_INPUT_PARAMETER(remote_address);
 261
 262         info = (bluetooth_device_info_t *)malloc(sizeof(bluetooth_device_info_t));
 263         if (info == NULL)
 264                 return BT_ERROR_OUT_OF_MEMORY;
 265
 266         _bt_convert_address_to_hex(&addr_hex, remote_address);
 267
 268         ret = _bt_get_error_code(bluetooth_get_bonded_device(&addr_hex, info));
 269         if (ret != BT_ERROR_NONE) {
 270                 BT_ERR("%s(0x%08x) : Failed to run function",
 271                                         _bt_convert_error_to_string(ret), ret);
 272         } else {
 273                 ret = _bt_get_bt_device_info_s(device_info, info);
 274                 if (ret != BT_ERROR_NONE) {
 275                         BT_ERR("%s(0x%08x) : Failed to get device info",
 276                                                 _bt_convert_error_to_string(ret),
 277                                                 ret);
 278                 }
 279         }
 280
 281         free(info);
 282
 283         return ret;
 284 }
 285
 286 int bt_adapter_free_device_info(bt_device_info_s *device_info)
 287 {
 288         BT_CHECK_INIT_STATUS();
 289         BT_CHECK_INPUT_PARAMETER(device_info);
 290
 291         _bt_free_bt_device_info_s(device_info);
 292
 293         return BT_ERROR_NONE;
 294 }
 295
 296 int bt_adapter_is_service_used(const char *service_uuid, bool *used)
 297 {
 298         int ret = BT_ERROR_NONE;
 299
 300         BT_CHECK_INIT_STATUS();
 301         BT_CHECK_INPUT_PARAMETER(service_uuid);
 302         BT_CHECK_INPUT_PARAMETER(used);
 303
 304         if (strcmp(service_uuid, OPP_UUID) == 0) {
 305                 *used = bluetooth_obex_server_is_activated();
 306         } else {
 307                 ret = _bt_get_error_code(bluetooth_is_service_used(service_uuid,
 308                                                         (gboolean *)used));
 309         }
 310
 311         if (ret != BT_ERROR_NONE) {
 312                 BT_ERR("%s(0x%08x) : Failed to run function", _bt_convert_error_to_string(ret), ret);
 313         }
 314
 315         return ret;
 316 }
 317
 318 int bt_adapter_set_state_changed_cb(bt_adapter_state_changed_cb callback, void *user_data)
 319 {
 320         int ret = BT_ERROR_NONE;
 321
 322         BT_CHECK_INIT_STATUS();
 323         BT_CHECK_INPUT_PARAMETER(callback);
 324         _bt_set_cb(BT_EVENT_STATE_CHANGED, callback, user_data);
 325         if (ret != BT_ERROR_NONE) {
 326                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
 327         }
 328
 329         return ret;
 330 }
 331
 332 int bt_adapter_set_name_changed_cb(bt_adapter_name_changed_cb callback, void *user_data)
 333 {
 334         int ret = BT_ERROR_NONE;
 335
 336         BT_CHECK_INIT_STATUS();
 337         BT_CHECK_INPUT_PARAMETER(callback);
 338         _bt_set_cb(BT_EVENT_NAME_CHANGED, callback, user_data);
 339         if (ret != BT_ERROR_NONE) {
 340                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
 341         }
 342
 343         return ret;
 344 }
 345
 346 int bt_adapter_set_visibility_mode_changed_cb(bt_adapter_visibility_mode_changed_cb callback, void *user_data)
 347 {
 348         int ret = BT_ERROR_NONE;
 349
 350         BT_CHECK_INIT_STATUS();
 351         BT_CHECK_INPUT_PARAMETER(callback);
 352         _bt_set_cb(BT_EVENT_VISIBILITY_MODE_CHANGED, callback, user_data);
 353         if (ret != BT_ERROR_NONE) {
 354                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
 355         }
 356
 357         return ret;
 358 }
 359
 360 int bt_adapter_set_device_discovery_state_changed_cb(bt_adapter_device_discovery_state_changed_cb callback, void *user_data)
 361 {
 362         int ret = BT_ERROR_NONE;
 363
 364         BT_CHECK_INIT_STATUS();
 365         BT_CHECK_INPUT_PARAMETER(callback);
 366         _bt_set_cb(BT_EVENT_DEVICE_DISCOVERY_STATE_CHANGED, callback, user_data);
 367         if (ret != BT_ERROR_NONE) {
 368                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
 369         }
 370
 371         return ret;
 372 }
 373
 374 int bt_adapter_unset_state_changed_cb(void)
 375 {
 376         BT_CHECK_INIT_STATUS();
 377         _bt_unset_cb(BT_EVENT_STATE_CHANGED);
 378         return BT_ERROR_NONE;
 379 }
 380
 381 int bt_adapter_unset_name_changed_cb(void)
 382 {
 383         BT_CHECK_INIT_STATUS();
 384         _bt_unset_cb(BT_EVENT_NAME_CHANGED);
 385         return BT_ERROR_NONE;
 386 }
 387
 388 int bt_adapter_unset_visibility_mode_changed_cb(void)
 389 {
 390         BT_CHECK_INIT_STATUS();
 391         _bt_unset_cb(BT_EVENT_VISIBILITY_MODE_CHANGED);
 392         return BT_ERROR_NONE;
 393 }
 394
 395 int bt_adapter_set_visibility_duration_changed_cb(bt_adapter_visibility_duration_changed_cb callback, void *user_data)
 396 {
 397         BT_CHECK_INIT_STATUS();
 398
 399         /* Will impelement it */
 400
 401         return BT_ERROR_NONE;
 402 }
 403
 404 int bt_adapter_unset_visibility_duration_changed_cb(void)
 405 {
 406         BT_CHECK_INIT_STATUS();
 407
 408         /* Will impelement it */
 409
 410         return BT_ERROR_NONE;
 411 }
 412
 413 int bt_adapter_unset_device_discovery_state_changed_cb(void)
 414 {
 415         BT_CHECK_INIT_STATUS();
 416         _bt_unset_cb(BT_EVENT_DEVICE_DISCOVERY_STATE_CHANGED);
 417         return BT_ERROR_NONE;
 418 }
 419
 420 int bt_adapter_start_device_discovery(void)
 421 {
 422         int error_code = BT_ERROR_NONE;
 423
 424         BT_CHECK_INIT_STATUS();
 425         error_code = _bt_get_error_code(bluetooth_start_discovery(0, 0, BLUETOOTH_DEVICE_MAJOR_MASK_MISC));
 426         if (error_code != BT_ERROR_NONE) {
 427                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code);
 428         }
 429         return error_code;
 430 }
 431
 432 int bt_adapter_start_discover_devices(bt_adapter_discover_devices_type_e type)
 433 {
 434         int error_code = BT_ERROR_NONE;
 435
 436         BT_CHECK_INIT_STATUS();
 437         error_code = _bt_get_error_code(bluetooth_start_custom_discovery(type,
 438                                         0, 0, BLUETOOTH_DEVICE_MAJOR_MASK_MISC));
 439         if (error_code != BT_ERROR_NONE) {
 440                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code);
 441         }
 442         return error_code;
 443 }
 444
 445 int bt_adapter_stop_device_discovery(void)
 446 {
 447         int error_code = BT_ERROR_NONE;
 448
 449         BT_CHECK_INIT_STATUS();
 450         error_code = _bt_get_error_code(bluetooth_cancel_discovery());
 451         if (error_code != BT_ERROR_NONE) {
 452                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code);
 453         }
 454         return error_code;
 455 }
 456
 457 int bt_adapter_is_discovering(bool *is_discovering)
 458 {
 459         int ret = 0;
 460
 461         BT_CHECK_INIT_STATUS();
 462         BT_CHECK_INPUT_PARAMETER(is_discovering);
 463
 464         ret = bluetooth_is_discovering();
 465         if (ret >= BLUETOOTH_ERROR_BASE) {
 466                 *is_discovering = (ret == 1) ? true : false;
 467                 return BT_ERROR_NONE;
 468         } else {
 469                 ret = _bt_get_error_code(ret);
 470                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
 471                 return ret;
 472         }
 473 }
 474
 475 int bt_adapter_get_local_oob_data(unsigned char **hash, unsigned char **randomizer,
 476                                         int *hash_len, int *randomizer_len)
 477 {
 478         int ret = BT_ERROR_NONE;
 479
 480         BT_CHECK_INIT_STATUS();
 481         BT_CHECK_INPUT_PARAMETER(hash);
 482         BT_CHECK_INPUT_PARAMETER(randomizer);
 483         BT_CHECK_INPUT_PARAMETER(hash_len);
 484         BT_CHECK_INPUT_PARAMETER(randomizer_len);
 485
 486         bt_oob_data_t oob_data;
 487
 488         ret = _bt_get_error_code(bluetooth_oob_read_local_data(&oob_data));
 489         if (BT_ERROR_NONE == ret) {
 490                 *hash = g_memdup(oob_data.hash, BLUETOOTH_OOB_DATA_LENGTH);
 491                 *randomizer = g_memdup(oob_data.randomizer,
 492                                                 BLUETOOTH_OOB_DATA_LENGTH);
 493                 *hash_len = BLUETOOTH_OOB_DATA_LENGTH;
 494                 *randomizer_len = BLUETOOTH_OOB_DATA_LENGTH;
 495         } else {
 496                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
 497         }
 498         return ret;
 499 }
 500
 501 int bt_adapter_set_remote_oob_data(const char *remote_address,
 502                                 unsigned char *hash, unsigned char *randomizer,
 503                                 int hash_len, int randomizer_len)
 504 {
 505         int ret = BT_ERROR_NONE;
 506         bluetooth_device_address_t addr_hex = { {0,} };
 507         bt_oob_data_t oob_data = { {0},};
 508
 509         BT_CHECK_INIT_STATUS();
 510         BT_CHECK_INPUT_PARAMETER(remote_address);
 511
 512         _bt_convert_address_to_hex(&addr_hex, remote_address);
 513
 514         if (hash != NULL && randomizer != NULL) {
 515                 memcpy(oob_data.hash, hash, hash_len);
 516                 memcpy(oob_data.randomizer, randomizer, randomizer_len);
 517                 oob_data.hash_len = hash_len;
 518                 oob_data.randomizer_len = randomizer_len;
 519         }
 520
 521         ret = _bt_get_error_code(bluetooth_oob_add_remote_data(&addr_hex, &oob_data));
 522         if (BT_ERROR_NONE != ret) {
 523                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
 524         }
 525         return ret;
 526 }
 527
 528 int bt_adapter_remove_remote_oob_data(const char *remote_address)
 529 {
 530         int ret = BT_ERROR_NONE;
 531         bluetooth_device_address_t addr_hex = { {0,} };
 532
 533         BT_CHECK_INIT_STATUS();
 534         BT_CHECK_INPUT_PARAMETER(remote_address);
 535
 536         _bt_convert_address_to_hex(&addr_hex, remote_address);
 537
 538         ret = _bt_get_error_code(bluetooth_oob_remove_remote_data(&addr_hex));
 539         if (BT_ERROR_NONE != ret) {
 540                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
 541         }
 542         return ret;
 543 }
 544