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
 229         BT_CHECK_PARAMETER(discoverable_mode_ptr, return);
 230
 231         BT_INIT_PARAMS();
 232         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 233
 234         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_DISCOVERABLE_MODE,
 235                 in_param1, in_param2, in_param3, in_param4, &out_param);
 236
 237         if (result == BLUETOOTH_ERROR_NONE) {
 238                 *discoverable_mode_ptr = g_array_index(out_param,
 239                                         int, 0);
 240         }
 241
 242         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 243
 244         return result;
 245 }
 246
 247 BT_EXPORT_API int bluetooth_set_discoverable_mode(bluetooth_discoverable_mode_t discoverable_mode,
 248                                                   int timeout)
 249 {
 250         int result;
 251
 252         BT_CHECK_ENABLED(return);
 253
 254         BT_INIT_PARAMS();
 255         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 256
 257         g_array_append_vals(in_param1, &discoverable_mode, sizeof(int));
 258         g_array_append_vals(in_param2, &timeout, sizeof(int));
 259
 260         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_DISCOVERABLE_MODE,
 261                 in_param1, in_param2, in_param3, in_param4, &out_param);
 262
 263         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 264
 265         return result;
 266 }
 267
 268 BT_EXPORT_API int bluetooth_get_timeout_value(int *timeout)
 269 {
 270         int result;
 271
 272         BT_CHECK_PARAMETER(timeout, return);
 273         BT_CHECK_ENABLED(return);
 274
 275         BT_INIT_PARAMS();
 276         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 277
 278         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_DISCOVERABLE_TIME,
 279                 in_param1, in_param2, in_param3, in_param4, &out_param);
 280
 281         if (result == BLUETOOTH_ERROR_NONE) {
 282                 *timeout = g_array_index(out_param, int, 0);
 283         }
 284
 285         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 286
 287         return result;
 288 }
 289
 290 BT_EXPORT_API int bluetooth_start_discovery(unsigned short max_response,
 291                                             unsigned short discovery_duration,
 292                                             unsigned int classOfDeviceMask)
 293 {
 294         int result;
 295
 296         BT_CHECK_ENABLED(return);
 297
 298         BT_INIT_PARAMS();
 299         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 300
 301         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_START_DISCOVERY,
 302                 in_param1, in_param2, in_param3, in_param4, &out_param);
 303
 304         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 305
 306         return result;
 307 }
 308
 309 BT_EXPORT_API int bluetooth_cancel_discovery(void)
 310 {
 311         int result;
 312
 313         BT_CHECK_ENABLED(return);
 314
 315         BT_INIT_PARAMS();
 316         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 317
 318         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_CANCEL_DISCOVERY,
 319                 in_param1, in_param2, in_param3, in_param4, &out_param);
 320
 321
 322         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 323
 324         return result;
 325 }
 326
 327 BT_EXPORT_API int bluetooth_is_discovering(void)
 328 {
 329         int result;
 330         int is_discovering = FALSE;
 331
 332         BT_CHECK_ENABLED(return);
 333
 334         BT_INIT_PARAMS();
 335         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 336
 337         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_IS_DISCOVERYING,
 338                 in_param1, in_param2, in_param3, in_param4, &out_param);
 339
 340         if (result == BLUETOOTH_ERROR_NONE) {
 341                 is_discovering = g_array_index(out_param,
 342                                 int, 0);
 343         } else {
 344                 BT_ERR("Fail to send request");
 345         }
 346
 347         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 348
 349         return is_discovering;
 350 }
 351
 352 BT_EXPORT_API int bluetooth_get_bonded_device_list(GPtrArray **dev_list)
 353 {
 354         int result;
 355
 356         BT_CHECK_PARAMETER(dev_list, return);
 357         BT_CHECK_ENABLED(return);
 358
 359         BT_INIT_PARAMS();
 360         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 361
 362         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_BONDED_DEVICES,
 363                 in_param1, in_param2, in_param3, in_param4, &out_param);
 364
 365         if (result == BLUETOOTH_ERROR_NONE) {
 366                 result = __bt_fill_device_list(out_param, dev_list);
 367         }
 368
 369         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 370
 371         return result;
 372 }
 373