4 * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
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
10 * http://www.apache.org/licenses/LICENSE-2.0
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.
23 #include <sys/types.h>
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"
32 #include "bt-common.h"
33 #include "bt-request-sender.h"
34 #include "bt-event-handler.h"
36 static bt_user_info_t user_info[BT_MAX_USER_INFO];
37 static DBusGConnection *system_conn = NULL;
39 void _bt_print_device_address_t(const bluetooth_device_address_t *addr)
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]);
45 void _bt_set_user_data(int type, void *callback, void *user_data)
47 user_info[type].cb = callback;
48 user_info[type].user_data = user_data;
51 bt_user_info_t *_bt_get_user_data(int type)
53 return &user_info[type];
56 void _bt_common_event_cb(int event, int result, void *param,
57 void *callback, void *user_data)
59 bluetooth_event_param_t bt_event = { 0, };
60 bt_event.event = event;
61 bt_event.result = result;
62 bt_event.param_data = param;
65 ((bluetooth_cb_func_ptr)callback)(bt_event.event, &bt_event,
69 void _bt_input_event_cb(int event, int result, void *param,
70 void *callback, void *user_data)
72 hid_event_param_t bt_event = { 0, };
73 bt_event.event = event;
74 bt_event.result = result;
75 bt_event.param_data = param;
78 ((hid_cb_func_ptr)callback)(bt_event.event, &bt_event,
82 void _bt_headset_event_cb(int event, int result, void *param,
83 void *callback, void *user_data)
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;
91 ((bt_audio_func_ptr)callback)(bt_event.event, &bt_event,
95 void _bt_avrcp_event_cb(int event, int result, void *param,
96 void *callback, void *user_data)
98 media_event_param_t bt_event = { 0, };
99 bt_event.event = event;
100 bt_event.result = result;
101 bt_event.param_data = param;
104 ((media_cb_func_ptr)callback)(bt_event.event, &bt_event,
108 void _bt_divide_device_class(bluetooth_device_class_t *device_class,
111 ret_if(device_class == NULL);
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));
117 if (cod & 0x002000) {
118 device_class->service_class |=
119 BLUETOOTH_DEVICE_SERVICE_CLASS_LIMITED_DISCOVERABLE_MODE;
123 void _bt_convert_addr_string_to_type(unsigned char *addr,
129 ret_if(address == NULL);
130 ret_if(addr == NULL);
132 for (i = 0; i < BT_ADDRESS_LENGTH_MAX; i++) {
133 addr[i] = strtol(address, &ptr, 16);
143 void _bt_convert_addr_type_to_string(char *address,
146 ret_if(address == NULL);
147 ret_if(addr == NULL);
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]);
155 int _bt_copy_utf8_string(char *dest, const char *src, unsigned int length)
162 if (dest == NULL || src == NULL)
163 return BLUETOOTH_ERROR_INVALID_PARAM;
166 while (*p != '\0' && i < length) {
167 next = g_utf8_next_char(p);
170 while (count > 0 && ((i + count) < length)) {
177 return BLUETOOTH_ERROR_NONE;
180 static char *__bt_extract_adapter_path(DBusMessageIter *msg_iter)
182 char *object_path = NULL;
183 DBusMessageIter value_iter;
185 /* Parse the signature: oa{sa{sv}}} */
186 retv_if(dbus_message_iter_get_arg_type(msg_iter) !=
187 DBUS_TYPE_OBJECT_PATH, NULL);
189 dbus_message_iter_get_basic(msg_iter, &object_path);
190 retv_if(object_path == NULL, NULL);
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);
197 dbus_message_iter_recurse(msg_iter, &value_iter);
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;
205 dbus_message_iter_recurse(&value_iter, &interface_iter);
207 retv_if(dbus_message_iter_get_arg_type(&interface_iter) !=
208 DBUS_TYPE_STRING, NULL);
210 dbus_message_iter_get_basic(&interface_iter, &interface_name);
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);
218 dbus_message_iter_next(&value_iter);
221 BT_DBG("There is no adapter");
227 /* Change DBusGConnection to DBusConnection*/
228 int _bt_get_adapter_path(DBusGConnection *g_conn, char *path)
232 DBusMessageIter reply_iter;
233 DBusMessageIter value_iter;
235 DBusConnection *conn;
236 char *adapter_path = NULL;
238 retv_if(g_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
240 conn = dbus_g_connection_get_connection(g_conn);
241 retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
243 msg = dbus_message_new_method_call(BT_BLUEZ_NAME, BT_MANAGER_PATH,
244 BT_MANAGER_INTERFACE,
245 "GetManagedObjects");
248 BT_ERR("Can't allocate D-Bus message");
252 /* Synchronous call */
253 dbus_error_init(&err);
254 reply = dbus_connection_send_with_reply_and_block(
257 dbus_message_unref(msg);
260 BT_ERR("Can't get managed objects");
262 if (dbus_error_is_set(&err)) {
263 BT_ERR("%s", err.message);
264 dbus_error_free(&err);
269 if (dbus_message_iter_init(reply, &reply_iter) == FALSE) {
270 BT_ERR("Fail to iterate the reply");
274 dbus_message_iter_recurse(&reply_iter, &value_iter);
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;
281 dbus_message_iter_recurse(&value_iter, &msg_iter);
283 adapter_path = __bt_extract_adapter_path(&msg_iter);
284 if (adapter_path != NULL) {
285 BT_DBG("Found the adapter path");
289 dbus_message_iter_next(&value_iter);
292 if (adapter_path == NULL ||
293 strlen(adapter_path) >= BT_ADAPTER_OBJECT_PATH_MAX) {
294 BT_ERR("Adapter path is inproper\n");
298 BT_DBG("adapter path: %s", adapter_path);
301 g_strlcpy(path, adapter_path, BT_ADAPTER_OBJECT_PATH_MAX);
303 g_free(adapter_path);
305 return BLUETOOTH_ERROR_NONE;
308 g_free(adapter_path);
310 return BLUETOOTH_ERROR_INTERNAL;
313 DBusGProxy *_bt_get_adapter_proxy(DBusGConnection *conn)
315 DBusGProxy *adapter_proxy = NULL;
316 char adapter_path[BT_ADAPTER_OBJECT_PATH_MAX] = { 0 };
318 retv_if(conn == NULL, NULL);
320 if (_bt_get_adapter_path(conn, adapter_path) < 0) {
321 BT_DBG("Could not get adapter path\n");
325 adapter_proxy = dbus_g_proxy_new_for_name(conn, BT_BLUEZ_NAME,
326 adapter_path, BT_PROPERTIES_INTERFACE);
328 return adapter_proxy;
331 gboolean _bt_get_adapter_power(DBusGConnection *conn)
333 DBusGProxy *proxy = NULL;
335 GValue powered_v = { 0 };
340 proxy = _bt_get_adapter_proxy(conn);
341 retv_if(proxy == NULL, FALSE);
343 if (!dbus_g_proxy_call(proxy, "Get", &err,
344 G_TYPE_STRING, BT_ADAPTER_INTERFACE,
345 G_TYPE_STRING, "Powered",
347 G_TYPE_VALUE, &powered_v,
350 BT_ERR("Getting property failed: [%s]\n", err->message);
356 powered = (gboolean)g_value_get_boolean(&powered_v);
358 BT_DBG("powered = %d", powered);
364 void _bt_device_path_to_address(const char *device_path, char *device_address)
366 char address[BT_ADDRESS_STRING_SIZE] = { 0 };
367 char *dev_addr = NULL;
369 if (!device_path || !device_address)
372 dev_addr = strstr(device_path, "dev_");
373 if (dev_addr != NULL) {
376 g_strlcpy(address, dev_addr, sizeof(address));
378 while ((pos = strchr(address, '_')) != NULL) {
382 g_strlcpy(device_address, address, BT_ADDRESS_STRING_SIZE);
386 DBusGConnection *__bt_init_system_gconn(void)
390 if (system_conn == NULL)
391 system_conn = dbus_g_bus_get(DBUS_BUS_SYSTEM, NULL);
396 DBusGConnection *_bt_get_system_gconn(void)
398 return (system_conn) ? system_conn : __bt_init_system_gconn();
401 DBusConnection *_bt_get_system_conn(void)
403 DBusGConnection *g_conn;
405 if (system_conn == NULL) {
406 g_conn = __bt_init_system_gconn();
408 g_conn = system_conn;
411 retv_if(g_conn == NULL, NULL);
413 return dbus_g_connection_get_connection(g_conn);
416 BT_EXPORT_API int bluetooth_is_supported(void)
418 int is_supported = 0;
423 fd = open(RFKILL_NODE, O_RDONLY);
425 BT_DBG("Fail to open RFKILL node");
426 return BLUETOOTH_ERROR_INTERNAL;
429 if (fcntl(fd, F_SETFL, O_NONBLOCK) < 0) {
430 BT_DBG("Fail to set RFKILL node to non-blocking");
432 return BLUETOOTH_ERROR_INTERNAL;
436 len = read(fd, &event, sizeof(event));
438 BT_DBG("Fail to read events");
442 if (len != RFKILL_EVENT_SIZE) {
443 BT_DBG("The size is wrong\n");
447 if (event.type == RFKILL_TYPE_BLUETOOTH) {
455 BT_DBG("supported: %d", is_supported);
460 BT_EXPORT_API int bluetooth_register_callback(bluetooth_cb_func_ptr callback_ptr, void *user_data)
464 __bt_init_system_gconn();
466 ret = _bt_init_event_handler();
468 if (ret != BLUETOOTH_ERROR_NONE &&
469 ret != BLUETOOTH_ERROR_ALREADY_INITIALIZED) {
470 BT_ERR("Fail to init the event handler");
474 _bt_set_user_data(BT_COMMON, (void *)callback_ptr, user_data);
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);
483 return BLUETOOTH_ERROR_NONE;
486 BT_EXPORT_API int bluetooth_unregister_callback(void)
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);
494 _bt_set_user_data(BT_COMMON, NULL, NULL);
497 dbus_g_connection_unref(system_conn);
501 return BLUETOOTH_ERROR_NONE;