bt-api/bt-adapter.c

   1 /*
   2  * bluetooth-frwk
   3  *
   4  * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  *              http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  */
  19
  20
  21 #include <vconf.h>
  22 #ifndef LIBNOTIFY_SUPPORT
  23 #include <syspopup_caller.h>
  24 #endif
  25
  26 #include "bluetooth-api.h"
  27 #include "bt-internal-types.h"
  28
  29 #include "bt-common.h"
  30 #include "bt-request-sender.h"
  31 #include "bt-event-handler.h"
  32
  33 static int __bt_fill_device_list(GArray *out_param2, GPtrArray **dev_list)
  34 {
  35         int i;
  36         guint size;
  37         bluetooth_device_info_t info;
  38
  39         BT_CHECK_PARAMETER(out_param2, return);
  40         BT_CHECK_PARAMETER(dev_list, return);
  41
  42         size = out_param2->len;
  43         retv_if(size == 0, BLUETOOTH_ERROR_NONE);
  44
  45         size = (out_param2->len) / sizeof(bluetooth_device_info_t);
  46
  47         for (i = 0; i < size; i++) {
  48                 bluetooth_device_info_t *dev_info = NULL;
  49
  50                 info = g_array_index(out_param2,
  51                                 bluetooth_device_info_t, i);
  52
  53                 dev_info = g_memdup(&info, sizeof(bluetooth_device_info_t));
  54
  55                 if (dev_info) {
  56                         g_ptr_array_add(*dev_list, (gpointer)dev_info);
  57                 }
  58         }
  59
  60         return BLUETOOTH_ERROR_NONE;
  61 }
  62
  63 BT_EXPORT_API int bluetooth_check_adapter(void)
  64 {
  65         int ret;
  66
  67         ret = _bt_get_adapter_path(_bt_get_system_gconn(), NULL);
  68
  69         return ret == BLUETOOTH_ERROR_NONE ? BLUETOOTH_ADAPTER_ENABLED :
  70                                                 BLUETOOTH_ADAPTER_DISABLED;
  71 }
  72
  73 BT_EXPORT_API int bluetooth_enable_adapter(void)
  74 {
  75         int result;
  76
  77         BT_INIT_PARAMS();
  78         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
  79
  80         retv_if(bluetooth_check_adapter() == BLUETOOTH_ADAPTER_ENABLED,
  81                                 BLUETOOTH_ERROR_DEVICE_ALREADY_ENABLED);
  82
  83         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_ENABLE_ADAPTER,
  84                 in_param1, in_param2, in_param3, in_param4, &out_param);
  85
  86         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
  87
  88         return result;
  89 }
  90
  91 BT_EXPORT_API int bluetooth_disable_adapter(void)
  92 {
  93         int result;
  94
  95         BT_CHECK_ENABLED(return);
  96
  97         BT_INIT_PARAMS();
  98         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
  99
 100         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DISABLE_ADAPTER,
 101                 in_param1, in_param2, in_param3, in_param4, &out_param);
 102
 103         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 104
 105         return result;
 106 }
 107
 108 BT_EXPORT_API int bluetooth_reset_adapter(void)
 109 {
 110         int result;
 111
 112         BT_INIT_PARAMS();
 113         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 114
 115         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_RESET_ADAPTER,
 116                 in_param1, in_param2, in_param3, in_param4, &out_param);
 117
 118         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 119
 120         return result;
 121 }
 122
 123 BT_EXPORT_API int bluetooth_get_local_address(bluetooth_device_address_t *local_address)
 124 {
 125         int result;
 126
 127         BT_CHECK_PARAMETER(local_address, return);
 128         BT_CHECK_ENABLED(return);
 129
 130         BT_INIT_PARAMS();
 131         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 132
 133         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_LOCAL_ADDRESS,
 134                 in_param1, in_param2, in_param3, in_param4, &out_param);
 135
 136         if (result == BLUETOOTH_ERROR_NONE) {
 137                 *local_address = g_array_index(out_param,
 138                         bluetooth_device_address_t, 0);
 139         }
 140
 141         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 142
 143         return result;
 144 }
 145
 146 BT_EXPORT_API int bluetooth_get_local_name(bluetooth_device_name_t *local_name)
 147 {
 148         int result;
 149
 150         BT_CHECK_PARAMETER(local_name, return);
 151         BT_CHECK_ENABLED(return);
 152
 153         BT_INIT_PARAMS();
 154         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 155
 156         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_LOCAL_NAME,
 157                 in_param1, in_param2, in_param3, in_param4, &out_param);
 158
 159         if (result == BLUETOOTH_ERROR_NONE) {
 160                 *local_name = g_array_index(out_param,
 161                                 bluetooth_device_name_t, 0);
 162         }
 163
 164         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 165
 166         return result;
 167 }
 168
 169 BT_EXPORT_API int bluetooth_set_local_name(const bluetooth_device_name_t *local_name)
 170 {
 171         int result;
 172
 173         BT_CHECK_PARAMETER(local_name, return);
 174         BT_CHECK_ENABLED(return);
 175
 176         BT_INIT_PARAMS();
 177         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 178
 179         g_array_append_vals(in_param1, local_name, sizeof(bluetooth_device_name_t));
 180
 181         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_LOCAL_NAME,
 182                 in_param1, in_param2, in_param3, in_param4, &out_param);
 183
 184         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 185
 186         return result;
 187 }
 188
 189 BT_EXPORT_API int bluetooth_is_service_used(const char *service_uuid,
 190                                                 gboolean *used)
 191 {
 192         int result;
 193         char uuid[BLUETOOTH_UUID_STRING_MAX];
 194
 195         BT_CHECK_PARAMETER(service_uuid, return);
 196         BT_CHECK_PARAMETER(used, return);
 197         BT_CHECK_ENABLED(return);
 198
 199         BT_INIT_PARAMS();
 200         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 201
 202         g_strlcpy(uuid, service_uuid, sizeof(uuid));
 203         g_array_append_vals(in_param1, uuid, BLUETOOTH_UUID_STRING_MAX);
 204
 205         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_IS_SERVICE_USED,
 206                 in_param1, in_param2, in_param3, in_param4, &out_param);
 207
 208         if (result == BLUETOOTH_ERROR_NONE) {
 209                 *used = g_array_index(out_param, gboolean, 0);
 210         }
 211
 212         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 213
 214         return result;
 215 }
 216
 217 BT_EXPORT_API int bluetooth_get_discoverable_mode(bluetooth_discoverable_mode_t *
 218                                                   discoverable_mode_ptr)
 219 {
 220         int result;
 221         int timeout = 0;
 222
 223         BT_CHECK_PARAMETER(discoverable_mode_ptr, return);
 224
 225         /* Requirement in OSP */
 226         if (bluetooth_check_adapter() == BLUETOOTH_ADAPTER_DISABLED) {
 227                 if (vconf_get_int(BT_FILE_VISIBLE_TIME, &timeout) != 0) {
 228                         BT_ERR("Fail to get the timeout value");
 229                         return BLUETOOTH_ERROR_INTERNAL;
 230                 }
 231
 232                 if (timeout == -1) {
 233                         *discoverable_mode_ptr = BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE;
 234                 } else {
 235                         *discoverable_mode_ptr = BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE;
 236                 }
 237
 238                 return BLUETOOTH_ERROR_NONE;
 239         }
 240
 241         BT_INIT_PARAMS();
 242         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 243
 244         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_DISCOVERABLE_MODE,
 245                 in_param1, in_param2, in_param3, in_param4, &out_param);
 246
 247         if (result == BLUETOOTH_ERROR_NONE) {
 248                 *discoverable_mode_ptr = g_array_index(out_param,
 249                                         int, 0);
 250         }
 251
 252         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 253
 254         return result;
 255 }
 256
 257 BT_EXPORT_API int bluetooth_set_discoverable_mode(bluetooth_discoverable_mode_t discoverable_mode,
 258                                                   int timeout)
 259 {
 260         int result;
 261
 262         BT_CHECK_ENABLED(return);
 263
 264         BT_INIT_PARAMS();
 265         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 266
 267         g_array_append_vals(in_param1, &discoverable_mode, sizeof(int));
 268         g_array_append_vals(in_param2, &timeout, sizeof(int));
 269
 270         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_DISCOVERABLE_MODE,
 271                 in_param1, in_param2, in_param3, in_param4, &out_param);
 272
 273         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 274
 275         return result;
 276 }
 277
 278 BT_EXPORT_API int bluetooth_get_timeout_value(int *timeout)
 279 {
 280         int result;
 281
 282         BT_CHECK_PARAMETER(timeout, return);
 283         BT_CHECK_ENABLED(return);
 284
 285         BT_INIT_PARAMS();
 286         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 287
 288         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_DISCOVERABLE_TIME,
 289                 in_param1, in_param2, in_param3, in_param4, &out_param);
 290
 291         if (result == BLUETOOTH_ERROR_NONE) {
 292                 *timeout = g_array_index(out_param, int, 0);
 293         }
 294
 295         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 296
 297         return result;
 298 }
 299
 300 BT_EXPORT_API int bluetooth_start_discovery(unsigned short max_response,
 301                                             unsigned short discovery_duration,
 302                                             unsigned int classOfDeviceMask)
 303 {
 304         int result;
 305
 306         BT_CHECK_ENABLED(return);
 307
 308         BT_INIT_PARAMS();
 309         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 310
 311         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_START_DISCOVERY,
 312                 in_param1, in_param2, in_param3, in_param4, &out_param);
 313
 314         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 315
 316         return result;
 317 }
 318
 319 BT_EXPORT_API int bluetooth_cancel_discovery(void)
 320 {
 321         int result;
 322
 323         BT_CHECK_ENABLED(return);
 324
 325         BT_INIT_PARAMS();
 326         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 327
 328         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_CANCEL_DISCOVERY,
 329                 in_param1, in_param2, in_param3, in_param4, &out_param);
 330
 331
 332         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 333
 334         return result;
 335 }
 336
 337 BT_EXPORT_API int bluetooth_is_discovering(void)
 338 {
 339         int result;
 340         int is_discovering = FALSE;
 341
 342         BT_CHECK_ENABLED(return);
 343
 344         BT_INIT_PARAMS();
 345         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 346
 347         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_IS_DISCOVERYING,
 348                 in_param1, in_param2, in_param3, in_param4, &out_param);
 349
 350         if (result == BLUETOOTH_ERROR_NONE) {
 351                 is_discovering = g_array_index(out_param,
 352                                 int, 0);
 353         } else {
 354                 BT_ERR("Fail to send request");
 355         }
 356
 357         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 358
 359         return is_discovering;
 360 }
 361
 362 BT_EXPORT_API int bluetooth_get_bonded_device_list(GPtrArray **dev_list)
 363 {
 364         int result;
 365
 366         BT_CHECK_PARAMETER(dev_list, return);
 367         BT_CHECK_ENABLED(return);
 368
 369         BT_INIT_PARAMS();
 370         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 371
 372         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_BONDED_DEVICES,
 373                 in_param1, in_param2, in_param3, in_param4, &out_param);
 374
 375         if (result == BLUETOOTH_ERROR_NONE) {
 376                 result = __bt_fill_device_list(out_param, dev_list);
 377         }
 378
 379         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 380
 381         return result;
 382 }
 383