bt-api/bt-adapter-le.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 <stdio.h>
  25 #include <vconf.h>
  26
  27 #include "bluetooth-api.h"
  28 #include "bt-internal-types.h"
  29
  30 #include "bt-common.h"
  31 #include "bt-request-sender.h"
  32 #include "bt-event-handler.h"
  33
  34 BT_EXPORT_API int bluetooth_check_adapter_le(void)
  35 {
  36         int ret;
  37         int value = 1;
  38
  39         ret = _bt_get_adapter_path(_bt_gdbus_get_system_gconn(), NULL);
  40
  41         if (ret != BLUETOOTH_ERROR_NONE) {
  42                 return BLUETOOTH_ADAPTER_LE_DISABLED;
  43         }
  44
  45 #ifdef ENABLE_TIZEN_2_4
  46         ret = vconf_get_int(VCONFKEY_BT_LE_STATUS, &value);
  47         if (ret != 0) {
  48                 BT_ERR("fail to get vconf key!");
  49                 return ret;
  50         }
  51
  52         BT_DBG("value : %d", value);
  53         return value == VCONFKEY_BT_LE_STATUS_ON ? BLUETOOTH_ADAPTER_LE_ENABLED :
  54                                                 BLUETOOTH_ADAPTER_LE_DISABLED;
  55 #else
  56         return value = BLUETOOTH_ADAPTER_LE_DISABLED;
  57 #endif
  58 }
  59
  60 BT_EXPORT_API int bluetooth_enable_adapter_le(void)
  61 {
  62         int result;
  63
  64         retv_if(bluetooth_check_adapter_le() == BLUETOOTH_ADAPTER_LE_ENABLED,
  65                                 BLUETOOTH_ERROR_DEVICE_ALREADY_ENABLED);
  66
  67         BT_INIT_PARAMS();
  68         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
  69
  70         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_ENABLE_ADAPTER_LE,
  71                 in_param1, in_param2, in_param3, in_param4, &out_param);
  72
  73         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
  74         return result;
  75 }
  76
  77 BT_EXPORT_API int bluetooth_disable_adapter_le(void)
  78 {
  79         int result;
  80         retv_if(bluetooth_check_adapter_le() == BLUETOOTH_ADAPTER_LE_DISABLED,
  81                                 BLUETOOTH_ERROR_DEVICE_NOT_ENABLED);
  82
  83         BT_INIT_PARAMS();
  84         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
  85
  86         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DISABLE_ADAPTER_LE,
  87                 in_param1, in_param2, in_param3, in_param4, &out_param);
  88
  89         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
  90
  91         return result;
  92 }
  93
  94 BT_EXPORT_API int bluetooth_start_le_discovery(void)
  95 {
  96         int result;
  97
  98         BT_CHECK_ENABLED_ANY(return);
  99
 100         BT_INIT_PARAMS();
 101         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 102
 103         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_START_LE_DISCOVERY,
 104                 in_param1, in_param2, in_param3, in_param4, &out_param);
 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_stop_le_discovery(void)
 112 {
 113         int result;
 114
 115         BT_CHECK_ENABLED_ANY(return);
 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(BT_BLUEZ_SERVICE, BT_STOP_LE_DISCOVERY,
 121                 in_param1, in_param2, in_param3, in_param4, &out_param);
 122
 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_is_le_discovering(void)
 130 {
 131         int result;
 132         int is_discovering = FALSE;
 133
 134         BT_CHECK_ENABLED_ANY(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_IS_LE_DISCOVERYING,
 140                 in_param1, in_param2, in_param3, in_param4, &out_param);
 141
 142         if (result == BLUETOOTH_ERROR_NONE) {
 143                 is_discovering = g_array_index(out_param,
 144                                 int, 0);
 145         } else {
 146                 BT_ERR("Fail to send request");
 147         }
 148
 149         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 150
 151         return is_discovering;
 152 }
 153
 154 #ifdef TIZEN_WEARABLE
 155 gboolean __bluetooth_is_privileged_process(void)
 156 {
 157         FILE *fp= NULL;
 158         char path[30] = {0, };
 159         char buf[256] = {0, };
 160
 161         snprintf(path, sizeof(path), "/proc/%d/cmdline", getpid());
 162         fp = fopen(path, "r");
 163         if (fp == NULL)
 164                 return FALSE;
 165
 166         if (fgets(buf, 256, fp) != NULL) {
 167                 if (strstr(buf, "weconnd") != NULL) {
 168                         fclose(fp);
 169                         return TRUE;
 170                 }
 171         }
 172
 173         fclose(fp);
 174         return FALSE;
 175 }
 176 #endif
 177
 178 BT_EXPORT_API int bluetooth_set_advertising(gboolean enable)
 179 {
 180         int result;
 181         gboolean use_reserved_slot = FALSE;
 182
 183         BT_CHECK_ENABLED_ANY(return);
 184
 185 #ifdef TIZEN_WEARABLE
 186         use_reserved_slot = __bluetooth_is_privileged_process();
 187 #endif
 188
 189         BT_INIT_PARAMS();
 190         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 191
 192         g_array_append_vals(in_param1, &enable, sizeof(gboolean));
 193         g_array_append_vals(in_param2, &use_reserved_slot, sizeof(gboolean));
 194
 195         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_ADVERTISING,
 196                 in_param1, in_param2, in_param3, in_param4, &out_param);
 197
 198         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 199
 200         return result;
 201 }
 202
 203 BT_EXPORT_API int bluetooth_set_custom_advertising(gboolean enable,
 204                                                 bluetooth_advertising_params_t *params)
 205 {
 206         int result;
 207         gboolean use_reserved_slot = FALSE;
 208
 209         BT_CHECK_ENABLED_ANY(return);
 210
 211 #ifdef TIZEN_WEARABLE
 212         use_reserved_slot = __bluetooth_is_privileged_process();
 213 #endif
 214
 215         BT_INIT_PARAMS();
 216         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 217
 218         g_array_append_vals(in_param1, &enable, sizeof(gboolean));
 219         g_array_append_vals(in_param2, params, sizeof(bluetooth_advertising_params_t));
 220         g_array_append_vals(in_param3, &use_reserved_slot, sizeof(gboolean));
 221
 222         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_CUSTOM_ADVERTISING,
 223                 in_param1, in_param2, in_param3, in_param4, &out_param);
 224
 225         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 226
 227         return result;
 228 }
 229
 230 BT_EXPORT_API int bluetooth_get_advertising_data(bluetooth_advertising_data_t *adv_data, int *length)
 231 {
 232         int result;
 233         guint8 *data;
 234
 235         BT_CHECK_PARAMETER(adv_data, return);
 236         BT_CHECK_PARAMETER(length, return);
 237         BT_CHECK_ENABLED_ANY(return);
 238
 239         BT_INIT_PARAMS();
 240         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 241
 242         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_ADVERTISING_DATA,
 243                 in_param1, in_param2, in_param3, in_param4, &out_param);
 244
 245         if (result == BLUETOOTH_ERROR_NONE) {
 246                 data = &g_array_index(out_param, guint8, 0);
 247                 *length = out_param->len;
 248
 249                 memset(adv_data, 0x00, sizeof(bluetooth_advertising_data_t));
 250                 memcpy(adv_data->data, data, *length);
 251         }
 252
 253         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 254
 255         return result;
 256 }
 257
 258 BT_EXPORT_API int bluetooth_set_advertising_data(const bluetooth_advertising_data_t *value, int length)
 259 {
 260         int result;
 261         gboolean use_reserved_slot = FALSE;
 262
 263         BT_CHECK_PARAMETER(value, return);
 264         BT_CHECK_ENABLED_ANY(return);
 265
 266         if (length > BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX - 3)
 267                 return BLUETOOTH_ERROR_INVALID_PARAM;
 268
 269 #ifdef TIZEN_WEARABLE
 270         use_reserved_slot = __bluetooth_is_privileged_process();
 271 #endif
 272
 273         BT_INIT_PARAMS();
 274         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 275
 276         g_array_append_vals(in_param1, value, sizeof(bluetooth_advertising_data_t));
 277         g_array_append_vals(in_param2, &length, sizeof(int));
 278         g_array_append_vals(in_param3, &use_reserved_slot, sizeof(gboolean));
 279
 280         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_ADVERTISING_DATA,
 281                 in_param1, in_param2, in_param3, in_param4, &out_param);
 282
 283         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 284
 285         return result;
 286 }
 287
 288 BT_EXPORT_API int bluetooth_get_scan_response_data(bluetooth_scan_resp_data_t *value, int *length)
 289 {
 290         int result;
 291         guint8 *data;
 292
 293         BT_CHECK_PARAMETER(value, return);
 294         BT_CHECK_PARAMETER(length, return);
 295         BT_CHECK_ENABLED_ANY(return);
 296
 297         BT_INIT_PARAMS();
 298         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 299
 300         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_SCAN_RESPONSE_DATA,
 301                 in_param1, in_param2, in_param3, in_param4, &out_param);
 302
 303         if (result == BLUETOOTH_ERROR_NONE) {
 304                 data = &g_array_index(out_param, guint8, 0);
 305                 *length = out_param->len;
 306
 307                 memset(value, 0x00, sizeof(bluetooth_scan_resp_data_t));
 308                 memcpy(value->data, data, *length);
 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_scan_response_data(
 317                         const bluetooth_scan_resp_data_t *value, int length)
 318 {
 319         int result;
 320         gboolean use_reserved_slot = FALSE;
 321
 322         BT_CHECK_PARAMETER(value, return);
 323         BT_CHECK_ENABLED_ANY(return);
 324
 325         if (length > BLUETOOTH_SCAN_RESP_DATA_LENGTH_MAX)
 326                 return BLUETOOTH_ERROR_INVALID_PARAM;
 327
 328 #ifdef TIZEN_WEARABLE
 329         use_reserved_slot = __bluetooth_is_privileged_process();
 330 #endif
 331
 332         BT_INIT_PARAMS();
 333         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 334
 335         g_array_append_vals(in_param1, value, length);
 336         g_array_append_vals(in_param2, &length, sizeof(int));
 337         g_array_append_vals(in_param3, &use_reserved_slot, sizeof(gboolean));
 338
 339         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_SCAN_RESPONSE_DATA,
 340                 in_param1, in_param2, in_param3, in_param4, &out_param);
 341
 342         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 343
 344         return result;
 345 }
 346
 347 BT_EXPORT_API int bluetooth_set_scan_parameters(bluetooth_le_scan_params_t *params)
 348 {
 349         int result;
 350
 351         BT_CHECK_ENABLED_ANY(return);
 352
 353         BT_INIT_PARAMS();
 354         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 355
 356         g_array_append_vals(in_param1, params, sizeof(bluetooth_le_scan_params_t));
 357
 358         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_SCAN_PARAMETERS,
 359                 in_param1, in_param2, in_param3, in_param4, &out_param);
 360
 361         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 362
 363         return result;
 364 }
 365
 366 BT_EXPORT_API int bluetooth_is_advertising(gboolean *is_advertising)
 367 {
 368         int result;
 369
 370         BT_CHECK_ENABLED_ANY(return);
 371
 372         BT_INIT_PARAMS();
 373         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 374
 375         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_IS_ADVERTISING,
 376                 in_param1, in_param2, in_param3, in_param4, &out_param);
 377
 378         if (result == BLUETOOTH_ERROR_NONE) {
 379                 *is_advertising = g_array_index(out_param, int, 0);
 380         } else {
 381                 BT_ERR("Fail to send request");
 382         }
 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_add_white_list(bluetooth_device_address_t *address, bluetooth_device_address_type_t address_type)
 390 {
 391         int result;
 392
 393         BT_CHECK_PARAMETER(address, return);
 394         BT_CHECK_ENABLED_ANY(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, address, sizeof(bluetooth_device_address_t));
 400         g_array_append_vals(in_param2, &address_type, sizeof(int));
 401
 402         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_ADD_WHITE_LIST,
 403                 in_param1, in_param2, in_param3, in_param4, &out_param);
 404
 405         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 406
 407         return result;
 408 }
 409
 410 BT_EXPORT_API int bluetooth_remove_white_list(bluetooth_device_address_t *address, bluetooth_device_address_type_t address_type)
 411 {
 412         int result;
 413
 414         BT_CHECK_PARAMETER(address, return);
 415         BT_CHECK_ENABLED_ANY(return);
 416
 417         BT_INIT_PARAMS();
 418         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 419
 420         g_array_append_vals(in_param1, address, sizeof(bluetooth_device_address_t));
 421         g_array_append_vals(in_param2, &address_type, sizeof(int));
 422
 423         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_REMOVE_WHITE_LIST,
 424                 in_param1, in_param2, in_param3, in_param4, &out_param);
 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_clear_white_list(void)
 432 {
 433         int result;
 434
 435         BT_CHECK_ENABLED_ANY(return);
 436
 437         BT_INIT_PARAMS();
 438         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 439
 440         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_CLEAR_WHITE_LIST,
 441                 in_param1, in_param2, in_param3, in_param4, &out_param);
 442
 443         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 444
 445         return result;
 446 }
 447
 448 BT_EXPORT_API int bluetooth_enable_le_privacy(gboolean enable_privacy)
 449 {
 450         int result;
 451
 452         BT_CHECK_ENABLED_ANY(return);
 453
 454         BT_INIT_PARAMS();
 455         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 456
 457         g_array_append_vals(in_param1, &enable_privacy, sizeof(gboolean));
 458
 459         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_LE_PRIVACY,
 460                 in_param1, in_param2, in_param3, in_param4, &out_param);
 461
 462         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 463
 464         return result;
 465 }
 466
 467 BT_EXPORT_API int bluetooth_le_register_callback(bluetooth_cb_func_ptr callback_ptr, void *user_data)
 468 {
 469         int ret;
 470
 471         ret = _bt_register_event(BT_LE_ADAPTER_EVENT, (void *)callback_ptr, user_data);
 472         if (ret != BLUETOOTH_ERROR_NONE &&
 473             ret != BLUETOOTH_ERROR_ALREADY_INITIALIZED) {
 474                 BT_ERR("Fail to register BT_LE_ADAPTER_EVENT event : %d", ret);
 475                 return ret;
 476         }
 477
 478         return BLUETOOTH_ERROR_NONE;
 479 }
 480
 481 BT_EXPORT_API int bluetooth_le_unregister_callback(void)
 482 {
 483         _bt_unregister_event(BT_LE_ADAPTER_EVENT);
 484
 485         return BLUETOOTH_ERROR_NONE;
 486 }