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