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, return);
  38         BT_CHECK_PARAMETER(dev_list, return);
  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(return);
  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_reset_adapter(void)
 107 {
 108         int result;
 109
 110         BT_INIT_PARAMS();
 111         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 112
 113         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_RESET_ADAPTER,
 114                 in_param1, in_param2, in_param3, in_param4, &out_param);
 115
 116         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 117
 118         return result;
 119 }
 120
 121 BT_EXPORT_API int bluetooth_get_local_address(bluetooth_device_address_t *local_address)
 122 {
 123         int result;
 124
 125         BT_CHECK_PARAMETER(local_address, return);
 126         BT_CHECK_ENABLED(return);
 127
 128         BT_INIT_PARAMS();
 129         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 130
 131         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_LOCAL_ADDRESS,
 132                 in_param1, in_param2, in_param3, in_param4, &out_param);
 133
 134         if (result == BLUETOOTH_ERROR_NONE) {
 135                 *local_address = g_array_index(out_param,
 136                         bluetooth_device_address_t, 0);
 137         }
 138
 139         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 140
 141         return result;
 142 }
 143
 144 BT_EXPORT_API int bluetooth_get_local_name(bluetooth_device_name_t *local_name)
 145 {
 146         int result;
 147
 148         BT_CHECK_PARAMETER(local_name, return);
 149         BT_CHECK_ENABLED(return);
 150
 151         BT_INIT_PARAMS();
 152         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 153
 154         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_LOCAL_NAME,
 155                 in_param1, in_param2, in_param3, in_param4, &out_param);
 156
 157         if (result == BLUETOOTH_ERROR_NONE) {
 158                 *local_name = g_array_index(out_param,
 159                                 bluetooth_device_name_t, 0);
 160         }
 161
 162         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 163
 164         return result;
 165 }
 166
 167 BT_EXPORT_API int bluetooth_set_local_name(const bluetooth_device_name_t *local_name)
 168 {
 169         int result;
 170
 171         BT_CHECK_PARAMETER(local_name, return);
 172         BT_CHECK_ENABLED(return);
 173
 174         BT_INIT_PARAMS();
 175         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 176
 177         g_array_append_vals(in_param1, local_name, sizeof(bluetooth_device_name_t));
 178
 179         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_LOCAL_NAME,
 180                 in_param1, in_param2, in_param3, in_param4, &out_param);
 181
 182         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 183
 184         return result;
 185 }
 186
 187 BT_EXPORT_API int bluetooth_is_service_used(const char *service_uuid,
 188                                                 gboolean *used)
 189 {
 190         int result;
 191         char uuid[BLUETOOTH_UUID_STRING_MAX];
 192
 193         BT_CHECK_PARAMETER(service_uuid, return);
 194         BT_CHECK_PARAMETER(used, return);
 195         BT_CHECK_ENABLED(return);
 196
 197         BT_INIT_PARAMS();
 198         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 199
 200         g_strlcpy(uuid, service_uuid, sizeof(uuid));
 201         g_array_append_vals(in_param1, uuid, BLUETOOTH_UUID_STRING_MAX);
 202
 203         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_IS_SERVICE_USED,
 204                 in_param1, in_param2, in_param3, in_param4, &out_param);
 205
 206         if (result == BLUETOOTH_ERROR_NONE) {
 207                 *used = g_array_index(out_param, gboolean, 0);
 208         }
 209
 210         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 211
 212         return result;
 213 }
 214
 215 BT_EXPORT_API int bluetooth_get_discoverable_mode(bluetooth_discoverable_mode_t *
 216                                                   discoverable_mode_ptr)
 217 {
 218         int result;
 219         int timeout = 0;
 220
 221         BT_CHECK_PARAMETER(discoverable_mode_ptr, return);
 222
 223         /* Requirement in OSP */
 224         if (bluetooth_check_adapter() == BLUETOOTH_ADAPTER_DISABLED) {
 225                 if (vconf_get_int(BT_FILE_VISIBLE_TIME, &timeout) != 0) {
 226                         BT_ERR("Fail to get the timeout value");
 227                         return BLUETOOTH_ERROR_INTERNAL;
 228                 }
 229
 230                 if (timeout == -1) {
 231                         *discoverable_mode_ptr = BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE;
 232                 } else {
 233                         *discoverable_mode_ptr = BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE;
 234                 }
 235
 236                 return BLUETOOTH_ERROR_NONE;
 237         }
 238
 239         BT_INIT_PARAMS();
 240         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 241
 242         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_DISCOVERABLE_MODE,
 243                 in_param1, in_param2, in_param3, in_param4, &out_param);
 244
 245         if (result == BLUETOOTH_ERROR_NONE) {
 246                 *discoverable_mode_ptr = g_array_index(out_param,
 247                                         int, 0);
 248         }
 249
 250         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 251
 252         return result;
 253 }
 254
 255 BT_EXPORT_API int bluetooth_set_discoverable_mode(bluetooth_discoverable_mode_t discoverable_mode,
 256                                                   int timeout)
 257 {
 258         int result;
 259
 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_array_append_vals(in_param1, &discoverable_mode, sizeof(int));
 266         g_array_append_vals(in_param2, &timeout, sizeof(int));
 267
 268         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_DISCOVERABLE_MODE,
 269                 in_param1, in_param2, in_param3, in_param4, &out_param);
 270
 271         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 272
 273         return result;
 274 }
 275
 276 BT_EXPORT_API int bluetooth_get_timeout_value(int *timeout)
 277 {
 278         int result;
 279
 280         BT_CHECK_PARAMETER(timeout, return);
 281         BT_CHECK_ENABLED(return);
 282
 283         BT_INIT_PARAMS();
 284         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 285
 286         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_DISCOVERABLE_TIME,
 287                 in_param1, in_param2, in_param3, in_param4, &out_param);
 288
 289         if (result == BLUETOOTH_ERROR_NONE) {
 290                 *timeout = g_array_index(out_param, int, 0);
 291         }
 292
 293         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 294
 295         return result;
 296 }
 297
 298 BT_EXPORT_API int bluetooth_start_discovery(unsigned short max_response,
 299                                             unsigned short discovery_duration,
 300                                             unsigned int classOfDeviceMask)
 301 {
 302         int result;
 303
 304         BT_CHECK_ENABLED(return);
 305
 306         BT_INIT_PARAMS();
 307         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 308
 309         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_START_DISCOVERY,
 310                 in_param1, in_param2, in_param3, in_param4, &out_param);
 311
 312         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 313
 314         return result;
 315 }
 316
 317 BT_EXPORT_API int bluetooth_cancel_discovery(void)
 318 {
 319         int result;
 320
 321         BT_CHECK_ENABLED(return);
 322
 323         BT_INIT_PARAMS();
 324         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 325
 326         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_CANCEL_DISCOVERY,
 327                 in_param1, in_param2, in_param3, in_param4, &out_param);
 328
 329
 330         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 331
 332         return result;
 333 }
 334
 335 BT_EXPORT_API int bluetooth_is_discovering(void)
 336 {
 337         int result;
 338         int is_discovering = FALSE;
 339
 340         BT_CHECK_ENABLED(return);
 341
 342         BT_INIT_PARAMS();
 343         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 344
 345         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_IS_DISCOVERYING,
 346                 in_param1, in_param2, in_param3, in_param4, &out_param);
 347
 348         if (result == BLUETOOTH_ERROR_NONE) {
 349                 is_discovering = g_array_index(out_param,
 350                                 int, 0);
 351         } else {
 352                 BT_ERR("Fail to send request");
 353         }
 354
 355         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 356
 357         return is_discovering;
 358 }
 359
 360 BT_EXPORT_API int bluetooth_get_bonded_device_list(GPtrArray **dev_list)
 361 {
 362         int result;
 363
 364         BT_CHECK_PARAMETER(dev_list, return);
 365         BT_CHECK_ENABLED(return);
 366
 367         BT_INIT_PARAMS();
 368         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 369
 370         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_BONDED_DEVICES,
 371                 in_param1, in_param2, in_param3, in_param4, &out_param);
 372
 373         if (result == BLUETOOTH_ERROR_NONE) {
 374                 result = __bt_fill_device_list(out_param, dev_list);
 375         }
 376
 377         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 378
 379         return result;
 380 }
 381