bt-api/bt-common.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 <string.h>
  21 #include <fcntl.h>
  22 #include <unistd.h>
  23 #include <sys/types.h>
  24 #include <stdlib.h>
  25
  26 #include "bluetooth-api.h"
  27 #include "bluetooth-audio-api.h"
  28 #include "bluetooth-hid-api.h"
  29 #include "bluetooth-media-control.h"
  30 #include "bt-internal-types.h"
  31
  32 #include "bt-common.h"
  33 #include "bt-request-sender.h"
  34 #include "bt-event-handler.h"
  35
  36 static bt_user_info_t user_info[BT_MAX_USER_INFO];
  37 static DBusGConnection *system_conn = NULL;
  38
  39 void _bt_print_device_address_t(const bluetooth_device_address_t *addr)
  40 {
  41         BT_DBG("%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X\n", addr->addr[0], addr->addr[1], addr->addr[2],
  42                                 addr->addr[3], addr->addr[4], addr->addr[5]);
  43 }
  44
  45 void _bt_set_user_data(int type, void *callback, void *user_data)
  46 {
  47         user_info[type].cb = callback;
  48         user_info[type].user_data = user_data;
  49 }
  50
  51 bt_user_info_t *_bt_get_user_data(int type)
  52 {
  53         return &user_info[type];
  54 }
  55
  56 void _bt_common_event_cb(int event, int result, void *param,
  57                                         void *callback, void *user_data)
  58 {
  59         bluetooth_event_param_t bt_event = { 0, };
  60         bt_event.event = event;
  61         bt_event.result = result;
  62         bt_event.param_data = param;
  63
  64         if (callback)
  65                 ((bluetooth_cb_func_ptr)callback)(bt_event.event, &bt_event,
  66                                         user_data);
  67 }
  68
  69 void _bt_input_event_cb(int event, int result, void *param,
  70                                         void *callback, void *user_data)
  71 {
  72         hid_event_param_t bt_event = { 0, };
  73         bt_event.event = event;
  74         bt_event.result = result;
  75         bt_event.param_data = param;
  76
  77         if (callback)
  78                 ((hid_cb_func_ptr)callback)(bt_event.event, &bt_event,
  79                                         user_data);
  80 }
  81
  82 void _bt_headset_event_cb(int event, int result, void *param,
  83                                         void *callback, void *user_data)
  84 {
  85         bt_audio_event_param_t bt_event = { 0, };
  86         bt_event.event = event;
  87         bt_event.result = result;
  88         bt_event.param_data = param;
  89
  90         if (callback)
  91                 ((bt_audio_func_ptr)callback)(bt_event.event, &bt_event,
  92                                         user_data);
  93 }
  94
  95 void _bt_avrcp_event_cb(int event, int result, void *param,
  96                                         void *callback, void *user_data)
  97 {
  98         media_event_param_t bt_event = { 0, };
  99         bt_event.event = event;
 100         bt_event.result = result;
 101         bt_event.param_data = param;
 102
 103         if (callback)
 104                 ((media_cb_func_ptr)callback)(bt_event.event, &bt_event,
 105                                         user_data);
 106 }
 107
 108 void _bt_divide_device_class(bluetooth_device_class_t *device_class,
 109                                 unsigned int cod)
 110 {
 111         ret_if(device_class == NULL);
 112
 113         device_class->major_class = (unsigned short)(cod & 0x00001F00) >> 8;
 114         device_class->minor_class = (unsigned short)((cod & 0x000000FC));
 115         device_class->service_class = (unsigned long)((cod & 0x00FF0000));
 116
 117         if (cod & 0x002000) {
 118                 device_class->service_class |=
 119                 BLUETOOTH_DEVICE_SERVICE_CLASS_LIMITED_DISCOVERABLE_MODE;
 120         }
 121 }
 122
 123 void _bt_convert_addr_string_to_type(unsigned char *addr,
 124                                         const char *address)
 125 {
 126         int i;
 127         char *ptr = NULL;
 128
 129         ret_if(address == NULL);
 130         ret_if(addr == NULL);
 131
 132         for (i = 0; i < BT_ADDRESS_LENGTH_MAX; i++) {
 133                 addr[i] = strtol(address, &ptr, 16);
 134                 if (ptr != NULL) {
 135                         if (ptr[0] != ':')
 136                                 return;
 137
 138                         address = ptr + 1;
 139                 }
 140         }
 141 }
 142
 143 void _bt_convert_addr_type_to_string(char *address,
 144                                 unsigned char *addr)
 145 {
 146         ret_if(address == NULL);
 147         ret_if(addr == NULL);
 148
 149         g_snprintf(address, BT_ADDRESS_STRING_SIZE,
 150                         "%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X",
 151                         addr[0], addr[1], addr[2],
 152                         addr[3], addr[4], addr[5]);
 153 }
 154
 155 int _bt_copy_utf8_string(char *dest, const char *src, unsigned int length)
 156 {
 157         int i;
 158         char *p = src;
 159         char *next;
 160         int count;
 161
 162         if (dest == NULL || src == NULL)
 163                 return BLUETOOTH_ERROR_INVALID_PARAM;
 164
 165         i = 0;
 166         while (*p != '\0' && i < length) {
 167                 next = g_utf8_next_char(p);
 168                 count = next - p;
 169
 170                 while (count > 0 && ((i + count) < length)) {
 171                         dest[i++] = *p;
 172                         p++;
 173                         count --;
 174                 }
 175                 p = next;
 176         }
 177         return BLUETOOTH_ERROR_NONE;
 178 }
 179
 180 static char *__bt_extract_adapter_path(DBusMessageIter *msg_iter)
 181 {
 182         char *object_path = NULL;
 183         DBusMessageIter value_iter;
 184
 185         /* Parse the signature:  oa{sa{sv}}} */
 186         retv_if(dbus_message_iter_get_arg_type(msg_iter) !=
 187                                 DBUS_TYPE_OBJECT_PATH, NULL);
 188
 189         dbus_message_iter_get_basic(msg_iter, &object_path);
 190         retv_if(object_path == NULL, NULL);
 191
 192         /* object array (oa) */
 193         retv_if(dbus_message_iter_next(msg_iter) == FALSE, NULL);
 194         retv_if(dbus_message_iter_get_arg_type(msg_iter) !=
 195                                 DBUS_TYPE_ARRAY, NULL);
 196
 197         dbus_message_iter_recurse(msg_iter, &value_iter);
 198
 199         /* string array (sa) */
 200         while (dbus_message_iter_get_arg_type(&value_iter) ==
 201                                         DBUS_TYPE_DICT_ENTRY) {
 202                 char *interface_name = NULL;
 203                 DBusMessageIter interface_iter;
 204
 205                 dbus_message_iter_recurse(&value_iter, &interface_iter);
 206
 207                 retv_if(dbus_message_iter_get_arg_type(&interface_iter) !=
 208                         DBUS_TYPE_STRING, NULL);
 209
 210                 dbus_message_iter_get_basic(&interface_iter, &interface_name);
 211
 212                 if (g_strcmp0(interface_name, "org.bluez.Adapter1") == 0) {
 213                         /* Tizen don't allow the multi-adapter */
 214                         BT_DBG("Found an adapter: %s", object_path);
 215                         return g_strdup(object_path);
 216                 }
 217
 218                 dbus_message_iter_next(&value_iter);
 219         }
 220
 221         BT_DBG("There is no adapter");
 222
 223         return NULL;
 224 }
 225
 226 /* TO DO */
 227 /* Change DBusGConnection to DBusConnection*/
 228 int _bt_get_adapter_path(DBusGConnection *g_conn, char *path)
 229 {
 230         DBusMessage *msg;
 231         DBusMessage *reply;
 232         DBusMessageIter reply_iter;
 233         DBusMessageIter value_iter;
 234         DBusError err;
 235         DBusConnection *conn;
 236         char *adapter_path = NULL;
 237
 238         retv_if(g_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
 239
 240         conn = dbus_g_connection_get_connection(g_conn);
 241         retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
 242
 243         msg = dbus_message_new_method_call(BT_BLUEZ_NAME, BT_MANAGER_PATH,
 244                                                 BT_MANAGER_INTERFACE,
 245                                                 "GetManagedObjects");
 246
 247         if (msg == NULL) {
 248                 BT_ERR("Can't allocate D-Bus message");
 249                 goto fail;
 250         }
 251
 252         /* Synchronous call */
 253         dbus_error_init(&err);
 254         reply = dbus_connection_send_with_reply_and_block(
 255                                         conn, msg,
 256                                         -1, &err);
 257         dbus_message_unref(msg);
 258
 259         if (!reply) {
 260                 BT_ERR("Can't get managed objects");
 261
 262                 if (dbus_error_is_set(&err)) {
 263                         BT_ERR("%s", err.message);
 264                         dbus_error_free(&err);
 265                 }
 266                 goto fail;
 267         }
 268
 269         if (dbus_message_iter_init(reply, &reply_iter) == FALSE) {
 270             BT_ERR("Fail to iterate the reply");
 271             goto fail;
 272         }
 273
 274         dbus_message_iter_recurse(&reply_iter, &value_iter);
 275
 276         /* signature of GetManagedObjects:  a{oa{sa{sv}}} */
 277         while (dbus_message_iter_get_arg_type(&value_iter) ==
 278                                                 DBUS_TYPE_DICT_ENTRY) {
 279                 DBusMessageIter msg_iter;
 280
 281                 dbus_message_iter_recurse(&value_iter, &msg_iter);
 282
 283                 adapter_path = __bt_extract_adapter_path(&msg_iter);
 284                 if (adapter_path != NULL) {
 285                         BT_DBG("Found the adapter path");
 286                         break;
 287                 }
 288
 289                 dbus_message_iter_next(&value_iter);
 290         }
 291
 292         if (adapter_path == NULL ||
 293              strlen(adapter_path) >= BT_ADAPTER_OBJECT_PATH_MAX) {
 294                 BT_ERR("Adapter path is inproper\n");
 295                 goto fail;
 296         }
 297
 298         BT_DBG("adapter path: %s", adapter_path);
 299
 300         if (path)
 301                 g_strlcpy(path, adapter_path, BT_ADAPTER_OBJECT_PATH_MAX);
 302
 303         g_free(adapter_path);
 304
 305         return BLUETOOTH_ERROR_NONE;
 306
 307 fail:
 308         g_free(adapter_path);
 309
 310         return BLUETOOTH_ERROR_INTERNAL;
 311 }
 312
 313 DBusGProxy *_bt_get_adapter_proxy(DBusGConnection *conn)
 314 {
 315         DBusGProxy *adapter_proxy = NULL;
 316         char adapter_path[BT_ADAPTER_OBJECT_PATH_MAX] = { 0 };
 317
 318         retv_if(conn == NULL, NULL);
 319
 320         if (_bt_get_adapter_path(conn, adapter_path) < 0) {
 321                 BT_DBG("Could not get adapter path\n");
 322                 return NULL;
 323         }
 324
 325         adapter_proxy = dbus_g_proxy_new_for_name(conn, BT_BLUEZ_NAME,
 326                                 adapter_path, BT_PROPERTIES_INTERFACE);
 327
 328         return adapter_proxy;
 329 }
 330
 331 gboolean _bt_get_adapter_power(DBusGConnection *conn)
 332 {
 333         DBusGProxy *proxy = NULL;
 334         gboolean powered;
 335         GValue powered_v = { 0 };
 336         GError *err = NULL;
 337
 338         BT_DBG("+");
 339
 340         proxy = _bt_get_adapter_proxy(conn);
 341         retv_if(proxy == NULL, FALSE);
 342
 343         if (!dbus_g_proxy_call(proxy, "Get", &err,
 344                         G_TYPE_STRING, BT_ADAPTER_INTERFACE,
 345                         G_TYPE_STRING, "Powered",
 346                         G_TYPE_INVALID,
 347                         G_TYPE_VALUE, &powered_v,
 348                         G_TYPE_INVALID)) {
 349                 if (err != NULL) {
 350                         BT_ERR("Getting property failed: [%s]\n", err->message);
 351                         g_error_free(err);
 352                 }
 353                 return FALSE;
 354         }
 355
 356         powered = (gboolean)g_value_get_boolean(&powered_v);
 357
 358         BT_DBG("powered = %d", powered);
 359         BT_DBG("-");
 360
 361         return powered;
 362 }
 363
 364 void _bt_device_path_to_address(const char *device_path, char *device_address)
 365 {
 366         char address[BT_ADDRESS_STRING_SIZE] = { 0 };
 367         char *dev_addr = NULL;
 368
 369         if (!device_path || !device_address)
 370                 return;
 371
 372         dev_addr = strstr(device_path, "dev_");
 373         if (dev_addr != NULL) {
 374                 char *pos = NULL;
 375                 dev_addr += 4;
 376                 g_strlcpy(address, dev_addr, sizeof(address));
 377
 378                 while ((pos = strchr(address, '_')) != NULL) {
 379                         *pos = ':';
 380                 }
 381
 382                 g_strlcpy(device_address, address, BT_ADDRESS_STRING_SIZE);
 383         }
 384 }
 385
 386 DBusGConnection *__bt_init_system_gconn(void)
 387 {
 388         g_type_init();
 389
 390         if (system_conn == NULL)
 391                 system_conn = dbus_g_bus_get(DBUS_BUS_SYSTEM, NULL);
 392
 393         return system_conn;
 394 }
 395
 396 DBusGConnection *_bt_get_system_gconn(void)
 397 {
 398         return (system_conn) ? system_conn : __bt_init_system_gconn();
 399 }
 400
 401 DBusConnection *_bt_get_system_conn(void)
 402 {
 403         DBusGConnection *g_conn;
 404
 405         if (system_conn == NULL) {
 406                 g_conn = __bt_init_system_gconn();
 407         } else {
 408                 g_conn = system_conn;
 409         }
 410
 411         retv_if(g_conn == NULL, NULL);
 412
 413         return dbus_g_connection_get_connection(g_conn);
 414 }
 415
 416 BT_EXPORT_API int bluetooth_is_supported(void)
 417 {
 418         int is_supported = 0;
 419         int len = 0;
 420         int fd = -1;
 421         rfkill_event event;
 422
 423         fd = open(RFKILL_NODE, O_RDONLY);
 424         if (fd < 0) {
 425                 BT_DBG("Fail to open RFKILL node");
 426                 return BLUETOOTH_ERROR_INTERNAL;
 427         }
 428
 429         if (fcntl(fd, F_SETFL, O_NONBLOCK) < 0) {
 430                 BT_DBG("Fail to set RFKILL node to non-blocking");
 431                 close(fd);
 432                 return BLUETOOTH_ERROR_INTERNAL;
 433         }
 434
 435         while (1) {
 436                 len = read(fd, &event, sizeof(event));
 437                 if (len < 0) {
 438                         BT_DBG("Fail to read events");
 439                         break;
 440                 }
 441
 442                 if (len != RFKILL_EVENT_SIZE) {
 443                         BT_DBG("The size is wrong\n");
 444                         continue;
 445                 }
 446
 447                 if (event.type == RFKILL_TYPE_BLUETOOTH) {
 448                         is_supported = 1;
 449                         break;
 450                 }
 451         }
 452
 453         close(fd);
 454
 455         BT_DBG("supported: %d", is_supported);
 456
 457         return is_supported;
 458 }
 459
 460 BT_EXPORT_API int bluetooth_register_callback(bluetooth_cb_func_ptr callback_ptr, void *user_data)
 461 {
 462         int ret;
 463
 464         __bt_init_system_gconn();
 465
 466         ret = _bt_init_event_handler();
 467
 468         if (ret != BLUETOOTH_ERROR_NONE &&
 469              ret != BLUETOOTH_ERROR_ALREADY_INITIALIZED) {
 470                 BT_ERR("Fail to init the event handler");
 471                 return ret;
 472         }
 473
 474         _bt_set_user_data(BT_COMMON, (void *)callback_ptr, user_data);
 475
 476         /* Register All events */
 477         _bt_register_event(BT_ADAPTER_EVENT, (void *)callback_ptr, user_data);
 478         _bt_register_event(BT_DEVICE_EVENT, (void *)callback_ptr, user_data);
 479         _bt_register_event(BT_NETWORK_EVENT, (void *)callback_ptr, user_data);
 480         _bt_register_event(BT_RFCOMM_CLIENT_EVENT, (void *)callback_ptr, user_data);
 481         _bt_register_event(BT_RFCOMM_SERVER_EVENT, (void *)callback_ptr, user_data);
 482
 483         return BLUETOOTH_ERROR_NONE;
 484 }
 485
 486 BT_EXPORT_API int bluetooth_unregister_callback(void)
 487 {
 488         _bt_unregister_event(BT_ADAPTER_EVENT);
 489         _bt_unregister_event(BT_DEVICE_EVENT);
 490         _bt_unregister_event(BT_NETWORK_EVENT);
 491         _bt_unregister_event(BT_RFCOMM_CLIENT_EVENT);
 492         _bt_unregister_event(BT_RFCOMM_SERVER_EVENT);
 493
 494         _bt_set_user_data(BT_COMMON, NULL, NULL);
 495
 496         if (system_conn) {
 497                 dbus_g_connection_unref(system_conn);
 498                 system_conn = NULL;
 499         }
 500
 501         return BLUETOOTH_ERROR_NONE;
 502 }
 503