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_get_state(bt_adapter_state_e *adapter_state)
  54 {
  55         BT_CHECK_INIT_STATUS();
  56         BT_CHECK_INPUT_PARAMETER(adapter_state);
  57
  58         *adapter_state = bluetooth_check_adapter();
  59         return BT_ERROR_NONE;
  60 }
  61
  62 int bt_adapter_get_address(char **address)
  63 {
  64         bluetooth_device_address_t loc_address = { {0} };
  65         int error_code = BT_ERROR_NONE;
  66
  67         BT_CHECK_INIT_STATUS();
  68         BT_CHECK_INPUT_PARAMETER(address);
  69
  70         error_code = _bt_get_error_code(bluetooth_get_local_address(&loc_address));
  71         if (error_code != BT_ERROR_NONE) {
  72                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code);
  73                 return error_code;
  74         }
  75
  76         error_code = _bt_convert_address_to_string(address, &loc_address);
  77         if (error_code != BT_ERROR_NONE) {
  78                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code);
  79                 return error_code;
  80         }
  81
  82         return BT_ERROR_NONE;
  83 }
  84
  85 int bt_adapter_get_name(char **name)
  86 {
  87         int ret = BT_ERROR_NONE;
  88         bluetooth_device_name_t loc_name = { {0} };
  89
  90         BT_CHECK_INIT_STATUS();
  91         BT_CHECK_INPUT_PARAMETER(name);
  92
  93         ret = _bt_get_error_code(bluetooth_get_local_name(&loc_name));
  94         if (ret != BT_ERROR_NONE) {
  95                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
  96                 return ret;
  97         }
  98
  99         *name = strdup(loc_name.name);
 100         if (*name == NULL) {
 101                 BT_ERR("OUT_OF_MEMORY(0x%08x)", BT_ERROR_OUT_OF_MEMORY);
 102                 return BT_ERROR_OUT_OF_MEMORY;
 103         }
 104
 105         return BT_ERROR_NONE;
 106 }
 107
 108 int bt_adapter_set_name(const char *name)
 109 {
 110         bluetooth_device_name_t loc_name = { {0} };
 111         int ret = BT_ERROR_NONE;
 112
 113         BT_CHECK_INIT_STATUS();
 114         BT_CHECK_INPUT_PARAMETER(name);
 115
 116         strncpy(loc_name.name, name, BLUETOOTH_DEVICE_NAME_LENGTH_MAX);
 117         loc_name.name[BLUETOOTH_DEVICE_NAME_LENGTH_MAX] = '\0';
 118
 119         ret = _bt_get_error_code(bluetooth_set_local_name(&loc_name));
 120         if (ret != BT_ERROR_NONE) {
 121                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
 122         }
 123
 124         return ret;
 125 }
 126
 127 int bt_adapter_get_visibility(bt_adapter_visibility_mode_e *mode, int *duration)
 128 {
 129         bluetooth_discoverable_mode_t discoverable_mode = BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE;
 130         int ret = BT_ERROR_NONE;
 131
 132         BT_CHECK_INIT_STATUS();
 133         BT_CHECK_INPUT_PARAMETER(mode);
 134
 135         ret = _bt_get_error_code(bluetooth_get_discoverable_mode(&discoverable_mode));
 136         if (ret != BT_ERROR_NONE) {
 137                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
 138                 return ret;
 139         }
 140
 141         *mode = _bt_get_bt_visibility_mode_e(discoverable_mode);
 142
 143         if (duration)
 144                 *duration = 0;
 145
 146         if (discoverable_mode == BLUETOOTH_DISCOVERABLE_MODE_TIME_LIMITED_DISCOVERABLE) {
 147                 if (duration == NULL)
 148                         return BT_ERROR_NONE;
 149                 ret = bluetooth_get_timeout_value(duration);
 150                 if (ret != BT_ERROR_NONE) {
 151                         BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
 152                 }
 153         }
 154
 155         return BT_ERROR_NONE;
 156 }
 157
 158 int bt_adapter_set_visibility(bt_adapter_visibility_mode_e visibility_mode, int timeout_sec)
 159 {
 160         bluetooth_discoverable_mode_t discoverable_mode = BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE;
 161         int error_code = BT_ERROR_NONE;
 162
 163         BT_CHECK_INIT_STATUS();
 164         switch (visibility_mode) {
 165         case BT_ADAPTER_VISIBILITY_MODE_LIMITED_DISCOVERABLE:
 166                 discoverable_mode = BLUETOOTH_DISCOVERABLE_MODE_TIME_LIMITED_DISCOVERABLE;
 167                 break;
 168         case BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE:
 169                 discoverable_mode = BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE;
 170                 timeout_sec = 0;
 171                 break;
 172         case BT_ADAPTER_VISIBILITY_MODE_GENERAL_DISCOVERABLE:
 173                 discoverable_mode = BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE;
 174                 timeout_sec = 0;
 175                 break;
 176         default:
 177                 BT_ERR("INVALID_PARAMETER(0x%08x)", BT_ERROR_INVALID_PARAMETER);
 178                 return BT_ERROR_INVALID_PARAMETER;
 179         }
 180
 181         error_code = _bt_get_error_code(bluetooth_set_discoverable_mode(discoverable_mode, timeout_sec));
 182         if (error_code != BT_ERROR_NONE) {
 183                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code);
 184         }
 185
 186         return error_code;
 187 }
 188
 189 int bt_adapter_foreach_bonded_device(bt_adapter_bonded_device_cb foreach_cb, void *user_data)
 190 {
 191         GPtrArray *dev_list = NULL;
 192         bt_device_info_s *dev_info = NULL;
 193         bluetooth_device_info_t *ptr = NULL;
 194         int ret = BT_ERROR_NONE;
 195         int i = 0;
 196
 197         BT_CHECK_INIT_STATUS();
 198         BT_CHECK_INPUT_PARAMETER(foreach_cb);
 199
 200         dev_list = g_ptr_array_new();
 201         if (dev_list == NULL) {
 202                 BT_ERR("OUT_OF_MEMORY(0x%08x)", BT_ERROR_OUT_OF_MEMORY);
 203                 return BT_ERROR_OUT_OF_MEMORY;
 204         }
 205
 206         ret = _bt_get_error_code(bluetooth_get_bonded_device_list(&dev_list));
 207         if (ret != BT_ERROR_NONE) {
 208                 BT_ERR("%s(0x%08x) : Failed to get bonded device list", _bt_convert_error_to_string(ret), ret);
 209                 return ret;
 210         }
 211
 212         for (i = 0; i < dev_list->len; i++) {
 213                 ptr = g_ptr_array_index(dev_list, i);
 214                 if (ptr != NULL) {
 215                         ret = _bt_get_bt_device_info_s(&dev_info, (bluetooth_device_info_t *)ptr);
 216                         if (ret != BT_ERROR_NONE) {
 217                                 BT_ERR("%s(0x%08x) : Failed to get device info", _bt_convert_error_to_string(ret), ret);
 218                                 break;
 219                         }
 220
 221                         if (!foreach_cb(dev_info, user_data)) {
 222                                 _bt_free_bt_device_info_s(dev_info);
 223                                 break;
 224                         }
 225                         _bt_free_bt_device_info_s(dev_info);
 226                 } else {
 227                         BT_ERR("OPERATION_FAILED(0x%08x)", BT_ERROR_OPERATION_FAILED);
 228                         ret = BT_ERROR_OPERATION_FAILED;
 229                         break;
 230                 }
 231         }
 232
 233         if (dev_list != NULL) {
 234                 g_ptr_array_free(dev_list, TRUE);
 235         }
 236
 237         return ret;
 238 }
 239
 240 int bt_adapter_get_bonded_device_info(const char *remote_address, bt_device_info_s **device_info)
 241 {
 242         int ret;
 243         bluetooth_device_address_t addr_hex = { {0,} };
 244         bluetooth_device_info_t *info;
 245
 246         BT_CHECK_INIT_STATUS();
 247         BT_CHECK_INPUT_PARAMETER(remote_address);
 248
 249         info = (bluetooth_device_info_t *)malloc(sizeof(bluetooth_device_info_t));
 250         if (info == NULL)
 251                 return BT_ERROR_OUT_OF_MEMORY;
 252
 253         _bt_convert_address_to_hex(&addr_hex, remote_address);
 254
 255         ret = _bt_get_error_code(bluetooth_get_bonded_device(&addr_hex, info));
 256         if (ret != BT_ERROR_NONE) {
 257                 BT_ERR("%s(0x%08x) : Failed to run function",
 258                                         _bt_convert_error_to_string(ret), ret);
 259         } else {
 260                 ret = _bt_get_bt_device_info_s(device_info, info);
 261                 if (ret != BT_ERROR_NONE) {
 262                         BT_ERR("%s(0x%08x) : Failed to get device info",
 263                                                 _bt_convert_error_to_string(ret),
 264                                                 ret);
 265                 }
 266         }
 267
 268         free(info);
 269
 270         return ret;
 271 }
 272
 273 int bt_adapter_free_device_info(bt_device_info_s *device_info)
 274 {
 275         BT_CHECK_INIT_STATUS();
 276         BT_CHECK_INPUT_PARAMETER(device_info);
 277
 278         _bt_free_bt_device_info_s(device_info);
 279
 280         return BT_ERROR_NONE;
 281 }
 282
 283 int bt_adapter_is_service_used(const char *service_uuid, bool *used)
 284 {
 285         int ret = BT_ERROR_NONE;
 286
 287         BT_CHECK_INIT_STATUS();
 288         BT_CHECK_INPUT_PARAMETER(service_uuid);
 289         BT_CHECK_INPUT_PARAMETER(used);
 290
 291         if (strcmp(service_uuid, OPP_UUID) == 0) {
 292                 *used = bluetooth_obex_server_is_activated();
 293         } else {
 294                 ret = _bt_get_error_code(bluetooth_is_service_used(service_uuid,
 295                                                         (gboolean *)used));
 296         }
 297
 298         if (ret != BT_ERROR_NONE) {
 299                 BT_ERR("%s(0x%08x) : Failed to run function", _bt_convert_error_to_string(ret), ret);
 300         }
 301
 302         return ret;
 303 }
 304
 305 int bt_adapter_set_state_changed_cb(bt_adapter_state_changed_cb callback, void *user_data)
 306 {
 307         int ret = BT_ERROR_NONE;
 308
 309         BT_CHECK_INIT_STATUS();
 310         BT_CHECK_INPUT_PARAMETER(callback);
 311         _bt_set_cb(BT_EVENT_STATE_CHANGED, callback, user_data);
 312         if (ret != BT_ERROR_NONE) {
 313                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
 314         }
 315
 316         return ret;
 317 }
 318
 319 int bt_adapter_set_name_changed_cb(bt_adapter_name_changed_cb callback, void *user_data)
 320 {
 321         int ret = BT_ERROR_NONE;
 322
 323         BT_CHECK_INIT_STATUS();
 324         BT_CHECK_INPUT_PARAMETER(callback);
 325         _bt_set_cb(BT_EVENT_NAME_CHANGED, callback, user_data);
 326         if (ret != BT_ERROR_NONE) {
 327                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
 328         }
 329
 330         return ret;
 331 }
 332
 333 int bt_adapter_set_visibility_mode_changed_cb(bt_adapter_visibility_mode_changed_cb callback, void *user_data)
 334 {
 335         int ret = BT_ERROR_NONE;
 336
 337         BT_CHECK_INIT_STATUS();
 338         BT_CHECK_INPUT_PARAMETER(callback);
 339         _bt_set_cb(BT_EVENT_VISIBILITY_MODE_CHANGED, callback, user_data);
 340         if (ret != BT_ERROR_NONE) {
 341                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
 342         }
 343
 344         return ret;
 345 }
 346
 347 int bt_adapter_set_device_discovery_state_changed_cb(bt_adapter_device_discovery_state_changed_cb callback, void *user_data)
 348 {
 349         int ret = BT_ERROR_NONE;
 350
 351         BT_CHECK_INIT_STATUS();
 352         BT_CHECK_INPUT_PARAMETER(callback);
 353         _bt_set_cb(BT_EVENT_DEVICE_DISCOVERY_STATE_CHANGED, callback, user_data);
 354         if (ret != BT_ERROR_NONE) {
 355                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
 356         }
 357
 358         return ret;
 359 }
 360
 361 int bt_adapter_unset_state_changed_cb(void)
 362 {
 363         BT_CHECK_INIT_STATUS();
 364         _bt_unset_cb(BT_EVENT_STATE_CHANGED);
 365         return BT_ERROR_NONE;
 366 }
 367
 368 int bt_adapter_unset_name_changed_cb(void)
 369 {
 370         BT_CHECK_INIT_STATUS();
 371         _bt_unset_cb(BT_EVENT_NAME_CHANGED);
 372         return BT_ERROR_NONE;
 373 }
 374
 375 int bt_adapter_unset_visibility_mode_changed_cb(void)
 376 {
 377         BT_CHECK_INIT_STATUS();
 378         _bt_unset_cb(BT_EVENT_VISIBILITY_MODE_CHANGED);
 379         return BT_ERROR_NONE;
 380 }
 381
 382 int bt_adapter_set_visibility_duration_changed_cb(bt_adapter_visibility_duration_changed_cb callback, void *user_data)
 383 {
 384         BT_CHECK_INIT_STATUS();
 385
 386         /* Will impelement it */
 387
 388         return BT_ERROR_NONE;
 389 }
 390
 391 int bt_adapter_unset_visibility_duration_changed_cb(void)
 392 {
 393         BT_CHECK_INIT_STATUS();
 394
 395         /* Will impelement it */
 396
 397         return BT_ERROR_NONE;
 398 }
 399
 400 int bt_adapter_unset_device_discovery_state_changed_cb(void)
 401 {
 402         BT_CHECK_INIT_STATUS();
 403         _bt_unset_cb(BT_EVENT_DEVICE_DISCOVERY_STATE_CHANGED);
 404         return BT_ERROR_NONE;
 405 }
 406
 407 int bt_adapter_start_device_discovery(void)
 408 {
 409         int error_code = BT_ERROR_NONE;
 410
 411         BT_CHECK_INIT_STATUS();
 412         error_code = _bt_get_error_code(bluetooth_start_discovery(0, 0, BLUETOOTH_DEVICE_MAJOR_MASK_MISC));
 413         if (error_code != BT_ERROR_NONE) {
 414                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code);
 415         }
 416         return error_code;
 417 }
 418
 419 int bt_adapter_stop_device_discovery(void)
 420 {
 421         int error_code = BT_ERROR_NONE;
 422
 423         BT_CHECK_INIT_STATUS();
 424         error_code = _bt_get_error_code(bluetooth_cancel_discovery());
 425         if (error_code != BT_ERROR_NONE) {
 426                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code);
 427         }
 428         return error_code;
 429 }
 430
 431 int bt_adapter_is_discovering(bool *is_discovering)
 432 {
 433         int ret = 0;
 434
 435         BT_CHECK_INIT_STATUS();
 436         BT_CHECK_INPUT_PARAMETER(is_discovering);
 437
 438         ret = bluetooth_is_discovering();
 439         if (ret >= BLUETOOTH_ERROR_BASE) {
 440                 *is_discovering = (ret == 1) ? true : false;
 441                 return BT_ERROR_NONE;
 442         } else {
 443                 ret = _bt_get_error_code(ret);
 444                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
 445                 return ret;
 446         }
 447 }
 448