4 * Copyright (c) 2015 -2016 Samsung Electronics Co., Ltd All Rights Reserved.
6 * Contact: Anupam Roy <anupam.r@samsung.com>
8 * Licensed under the Apache License, Version 2.0 (the "License");
9 * you may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
12 * http://www.apache.org/licenses/LICENSE-2.0
14 * Unless required by applicable law or agreed to in writing, software
15 * distributed under the License is distributed on an "AS IS" BASIS,
16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17 * See the License for the specific language governing permissions and
18 * limitations under the License.
33 #include "bt-hal-log.h"
34 #include "bt-hal-msg.h"
35 #include "bt-hal-internal.h"
36 #include "bt-hal-event-receiver.h"
37 #include "bt-hal-dbus-common-utils.h"
38 #include "bt-hal-agent.h"
39 #include "bt-hal-adapter-le.h"
40 #include "bt-hal-gatt-server.h"
41 #include "bt-hal-gatt-client.h"
42 #include "bt-hal-adapter-dbus-handler.h"
44 #include "bt-internal-types.h"
46 #define BASELEN_PROP_CHANGED (sizeof(struct hal_ev_adapter_props_changed) \
47 + sizeof(struct hal_property))
49 /*TODO: Basic filters are currently added,
50 Need to add different event filters like HID,
51 Device etc in subsequent patches */
53 /* Global variables and structures */
54 static GDBusConnection *manager_conn;
55 static handle_stack_msg event_cb = NULL;
56 static handle_stack_msg hid_event_cb = NULL;
57 static handle_stack_msg hid_device_event_cb = NULL;
58 static handle_stack_msg av_event_cb = NULL;
59 static handle_stack_msg a2dp_sink_event_cb = NULL;
60 static handle_stack_msg hf_event_cb = NULL;
61 static handle_stack_msg hf_client_event_cb = NULL;
62 static handle_stack_msg avrcp_ctrl_event_cb = NULL;
63 static handle_stack_msg avrcp_tg_event_cb = NULL;
64 static handle_stack_msg gatt_event_cb = NULL;
65 static guint event_id;
67 /*State Management sepration Control for Adapter and LE */
68 static gboolean is_adapter_activating = FALSE;
69 static gboolean is_le_activating = FALSE;
74 gchar* interface_name;
77 } bt_hal_main_event_data_t;
79 /* Forward declarations */
80 static gboolean __bt_hal_event_manager(gpointer param);
81 static int __bt_hal_register_service_event(GDBusConnection *g_conn, int event_type);
82 static int __bt_hal_register_manager_subscribe_signal(GDBusConnection *conn, int subscribe);
83 static int __bt_hal_register_device_subscribe_signal(GDBusConnection *conn, int subscribe);
84 static int __bt_hal_register_input_subscribe_signal(GDBusConnection *conn, int subscribe);
86 static int __bt_hal_parse_event(GVariant *msg);
87 static int __bt_hal_get_owner_info(GVariant *msg, char **name, char **previous, char **current);
89 static void __bt_hal_handle_property_changed_event(GVariant *msg, const char *object_path);
90 static void __bt_hal_adapter_property_changed_event(GVariant *msg);
91 static void __bt_hal_manager_event_filter(GDBusConnection *connection, const gchar *sender_name,
92 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
93 GVariant *parameters, gpointer user_data);
94 static int __bt_hal_initialize_manager_receiver(void);
95 static gboolean __bt_hal_parse_interface(GVariant *msg);
96 static void __bt_hal_handle_device_event(GVariant *value, GVariant *parameters);
97 static gboolean __bt_hal_parse_device_properties(GVariant *item);
98 static gboolean __bt_hal_discovery_finished_cb(gpointer user_data);
99 static void __bt_hal_device_property_changed_event(GVariant *msg, const char *path);
100 static void __bt_hal_dbus_device_found_properties(const char *device_path);
101 static void __bt_hal_device_properties_lookup(GVariant *result, char *address);
102 static void __bt_hal_handle_device_specific_events(GVariant *msg, const char *member, const char *path);
103 static void __bt_hal_send_device_acl_connection_state_event(int status, gboolean connected, const char *address);
104 static void __bt_hal_handle_input_event(GVariant *msg, const char *path);
105 static void __bt_hal_send_av_connection_state_event(gboolean connected, const char *address);
106 static void __bt_hal_send_a2dp_sink_connection_state_event(gboolean connected, const char *address);
107 static void __bt_hal_send_avrcp_ctrl_connection_state_event(gboolean connected, const char *address);
108 static void __bt_hal_handle_avrcp_ctrl_events(GVariant *msg, const char *member, const char *path);
109 static void __bt_hal_handle_avrcp_transport_events(GVariant *msg, const char *member, const char *path);
111 static void __bt_hal_send_device_trust_state_event(gboolean is_trusted, const char *address);
112 static int __bt_hal_register_audio_subscribe_signal(GDBusConnection *conn, int subscribe);
113 static void __bt_hal_handle_headset_events(GVariant *msg, const char *member, const char *path);
114 static void __bt_hal_send_hf_audio_connection_state_event(gboolean connected, const char *address);
115 static void __bt_hal_send_hf_connection_state_event(gboolean connected, const char *address);
116 static void __bt_hal_send_device_trusted_profile_changed_event(uint32_t trust_val, const char *address);
117 static void __bt_hal_handle_adv_report(GVariant *msg, const char *path);
118 static void __bt_hal_handle_gatts_mtu_changed_event(char *address, int mtu);
119 static void __bt_hal_send_hf_client_connection_state_event(gboolean connected, const char *address);
122 static gboolean __bt_hal_discovery_finished_cb(gpointer user_data)
126 struct hal_ev_discovery_state_changed ev;
127 ev.state = HAL_DISCOVERY_STATE_STOPPED;
128 event_cb(HAL_EV_DISCOVERY_STATE_CHANGED, &ev, sizeof(ev));
133 static int __bt_hal_parse_event(GVariant *msg)
137 char *interface_name = NULL;
138 GVariant *inner_iter = NULL;
140 g_variant_iter_init(&iter, msg);
142 while ((child = g_variant_iter_next_value(&iter))) {
143 g_variant_get(child, "{&s@a{sv}}", &interface_name, &inner_iter);
144 if (g_strcmp0(interface_name,
145 BT_HAL_DEVICE_INTERFACE) == 0) {
146 DBG("__bt_hal_parse_event: Interface: BT_HAL_DEVICE_INTERFACE");
147 g_variant_unref(inner_iter);
148 g_variant_unref(child);
149 return BT_HAL_DEVICE_EVENT;
150 } else if (g_strcmp0(interface_name,
151 BT_HAL_MEDIATRANSPORT_INTERFACE) == 0) {
152 DBG("__bt_hal_parse_event: Interface: BT_HAL_MEDIATRANSPORT_INTERFACE");
153 g_variant_unref(inner_iter);
154 g_variant_unref(child);
155 return BT_HAL_MEDIA_TRANSFER_EVENT;
156 } else if (g_strcmp0(interface_name,
157 BT_HAL_PLAYER_CONTROL_INTERFACE) == 0) {
158 DBG("__bt_hal_parse_event: Interface: BT_HAL_PLAYER_CONTROL_INTERFACE");
159 g_variant_unref(inner_iter);
160 g_variant_unref(child);
161 return BT_HAL_AVRCP_CONTROL_EVENT;
163 g_variant_unref(inner_iter);
164 g_variant_unref(child);
170 static int __bt_hal_get_owner_info(GVariant *msg, char **name, char **previous, char **current)
172 g_variant_get(msg, "(&s&s&s)", name, previous, current);
173 return BT_HAL_ERROR_NONE;
176 int __bt_insert_hal_properties(void *buf, uint8_t type, uint16_t len, const void *val)
177 { struct hal_property *prop = buf;
183 memcpy(prop->val, val, len);
185 return sizeof(*prop) + len;
188 handle_stack_msg _bt_hal_get_stack_message_handler(void)
193 static void __bt_hal_adapter_property_changed_event(GVariant *msg)
195 GVariantIter value_iter;
196 GVariant *value = NULL;
197 GDBusProxy *adapter_proxy;
200 g_variant_iter_init(&value_iter, msg);
202 /* Buffer and propety count management */
203 uint8_t buf[BT_HAL_MAX_PROPERTY_BUF_SIZE];
204 struct hal_ev_adapter_props_changed *ev = (void*) buf;
206 const gchar *address = NULL;
208 unsigned int cod = 0;
209 unsigned int a2dp_role = 0;
210 gboolean discoverable;
211 gboolean connectable;
212 unsigned int scan_mode = BT_SCAN_MODE_NONE;
213 unsigned int disc_timeout;
214 const gchar *version;
215 gboolean ipsp_initialized;
218 unsigned int pairable_timeout;
219 gboolean scan_mode_property_update = FALSE;
220 gboolean is_discovering;
221 gboolean is_le_discovering;
223 memset(buf, 0, sizeof(buf));
226 ev->status = BT_STATUS_SUCCESS;
228 while (g_variant_iter_loop(&value_iter, "{sv}", &key, &value)) {
229 if (!g_strcmp0(key, "Address")) {
232 address = g_variant_get_string(value, NULL);
233 DBG("##Address [%s]", address);
234 _bt_hal_convert_addr_string_to_type(bdaddr, address);
235 size += __bt_insert_hal_properties(buf + size,
236 HAL_PROP_ADAPTER_ADDR, sizeof(bdaddr), bdaddr);
238 } else if (!g_strcmp0(key, "Alias")) {
239 g_variant_get(value, "&s", &name);
240 DBG("##Alias [%s] ", name);
241 size += __bt_insert_hal_properties(buf + size,
242 HAL_PROP_ADAPTER_NAME, strlen(name) + 1, name);
244 } else if (!g_strcmp0(key, "Class")) {
245 cod = g_variant_get_uint32(value);
246 DBG("##Class [%d]", cod);
247 size += __bt_insert_hal_properties(buf + size,
248 HAL_PROP_ADAPTER_CLASS, sizeof(unsigned int), &cod);
250 } else if (!g_strcmp0(key, "Discoverable")) {
251 discoverable = g_variant_get_boolean(value);
252 DBG("##Discoverable [%d]", discoverable);
254 scan_mode = BT_SCAN_MODE_CONNECTABLE_DISCOVERABLE;
256 scan_mode = BT_SCAN_MODE_CONNECTABLE;
257 scan_mode_property_update = TRUE;
258 } else if (!g_strcmp0(key, "DiscoverableTimeout")) {
259 disc_timeout = g_variant_get_uint32(value);
260 DBG("##Discoverable Timeout [%d]", disc_timeout);
261 size += __bt_insert_hal_properties(buf + size,
262 HAL_PROP_ADAPTER_DISC_TIMEOUT, sizeof(unsigned int), &disc_timeout);
264 } else if (!g_strcmp0(key, "Connectable")) {
265 connectable = g_variant_get_boolean(value);
266 DBG("##Connectable [%d]", connectable);
268 scan_mode = BT_SCAN_MODE_NONE;
269 else if (scan_mode == BT_SCAN_MODE_NONE)
270 scan_mode = BT_SCAN_MODE_CONNECTABLE;
271 scan_mode_property_update = TRUE;
272 } else if (!g_strcmp0(key, "Version")) {
273 version = g_variant_get_string(value, NULL);
274 DBG("##Version [%s]", version);
275 size += __bt_insert_hal_properties(buf + size,
276 HAL_PROP_ADAPTER_VERSION, strlen(version) + 1, version);
278 } else if (!g_strcmp0(key, "Name")) {
279 g_variant_get(value, "&s", &name);
280 DBG("##Name [%s]", name);
281 size += __bt_insert_hal_properties(buf + size,
282 HAL_PROP_ADAPTER_NAME, strlen(name) + 1, name);
284 } else if (!g_strcmp0(key, "Powered")) {
285 powered = g_variant_get_boolean(value);
286 DBG("##Powered = %d", powered);
287 /* TODO: Need to check this operation!! */
288 if (powered == FALSE) {
289 DBG("###### Adapter Powered Down ######");
291 if (TIZEN_FEATURE_BT_USB_DONGLE) {
292 struct hal_ev_adapter_state_changed ev;
293 ev.state = HAL_POWER_OFF;
294 event_cb(HAL_EV_ADAPTER_STATE_CHANGED, &ev, sizeof(ev));
296 struct hal_ev_le_state_changed le_ev;
297 le_ev.state = HAL_POWER_OFF;
298 event_cb(HAL_EV_LE_STATE_CHANGED, &le_ev, sizeof(le_ev));
301 _bt_hal_destroy_adapter_agent();
303 DBG("Pending disalbed event after bluetoothd is terminated");
306 DBG("###### Adapter Powered Up ######");
307 if (_bt_hal_get_adapter_request_state()) {
308 DBG("Sending STATE CHANGE EVENT for Adapter... ");
309 _bt_hal_set_adapter_request_state(FALSE);
310 struct hal_ev_adapter_state_changed ev;
311 ev.state = HAL_POWER_ON;
312 event_cb(HAL_EV_ADAPTER_STATE_CHANGED, &ev, sizeof(ev));
315 if (_bt_hal_get_le_request_state()) {
316 DBG("Sending STATE CHANGE EVENT for LE... ");
317 _bt_hal_set_le_request_state(FALSE);
318 struct hal_ev_le_state_changed ev;
319 ev.state = HAL_POWER_ON;
320 event_cb(HAL_EV_LE_STATE_CHANGED, &ev, sizeof(ev));
324 _bt_hal_initialize_adapter_agent();
327 } else if (!g_strcmp0(key, "Pairable")) {
328 pairable = g_variant_get_boolean(value);
329 DBG("##Pairable [%d]", pairable);
330 } else if (!g_strcmp0(key, "PairableTimeout")) {
331 pairable_timeout = g_variant_get_uint32(value);
332 DBG("##Pairable Timeout = %d", pairable_timeout);
333 } else if (!g_strcmp0(key, "UUIDs")) {
338 size1 = g_variant_get_size(value);
339 int num_props_tmp = ev->num_props;
341 uuid_value = (char **)g_variant_get_strv(value, &size1);
342 for (i = 0; uuid_value[i] != NULL; i++)
344 /* UUID collection */
345 uint8_t uuids[BT_HAL_STACK_UUID_SIZE * uuid_count];
346 for (i = 0; uuid_value[i] != NULL; i++) {
347 char *uuid_str = NULL;
348 uint8_t uuid[BT_HAL_STACK_UUID_SIZE];
349 uuid_str = g_strdup(uuid_value[i]);
350 DBG("##UUID string [%s]\n", uuid_str);
351 _bt_hal_convert_uuid_string_to_type(uuid, uuid_str);
352 memcpy(uuids+i*BT_HAL_STACK_UUID_SIZE, uuid, BT_HAL_STACK_UUID_SIZE);
355 size += __bt_insert_hal_properties(buf + size, HAL_PROP_ADAPTER_UUIDS,
356 (BT_HAL_STACK_UUID_SIZE * uuid_count),
358 ev->num_props = num_props_tmp + 1;
361 } else if (!g_strcmp0(key, "Discovering")) {
362 is_discovering = g_variant_get_boolean(value);
363 DBG("##Discovering = [%d]", is_discovering);
365 if (is_discovering == FALSE) {
366 /* In Tizen Bluez, this actually does not mean Discovery is stopped
367 in Bluez. Tizen Bluez sends this event after a certain timeout,
368 Therefore, we must forecefully call StopDiscovery to stop discovery in BlueZ */
372 adapter_proxy = _bt_hal_get_adapter_proxy();
374 if (adapter_proxy == NULL)
377 /* Need to stop searching */
378 DBG("Event though Bluez reported DIscovering stopped, we force stop Discovery ");
379 g_dbus_proxy_call_sync(adapter_proxy, "StopDiscovery",
381 G_DBUS_CALL_FLAGS_NONE,
385 ERR("Dbus Error : %s", err->message);
387 /* This error is thrown by Bluez, as Discovery is already stopped.
388 Discovery is stopped if user cancels on going discovery.
389 In order to maintain correct state of Bluetooth Discovery state,
390 simply send Discovery stopped event to HAL user */
391 struct hal_ev_discovery_state_changed ev;
392 ev.state = HAL_DISCOVERY_STATE_STOPPED;
393 event_cb(HAL_EV_DISCOVERY_STATE_CHANGED, &ev, sizeof(ev));
398 event_id = g_timeout_add(BT_HAL_DISCOVERY_FINISHED_DELAY,
399 (GSourceFunc)__bt_hal_discovery_finished_cb, NULL);
403 struct hal_ev_discovery_state_changed ev;
404 ev.state = HAL_DISCOVERY_STATE_STARTED;
405 event_cb(HAL_EV_DISCOVERY_STATE_CHANGED, &ev, sizeof(ev));
408 } else if (!g_strcmp0(key, "LEDiscovering")) {
411 is_le_discovering = g_variant_get_boolean(value);
412 DBG("##LE Discovering = [%d]", is_le_discovering);
414 if (is_le_discovering) {
415 /* Send LE discovering started event */
416 size += __bt_insert_hal_properties(buf + size,
417 HAL_PROP_ADAPTER_LE_DISCOVERY_STARTED, 0, NULL);
422 adapter_proxy = _bt_hal_get_adapter_proxy();
423 if (adapter_proxy == NULL) {
424 ERR("adapter_proxy == NULL");
428 /* Need to stop searching */
429 result = g_dbus_proxy_call_sync(adapter_proxy, "StopLEDiscovery",
430 NULL, G_DBUS_CALL_FLAGS_NONE,
431 DBUS_TIMEOUT, NULL, &err);
433 ERR("Error occured in Proxy call");
435 ERR("(Error: %s)", err->message);
439 g_variant_unref(result);
442 /* Send LE discovering finished event */
443 size += __bt_insert_hal_properties(buf + size,
444 HAL_PROP_ADAPTER_LE_DISCOVERY_STOPPED, 0, NULL);
446 } else if (!g_strcmp0(key, "Modalias")) {
447 char *modalias = NULL;
448 g_variant_get(value, "&s", &modalias);
449 DBG("##Adapter ModAlias [%s]", modalias);
450 } else if (!g_strcmp0(key, "SupportedLEFeatures")) {
451 DBG("##LE Supported features");
454 GVariantIter *iter = NULL;
455 g_variant_get(value, "as", &iter);
456 bt_local_le_features_t le_features;
457 gboolean le_features_present = FALSE;
462 memset(&le_features, 0x00, sizeof(le_features));
464 while (g_variant_iter_next(iter, "&s", &name) &&
465 g_variant_iter_next(iter, "&s", &val)) {
466 DBG("name = %s, Value = %s", name, val);
467 if (FALSE == _bt_hal_update_le_feature_support(name, val, &le_features))
468 ERR("Failed to update LE feature (name = %s, value = %s)", name, val);
470 le_features_present = TRUE;
473 g_variant_iter_free(iter);
474 if (le_features_present) {
475 size += __bt_insert_hal_properties(buf + size,
476 HAL_PROP_ADAPTER_LOCAL_LE_FEAT, sizeof(le_features), &le_features);
479 DBG("le supported features values are NOT provided by Stack");
481 } else if (!g_strcmp0(key, "IpspInitStateChanged")) {
482 g_variant_get(value, "b" , &ipsp_initialized);
483 DBG("##IPSP Initialized = %d", ipsp_initialized);
484 } else if (!g_strcmp0(key, "A2dpRole")) {
485 a2dp_role = g_variant_get_uint32(value);
486 DBG("##A2dp Role [%d]", a2dp_role);
487 size += __bt_insert_hal_properties(buf + size,
488 HAL_PROP_ADAPTER_A2DP_ROLE, sizeof(unsigned int), &a2dp_role);
491 ERR("Unhandled Property:[%s]", key);
495 if (scan_mode_property_update) {
496 size += __bt_insert_hal_properties(buf + size,
497 HAL_PROP_ADAPTER_SCAN_MODE, sizeof(int), &scan_mode);
503 DBG("Send Adapter properties changed event to HAL user, Num Prop [%d] total size [%zd]", ev->num_props, size);
504 event_cb(HAL_EV_ADAPTER_PROPS_CHANGED, buf, size);
508 void _bt_hal_handle_adapter_event(GVariant *msg, const char *member)
513 if (strcasecmp(member, "DeviceCreated") == 0) {
514 DBG("DeviceCreated: Unhandled");
515 } else if (strcasecmp(member, "AdvertisingEnabled") == 0) {
517 gboolean status = FALSE;
518 g_variant_get(msg, "(ib)", &slot_id, &status);
520 /* Send event to application */
521 _bt_hal_set_advertising_status(slot_id, status);
522 } else if (strcasecmp(member, "RssiEnabled") == 0) {
523 struct hal_ev_rssi_monitor_state_changed ev;
524 gboolean status = FALSE;
525 char *address = NULL;
528 g_variant_get(msg, "(sib)", &address, &link_type, &status);
529 DBG("RSSI monitoring %s for %s",
530 (status ? "Enabled" : "Disabled"), address);
532 _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
533 ev.link_type = link_type;
534 ev.state = (status ? HAL_RSSI_MONITORING_ENABLED : HAL_RSSI_MONITORING_DISABLED);
536 ERR("event_cb is NULL");
538 event_cb(HAL_EV_RSSI_MONITOR_STATE_CHANGED, &ev, sizeof(ev));
541 } else if (strcasecmp(member, "RssiAlert") == 0) {
542 struct hal_ev_rssi_alert_recieved ev;
546 char *address = NULL;
548 g_variant_get(msg, "(siii)", &address, &link_type, &alert_type, &rssi_dbm);
549 DBG("RSSI Alert: [Address %s LinkType %d] [Type %d DBM %d]",
550 address, alert_type, rssi_dbm, link_type);
552 _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
553 ev.link_type = link_type;
554 ev.alert_type = alert_type;
558 ERR("event_cb is NULL");
560 event_cb(HAL_EV_RSSI_ALERT_RECIEVED, &ev, sizeof(ev));
563 } else if (strcasecmp(member, "RawRssi") == 0) {
564 struct hal_ev_raw_rssi_recieved ev;
567 char *address = NULL;
569 g_variant_get(msg, "(sii)", &address, &link_type, &rssi_dbm);
570 DBG("Raw RSSI: [Address %s] [Link Type %d][RSSI DBM %d]",
571 address, link_type, rssi_dbm);
573 _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
574 ev.link_type = link_type;
578 ERR("event_cb is NULL");
580 event_cb(HAL_EV_RAW_RSSI_RECIEVED, &ev, sizeof(ev));
583 } else if (strcasecmp(member, BT_HAL_HARDWARE_ERROR) == 0) {
584 DBG("BT Hardware Error: Unhandled");
585 } else if (strcasecmp(member, BT_HAL_TX_TIMEOUT_ERROR) == 0) {
586 DBG("BT TX Timeout Error: Unhandled");
587 } else if (strcasecmp(member, BT_HAL_DBFW_PLUS_INFO) == 0) {
589 DBG("### DBFW+ info received from BLUEZ");
590 struct hal_ev_dbfw_plus_info_recieved info;
593 unsigned char *buffer = NULL;
594 GVariant *value = NULL;
596 g_variant_get(msg, "(y@ay)", &event_code, &value);
598 ERR("g_variant_get fails");
600 length = g_variant_get_size(value);
602 ERR("Invalid g_variant len = %d", length);
604 info.event_code = event_code;
605 buffer = (unsigned char*)g_variant_get_data(value);
606 info.data = g_memdup(buffer, length);
607 info.data_len = length;
609 ERR("event_cb is NULL");
611 event_cb(HAL_EV_DBFW_PLUS_INFO_RECIEVED, &info, sizeof(info));
619 static gboolean __bt_hal_parse_device_properties(GVariant *item)
625 gboolean is_bredr_dev = FALSE;
630 /* Buffer and propety count management */
631 uint8_t buf[BT_HAL_MAX_PROPERTY_BUF_SIZE];
632 struct hal_ev_device_found *ev = (void *) buf;
634 memset(buf, 0, sizeof(buf));
638 g_variant_iter_init(&iter, item);
639 while (g_variant_iter_loop(&iter, "{sv}", &key, &val)) {
641 if (strcasecmp(key, "Address") == 0) {
642 char * address = NULL;
643 address = g_variant_dup_string(val, &len);
645 _bt_hal_convert_addr_string_to_type(bdaddr, address);
647 size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_ADDR,
648 sizeof(bdaddr), bdaddr);
651 DBG("Device address [%s] property Num [%d]", address, ev->num_props);
653 } else if (strcasecmp(key, "AddressType") == 0) {
654 char *addresstype = g_variant_dup_string(val, &len);
656 DBG("AddressType [%s]", addresstype);
658 } else if (strcasecmp(key, "Class") == 0) {
659 unsigned int class = g_variant_get_uint32(val);
660 size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_CLASS,
661 sizeof(unsigned int), &class);
663 DBG("Device class [%d] Property num [%d]", class, ev->num_props);
665 } else if (strcasecmp(key, "name") == 0) {
666 char *name = g_variant_dup_string(val, &len);
668 size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_NAME,
669 strlen(name) + 1, name);
671 DBG("Device Name [%s] Property num [%d]", name, ev->num_props);
674 } else if (strcasecmp(key, "Connected") == 0) {
675 unsigned int connected = g_variant_get_byte(val);
677 size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_CONNECTED,
678 sizeof(unsigned int), &connected);
680 DBG("Device connected [%u] Property num [%d]", connected, ev->num_props);
681 } else if (strcasecmp(key, "paired") == 0) {
682 uint8_t paired = (g_variant_get_boolean(val) ? 1 : 0);
683 size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_PAIRED,
684 sizeof(uint8_t), &paired);
686 DBG("Device Paired [%d] Property num [%d]", paired, ev->num_props);
687 } else if (strcasecmp(key, "Trusted") == 0) {
688 uint8_t trust = (g_variant_get_boolean(val) ? 1 : 0);
689 size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_TRUSTED,
690 sizeof(uint8_t), &trust);
692 DBG("Device trusted [%d] Property num [%d]", trust, ev->num_props);
693 } else if (strcasecmp(key, "RSSI") == 0) {
694 int rssi = g_variant_get_int16(val);
695 size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_RSSI,
698 DBG("Device RSSI [%d] Property num [%d]", rssi, ev->num_props);
699 } else if (strcasecmp(key, "LastAddrType") == 0) {
700 /* TODO: To be handled later*/
701 } else if (!g_strcmp0(key, "IsAliasSet")) {
702 uint8_t is_alias_set = (g_variant_get_boolean(val) ? 1 : 0);
703 DBG("IsAliasSet: %s", (is_alias_set ? "TRUE" : "FALSE"));
704 size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_IS_ALIAS_SET,
705 sizeof(uint8_t), &is_alias_set);
707 } else if (strcasecmp(key, "UUIDs") == 0) {
712 size1 = g_variant_get_size(val);
713 DBG("UUID count from size [%zu]\n", size1);
714 int num_props_tmp = ev->num_props;
717 uuid_value = (char **)g_variant_get_strv(val, &size1);
718 for (i = 0; uuid_value[i] != NULL; i++)
720 DBG("UUID count [%d]\n", uuid_count);
721 /* UUID collection */
722 uint8_t uuids[BT_HAL_STACK_UUID_SIZE * uuid_count];
724 for (i = 0; uuid_value[i] != NULL; i++) {
726 char *uuid_str = NULL;
727 uint8_t uuid[BT_HAL_STACK_UUID_SIZE];
728 memset(uuid, 0x00, BT_HAL_STACK_UUID_SIZE);
730 DBG("UUID string from Bluez [%s]\n", uuid_value[i]);
731 uuid_str = g_strdup(uuid_value[i]);
732 DBG("UUID string [%s]\n", uuid_str);
733 _bt_hal_convert_uuid_string_to_type(uuid, uuid_str);
734 memcpy(uuids+i*BT_HAL_STACK_UUID_SIZE, uuid, BT_HAL_STACK_UUID_SIZE);
738 size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_UUIDS,
739 (BT_HAL_STACK_UUID_SIZE * uuid_count),
741 ev->num_props = num_props_tmp + 1;
745 } else if (strcasecmp(key, "LegacyManufacturerDataLen") == 0) {
746 /* TODO: To be handled later*/
747 } else if (strcasecmp(key, "LegacyManufacturerData") == 0) {
748 /* TODO: To be handled later*/
750 DBG("Unhandled Property:[%s]", key);
754 if (size > 1 && is_bredr_dev) {
755 DBG("Send Device found event to HAL user, Num Prop [%d] total size [%zd]", ev->num_props, size);
756 event_cb(HAL_EV_DEVICE_FOUND, (void*) buf, size);
762 static void __bt_hal_handle_avrcp_tg_events(GVariant *msg, const char *path)
765 GVariantIter value_iter;
766 char *property = NULL;
768 GVariant *val = NULL;
769 GVariant *child = NULL;
771 g_variant_iter_init(&value_iter, msg);
772 while ((child = g_variant_iter_next_value(&value_iter))) {
773 g_variant_get(child, "{sv}", &property, &val);
774 INFO("Property %s", property);
775 if (strcasecmp(property, "Connected") == 0) {
776 struct hal_ev_avrcp_tg_conn_state ev;
778 gboolean connected = FALSE;
780 g_variant_get(val, "b", &connected);
782 state = connected ? HAL_AVRCP_TG_STATE_CONNECTED :
783 HAL_AVRCP_TG_STATE_DISCONNECTED;
785 address = g_malloc0(BT_HAL_ADDRESS_STRING_SIZE);
787 _bt_hal_convert_device_path_to_address(path, address);
789 DBG("connected: %d", connected);
790 DBG("address: %s", address);
792 /* Prepare to send AVRCP Target connection state event */
793 memset(&ev, 0, sizeof(ev));
794 _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
796 if (!avrcp_tg_event_cb)
797 ERR("AVRCP target DBUS handler callback not registered");
799 avrcp_tg_event_cb(HAL_EV_AVRCP_TG_CONN_STATE, (void *)&ev, sizeof(ev));
803 g_variant_unref(child);
804 g_variant_unref(val);
810 static void __bt_hal_handle_property_changed_event(GVariant *msg, const char *object_path)
812 char *interface_name = NULL;
813 GVariant *val = NULL;
815 g_variant_get(msg, "(&s@a{sv}@as)", &interface_name, &val, NULL);
817 if (!interface_name) {
818 DBG("Failed to get interface name");
821 g_variant_unref(val);
825 if (strcasecmp(interface_name, BT_HAL_ADAPTER_INTERFACE) == 0) {
826 DBG("Event: Property Changed: Interface: BT_HAL_ADAPTER_INTERFACE");
827 __bt_hal_adapter_property_changed_event(val);
828 } else if (strcasecmp(interface_name, BT_HAL_DEVICE_INTERFACE) == 0) {
829 DBG("Event: Property Changed: Interface: BT_HAL_DEVICE_INTERFACE");
830 __bt_hal_device_property_changed_event(val, object_path);
831 } else if (strcasecmp(interface_name, BT_HAL_OBEX_TRANSFER_INTERFACE) == 0) {
832 DBG("Event: Property Changed: Interface: BT_HAL_OBEX_TRANSFER_INTERFACE");
833 /* TODO: Handle event */
834 } else if (strcasecmp(interface_name, BT_HAL_MEDIA_CONTROL_INTERFACE) == 0) {
835 DBG("Event: Property Changed: Interface: BT_HAL_MEDIA_CONTROL_INTERFACE");
836 /* Handle AVRCP target event */
837 __bt_hal_handle_avrcp_tg_events(val, object_path);
838 } else if (strcasecmp(interface_name, BT_HAL_PLAYER_CONTROL_INTERFACE) == 0) {
839 DBG("Event: Property Changed: Interface: BT_HAL_PLAYER_CONTROL_INTERFACE");
840 __bt_hal_handle_avrcp_ctrl_events(val, NULL, object_path);
841 } else if (strcasecmp(interface_name, BT_HAL_MEDIATRANSPORT_INTERFACE) == 0) {
842 DBG("Event: Property Changed: Interface: BT_HAL_MEDIATRANSPORT_INTERFACE");
843 __bt_hal_handle_avrcp_transport_events(val, NULL, object_path);
844 } else if (strcasecmp(interface_name, BT_HAL_NETWORK_CLIENT_INTERFACE) == 0) {
845 DBG("Event: Property Changed: Interface: BT_HAL_NETWORK_CLIENT_INTERFACE");
846 /* TODO: Handle event */
847 } else if (strcasecmp(interface_name, BT_HAL_GATT_CHAR_INTERFACE) == 0) {
848 DBG("Event: Property Changed: Interface: BT_HAL_GATT_CHAR_INTERFACE");
849 /* TODO: Handle event */
850 } else if (strcasecmp(interface_name, BT_HAL_INPUT_INTERFACE) == 0) {
851 DBG("Event: Property Changed: Interface: BT_HAL_INPUT_INTERFACE");
852 __bt_hal_handle_input_event(val, object_path);
854 g_variant_unref(val);
857 static void __bt_hal_handle_device_event(GVariant *value, GVariant *parameters)
861 if (__bt_hal_parse_interface(parameters) == FALSE) {
862 ERR("Fail to parse the properies");
863 g_variant_unref(value);
868 static void __bt_hal_send_hid_connection_state_event(
869 gboolean connected, const char *address)
871 struct hal_ev_hidhost_conn_state ev;
873 ev.state = (connected == TRUE) ?
874 HAL_HIDHOST_STATE_CONNECTED :
875 HAL_HIDHOST_STATE_DISCONNECTED;
877 _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
880 ERR("HID event handler not registered");
882 hid_event_cb(HAL_EV_HIDHOST_CONN_STATE, &ev, sizeof(ev));
885 static void __bt_hal_send_hid_device_connection_state_event(
886 gboolean connected, const char *address)
888 struct hal_ev_hiddevice_conn_state ev;
890 ev.state = (connected == TRUE) ?
891 HAL_HIDDEVICE_STATE_CONNECTED :
892 HAL_HIDDEVICE_STATE_DISCONNECTED;
894 _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
896 if (!hid_device_event_cb)
897 ERR("HID device event handler not registered");
899 hid_device_event_cb(HAL_EV_HIDDEVICE_CONN_STATE, &ev, sizeof(ev));
902 static void __bt_hal_handle_input_event(GVariant *msg, const char *path)
904 gboolean property_flag = FALSE;
905 GVariantIter value_iter;
906 char *property = NULL;
907 GVariant *child = NULL, *val = NULL;
910 g_variant_iter_init(&value_iter, msg);
911 while ((child = g_variant_iter_next_value(&value_iter))) {
912 g_variant_get(child, "{sv}", &property, &val);
914 if (property == NULL)
917 if (strcasecmp(property, "Connected") == 0) {
920 g_variant_get(val, "b", &property_flag);
921 address = g_malloc0(BT_HAL_ADDRESS_STRING_SIZE);
922 _bt_hal_convert_device_path_to_address(path, address);
923 __bt_hal_send_hid_connection_state_event(property_flag, address);
927 g_variant_unref(val);
928 g_variant_unref(child);
932 static gboolean __bt_hal_parse_interface(GVariant *msg)
935 GVariant *optional_param;
938 char *interface_name = NULL;
939 GVariant *inner_iter = NULL;
940 g_variant_get(msg, "(&o@a{sa{sv}})",
941 &path, &optional_param);
942 g_variant_iter_init(&iter, optional_param);
944 while ((child = g_variant_iter_next_value(&iter))) {
945 g_variant_get(child, "{&s@a{sv}}", &interface_name, &inner_iter);
946 if (g_strcmp0(interface_name, BT_HAL_DEVICE_INTERFACE) == 0) {
947 DBG("Found a device: %s", path);
948 if (__bt_hal_parse_device_properties(inner_iter) == FALSE) {
949 g_variant_unref(inner_iter);
950 g_variant_unref(child);
951 g_variant_unref(optional_param);
952 ERR("Fail to parse the properies");
955 g_variant_unref(inner_iter);
956 g_variant_unref(child);
957 g_variant_unref(optional_param);
961 g_variant_unref(inner_iter);
962 g_variant_unref(child);
965 g_variant_unref(optional_param);
970 void __bt_hal_handle_gatt_char_event(GVariant *parameters, const char *signal_name)
974 if (signal_name == NULL)
977 if (strcasecmp(signal_name, "GattValueChanged") == 0) {
978 DBG("GattValueChanged event received");
981 const char *char_handle = NULL;
982 GVariant *char_value_var = NULL;
984 char *char_value = NULL;
986 g_variant_get(parameters, "(i&s@ay)", &result, &char_handle, &char_value_var);
987 DBG("char handle: %s", char_handle);
989 len = g_variant_get_size(char_value_var);
991 char_value = (char *)g_variant_get_data(char_value_var);
993 _bt_hal_handle_gattc_value_changed_event(result, char_handle, char_value, len);
995 g_variant_unref(char_value_var);
999 static void __bt_hal_handle_gatt_service_event(GVariant *parameters, const char *signal_name)
1001 if (signal_name == NULL)
1004 if (strcasecmp(signal_name, "GattServiceAdded") == 0) {
1006 g_variant_get(parameters, "(&s)", &path);
1007 _bt_hal_handle_gattc_service_changed_event(TRUE, path);
1011 static gboolean __bt_hal_event_manager(gpointer data)
1013 bt_hal_event_type_t bt_event = 0x00;
1015 char *obj_path = NULL;
1017 bt_hal_main_event_data_t *param = (bt_hal_main_event_data_t*)data;
1018 if (strcasecmp(param->signal_name, "InterfacesAdded") == 0) {
1020 /*TODO: Handle Interfaces Added Signal from stack */
1022 g_variant_get(param->parameters, "(&o@a{sa{sv}})", &obj_path, &value);
1024 if (obj_path == NULL) {
1025 ERR("obj_path is NULL");
1029 if (strcasecmp(obj_path, BT_HAL_BLUEZ_HCI_PATH) == 0) {
1030 /* TODO: Handle adapter added */
1031 DBG("Manager Event: Signal Name: InterfiacesAdded: Adapter added in bluetoothd: path [hci0]");
1033 bt_event = __bt_hal_parse_event(value);
1034 if (bt_event == BT_HAL_DEVICE_EVENT) {
1035 DBG("InterfacesAdded %s ", obj_path);
1036 __bt_hal_handle_device_event(value, param->parameters);
1037 } else if (bt_event == BT_HAL_AVRCP_CONTROL_EVENT) {
1038 DBG("InterfacesAdded %s ", obj_path);
1039 _bt_hal_set_control_device_path(obj_path);
1042 g_variant_unref(value);
1044 } else if (strcasecmp(param->signal_name, "InterfacesRemoved") == 0) {
1048 /*TODO: Handle Interfaces Removed Signal from stack */
1050 g_variant_get(param->parameters, "(&oas)", &obj_path, &iter);
1051 DBG("InterfacesRemoved %s ", obj_path);
1052 while (g_variant_iter_loop(iter, "s", &str)) {
1053 if (g_strcmp0(str, BT_HAL_PLAYER_CONTROL_INTERFACE) == 0)
1054 _bt_hal_remove_control_device_path(obj_path);
1055 else if (g_strcmp0(str, BT_HAL_GATT_SERVICE_INTERFACE) == 0)
1056 _bt_hal_handle_gattc_service_changed_event(FALSE, obj_path);
1058 g_variant_iter_free(iter);
1059 } else if (strcasecmp(param->signal_name, "NameOwnerChanged") == 0) {
1061 char *previous = NULL;
1062 char *current = NULL;
1064 if (g_strcmp0(g_variant_get_type_string(param->parameters), "(sss)") != 0) {
1065 ERR("Invalid variant format");
1069 /* TODO: Handle Name Owener changed Signal */
1070 if (__bt_hal_get_owner_info(param->parameters, &name, &previous, ¤t)) {
1071 ERR("Fail to get the owner info");
1075 if (*current != '\0')
1081 if (strcasecmp(name, BT_HAL_BLUEZ_NAME) == 0) {
1082 struct hal_ev_adapter_state_changed ev;
1083 struct hal_ev_le_state_changed le_ev;
1085 INFO("Bluetoothd is terminated");
1087 /* Send the disable event in here */
1089 ev.state = HAL_POWER_OFF;
1090 le_ev.state = HAL_POWER_OFF;
1092 event_cb(HAL_EV_ADAPTER_STATE_CHANGED, &ev, sizeof(ev));
1093 event_cb(HAL_EV_LE_STATE_CHANGED, &le_ev, sizeof(le_ev));
1096 _bt_hal_destroy_adapter_agent();
1097 _bt_hal_le_deinit();
1099 } else if (g_strcmp0(param->interface_name, BT_HAL_PROPERTIES_INTERFACE) == 0) {
1100 __bt_hal_handle_property_changed_event(param->parameters, param->object_path);
1101 } else if (g_strcmp0(param->interface_name, BT_HAL_ADAPTER_INTERFACE) == 0) {
1102 DBG("Manager Event: Interface Name: BT_HAL_ADAPTER_INTERFACE");
1103 _bt_hal_handle_adapter_event(param->parameters, param->signal_name);
1104 } else if (g_strcmp0(param->interface_name, BT_HAL_INPUT_INTERFACE) == 0) {
1105 DBG("Manager Event: Interface Name: BT_HAL_INPUT_INTERFACE");
1106 __bt_hal_handle_input_event(param->parameters, param->object_path);
1107 } else if (g_strcmp0(param->interface_name, BT_HAL_NETWORK_SERVER_INTERFACE) == 0) {
1108 /* TODO: Handle Network Server events from stack */
1109 DBG("Manager Event: Interface Name: BT_HAL_NETWORK_SERVER_INTERFACE");
1110 } else if (g_strcmp0(param->interface_name, BT_HAL_HEADSET_INTERFACE) == 0) {
1111 DBG("Manager Event: Interface Name: BT_HAL_HEADSET_INTERFACE");
1112 __bt_hal_handle_headset_events(param->parameters, param->signal_name, param->object_path);
1113 } else if (g_strcmp0(param->interface_name, BT_HAL_SINK_INTERFACE) == 0) {
1114 /* TODO: Handle Sink interface events from stack */
1115 DBG("Manager Event: Interface Name:BT_HAL_SINK_INTERFACE");
1116 } else if (g_strcmp0(param->interface_name, BT_HAL_AGENT_INTERFACE) == 0) {
1117 /* TODO: Handle Agent events from stack */
1118 DBG("Manager Event: Interface Name:BT_HAL_AGENT_INTERFACE");
1119 } else if (g_strcmp0(param->interface_name, BT_HAL_DEVICE_INTERFACE) == 0) {
1120 DBG("Manager Event: Interface Name:BT_HAL_DEVICE_INTERFACE");
1121 __bt_hal_handle_device_specific_events(param->parameters, param->signal_name, param->object_path);
1122 } else if (g_strcmp0(param->interface_name, BT_HAL_PLAYER_CONTROL_INTERFACE) == 0) {
1123 DBG("Manager Event: Interface Name: BT_HAL_PLAYER_CONTROL_INTERFACE");
1124 __bt_hal_handle_avrcp_ctrl_events(param->parameters, param->signal_name, param->object_path);
1125 } else if (g_strcmp0(param->interface_name, BT_HAL_MEDIATRANSPORT_INTERFACE) == 0) {
1126 DBG("Manager Event: Interface Name: BT_HAL_MEDIATRANSPORT_INTERFACE");
1127 __bt_hal_handle_avrcp_transport_events(param->parameters, param->signal_name, param->object_path);
1128 } else if (g_strcmp0(param->interface_name, BT_HAL_GATT_CHAR_INTERFACE) == 0) {
1129 DBG("Manager Event: Interface Name: BT_HAL_GATT_CHAR_INTERFACE");
1130 __bt_hal_handle_gatt_char_event(param->parameters, param->signal_name);
1131 } else if (g_strcmp0(param->interface_name, BT_HAL_GATT_SERVICE_INTERFACE) == 0) {
1132 DBG("Manager Event: Interface Name: BT_HAL_GATT_SERVICE_INTERFACE");
1133 __bt_hal_handle_gatt_service_event(param->parameters, param->signal_name);
1137 g_free(param->sender_name);
1138 g_free(param->object_path);
1139 g_free(param->interface_name);
1140 g_free(param->signal_name);
1141 g_variant_unref(param->parameters);
1146 static void __bt_hal_manager_event_filter(GDBusConnection *connection,
1147 const gchar *sender_name,
1148 const gchar *object_path,
1149 const gchar *interface_name,
1150 const gchar *signal_name,
1151 GVariant *parameters,
1154 if (signal_name == NULL)
1157 bt_hal_main_event_data_t *param = g_new0(bt_hal_main_event_data_t, 1);
1158 param->sender_name = g_strdup(sender_name);
1159 param->object_path = g_strdup(object_path);
1160 param->interface_name = g_strdup(interface_name);
1161 param->signal_name = g_strdup(signal_name);
1162 param->parameters = g_variant_ref(parameters);
1164 g_idle_add(__bt_hal_event_manager, (gpointer)param);
1168 static void __bt_hal_handle_headset_events(GVariant *msg, const char *member, const char *path)
1170 gboolean property_flag = FALSE;
1171 char *property = NULL;
1172 GVariant *value = NULL;
1173 g_variant_get(msg, "(sv)", &property, &value);
1175 if (property == NULL)
1178 DBG("Property = %s \n", property);
1179 /* We allow only 1 headset connection (HSP or HFP)*/
1180 if (strcasecmp(property, "Connected") == 0) {
1182 g_variant_get(value, "b", &property_flag);
1184 address = g_malloc0(BT_HAL_ADDRESS_STRING_SIZE);
1186 /* Fix : NULL_RETURNS */
1187 if (address == NULL)
1190 _bt_hal_convert_device_path_to_address(path, address);
1191 __bt_hal_send_hf_audio_connection_state_event(property_flag, address);
1193 } else if (strcasecmp(property, "State") == 0) {
1196 g_variant_get(value, "s", &state);
1198 /* This code assumes we support only 1 headset connection */
1199 /* Need to use the headset list, if we support multi-headsets */
1200 if (strcasecmp(state, "Playing") == 0) {
1201 DBG("Playing: Sco Connected");
1202 } else if (strcasecmp(state, "connected") == 0 ||
1203 strcasecmp(state, "disconnected") == 0) {
1204 if (strcasecmp(state, "connected") == 0)
1205 DBG("Sco Connected");
1207 DBG("Sco Disconnected");
1209 ERR("Not handled state - %s", state);
1214 } else if (strcasecmp(property, "SpeakerGain") == 0) {
1217 address = g_malloc0(BT_HAL_ADDRESS_STRING_SIZE);
1219 _bt_hal_convert_device_path_to_address(path, address);
1220 INFO("Speaker Gain for address [%s]", address);
1221 /* TODO Handle event sending to HAL */
1224 } else if (strcasecmp(property, "MicrophoneGain") == 0) {
1227 address = g_malloc0(BT_HAL_ADDRESS_STRING_SIZE);
1229 _bt_hal_convert_device_path_to_address(path, address);
1230 INFO("Microphone Gain for address [%s]", address);
1231 /* TODO Handle event sending to HAL */
1238 g_variant_unref(value);
1241 static int __bt_hal_register_manager_subscribe_signal(GDBusConnection *conn,
1247 static int subs_interface_added_id = -1;
1248 static int subs_interface_removed_id = -1;
1249 static int subs_name_owner_id = -1;
1250 static int subs_property_id = -1;
1251 static int subs_adapter_id = -1;
1254 if (subs_interface_added_id == -1) {
1255 subs_interface_added_id = g_dbus_connection_signal_subscribe(conn,
1256 NULL, BT_HAL_MANAGER_INTERFACE,
1257 BT_HAL_INTERFACES_ADDED, NULL, NULL, 0,
1258 __bt_hal_manager_event_filter,
1261 if (subs_interface_removed_id == -1) {
1262 subs_interface_removed_id = g_dbus_connection_signal_subscribe(conn,
1263 NULL, BT_HAL_MANAGER_INTERFACE,
1264 BT_HAL_INTERFACES_REMOVED, NULL, NULL, 0,
1265 __bt_hal_manager_event_filter,
1268 if (subs_name_owner_id == -1) {
1269 subs_name_owner_id = g_dbus_connection_signal_subscribe(conn,
1270 NULL, BT_HAL_FREEDESKTOP_INTERFACE,
1271 BT_HAL_NAME_OWNER_CHANGED, NULL, NULL, 0,
1272 __bt_hal_manager_event_filter,
1275 if (subs_property_id == -1) {
1276 subs_property_id = g_dbus_connection_signal_subscribe(conn,
1277 NULL, BT_HAL_PROPERTIES_INTERFACE,
1278 BT_HAL_PROPERTIES_CHANGED, NULL, NULL, 0,
1279 __bt_hal_manager_event_filter,
1282 if (subs_adapter_id == -1) {
1283 subs_adapter_id = g_dbus_connection_signal_subscribe(conn,
1284 NULL, BT_HAL_ADAPTER_INTERFACE,
1285 NULL, NULL, NULL, 0,
1286 __bt_hal_manager_event_filter,
1290 if (subs_interface_added_id != -1) {
1291 g_dbus_connection_signal_unsubscribe(conn,
1292 subs_interface_added_id);
1293 subs_interface_added_id = -1;
1295 if (subs_interface_removed_id != -1) {
1296 g_dbus_connection_signal_unsubscribe(conn,
1297 subs_interface_removed_id);
1298 subs_interface_removed_id = -1;
1300 if (subs_name_owner_id != -1) {
1301 g_dbus_connection_signal_unsubscribe(conn,
1302 subs_name_owner_id);
1303 subs_name_owner_id = -1;
1305 if (subs_property_id != -1) {
1306 g_dbus_connection_signal_unsubscribe(conn,
1308 subs_property_id = -1;
1310 if (subs_adapter_id == -1) {
1311 g_dbus_connection_signal_unsubscribe(conn, subs_adapter_id);
1312 subs_adapter_id = -1;
1319 static int __bt_hal_register_device_subscribe_signal(GDBusConnection *conn,
1322 static int subs_device_id = -1;
1328 if (subs_device_id == -1) {
1329 subs_device_id = g_dbus_connection_signal_subscribe(conn,
1330 NULL, BT_HAL_DEVICE_INTERFACE,
1331 NULL, NULL, NULL, 0,
1332 __bt_hal_manager_event_filter,
1336 if (subs_device_id != -1) {
1337 g_dbus_connection_signal_unsubscribe(conn,
1339 subs_device_id = -1;
1346 static int __bt_hal_register_input_subscribe_signal(GDBusConnection *conn, int subscribe)
1348 static int subs_input_id = -1;
1354 if (subs_input_id == -1) {
1355 subs_input_id = g_dbus_connection_signal_subscribe(conn,
1356 NULL, BT_HAL_INPUT_INTERFACE,
1357 NULL, NULL, NULL, 0,
1358 __bt_hal_manager_event_filter,
1362 if (subs_input_id != -1) {
1363 g_dbus_connection_signal_unsubscribe(conn,
1372 static int __bt_hal_register_gatt_subscribe_signal(GDBusConnection *conn,
1375 static int subs_gatt_char_id = -1;
1376 static int subs_gatt_service_id = -1;
1379 if (subs_gatt_char_id == -1) {
1380 subs_gatt_char_id = g_dbus_connection_signal_subscribe(conn,
1381 NULL, BT_HAL_GATT_CHAR_INTERFACE,
1382 NULL, NULL, NULL, 0,
1383 __bt_hal_manager_event_filter,
1386 if (subs_gatt_service_id == -1) {
1387 subs_gatt_service_id = g_dbus_connection_signal_subscribe(conn,
1388 NULL, BT_HAL_GATT_SERVICE_INTERFACE,
1389 NULL, NULL, NULL, 0,
1390 __bt_hal_manager_event_filter,
1394 if (subs_gatt_char_id == -1) {
1395 g_dbus_connection_signal_unsubscribe(conn,
1397 subs_gatt_char_id = -1;
1399 if (subs_gatt_service_id == -1) {
1400 g_dbus_connection_signal_unsubscribe(conn,
1401 subs_gatt_service_id);
1402 subs_gatt_service_id = -1;
1406 return BT_HAL_ERROR_NONE;
1411 static int __bt_hal_register_service_event(GDBusConnection *g_conn, int event_type)
1414 return BT_HAL_ERROR_INTERNAL;
1416 /* TODO: Add more events in subsequent patches */
1417 switch (event_type) {
1418 case BT_HAL_MANAGER_EVENT:
1419 __bt_hal_register_manager_subscribe_signal(g_conn, TRUE);
1421 case BT_HAL_DEVICE_EVENT:
1422 __bt_hal_register_device_subscribe_signal(g_conn, TRUE);
1424 case BT_HAL_HID_EVENT:
1425 __bt_hal_register_input_subscribe_signal(g_conn, TRUE);
1427 case BT_HAL_HEADSET_EVENT:
1428 __bt_hal_register_audio_subscribe_signal(g_conn, TRUE);
1430 case BT_HAL_GATT_EVENT:
1431 __bt_hal_register_gatt_subscribe_signal(g_conn, TRUE);
1434 INFO_C("Register Event: event_type [%d]", event_type);
1435 return BT_HAL_ERROR_NOT_SUPPORT;
1438 return BT_HAL_ERROR_NONE;
1441 static int __bt_hal_register_audio_subscribe_signal(GDBusConnection *conn,
1447 static int subs_headset_id = -1;
1448 static int subs_sink_id = -1;
1451 if (subs_headset_id == -1) {
1452 subs_headset_id = g_dbus_connection_signal_subscribe(conn,
1453 NULL, BT_HAL_HEADSET_INTERFACE,
1454 NULL, NULL, NULL, 0,
1455 __bt_hal_manager_event_filter,
1458 if (subs_sink_id == -1) {
1459 subs_sink_id = g_dbus_connection_signal_subscribe(conn,
1460 NULL, BT_HAL_SINK_INTERFACE,
1461 NULL, NULL, NULL, 0,
1462 __bt_hal_manager_event_filter,
1466 if (subs_headset_id != -1) {
1467 g_dbus_connection_signal_unsubscribe(conn,
1469 subs_headset_id = -1;
1471 if (subs_sink_id != -1) {
1472 g_dbus_connection_signal_unsubscribe(conn,
1480 static int __bt_hal_initialize_manager_receiver(void)
1484 GError *error = NULL;
1486 if (manager_conn == NULL) {
1487 manager_conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
1488 if (error != NULL) {
1489 ERR_C("ERROR: Can't get on system bus [%s]", error->message);
1490 g_clear_error(&error);
1492 if (manager_conn == NULL)
1496 if (__bt_hal_register_service_event(manager_conn,
1497 BT_HAL_MANAGER_EVENT) != BT_HAL_ERROR_NONE)
1499 if (__bt_hal_register_service_event(manager_conn,
1500 BT_HAL_DEVICE_EVENT) != BT_HAL_ERROR_NONE)
1502 if (__bt_hal_register_service_event(manager_conn,
1503 BT_HAL_HID_EVENT) != BT_HAL_ERROR_NONE)
1505 if (__bt_hal_register_service_event(manager_conn,
1506 BT_HAL_HEADSET_EVENT) != BT_HAL_ERROR_NONE)
1508 if (__bt_hal_register_service_event(manager_conn,
1509 BT_HAL_GATT_EVENT) != BT_HAL_ERROR_NONE)
1511 return BT_HAL_ERROR_NONE;
1514 g_object_unref(manager_conn);
1515 manager_conn = NULL;
1518 return BT_HAL_ERROR_INTERNAL;
1521 /* To receive the event from bluez */
1522 int _bt_hal_initialize_event_receiver(handle_stack_msg cb)
1528 return BT_HAL_ERROR_INVALID_PARAM;
1530 result = __bt_hal_initialize_manager_receiver();
1532 DBG("Manager event receiver initialization result [%d]", result);
1533 if (result != BT_HAL_ERROR_NONE)
1536 /*TODO: Initialize Obexd Event receiver */
1540 return BT_HAL_ERROR_NONE;
1543 static void __bt_hal_device_property_changed_event(GVariant *msg, const char *path)
1545 GVariantIter value_iter;
1546 GVariant *value = NULL;
1548 g_variant_iter_init(&value_iter, msg);
1550 while (g_variant_iter_loop(&value_iter, "{sv}", &key, &value)) {
1551 if (!g_strcmp0(key, "Connected")) {
1552 guint connected = 0;
1553 g_variant_get(value, "i", &connected);
1554 INFO("Device property changed : Connected [%d]", connected);
1555 } else if (!g_strcmp0(key, "RSSI")) {
1556 DBG("Device property changed : RSSI");
1557 __bt_hal_dbus_device_found_properties(path);
1558 } else if (!g_strcmp0(key, "GattConnected")) {
1559 gboolean gatt_connected = FALSE;
1560 g_variant_get(value, "b", &gatt_connected);
1561 INFO("Device property changed : GattConnected [%d]", gatt_connected);
1563 char *address = g_malloc0(BT_HAL_ADDRESS_STRING_SIZE);
1564 _bt_hal_convert_device_path_to_address(path, address);
1565 _bt_hal_gatt_connected_state_event(gatt_connected, address);
1566 _bt_hal_handle_gattc_connected_event(address, gatt_connected);
1568 } else if (!g_strcmp0(key, "Paired")) {
1569 gboolean paired = FALSE;
1570 struct hal_ev_bond_state_changed ev;
1571 char address[BT_HAL_ADDRESS_STRING_SIZE];
1573 g_variant_get(value, "b", &paired);
1574 DBG("Device property changed : Paired = %s", (paired ? "TRUE" : "FALSE"));
1576 _bt_hal_agent_set_canceled(FALSE);
1577 _bt_hal_convert_device_path_to_address(path, address);
1579 /* Prepare to send event to HAL bluetooth */
1580 ev.status = BT_STATUS_SUCCESS;
1581 ev.state = paired ? BT_BOND_STATE_BONDED : BT_BOND_STATE_NONE;
1582 _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
1585 ERR("Bluetooth HAL event handler not registered");
1587 event_cb(HAL_EV_BOND_STATE_CHANGED, (void*)&ev, sizeof(ev));
1588 } else if (!g_strcmp0(key, "LegacyPaired")) {
1589 DBG("Device property changed : LegacyPaired");
1590 } else if (!g_strcmp0(key, "Trusted")) {
1591 DBG("Device property changed : Trusted");
1592 gboolean trusted = FALSE;
1593 gchar *address = NULL;
1594 g_variant_get(value, "b", &trusted);
1595 address = g_malloc0(BT_HAL_ADDRESS_STRING_SIZE);
1597 _bt_hal_convert_device_path_to_address(path, address);
1598 DBG("Device [%s] trusted: [%d]", address, trusted);
1600 __bt_hal_send_device_trust_state_event(trusted, address);
1602 } else if (!g_strcmp0(key, "IpspConnected")) {
1603 DBG("Device property changed : IpspConnected");
1604 } else if (!g_strcmp0(key, "IpspInitStateChanged")) {
1605 DBG("Device property changed : IpspInitStateChanged");
1606 } else if (!g_strcmp0(key, "TrustedProfiles")) {
1608 char address[BT_HAL_ADDRESS_STRING_SIZE];
1610 g_variant_get(value, "u", &trust_val);
1611 _bt_hal_convert_device_path_to_address(path, address);
1612 DBG("Address: %s, TrustedProfiles: 0x%X", address, trust_val);
1613 __bt_hal_send_device_trusted_profile_changed_event(trust_val, address);
1615 DBG("Unhandled Property:[%s]", key);
1620 static void __bt_hal_dbus_device_found_properties(const char *device_path)
1623 GError *error = NULL;
1624 GDBusProxy *device_proxy;
1625 GDBusConnection *conn;
1629 ERR("Invalid device path");
1633 conn = _bt_hal_get_system_gconn();
1635 ERR("_bt_hal_get_system_gconn failed");
1639 device_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
1643 BT_HAL_PROPERTIES_INTERFACE,
1646 if (!device_proxy) {
1647 ERR("Error creating device_proxy");
1651 result = g_dbus_proxy_call_sync(device_proxy,
1653 g_variant_new("(s)", BT_HAL_DEVICE_INTERFACE),
1654 G_DBUS_CALL_FLAGS_NONE,
1659 ERR("Error occured in Proxy call");
1660 if (error != NULL) {
1661 ERR("Error occured in Proxy call (Error: %s)", error->message);
1662 g_clear_error(&error);
1664 g_object_unref(device_proxy);
1668 address = g_malloc0(BT_HAL_ADDRESS_STRING_SIZE);
1669 _bt_hal_convert_device_path_to_address(device_path, address);
1671 __bt_hal_device_properties_lookup(result, address);
1673 g_object_unref(device_proxy);
1677 static void __bt_hal_device_properties_lookup(GVariant *result, char *address)
1679 /* Buffer and propety count management */
1680 uint8_t buf[BT_HAL_MAX_PROPERTY_BUF_SIZE];
1681 struct hal_ev_device_found *ev = (void *) buf;
1683 memset(buf, 0, sizeof(buf));
1687 GVariant *tmp_value;
1690 gchar *manufacturer_data = NULL;
1693 if (result != NULL) {
1694 g_variant_get(result , "(@a{sv})", &value);
1695 g_variant_unref(result);
1698 tmp_value = g_variant_lookup_value(value, "Alias", G_VARIANT_TYPE_STRING);
1700 g_variant_get(tmp_value, "s", &name);
1702 g_variant_unref(tmp_value);
1704 DBG_SECURE("Alias Name [%s]", name);
1705 size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_NAME,
1706 strlen(name) + 1, name);
1708 DBG("Device Name [%s] Property num [%d]", name, ev->num_props);
1711 tmp_value = g_variant_lookup_value(value, "Name", G_VARIANT_TYPE_STRING);
1712 g_variant_get(tmp_value, "s", &name);
1713 g_variant_unref(tmp_value);
1715 size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_NAME,
1716 strlen(name) + 1, name);
1718 DBG("Device Name [%s] Property num [%d]", name, ev->num_props);
1719 g_variant_get(tmp_value, "s", &name);
1723 tmp_value = g_variant_lookup_value(value, "Class", G_VARIANT_TYPE_UINT32);
1724 unsigned int class = tmp_value ? g_variant_get_uint32(tmp_value) : 0;
1725 size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_CLASS,
1726 sizeof(unsigned int), &class);
1729 g_variant_unref(tmp_value);
1733 tmp_value = g_variant_lookup_value(value, "Connected", G_VARIANT_TYPE_BOOLEAN);
1734 unsigned int connected = tmp_value ? g_variant_get_boolean(tmp_value) : 0;
1735 size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_CONNECTED,
1736 sizeof(unsigned int), &connected);
1738 DBG("Device connected [%u] Property num [%d]", connected, ev->num_props);
1740 g_variant_unref(tmp_value);
1743 tmp_value = g_variant_lookup_value(value, "Trusted", G_VARIANT_TYPE_BOOLEAN);
1744 uint8_t trust = tmp_value ? (g_variant_get_boolean(tmp_value) ? 1 : 0) : 0;
1745 size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_TRUSTED,
1746 sizeof(uint8_t), &trust);
1748 DBG("Device trusted [%d] Property num [%d]", trust, ev->num_props);
1750 g_variant_unref(tmp_value);
1753 tmp_value = g_variant_lookup_value(value, "Paired", G_VARIANT_TYPE_BOOLEAN);
1754 uint8_t paired = tmp_value ? (g_variant_get_boolean(tmp_value) ? 1 : 0) : 0;
1756 size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_PAIRED,
1757 sizeof(uint8_t), &paired);
1759 DBG("Device Paired [%d] Property num [%d]", paired, ev->num_props);
1761 g_variant_unref(tmp_value);
1764 tmp_value = g_variant_lookup_value(value, "RSSI", G_VARIANT_TYPE_INT32);
1765 int rssi = tmp_value ? g_variant_get_int32(tmp_value) : 0;
1766 size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_RSSI,
1767 sizeof(int), &rssi);
1769 DBG("Device RSSI [%d] Property num [%d]", rssi, ev->num_props);
1771 g_variant_unref(tmp_value);
1773 /* Last Addr Type */
1774 tmp_value = g_variant_lookup_value(value, "LastAddrType", G_VARIANT_TYPE_UINT32);
1775 unsigned int addr_type = tmp_value ? g_variant_get_uint32(tmp_value) : 0;
1777 g_variant_unref(tmp_value);
1778 DBG("Device Last Address Type [0x%x]", addr_type);
1781 tmp_value = g_variant_lookup_value(value, "IsAliasSet", G_VARIANT_TYPE_UINT32);
1782 uint8_t is_alias_set = tmp_value ? (g_variant_get_boolean(tmp_value) ? 1 : 0) : 0;
1783 size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_IS_ALIAS_SET,
1784 sizeof(uint8_t), &is_alias_set);
1786 DBG("IsAliasSet: [%s], Property num [%d]", (is_alias_set ? "TRUE" : "FALSE"), ev->num_props);
1788 g_variant_unref(tmp_value);
1791 tmp_value = g_variant_lookup_value(value, "UUIDs", G_VARIANT_TYPE_STRING_ARRAY);
1792 gsize uuid_count = g_variant_get_size(tmp_value);
1793 char **uuid_value = g_variant_dup_strv(tmp_value, &uuid_count);
1795 /* UUID collection */
1800 int num_props_tmp = ev->num_props;
1802 uint8_t uuids[BT_HAL_STACK_UUID_SIZE * uuid_count];
1804 for (i = 0; uuid_value[i] != NULL; i++) {
1806 char *uuid_str = NULL;
1807 uint8_t uuid[BT_HAL_STACK_UUID_SIZE];
1808 memset(uuid, 0x00, BT_HAL_STACK_UUID_SIZE);
1810 DBG("UUID string from Bluez [%s]\n", uuid_value[i]);
1811 uuid_str = g_strdup(uuid_value[i]);
1812 DBG("UUID string [%s]\n", uuid_str);
1814 _bt_hal_convert_uuid_string_to_type(uuid, uuid_str);
1816 for (z = 0; z < 16; z++)
1817 DBG("[0x%x]", uuid[z]);
1820 memcpy(uuids+i*BT_HAL_STACK_UUID_SIZE, uuid, BT_HAL_STACK_UUID_SIZE);
1824 size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_UUIDS,
1825 (BT_HAL_STACK_UUID_SIZE * uuid_count),
1827 ev->num_props = num_props_tmp + 1;
1828 g_strfreev(uuid_value);
1830 g_variant_unref(tmp_value);
1832 /* LegacyManufacturerDataLen */
1833 tmp_value = g_variant_lookup_value(value, "LegacyManufacturerDataLen", G_VARIANT_TYPE_UINT32);
1834 unsigned int manufacturer_data_len = tmp_value ? g_variant_get_uint32(tmp_value) : 0;
1835 if (manufacturer_data_len > BT_HAL_MANUFACTURER_DATA_LENGTH_MAX) {
1836 ERR("manufacturer_data_len is too long(len = %d)", manufacturer_data_len);
1837 manufacturer_data_len = BT_HAL_MANUFACTURER_DATA_LENGTH_MAX;
1840 g_variant_unref(tmp_value);
1841 /*size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_MANUFACTURER_DATA_LEN,
1842 sizeof(unsigned int), &manufacturer_data_len);
1844 DBG("Device Legacy Manufacturer data length [%u]", manufacturer_data_len);
1846 /* ManufacturerData */
1847 tmp_value = g_variant_lookup_value(value, "LegacyManufacturerData", G_VARIANT_TYPE_BYTESTRING);
1848 manufacturer_data = value ? (gchar *)g_variant_get_bytestring(tmp_value) : NULL;
1849 if (manufacturer_data) {
1850 if (manufacturer_data_len > 0) {
1851 //size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_MANUFACTURER_DATA,
1852 size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_BLE_ADV_DATA,
1853 manufacturer_data_len, manufacturer_data);
1858 g_variant_unref(tmp_value);
1862 _bt_hal_convert_addr_string_to_type(bdaddr, address);
1863 size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_ADDR,
1864 sizeof(bdaddr), bdaddr);
1866 DBG("Device address [%s] property Num [%d]", address, ev->num_props);
1869 g_variant_unref(value);
1871 ERR("result is NULL\n");
1874 DBG("Send Device found event to HAL user, Num Prop [%d] total size [%zd]", ev->num_props, size);
1875 event_cb(HAL_EV_DEVICE_FOUND, (void*) buf, size);
1879 static void __bt_hal_send_device_acl_connection_state_event(int status, gboolean connected, const char *address)
1882 struct hal_ev_acl_state_changed ev;
1885 ev.state = (connected == TRUE) ?
1886 HAL_ACL_STATE_CONNECTED :
1887 HAL_ACL_STATE_DISCONNECTED;
1889 _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
1892 ERR("Bluetooth HAL event handler not registered");
1894 event_cb(HAL_EV_ACL_STATE_CHANGED, &ev, sizeof(ev));
1897 static void __bt_hal_send_device_le_connection_state_event(int status, gboolean connected, const char *address)
1899 struct hal_ev_le_conn_state_changed ev;
1902 ev.state = (connected == TRUE) ?
1903 HAL_LE_STATE_CONNECTED :
1904 HAL_LE_STATE_DISCONNECTED;
1906 _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
1909 ERR("Bluetooth HAL event handler not registered");
1911 event_cb(HAL_EV_LE_CONN_STATE_CHANGED, &ev, sizeof(ev));
1914 static void __bt_hal_send_device_trust_state_event(gboolean is_trusted,
1915 const char *address)
1917 struct hal_ev_device_trust_state_changed ev;
1919 ev.trust = (is_trusted == TRUE) ?
1920 HAL_DEVICE_TRUSTED :
1921 HAL_DEVICE_UNTRUSTED;
1923 _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
1926 ERR("Bluetooth HAL event handler not registered");
1928 event_cb(HAL_EV_DEVICE_TRUST_CHANGED, &ev, sizeof(ev));
1931 static void __bt_hal_send_device_trusted_profile_changed_event(
1932 uint32_t trust_val, const char *address)
1934 struct hal_ev_device_trusted_profiles_changed ev;
1936 _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
1937 ev.trust_val = trust_val;
1940 ERR("Bluetooth HAL event handler not registered");
1942 event_cb(HAL_EV_DEVICE_TRUSTED_PROFILES_CHANGED, &ev, sizeof(ev));
1945 static void __bt_hal_handle_device_specific_events(GVariant *msg, const char *member,
1949 const char *property = NULL;
1953 if (strcasecmp(member, "PropertyChanged") == 0) {
1954 g_variant_get(msg, "(s)", &property);
1955 if (property == NULL)
1957 if (strcasecmp(property, "GattConnected") == 0) {
1958 INFO("GATT Connected");
1959 gboolean connected = FALSE;
1961 address = g_malloc0(BT_HAL_ADDRESS_STRING_SIZE);
1963 _bt_hal_convert_device_path_to_address(path, address);
1964 g_variant_get(msg, "(b)", &connected);
1966 INFO("Connected device address[%s] connnected[%d]", address, connected);
1968 } else if (strcasecmp(property, "Paired") == 0) {
1969 gboolean paired = FALSE;
1970 struct hal_ev_bond_state_changed ev;
1971 char address[BT_HAL_ADDRESS_STRING_SIZE];
1973 g_variant_get(msg, "(b)", &paired);
1974 DBG("Device property changed : Paired = %s", (paired ? "TRUE" : "FALSE"));
1976 _bt_hal_agent_set_canceled(FALSE);
1977 _bt_hal_convert_device_path_to_address(path, address);
1979 /* Prepare to send event to HAL bluetooth */
1980 ev.status = BT_STATUS_SUCCESS;
1981 ev.state = paired ? BT_BOND_STATE_BONDED : BT_BOND_STATE_NONE;
1982 _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
1985 ERR("Bluetooth HAL event handler not registered");
1987 DBG("Sending HAL_EV_BOND_STATE_CHANGED event");
1988 event_cb(HAL_EV_BOND_STATE_CHANGED, (void*)&ev, sizeof(ev));
1990 } else if (strcasecmp(property, "UUIDs") == 0) {
1993 } else if (strcasecmp(member, "DeviceConnected") == 0) {
1994 unsigned char addr_type = 0;
1996 g_variant_get(msg, "(y)", &addr_type);
1998 address = g_malloc0(BT_HAL_ADDRESS_STRING_SIZE);
1999 _bt_hal_convert_device_path_to_address(path, address);
2001 DBG("Member: [%s]", member);
2002 ERR_C("### Connected [%s] [%s]", !addr_type ? "BREDR" : "LE", address);
2004 __bt_hal_send_device_acl_connection_state_event(BT_STATUS_SUCCESS, TRUE, address);
2006 __bt_hal_send_device_le_connection_state_event(BT_STATUS_SUCCESS, TRUE, address);
2008 } else if (strcasecmp(member, "Disconnected") == 0) {
2009 unsigned char disc_reason = 0;
2010 unsigned char addr_type = 0;
2013 g_variant_get(msg, "(yy&s)", &addr_type, &disc_reason, &name);
2015 address = g_malloc0(BT_HAL_ADDRESS_STRING_SIZE);
2016 _bt_hal_convert_device_path_to_address(path, address);
2018 ERR_C("### Disconnected [%s] [%d : %s] [%s] [%s]", !addr_type ? "BREDR" : "LE",
2019 disc_reason, _bt_hal_convert_disc_reason_to_string(disc_reason), address, name);
2022 __bt_hal_send_device_acl_connection_state_event(_bt_hal_convert_disc_reason_to_status(disc_reason), FALSE, address);
2024 __bt_hal_send_device_le_connection_state_event(_bt_hal_convert_disc_reason_to_status(disc_reason), FALSE, address);
2026 } else if (strcasecmp(member, "ProfileStateChanged") == 0) {
2028 char *profile_uuid = NULL;
2030 g_variant_get(msg, "(si)", &profile_uuid, &state);
2031 address = g_malloc0(BT_HAL_ADDRESS_STRING_SIZE);
2032 _bt_hal_convert_device_path_to_address(path, address);
2034 if (strncmp(profile_uuid, HID_UUID, strlen(HID_UUID)) == 0) {
2035 DBG("HID Host Profile state: %d", state);
2036 if (state == BT_HAL_PROFILE_STATE_CONNECTED)
2037 __bt_hal_send_hid_connection_state_event(TRUE, address);
2038 else if (state == BT_HAL_PROFILE_STATE_DISCONNECTED)
2039 __bt_hal_send_hid_connection_state_event(FALSE, address);
2041 DBG("HID Host Profile state: Invalid");
2042 } else if (strcmp(profile_uuid, HID_DEVICE_UUID) == 0) {
2043 DBG("HID Device Profile state: %d", state);
2044 if (state == BT_HAL_PROFILE_STATE_CONNECTED)
2045 __bt_hal_send_hid_device_connection_state_event(TRUE, address);
2046 else if (state == BT_HAL_PROFILE_STATE_DISCONNECTED)
2047 __bt_hal_send_hid_device_connection_state_event(FALSE, address);
2049 DBG("HID Device Profile state: Invalid");
2050 } else if ((strcmp(profile_uuid, A2DP_SINK_UUID) == 0)) {
2051 if (state == BT_HAL_PROFILE_STATE_CONNECTED) {
2052 DBG("A2DP Profile state changed: BT_PROFILE_STATE_CONNECTED");
2053 __bt_hal_send_av_connection_state_event(TRUE, address);
2054 } else if (state == BT_HAL_PROFILE_STATE_DISCONNECTED) {
2055 DBG("A2DP Profile state changed: BT_PROFILE_STATE_DISCONNECTED");
2056 __bt_hal_send_av_connection_state_event(FALSE, address);
2057 } else if (state == BT_HAL_PROFILE_STATE_DISCONNECTING) {
2058 DBG("A2DP Profile state changed: BT_PROFILE_STATE_DISCONNECTING");
2059 } else if (state == BT_HAL_PROFILE_STATE_CONNECTING) {
2060 DBG("A2DP Profile state changed: BT_PROFILE_STATE_CONNECTING");
2062 ERR("A2DP Profile state: Invalid");
2064 } else if ((strcmp(profile_uuid, A2DP_SOURCE_UUID) == 0)) {
2065 if (state == BT_HAL_PROFILE_STATE_CONNECTED) {
2066 DBG("A2DP Sink Profile state changed: BT_HAL_PROFILE_STATE_CONNECTED");
2067 __bt_hal_send_a2dp_sink_connection_state_event(TRUE, address);
2068 } else if (state == BT_HAL_PROFILE_STATE_DISCONNECTED) {
2069 DBG("A2DP Sink Profile state changed: BT_HAL_PROFILE_STATE_DISCONNECTED");
2070 __bt_hal_send_a2dp_sink_connection_state_event(FALSE, address);
2071 } else if (state == BT_HAL_PROFILE_STATE_DISCONNECTING) {
2072 DBG("A2DP Sink Profile state changed: BT_HAL_PROFILE_STATE_DISCONNECTING");
2073 } else if (state == BT_HAL_PROFILE_STATE_CONNECTING) {
2074 DBG("A2DP Sink Profile state changed: BT_HAL_PROFILE_STATE_CONNECTING");
2076 } else if (strcmp(profile_uuid, HFP_HF_UUID) == 0) {
2077 if (state == BT_HAL_PROFILE_STATE_CONNECTING)
2078 DBG("HFP Profile state changed: BT_PROFILE_STATE_CONNECTING");
2079 else if (state == BT_HAL_PROFILE_STATE_CONNECTED) {
2080 DBG("HFP Profile state changed: BT_PROFILE_STATE_CONNECTED");
2081 __bt_hal_send_hf_connection_state_event(TRUE, address);
2082 } else if (state == BT_HAL_PROFILE_STATE_DISCONNECTED) {
2083 DBG("HFP Profile state changed: BT_PROFILE_STATE_DISCONNECTED");
2084 __bt_hal_send_hf_connection_state_event(FALSE, address);
2085 } else if (state == BT_HAL_PROFILE_STATE_DISCONNECTING) {
2086 DBG("HFP Profile state changed: BT_PROFILE_STATE_DISCONNECTING");
2088 ERR("HFP Profile state: Invalid");
2090 } else if (strcmp(profile_uuid, HFP_AG_UUID) == 0) {
2091 if (state == BT_HAL_PROFILE_STATE_CONNECTING)
2092 DBG("HFP Client Profile state changed: BT_PROFILE_STATE_CONNECTING");
2093 else if (state == BT_HAL_PROFILE_STATE_CONNECTED) {
2094 DBG("HFP Client Profile state changed: BT_PROFILE_STATE_CONNECTED");
2095 __bt_hal_send_hf_client_connection_state_event(TRUE, address);
2096 } else if (state == BT_HAL_PROFILE_STATE_DISCONNECTED) {
2097 DBG("HFP Client Profile state changed: BT_PROFILE_STATE_DISCONNECTED");
2098 __bt_hal_send_hf_client_connection_state_event(FALSE, address);
2099 } else if (state == BT_HAL_PROFILE_STATE_DISCONNECTING) {
2100 DBG("HFP Client Profile state changed: BT_PROFILE_STATE_DISCONNECTING");
2102 ERR("HFP Client Profile state: Invalid");
2104 } else if ((strcmp(profile_uuid, AVRCP_TARGET_UUID) == 0)) {
2105 if (state == BT_HAL_PROFILE_STATE_CONNECTED) {
2106 DBG("AVRCP Controller Profile state changed: BT_HAL_PROFILE_STATE_CONNECTED");
2107 __bt_hal_send_avrcp_ctrl_connection_state_event(TRUE, address);
2108 } else if (state == BT_HAL_PROFILE_STATE_DISCONNECTED) {
2109 DBG("AVRCP Controller Profile state changed: BT_HAL_PROFILE_STATE_DISCONNECTED");
2110 __bt_hal_send_avrcp_ctrl_connection_state_event(FALSE, address);
2111 } else if (state == BT_HAL_PROFILE_STATE_DISCONNECTING) {
2112 DBG("AVRCP Controller Profile state changed: BT_HAL_PROFILE_STATE_DISCONNECTING");
2113 } else if (state == BT_HAL_PROFILE_STATE_CONNECTING) {
2114 DBG("AVRCP Controller Profile state changed: BT_HAL_PROFILE_STATE_CONNECTING");
2117 DBG("Profile [%s] State changed [%d] [%s] ", profile_uuid, state, address);
2120 g_free(profile_uuid);
2121 } else if (strcasecmp(member, "AttMtuChanged") == 0) {
2125 address = g_malloc0(BT_HAL_ADDRESS_STRING_SIZE);
2127 _bt_hal_convert_device_path_to_address(path, address);
2128 g_variant_get(msg, "(q)", &mtu);
2130 __bt_hal_handle_gatts_mtu_changed_event(address, mtu);
2133 } else if (strcasecmp(member, "AdvReport") == 0) {
2134 __bt_hal_handle_adv_report(msg, path);
2138 static void __bt_hal_handle_adv_report(GVariant *msg, const char *path)
2140 uint8_t buf[BT_HAL_MAX_PROPERTY_BUF_SIZE];
2141 struct hal_ev_gatt_client_scan_result *ev = (void *)buf;
2143 char *address = NULL;
2144 GVariant *value = NULL;
2145 char *buffer = NULL;
2148 uint8_t addr_type = 0;
2149 uint8_t adv_type = 0;
2155 memset(buf, 0, sizeof(buf));
2158 g_variant_get(msg, "(&syyii@ay)", &address, &addr_type,
2159 &adv_type, &rssi, &data_len, &value);
2161 buffer_len = g_variant_get_size(value);
2163 buffer = (char *)g_variant_get_data(value);
2165 if (data_len != buffer_len) {
2166 ERR("Unexpected: buffer_len: %d, data_len: %d",
2167 buffer_len, data_len);
2168 data_len = buffer_len;
2171 DBG("Address: %s, len: %d, rssi: %d, addr_type: 0x%02X, adv_type: 0x%02X",
2172 address, data_len, rssi, addr_type, adv_type);
2174 _bt_hal_convert_addr_string_to_type(ev->bd_addr, address);
2175 ev->addr_type = addr_type;
2176 ev->adv_type = adv_type;
2179 memcpy(ev->adv_data, buffer, data_len);
2182 gatt_event_cb(HAL_EV_GATT_CLIENT_SCAN_RESULT, buf, size);
2183 g_variant_unref(value);
2186 static void __bt_hal_handle_gatts_mtu_changed_event(char *address, int mtu)
2188 uint8_t buf[BT_HAL_MAX_PROPERTY_BUF_SIZE];
2189 struct hal_ev_gatt_server_mtu_changed *ev = (void *)buf;
2195 memset(buf, 0, sizeof(buf));
2198 ev->conn_id = _bt_get_remote_gatt_client_conn_id(address);
2201 gatt_event_cb(HAL_EV_GATT_SERVER_MTU_CHANGED, buf, size);
2204 /* AVRCP Controller Role(Remote:AVRCP Target) Events */
2205 static void __bt_hal_send_avrcp_ctrl_connection_state_event(gboolean connected, const char *address)
2208 struct hal_ev_avrcp_ctrl_conn_state ev;
2210 if (connected == TRUE)
2211 INFO("AVRCP(Controller) Profile Connected for address [%s]", address);
2213 INFO("AVRCP(Controller) Profile DisConnected for address [%s]", address);
2215 if (connected == TRUE)
2216 ev.state = HAL_AVRCP_CTRL_STATE_CONNECTED;
2218 ev.state = HAL_AVRCP_CTRL_STATE_DISCONNECTED;
2219 _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
2221 if (!avrcp_ctrl_event_cb)
2222 ERR("AVRCP controller handler not registered");
2224 avrcp_ctrl_event_cb(HAL_EV_AVRCP_CTRL_CONN_STATE, &ev, sizeof(ev));
2227 static int __bt_media_attr_to_type(const char *str)
2229 if (!strcasecmp(str, "Equalizer"))
2230 return HAL_PLAYER_ATTR_EQUALIZER;
2231 else if (!strcasecmp(str, "Repeat"))
2232 return HAL_PLAYER_ATTR_REPEAT;
2233 else if (!strcasecmp(str, "Shuffle"))
2234 return HAL_PLAYER_ATTR_SHUFFLE;
2235 else if (!strcasecmp(str, "Scan"))
2236 return HAL_PLAYER_ATTR_SCAN;
2242 static int __bt_hal_play_status_str_to_type(const char *value)
2244 if (!strcmp(value, "stopped"))
2245 return HAL_PLAYSTATE_STOPPED;
2246 else if (!strcmp(value, "playing"))
2247 return HAL_PLAYSTATE_PLAYING;
2248 else if (!strcmp(value, "paused"))
2249 return HAL_PLAYSTATE_PAUSED;
2250 else if (!strcmp(value, "forward-seek"))
2251 return HAL_PLAYSTATE_FWD_SEEK;
2252 else if (!strcmp(value, "reverse-seek"))
2253 return HAL_PLAYSTATE_REV_SEEK;
2255 return HAL_PLAYSTATE_ERROR;
2258 static void __bt_avrcp_control_parse_properties(struct hal_ev_track_changed *ev, GVariant *item)
2260 GVariant *value = NULL;
2262 char *value_string = NULL;
2263 const char *key = NULL;
2269 g_variant_iter_init(&iter, item);
2270 while (g_variant_iter_loop(&iter, "{sv}", &key, &value)) {
2271 if (strcasecmp(key, "Title") == 0) {
2272 value_string = (char *)g_variant_get_string(value, NULL);
2273 DBG("Value : %s ", value_string);
2274 ev->attr[i].attr_id = HAL_MEDIA_ATTR_ID_TITLE;
2275 g_strlcpy((gchar *)ev->attr[i].text, value_string, HAL_MAX_ATTR_STR_LEN);
2277 } else if (strcasecmp(key, "Artist") == 0) {
2278 value_string = (char *)g_variant_get_string(value, NULL);
2279 DBG("Value : %s ", value_string);
2280 ev->attr[i].attr_id = HAL_MEDIA_ATTR_ID_ARTIST;
2281 g_strlcpy((gchar *)ev->attr[i].text, value_string, HAL_MAX_ATTR_STR_LEN);
2283 } else if (strcasecmp(key, "Album") == 0) {
2284 value_string = (char *)g_variant_get_string(value, NULL);
2285 DBG("Value : %s ", value_string);
2286 ev->attr[i].attr_id = HAL_MEDIA_ATTR_ID_ALBUM;
2287 g_strlcpy((gchar *)ev->attr[i].text, value_string, HAL_MAX_ATTR_STR_LEN);
2289 } else if (strcasecmp(key, "Genre") == 0) {
2290 value_string = (char *)g_variant_get_string(value, NULL);
2291 DBG("Value : %s ", value_string);
2292 ev->attr[i].attr_id = HAL_MEDIA_ATTR_ID_GENRE;
2293 g_strlcpy((gchar *)ev->attr[i].text, value_string, HAL_MAX_ATTR_STR_LEN);
2295 } else if (strcasecmp(key, "Duration") == 0) {
2298 val = g_variant_get_uint32(value);
2299 DBG("Value : %li", val);
2300 ev->attr[i].attr_id = HAL_MEDIA_ATTR_ID_PLAYING_TIME;
2301 snprintf((char*)ev->attr[i].text, HAL_MAX_ATTR_STR_LEN, "%ld", val);
2303 } else if (strcasecmp(key, "NumberOfTracks") == 0) {
2306 val = g_variant_get_uint32(value);
2307 DBG("Value : %li", val);
2308 ev->attr[i].attr_id = HAL_MEDIA_ATTR_ID_NUM_TRACKS;
2309 snprintf((char*)ev->attr[i].text, HAL_MAX_ATTR_STR_LEN, "%ld", val);
2311 } else if (strcasecmp(key, "TrackNumber") == 0) {
2314 val = g_variant_get_uint32(value);
2315 DBG("Value : %li", val);
2316 ev->attr[i].attr_id = HAL_MEDIA_ATTR_ID_TRACK_NUM;
2317 snprintf((char*)ev->attr[i].text, HAL_MAX_ATTR_STR_LEN, "%ld", val);
2320 DBG("%s not supported, ignoring", key);
2323 if (i >= HAL_MAX_ATTR_NUM) {
2324 ERR(" Received max attribute [%d]", i);
2333 static int __bt_media_attrval_to_val(int type, const char *value)
2338 case HAL_PLAYER_ATTR_EQUALIZER:
2339 if (!strcmp(value, "off"))
2344 case HAL_PLAYER_ATTR_REPEAT:
2345 if (!strcmp(value, "off"))
2346 ret = BTRC_PLAYER_VAL_OFF_REPEAT;
2347 else if (!strcmp(value, "singletrack"))
2348 ret = BTRC_PLAYER_VAL_SINGLE_REPEAT;
2349 else if (!strcmp(value, "alltracks"))
2350 ret = BTRC_PLAYER_VAL_ALL_REPEAT;
2352 ret = BTRC_PLAYER_VAL_GROUP_REPEAT;
2354 case HAL_PLAYER_ATTR_SHUFFLE:
2355 if (!strcmp(value, "off"))
2356 ret = BTRC_PLAYER_VAL_OFF_SHUFFLE;
2357 else if (!strcmp(value, "alltracks"))
2358 ret = BTRC_PLAYER_VAL_ALL_SHUFFLE;
2360 ret = BTRC_PLAYER_VAL_GROUP_SHUFFLE;
2362 case HAL_PLAYER_ATTR_SCAN:
2363 if (!strcmp(value, "off"))
2365 else if (!strcmp(value, "alltracks"))
2371 ERR("Value not handled");
2377 static void __bt_hal_handle_avrcp_ctrl_events(GVariant *msg, const char *member,
2380 const char *property = NULL;
2381 GVariant *value = NULL;
2383 char address[BT_HAL_ADDRESS_STRING_SIZE];
2386 ERR("Error returned in method call\n");
2390 if (!avrcp_ctrl_event_cb) {
2391 ERR("AVRCP controller DBUS handler callback not registered");
2395 g_variant_iter_init(&iter, msg);
2397 _bt_hal_convert_device_path_to_address(path, address);
2399 while (g_variant_iter_loop(&iter, "{sv}", &property, &value)) {
2400 DBG("Property = %s \n", property);
2401 if ((strcasecmp(property, "Equalizer") == 0) ||
2402 (strcasecmp(property, "Repeat") == 0) ||
2403 (strcasecmp(property, "Shuffle") == 0) ||
2404 (strcasecmp(property, "Scan") == 0)) {
2405 struct hal_ev_player_setting ev;
2409 valstr = g_variant_get_string(value, NULL);
2410 DBG("Value : %s ", valstr);
2413 val = __bt_media_attrval_to_val(__bt_media_attr_to_type(property), valstr);
2416 memset(&ev, 0, sizeof(ev));
2417 _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
2419 ev.attr_ids[0] = __bt_media_attr_to_type(property);
2420 ev.attr_values[0] = val;
2422 /* Send event to application */
2423 avrcp_ctrl_event_cb(HAL_EV_AVRCP_CTRL_PLAYER_APP_SETTING_CHANGED, &ev, sizeof(ev));
2425 } else if ((strcasecmp(property, "Status") == 0)) {
2426 struct hal_ev_play_status_changed ev;
2429 valstr = g_variant_get_string(value, NULL);
2430 DBG("Value : %s ", valstr);
2432 memset(&ev, 0, sizeof(ev));
2433 _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
2435 ev.status = __bt_hal_play_status_str_to_type(valstr);
2437 /* Send event to application */
2438 avrcp_ctrl_event_cb(HAL_EV_AVRCP_CTRL_PLAY_STATUS_CHANGED, &ev, sizeof(ev));
2440 } else if (strcasecmp(property, "Position") == 0) {
2441 struct hal_ev_play_position ev;
2443 memset(&ev, 0, sizeof(ev));
2444 _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
2445 ev.pos = g_variant_get_uint32(value);
2446 DBG("Value : %d ", ev.pos);
2448 /* Send event to application */
2449 avrcp_ctrl_event_cb(HAL_EV_AVRCP_CTRL_PLAY_POSITION_CHANGED, &ev, sizeof(ev));
2450 } else if (strcasecmp(property, "Track") == 0) {
2451 struct hal_ev_track_changed ev;
2453 memset(&ev, 0, sizeof(ev));
2454 _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
2455 __bt_avrcp_control_parse_properties(&ev, value);
2457 /* Send event to application */
2458 avrcp_ctrl_event_cb(HAL_EV_AVRCP_CTRL_TRACK_CHANGED, &ev, sizeof(ev));
2460 DBG("Property not handled");
2465 static void __bt_hal_handle_avrcp_transport_events(GVariant *msg, const char *member,
2468 const char *property = NULL;
2469 GVariant *value = NULL;
2471 char address[BT_HAL_ADDRESS_STRING_SIZE];
2475 ERR("Error returned in method call\n");
2479 if (!avrcp_tg_event_cb) {
2480 ERR("AVRCP target DBUS handler callback not registered");
2484 g_variant_iter_init(&iter, msg);
2486 _bt_hal_convert_device_path_to_address(path, address);
2488 while (g_variant_iter_loop(&iter, "{sv}", &property, &value)) {
2489 DBG("Property = %s \n", property);
2490 if ((strcasecmp(property, "Delay") == 0)) {
2491 struct hal_ev_avrcp_tg_delay_changed ev;
2494 memset(&ev, 0, sizeof(ev));
2495 _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
2497 val = g_variant_get_uint16(value);
2498 DBG("Value : %d", val);
2501 /* Send event to application */
2502 avrcp_tg_event_cb(HAL_EV_AVRCP_TG_DELAY_CHANGE, &ev, sizeof(ev));
2503 } else if ((strcasecmp(property, "Volume") == 0)) {
2504 struct hal_ev_avrcp_tg_volume_changed ev;
2507 memset(&ev, 0, sizeof(ev));
2508 _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
2510 val = g_variant_get_uint16(value);
2511 DBG("Value : %d", val);
2514 /* Send event to application */
2515 avrcp_tg_event_cb(HAL_EV_AVRCP_TG_VOLUME_CHANGE, &ev, sizeof(ev));
2517 DBG("Property not handled");
2522 /* A2DP Src Role(Remote:Sink) Events */
2523 static void __bt_hal_send_av_connection_state_event(gboolean connected, const char *address)
2525 struct hal_ev_a2dp_conn_state ev;
2527 if (connected == TRUE)
2528 INFO("A2DP(Src) Profile Connected for address [%s]", address);
2530 INFO("A2DP(Src) Profile DisConnected for address [%s]", address);
2532 ev.state = (connected == TRUE) ?
2533 HAL_EV_A2DP_STATE_CONNECTED :
2534 HAL_EV_A2DP_STATE_DISCONNECTED;
2536 _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
2539 ERR("AV event handler not registered");
2541 av_event_cb(HAL_EV_A2DP_CONN_STATE, &ev, sizeof(ev));
2544 /* A2DP Sink Role(Remote:Source) Events */
2545 static void __bt_hal_send_a2dp_sink_connection_state_event(gboolean connected, const char *address)
2547 struct hal_ev_a2dp_conn_state ev;
2549 if (connected == TRUE)
2550 INFO("A2DP(Sink) Profile Connected for address [%s]", address);
2552 INFO("A2DP(Sink) Profile DisConnected for address [%s]", address);
2554 ev.state = (connected == TRUE) ?
2555 HAL_EV_A2DP_STATE_CONNECTED :
2556 HAL_EV_A2DP_STATE_DISCONNECTED;
2558 _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
2560 if (!a2dp_sink_event_cb)
2561 ERR("AV event handler not registered");
2563 a2dp_sink_event_cb(HAL_EV_A2DP_SOURCE_CONN_STATE, &ev, sizeof(ev));
2566 /* HF(AG Role) Audio Events */
2567 static void __bt_hal_send_hf_audio_connection_state_event(gboolean connected,
2568 const char *address)
2570 struct hal_ev_handsfree_audio_state ev;
2572 if (connected == TRUE)
2573 INFO("AG Audio Connected for address [%s]", address);
2575 INFO("AG Audio DisConnected for address [%s]", address);
2577 ev.state = (connected == TRUE) ?
2578 HAL_EV_HANDSFREE_AUDIO_STATE_CONNECTED :
2579 HAL_EV_HANDSFREE_AUDIO_STATE_DISCONNECTED;
2581 _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
2584 ERR("HF event handler not registered");
2586 hf_event_cb(HAL_EV_HANDSFREE_AUDIO_STATE, &ev, sizeof(ev));
2589 /* HF(AG Role) Profile Events */
2590 static void __bt_hal_send_hf_connection_state_event(gboolean connected,
2591 const char *address)
2593 struct hal_ev_handsfree_conn_state ev;
2595 if (connected == TRUE)
2596 INFO("AG Profile Connected for address [%s]", address);
2598 INFO("AG Profile DisConnected for address [%s]", address);
2600 ev.state = (connected == TRUE) ?
2601 HAL_EV_HANDSFREE_CONN_STATE_CONNECTED :
2602 HAL_EV_HANDSFREE_CONN_STATE_DISCONNECTED;
2604 _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
2607 ERR("HF event handler not registered");
2609 hf_event_cb(HAL_EV_HANDSFREE_CONN_STATE, &ev, sizeof(ev));
2612 /* HF(Client Role) Profile Events */
2613 static void __bt_hal_send_hf_client_connection_state_event(gboolean connected,
2614 const char *address)
2616 struct hal_ev_hf_client_conn_state ev;
2618 if (connected == TRUE)
2619 INFO("HF Client Profile Connected for address [%s]", address);
2621 INFO("HF Client Profile DisConnected for address [%s]", address);
2623 ev.state = (connected == TRUE) ?
2624 HAL_EV_HF_CLIENT_CONN_STATE_CONNECTED :
2625 HAL_EV_HF_CLIENT_CONN_STATE_DISCONNECTED;
2627 _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
2629 if (!hf_client_event_cb)
2630 ERR("HF Client event handler not registered");
2632 hf_client_event_cb(HAL_EV_HF_CLIENT_CONN_STATE, &ev, sizeof(ev));
2635 void _bt_hal_register_event_handler_cb(bt_hal_module_e module, handle_stack_msg cb)
2642 hid_device_event_cb = cb;
2648 a2dp_sink_event_cb = cb;
2654 hf_client_event_cb = cb;
2657 avrcp_tg_event_cb = cb;
2659 case HAL_AVRCP_CTRL:
2660 avrcp_ctrl_event_cb = cb;
2666 ERR("Unknown module: %d", module);
2670 void _bt_hal_unregister_event_handler_cb(bt_hal_module_e module)
2674 hid_event_cb = NULL;
2680 a2dp_sink_event_cb = NULL;
2686 hf_client_event_cb = NULL;
2689 avrcp_tg_event_cb = NULL;
2691 case HAL_AVRCP_CTRL:
2692 avrcp_ctrl_event_cb = NULL;
2695 gatt_event_cb = NULL;
2698 ERR("Unknown module: %d", module);
2702 bool _bt_hal_get_adapter_request_state(void)
2704 return is_adapter_activating;
2707 bool _bt_hal_get_le_request_state(void)
2709 return is_le_activating;
2712 void _bt_hal_set_adapter_request_state(bool enable)
2714 DBG("set_adapter_request_state %d", enable);
2715 is_adapter_activating = enable;
2718 void _bt_hal_set_le_request_state(bool enable)
2720 DBG("set_le_request_state %d", enable);
2721 is_le_activating = enable;