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 #include <vconf.h>
  21 #if !defined(LIBNOTIFY_SUPPORT) && !defined(LIBNOTIFICATION_SUPPORT)
  22 #include <syspopup_caller.h>
  23 #endif
  24
  25 #include "bluetooth-api.h"
  26 #include "bt-internal-types.h"
  27
  28 #include "bt-common.h"
  29 #include "bt-request-sender.h"
  30 #include "bt-event-handler.h"
  31
  32 static int __bt_fill_device_list(GArray *out_param2, GPtrArray **dev_list)
  33 {
  34         int i;
  35         guint size;
  36         bluetooth_device_info_t info;
  37
  38         BT_CHECK_PARAMETER(out_param2, return);
  39         BT_CHECK_PARAMETER(dev_list, return);
  40
  41         size = out_param2->len;
  42         retv_if(size == 0, BLUETOOTH_ERROR_NONE);
  43
  44         size = (out_param2->len) / sizeof(bluetooth_device_info_t);
  45
  46         for (i = 0; i < size; i++) {
  47                 bluetooth_device_info_t *dev_info = NULL;
  48
  49                 info = g_array_index(out_param2,
  50                                 bluetooth_device_info_t, i);
  51
  52                 dev_info = g_memdup(&info, sizeof(bluetooth_device_info_t));
  53
  54                 if (dev_info) {
  55                         g_ptr_array_add(*dev_list, (gpointer)dev_info);
  56                 }
  57         }
  58
  59         return BLUETOOTH_ERROR_NONE;
  60 }
  61
  62 BT_EXPORT_API int bluetooth_check_adapter(void)
  63 {
  64         int result;
  65         bluetooth_adapter_state_t state;
  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_CHECK_ADAPTER,
  71                 in_param1, in_param2, in_param3, in_param4, &out_param);
  72
  73         if (result == BLUETOOTH_ERROR_NONE) {
  74                 state = g_array_index(out_param, bluetooth_adapter_state_t, 0);
  75         }
  76
  77         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
  78
  79         return state ? BLUETOOTH_ADAPTER_ENABLED : BLUETOOTH_ADAPTER_DISABLED;
  80 }
  81
  82 BT_EXPORT_API int bluetooth_enable_adapter(void)
  83 {
  84         int result;
  85
  86         BT_INIT_PARAMS();
  87         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
  88
  89         retv_if(bluetooth_check_adapter() == BLUETOOTH_ADAPTER_ENABLED,
  90                                 BLUETOOTH_ERROR_DEVICE_ALREADY_ENABLED);
  91
  92         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_ENABLE_ADAPTER,
  93                 in_param1, in_param2, in_param3, in_param4, &out_param);
  94
  95         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
  96
  97         return result;
  98 }
  99
 100 BT_EXPORT_API int bluetooth_disable_adapter(void)
 101 {
 102         int result;
 103
 104         BT_CHECK_ENABLED(return);
 105
 106         BT_INIT_PARAMS();
 107         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 108
 109         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DISABLE_ADAPTER,
 110                 in_param1, in_param2, in_param3, in_param4, &out_param);
 111
 112         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 113
 114         return result;
 115 }
 116
 117 BT_EXPORT_API int bluetooth_reset_adapter(void)
 118 {
 119         int result;
 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_RESET_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_get_local_address(bluetooth_device_address_t *local_address)
 133 {
 134         int result;
 135
 136         BT_CHECK_PARAMETER(local_address, return);
 137
 138         BT_INIT_PARAMS();
 139         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 140
 141         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_LOCAL_ADDRESS,
 142                 in_param1, in_param2, in_param3, in_param4, &out_param);
 143
 144         if (result == BLUETOOTH_ERROR_NONE) {
 145                 *local_address = g_array_index(out_param,
 146                         bluetooth_device_address_t, 0);
 147         }
 148
 149         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 150
 151         return result;
 152 }
 153
 154 BT_EXPORT_API int bluetooth_get_local_name(bluetooth_device_name_t *local_name)
 155 {
 156         int result;
 157
 158         BT_CHECK_PARAMETER(local_name, return);
 159
 160         BT_INIT_PARAMS();
 161         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 162
 163         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_LOCAL_NAME,
 164                 in_param1, in_param2, in_param3, in_param4, &out_param);
 165
 166         if (result == BLUETOOTH_ERROR_NONE) {
 167                 *local_name = g_array_index(out_param,
 168                                 bluetooth_device_name_t, 0);
 169         }
 170
 171         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 172
 173         return result;
 174 }
 175
 176 BT_EXPORT_API int bluetooth_set_local_name(const bluetooth_device_name_t *local_name)
 177 {
 178         int result;
 179
 180         BT_CHECK_PARAMETER(local_name, return);
 181         BT_CHECK_ENABLED(return);
 182
 183         BT_INIT_PARAMS();
 184         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 185
 186         g_array_append_vals(in_param1, local_name, sizeof(bluetooth_device_name_t));
 187
 188         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_LOCAL_NAME,
 189                 in_param1, in_param2, in_param3, in_param4, &out_param);
 190
 191         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 192
 193         return result;
 194 }
 195
 196 BT_EXPORT_API int bluetooth_is_service_used(const char *service_uuid,
 197                                                 gboolean *used)
 198 {
 199         int result;
 200         char uuid[BLUETOOTH_UUID_STRING_MAX];
 201
 202         BT_CHECK_PARAMETER(service_uuid, return);
 203         BT_CHECK_PARAMETER(used, return);
 204         BT_CHECK_ENABLED(return);
 205
 206         BT_INIT_PARAMS();
 207         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 208
 209         g_strlcpy(uuid, service_uuid, sizeof(uuid));
 210         g_array_append_vals(in_param1, uuid, BLUETOOTH_UUID_STRING_MAX);
 211
 212         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_IS_SERVICE_USED,
 213                 in_param1, in_param2, in_param3, in_param4, &out_param);
 214
 215         if (result == BLUETOOTH_ERROR_NONE) {
 216                 *used = g_array_index(out_param, gboolean, 0);
 217         }
 218
 219         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 220
 221         return result;
 222 }
 223
 224 BT_EXPORT_API int bluetooth_get_discoverable_mode(bluetooth_discoverable_mode_t *
 225                                                   discoverable_mode_ptr)
 226 {
 227         int result;
 228         int timeout = 0;
 229
 230         BT_CHECK_PARAMETER(discoverable_mode_ptr, return);
 231
 232         BT_INIT_PARAMS();
 233         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 234
 235         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_DISCOVERABLE_MODE,
 236                 in_param1, in_param2, in_param3, in_param4, &out_param);
 237
 238         if (result == BLUETOOTH_ERROR_NONE) {
 239                 *discoverable_mode_ptr = g_array_index(out_param,
 240                                         int, 0);
 241         }
 242
 243         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 244
 245         return result;
 246 }
 247
 248 BT_EXPORT_API int bluetooth_set_discoverable_mode(bluetooth_discoverable_mode_t discoverable_mode,
 249                                                   int timeout)
 250 {
 251         int result;
 252
 253         BT_CHECK_ENABLED(return);
 254
 255         BT_INIT_PARAMS();
 256         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 257
 258         g_array_append_vals(in_param1, &discoverable_mode, sizeof(int));
 259         g_array_append_vals(in_param2, &timeout, sizeof(int));
 260
 261         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_DISCOVERABLE_MODE,
 262                 in_param1, in_param2, in_param3, in_param4, &out_param);
 263
 264         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 265
 266         return result;
 267 }
 268
 269 BT_EXPORT_API int bluetooth_get_timeout_value(int *timeout)
 270 {
 271         int result;
 272
 273         BT_CHECK_PARAMETER(timeout, return);
 274         BT_CHECK_ENABLED(return);
 275
 276         BT_INIT_PARAMS();
 277         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 278
 279         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_DISCOVERABLE_TIME,
 280                 in_param1, in_param2, in_param3, in_param4, &out_param);
 281
 282         if (result == BLUETOOTH_ERROR_NONE) {
 283                 *timeout = g_array_index(out_param, int, 0);
 284         }
 285
 286         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 287
 288         return result;
 289 }
 290
 291 BT_EXPORT_API int bluetooth_start_discovery(unsigned short max_response,
 292                                             unsigned short discovery_duration,
 293                                             unsigned int classOfDeviceMask)
 294 {
 295         int result;
 296
 297         BT_CHECK_ENABLED(return);
 298
 299         BT_INIT_PARAMS();
 300         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 301
 302         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_START_DISCOVERY,
 303                 in_param1, in_param2, in_param3, in_param4, &out_param);
 304
 305         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 306
 307         return result;
 308 }
 309
 310 BT_EXPORT_API int bluetooth_cancel_discovery(void)
 311 {
 312         int result;
 313
 314         BT_CHECK_ENABLED(return);
 315
 316         BT_INIT_PARAMS();
 317         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 318
 319         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_CANCEL_DISCOVERY,
 320                 in_param1, in_param2, in_param3, in_param4, &out_param);
 321
 322
 323         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 324
 325         return result;
 326 }
 327
 328 BT_EXPORT_API int bluetooth_is_discovering(void)
 329 {
 330         int result;
 331         int is_discovering = FALSE;
 332
 333         BT_CHECK_ENABLED(return);
 334
 335         BT_INIT_PARAMS();
 336         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 337
 338         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_IS_DISCOVERYING,
 339                 in_param1, in_param2, in_param3, in_param4, &out_param);
 340
 341         if (result == BLUETOOTH_ERROR_NONE) {
 342                 is_discovering = g_array_index(out_param,
 343                                 int, 0);
 344         } else {
 345                 BT_ERR("Fail to send request");
 346         }
 347
 348         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 349
 350         return is_discovering;
 351 }
 352
 353 BT_EXPORT_API int bluetooth_get_bonded_device_list(GPtrArray **dev_list)
 354 {
 355         int result;
 356
 357         BT_CHECK_PARAMETER(dev_list, return);
 358         BT_CHECK_ENABLED(return);
 359
 360         BT_INIT_PARAMS();
 361         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 362
 363         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_BONDED_DEVICES,
 364                 in_param1, in_param2, in_param3, in_param4, &out_param);
 365
 366         if (result == BLUETOOTH_ERROR_NONE) {
 367                 result = __bt_fill_device_list(out_param, dev_list);
 368         }
 369
 370         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 371
 372         return result;
 373 }
 374