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