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