bt-api/bt-device.c

   1 /*
   2  * Bluetooth-frwk
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact:  Hocheol Seo <hocheol.seo@samsung.com>
   7  *               Girishashok Joshi <girish.joshi@samsung.com>
   8  *               Chanyeol Park <chanyeol.park@samsung.com>
   9  *
  10  * Licensed under the Apache License, Version 2.0 (the "License");
  11  * you may not use this file except in compliance with the License.
  12  * You may obtain a copy of the License at
  13  *
  14  *              http://www.apache.org/licenses/LICENSE-2.0
  15  *
  16  * Unless required by applicable law or agreed to in writing, software
  17  * distributed under the License is distributed on an "AS IS" BASIS,
  18  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  19  * See the License for the specific language governing permissions and
  20  * limitations under the License.
  21  *
  22  */
  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 BT_EXPORT_API int bluetooth_bond_device(const bluetooth_device_address_t *device_address)
  32 {
  33         int result;
  34         bt_user_info_t *user_info;
  35
  36         BT_CHECK_PARAMETER(device_address, return);
  37         BT_CHECK_ENABLED(return);
  38
  39         if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_BOND_DEVICE)
  40              == BLUETOOTH_ERROR_PERMISSION_DEINED) {
  41                 BT_ERR("Don't have a privilege to use this API");
  42                 return BLUETOOTH_ERROR_PERMISSION_DEINED;
  43         }
  44
  45         user_info = _bt_get_user_data(BT_COMMON);
  46         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
  47
  48         BT_INIT_PARAMS();
  49         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
  50
  51         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
  52
  53         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_BOND_DEVICE,
  54                 in_param1, in_param2, in_param3, in_param4,
  55                 user_info->cb, user_info->user_data);
  56
  57         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
  58
  59         return result;
  60 }
  61
  62 BT_EXPORT_API int bluetooth_bond_device_by_type(
  63         const bluetooth_device_address_t *device_address,
  64         bluetooth_conn_type_t conn_type)
  65 {
  66         int result;
  67         bt_user_info_t *user_info;
  68
  69         BT_CHECK_PARAMETER(device_address, return);
  70         BT_CHECK_ENABLED(return);
  71
  72         if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_BOND_DEVICE_BY_TYPE)
  73              == BLUETOOTH_ERROR_PERMISSION_DEINED) {
  74                 BT_ERR("Don't have a privilege to use this API");
  75                 return BLUETOOTH_ERROR_PERMISSION_DEINED;
  76         }
  77
  78         BT_INIT_PARAMS();
  79         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
  80
  81         user_info = _bt_get_user_data(BT_COMMON);
  82         retv_if(user_info == NULL, BLUETOOTH_ERROR_INTERNAL);
  83
  84         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
  85         g_array_append_vals(in_param2, &conn_type, sizeof(unsigned short));
  86
  87         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_BOND_DEVICE_BY_TYPE,
  88                 in_param1, in_param2, in_param3, in_param4,
  89                 user_info->cb, user_info->user_data);
  90
  91         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
  92
  93         return result;
  94 }
  95
  96 BT_EXPORT_API int bluetooth_cancel_bonding(void)
  97 {
  98         int result;
  99
 100         BT_CHECK_ENABLED(return);
 101
 102         BT_INIT_PARAMS();
 103         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 104
 105         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_CANCEL_BONDING,
 106                 in_param1, in_param2, in_param3, in_param4, &out_param);
 107
 108         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 109
 110         return result;
 111 }
 112
 113 BT_EXPORT_API int bluetooth_unbond_device(const bluetooth_device_address_t *device_address)
 114 {
 115         int result;
 116         bt_user_info_t *user_info;
 117
 118         BT_CHECK_PARAMETER(device_address, return);
 119         BT_CHECK_ENABLED(return);
 120
 121         if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_UNBOND_DEVICE)
 122              == BLUETOOTH_ERROR_PERMISSION_DEINED) {
 123                 BT_ERR("Don't have a privilege to use this API");
 124                 return BLUETOOTH_ERROR_PERMISSION_DEINED;
 125         }
 126
 127         user_info = _bt_get_user_data(BT_COMMON);
 128         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
 129
 130         BT_INIT_PARAMS();
 131         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 132
 133         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 134
 135         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_UNBOND_DEVICE,
 136                 in_param1, in_param2, in_param3, in_param4,
 137                 user_info->cb, user_info->user_data);
 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_bonded_device(const bluetooth_device_address_t *device_address,
 145                                               bluetooth_device_info_t *dev_info)
 146 {
 147         int result;
 148
 149         BT_CHECK_PARAMETER(device_address, return);
 150         BT_CHECK_PARAMETER(dev_info, return);
 151         BT_CHECK_ENABLED(return);
 152
 153         BT_INIT_PARAMS();
 154         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 155
 156         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 157
 158         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_BONDED_DEVICE,
 159                 in_param1, in_param2, in_param3, in_param4, &out_param);
 160
 161         if (result == BLUETOOTH_ERROR_NONE) {
 162                 if (out_param->len > 0) {
 163                         *dev_info = g_array_index(out_param,
 164                                         bluetooth_device_info_t, 0);
 165                 } else {
 166                         BT_ERR("out_param length is 0!!");
 167                 }
 168         }
 169
 170         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 171
 172         return result;
 173 }
 174
 175 BT_EXPORT_API int bluetooth_get_remote_device(const bluetooth_device_address_t *device_address)
 176 {
 177         return BLUETOOTH_ERROR_NONE;
 178 }
 179
 180 BT_EXPORT_API int bluetooth_search_service(const bluetooth_device_address_t *device_address)
 181 {
 182         int result;
 183         bt_user_info_t *user_info;
 184
 185         BT_CHECK_PARAMETER(device_address, return);
 186         BT_CHECK_ENABLED(return);
 187
 188         if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_SEARCH_SERVICE)
 189              == BLUETOOTH_ERROR_PERMISSION_DEINED) {
 190                 BT_ERR("Don't have a privilege to use this API");
 191                 return BLUETOOTH_ERROR_PERMISSION_DEINED;
 192         }
 193
 194         user_info = _bt_get_user_data(BT_COMMON);
 195         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
 196
 197         BT_INIT_PARAMS();
 198         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 199
 200         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 201
 202         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_SEARCH_SERVICE,
 203                 in_param1, in_param2, in_param3, in_param4,
 204                 user_info->cb, user_info->user_data);
 205
 206         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 207
 208         return result;
 209 }
 210
 211 BT_EXPORT_API int bluetooth_cancel_service_search(void)
 212 {
 213         int result;
 214
 215         BT_CHECK_ENABLED(return);
 216
 217         BT_INIT_PARAMS();
 218         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 219
 220         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_CANCEL_SEARCH_SERVICE,
 221                 in_param1, in_param2, in_param3, in_param4, &out_param);
 222
 223         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 224
 225         return result;
 226 }
 227
 228 BT_EXPORT_API int bluetooth_set_alias(const bluetooth_device_address_t *device_address,
 229                                       const char *alias)
 230 {
 231         int result;
 232         char alias_name[BLUETOOTH_DEVICE_NAME_LENGTH_MAX];
 233
 234         BT_CHECK_PARAMETER(device_address, return);
 235         BT_CHECK_PARAMETER(alias, return);
 236         BT_CHECK_ENABLED(return);
 237
 238         BT_INIT_PARAMS();
 239         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 240
 241         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 242         g_strlcpy(alias_name, alias, sizeof(alias_name));
 243         g_array_append_vals(in_param2, alias_name, BLUETOOTH_DEVICE_NAME_LENGTH_MAX);
 244
 245         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_ALIAS,
 246                 in_param1, in_param2, in_param3, in_param4, &out_param);
 247
 248         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 249
 250         return result;
 251 }
 252
 253 BT_EXPORT_API int bluetooth_authorize_device(const bluetooth_device_address_t *device_address,
 254                                              gboolean authorized)
 255 {
 256         int result;
 257
 258         BT_CHECK_PARAMETER(device_address, return);
 259         BT_CHECK_ENABLED(return);
 260
 261         BT_INIT_PARAMS();
 262         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 263
 264         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 265         g_array_append_vals(in_param2, &authorized, sizeof(gboolean));
 266
 267         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_AUTHORIZATION,
 268                 in_param1, in_param2, in_param3, in_param4, &out_param);
 269
 270         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 271
 272         return result;
 273 }
 274
 275 BT_EXPORT_API int bluetooth_is_device_connected(const bluetooth_device_address_t *device_address,
 276                                 bluetooth_service_type_t type,
 277                                 gboolean *is_connected)
 278 {
 279         int result;
 280
 281         BT_CHECK_PARAMETER(device_address, return);
 282         BT_CHECK_PARAMETER(is_connected, return);
 283         BT_CHECK_ENABLED(return);
 284
 285 #ifdef RFCOMM_DIRECT
 286         if (type & BLUETOOTH_RFCOMM_SERVICE) {
 287                 result = bluetooth_rfcomm_client_is_connected(device_address, is_connected);
 288                 if (*is_connected == FALSE)
 289                         result = bluetooth_rfcomm_server_is_connected(device_address, is_connected);
 290
 291                 return result;
 292         }
 293 #endif
 294
 295         BT_INIT_PARAMS();
 296         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 297
 298         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 299         g_array_append_vals(in_param2, &type, sizeof(int));
 300
 301         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_IS_DEVICE_CONNECTED,
 302                 in_param1, in_param2, in_param3, in_param4, &out_param);
 303
 304         if (result == BLUETOOTH_ERROR_NONE) {
 305                 *is_connected = g_array_index(out_param, gboolean, 0);
 306         }
 307
 308         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 309
 310         return result;
 311 }
 312
 313 BT_EXPORT_API int bluetooth_connect_le(const bluetooth_device_address_t *device_address, gboolean auto_connect)
 314 {
 315         int result;
 316
 317         BT_CHECK_PARAMETER(device_address, return);
 318         BT_CHECK_ENABLED_ANY(return);
 319
 320         BT_INIT_PARAMS();
 321         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 322
 323         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 324         g_array_append_vals(in_param2, &auto_connect, sizeof(gboolean));
 325
 326         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_CONNECT_LE,
 327                 in_param1, in_param2, in_param3, in_param4, &out_param);
 328
 329         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 330
 331         return result;
 332 }
 333
 334 BT_EXPORT_API int bluetooth_disconnect_le(const bluetooth_device_address_t *device_address)
 335 {
 336         int result;
 337
 338         BT_CHECK_PARAMETER(device_address, return);
 339         BT_CHECK_ENABLED_ANY(return);
 340
 341         BT_INIT_PARAMS();
 342         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 343
 344         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 345
 346         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DISCONNECT_LE,
 347                 in_param1, in_param2, in_param3, in_param4, &out_param);
 348
 349         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 350
 351         return result;
 352 }
 353
 354 BT_EXPORT_API int bluetooth_enable_rssi(const bluetooth_device_address_t *remote_address,
 355                 int link_type, bt_rssi_threshold_t *rssi_threshold)
 356 {
 357         int result;
 358
 359         BT_CHECK_ENABLED(return);
 360
 361         BT_INIT_PARAMS();
 362         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 363         g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
 364         g_array_append_vals(in_param2, &link_type, sizeof(int));
 365         g_array_append_vals(in_param3, rssi_threshold, sizeof(bt_rssi_threshold_t));
 366
 367         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_ENABLE_RSSI,
 368                 in_param1, in_param2, in_param3, in_param4, &out_param);
 369
 370         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 371
 372         return result;
 373 }
 374
 375 BT_EXPORT_API int bluetooth_get_rssi_strength(const bluetooth_device_address_t *remote_address, int link_type)
 376 {
 377         int result;
 378
 379         BT_CHECK_ENABLED(return);
 380
 381         BT_INIT_PARAMS();
 382         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 383         g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
 384         g_array_append_vals(in_param2, &link_type, sizeof(int));
 385
 386         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_RSSI,
 387                 in_param1, in_param2, in_param3, in_param4, &out_param);
 388
 389         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 390
 391         return result;
 392 }
 393
 394 BT_EXPORT_API int bluetooth_le_conn_update(const bluetooth_device_address_t *address,
 395                                         const bluetooth_le_conn_update_t *parameters)
 396 {
 397         int result;
 398
 399         BT_CHECK_ENABLED(return);
 400         BT_CHECK_PARAMETER(address, return);
 401         BT_CHECK_PARAMETER(parameters, return);
 402
 403         BT_INIT_PARAMS();
 404         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 405
 406         g_array_append_vals(in_param1, address,
 407                         sizeof(bluetooth_device_address_t));
 408         g_array_append_vals(in_param2, parameters,
 409                         sizeof(bluetooth_le_conn_update_t));
 410
 411         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_LE_CONN_UPDATE,
 412                         in_param1, in_param2, in_param3, in_param4, &out_param);
 413
 414         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 415
 416         return result;
 417 }