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"
43 #define BASELEN_PROP_CHANGED (sizeof(struct hal_ev_adapter_props_changed) \
44 + sizeof(struct hal_property))
46 /*TODO: Basic filters are currently added,
47 Need to add different event filters like HID,
48 Device etc in subsequent patches */
50 /* Global variables and structures */
51 static GDBusConnection *manager_conn;
52 static handle_stack_msg event_cb = NULL;
53 static handle_stack_msg hid_event_cb = NULL;
54 static handle_stack_msg av_event_cb = NULL;
55 static handle_stack_msg a2dp_sink_event_cb = NULL;
56 static handle_stack_msg hf_event_cb = NULL;
57 static handle_stack_msg avrcp_ctrl_event_cb = NULL;
58 static handle_stack_msg avrcp_tg_event_cb = NULL;
59 static handle_stack_msg gatt_event_cb = NULL;
60 static guint event_id;
62 /*State Management sepration Control for Adapter and LE */
63 static gboolean is_adapter_activating = FALSE;
64 static gboolean is_le_activating = FALSE;
69 gchar* interface_name;
72 } bt_hal_main_event_data_t;
74 /* Forward declarations */
75 static gboolean __bt_hal_event_manager(gpointer param);
76 static int __bt_hal_register_service_event(GDBusConnection *g_conn, int event_type);
77 static int __bt_hal_register_manager_subscribe_signal(GDBusConnection *conn, int subscribe);
78 static int __bt_hal_register_device_subscribe_signal(GDBusConnection *conn, int subscribe);
79 static int __bt_hal_register_input_subscribe_signal(GDBusConnection *conn, int subscribe);
81 static int __bt_hal_parse_event(GVariant *msg);
82 static int __bt_hal_get_owner_info(GVariant *msg, char **name, char **previous, char **current);
84 static void __bt_hal_handle_property_changed_event(GVariant *msg, const char *object_path);
85 static void __bt_hal_adapter_property_changed_event(GVariant *msg);
86 static void __bt_hal_manager_event_filter(GDBusConnection *connection, const gchar *sender_name,
87 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
88 GVariant *parameters, gpointer user_data);
89 static int __bt_hal_initialize_manager_receiver(void);
90 static gboolean __bt_hal_parse_interface(GVariant *msg);
91 static void __bt_hal_handle_device_event(GVariant *value, GVariant *parameters);
92 static gboolean __bt_hal_parse_device_properties(GVariant *item);
93 static gboolean __bt_hal_discovery_finished_cb(gpointer user_data);
94 static void __bt_hal_device_property_changed_event(GVariant *msg, const char *path);
95 static void __bt_hal_dbus_device_found_properties(const char *device_path);
96 static void __bt_hal_device_properties_lookup(GVariant *result, char *address);
97 static void __bt_hal_handle_device_specific_events(GVariant *msg, const char *member, const char *path);
98 static void __bt_hal_send_device_acl_connection_state_event(gboolean connected, const char *address);
99 static void __bt_hal_handle_input_event(GVariant *msg, const char *path);
100 static void __bt_hal_send_av_connection_state_event(gboolean connected, const char *address);
101 static void __bt_hal_send_a2dp_sink_connection_state_event(gboolean connected, const char *address);
102 static void __bt_hal_send_avrcp_ctrl_connection_state_event(gboolean connected, const char *address);
103 static void __bt_hal_handle_avrcp_ctrl_events(GVariant *msg, const char *member, const char *path);
104 static void __bt_hal_handle_avrcp_transport_events(GVariant *msg, const char *member, const char *path);
106 static void __bt_hal_send_device_trust_state_event(gboolean is_trusted, const char *address);
107 static int __bt_hal_register_audio_subscribe_signal(GDBusConnection *conn, int subscribe);
108 static void __bt_hal_handle_headset_events(GVariant *msg, const char *member, const char *path);
109 static void __bt_hal_send_hf_audio_connection_state_event(gboolean connected, const char *address);
110 static void __bt_hal_send_hf_connection_state_event(gboolean connected, const char *address);
111 static void __bt_hal_send_device_trusted_profile_changed_event(uint32_t trust_val, const char *address);
112 static void __bt_hal_handle_adv_report(GVariant *msg, const char *path);
114 static gboolean __bt_hal_discovery_finished_cb(gpointer user_data)
118 struct hal_ev_discovery_state_changed ev;
119 ev.state = HAL_DISCOVERY_STATE_STOPPED;
120 event_cb(HAL_EV_DISCOVERY_STATE_CHANGED, &ev, sizeof(ev));
126 static int __bt_hal_parse_event(GVariant *msg)
130 char *interface_name = NULL;
131 GVariant *inner_iter = NULL;
133 g_variant_iter_init(&iter, msg);
135 while ((child = g_variant_iter_next_value(&iter))) {
136 g_variant_get(child, "{&s@a{sv}}", &interface_name, &inner_iter);
137 if (g_strcmp0(interface_name,
138 BT_HAL_DEVICE_INTERFACE) == 0) {
139 DBG("__bt_hal_parse_event: Interface: BT_HAL_DEVICE_INTERFACE");
140 g_variant_unref(inner_iter);
141 g_variant_unref(child);
142 return BT_HAL_DEVICE_EVENT;
143 } else if (g_strcmp0(interface_name,
144 BT_HAL_MEDIATRANSPORT_INTERFACE) == 0) {
145 DBG("__bt_hal_parse_event: Interface: BT_HAL_MEDIATRANSPORT_INTERFACE");
146 g_variant_unref(inner_iter);
147 g_variant_unref(child);
148 return BT_HAL_MEDIA_TRANSFER_EVENT;
149 } else if (g_strcmp0(interface_name,
150 BT_HAL_PLAYER_CONTROL_INTERFACE) == 0) {
151 DBG("__bt_hal_parse_event: Interface: BT_HAL_PLAYER_CONTROL_INTERFACE");
152 g_variant_unref(inner_iter);
153 g_variant_unref(child);
154 return BT_HAL_AVRCP_CONTROL_EVENT;
156 g_variant_unref(inner_iter);
157 g_variant_unref(child);
163 static int __bt_hal_get_owner_info(GVariant *msg, char **name, char **previous, char **current)
165 g_variant_get(msg, "(sss)", name, previous, current);
166 return BT_HAL_ERROR_NONE;
169 int __bt_insert_hal_properties(void *buf, uint8_t type, uint16_t len, const void *val)
170 { struct hal_property *prop = buf;
176 memcpy(prop->val, val, len);
178 return sizeof(*prop) + len;
181 handle_stack_msg _bt_hal_get_stack_message_handler(void)
186 static void __bt_hal_adapter_property_changed_event(GVariant *msg)
188 GVariantIter value_iter;
189 GVariant *value = NULL;
190 GDBusProxy *adapter_proxy;
193 g_variant_iter_init(&value_iter, msg);
195 /* Buffer and propety count management */
196 uint8_t buf[BT_HAL_MAX_PROPERTY_BUF_SIZE];
197 struct hal_ev_adapter_props_changed *ev = (void*) buf;
199 const gchar *address = NULL;
201 unsigned int cod = 0;
202 gboolean discoverable;
203 gboolean connectable;
204 unsigned int scan_mode = BT_SCAN_MODE_NONE;
205 unsigned int disc_timeout;
206 const gchar *version;
207 gboolean ipsp_initialized;
210 unsigned int pairable_timeout;
211 gboolean scan_mode_property_update = FALSE;
212 gboolean is_discovering;
213 gboolean is_le_discovering;
215 memset(buf, 0, sizeof(buf));
218 ev->status = BT_STATUS_SUCCESS;
222 while (g_variant_iter_loop(&value_iter, "{sv}", &key, &value)) {
223 if (!g_strcmp0(key, "Address")) {
226 address = g_variant_get_string(value, NULL);
227 DBG("##Address [%s]", address);
228 _bt_hal_convert_addr_string_to_type(bdaddr, address);
229 size += __bt_insert_hal_properties(buf + size,
230 HAL_PROP_ADAPTER_ADDR, sizeof(bdaddr), bdaddr);
232 } else if (!g_strcmp0(key, "Alias")) {
233 g_variant_get(value, "&s", &name);
234 DBG("##Alias [%s] ", name);
235 size += __bt_insert_hal_properties(buf + size,
236 HAL_PROP_ADAPTER_NAME, strlen(name) + 1, name);
238 } else if (!g_strcmp0(key, "Class")) {
239 cod = g_variant_get_uint32(value);
240 DBG("##Class [%d]", cod);
241 size += __bt_insert_hal_properties(buf + size,
242 HAL_PROP_ADAPTER_CLASS, sizeof(unsigned int), &cod);
244 } else if (!g_strcmp0(key, "Discoverable")) {
245 discoverable = g_variant_get_boolean(value);
246 DBG("##Discoverable [%d]", discoverable);
248 scan_mode = BT_SCAN_MODE_CONNECTABLE_DISCOVERABLE;
250 scan_mode = BT_SCAN_MODE_CONNECTABLE;
251 scan_mode_property_update = TRUE;
252 } else if (!g_strcmp0(key, "DiscoverableTimeout")) {
253 disc_timeout = g_variant_get_uint32(value);
254 DBG("##Discoverable Timeout [%d]", disc_timeout);
255 size += __bt_insert_hal_properties(buf + size,
256 HAL_PROP_ADAPTER_DISC_TIMEOUT, sizeof(unsigned int), &disc_timeout);
258 } else if (!g_strcmp0(key, "Connectable")) {
259 connectable = g_variant_get_boolean(value);
260 DBG("##Connectable [%d]", connectable);
262 scan_mode = BT_SCAN_MODE_NONE;
263 else if (scan_mode == BT_SCAN_MODE_NONE)
264 scan_mode = BT_SCAN_MODE_CONNECTABLE;
265 scan_mode_property_update = TRUE;
266 } else if (!g_strcmp0(key, "Version")) {
267 version = g_variant_get_string(value, NULL);
268 DBG("##Version [%s]", version);
269 size += __bt_insert_hal_properties(buf + size,
270 HAL_PROP_ADAPTER_VERSION, strlen(version) + 1, version);
272 } else if (!g_strcmp0(key, "Name")) {
273 g_variant_get(value, "&s", &name);
274 DBG("##Name [%s]", name);
275 size += __bt_insert_hal_properties(buf + size,
276 HAL_PROP_ADAPTER_NAME, strlen(name) + 1, name);
278 } else if (!g_strcmp0(key, "Powered")) {
279 powered = g_variant_get_boolean(value);
280 DBG("##Powered = %d", powered);
281 /* TODO: Need to check this operation!! */
282 if (powered == FALSE) {
283 DBG("###### Adapter Powered Down ######");
284 struct hal_ev_adapter_state_changed ev;
285 ev.state = HAL_POWER_OFF;
286 event_cb(HAL_EV_ADAPTER_STATE_CHANGED, &ev, sizeof(ev));
288 struct hal_ev_le_state_changed le_ev;
289 le_ev.state = HAL_POWER_OFF;
290 event_cb(HAL_EV_LE_STATE_CHANGED, &le_ev, sizeof(le_ev));
293 _bt_hal_destroy_adapter_agent();
295 DBG("###### Adapter Powered Up ######");
296 if (_bt_hal_get_adapter_request_state()) {
297 DBG("Sending STATE CHANGE EVENT for Adapter... ");
298 _bt_hal_set_adapter_request_state(FALSE);
299 struct hal_ev_adapter_state_changed ev;
300 ev.state = HAL_POWER_ON;
301 event_cb(HAL_EV_ADAPTER_STATE_CHANGED, &ev, sizeof(ev));
304 if (_bt_hal_get_le_request_state()) {
305 DBG("Sending STATE CHANGE EVENT for LE... ");
306 _bt_hal_set_le_request_state(FALSE);
307 struct hal_ev_le_state_changed ev;
308 ev.state = HAL_POWER_ON;
309 event_cb(HAL_EV_LE_STATE_CHANGED, &ev, sizeof(ev));
313 _bt_hal_initialize_adapter_agent();
316 } else if (!g_strcmp0(key, "Pairable")) {
317 pairable = g_variant_get_boolean(value);
318 DBG("##Pairable [%d]", pairable);
319 } else if (!g_strcmp0(key, "PairableTimeout")) {
320 pairable_timeout = g_variant_get_uint32(value);
321 DBG("##Pairable Timeout = %d", pairable_timeout);
322 } else if (!g_strcmp0(key, "UUIDs")) {
327 size1 = g_variant_get_size(value);
328 int num_props_tmp = ev->num_props;
330 uuid_value = (char **)g_variant_get_strv(value, &size1);
331 for (i = 0; uuid_value[i] != NULL; i++)
333 /* UUID collection */
334 uint8_t uuids[BT_HAL_STACK_UUID_SIZE * uuid_count];
335 for (i = 0; uuid_value[i] != NULL; i++) {
336 char *uuid_str = NULL;
337 uint8_t uuid[BT_HAL_STACK_UUID_SIZE];
338 uuid_str = g_strdup(uuid_value[i]);
339 DBG("##UUID string [%s]\n", uuid_str);
340 _bt_hal_convert_uuid_string_to_type(uuid, uuid_str);
341 memcpy(uuids+i*BT_HAL_STACK_UUID_SIZE, uuid, BT_HAL_STACK_UUID_SIZE);
344 size += __bt_insert_hal_properties(buf + size, HAL_PROP_ADAPTER_UUIDS,
345 (BT_HAL_STACK_UUID_SIZE * uuid_count),
347 ev->num_props = num_props_tmp + 1;
350 } else if (!g_strcmp0(key, "Discovering")) {
351 is_discovering = g_variant_get_boolean(value);
352 DBG("##Discovering = [%d]", is_discovering);
354 if (is_discovering == FALSE) {
355 DBG("###### Adapter Has stopped Discovering ######");
356 /* In Tizen Bluez, this actually does not mean Discovery is stopped
357 in Bluez. Tizen Bluez sends this event after a certain timeout,
358 Therefore, we must forecefully call StopDiscovery to stop discovery in BlueZ */
362 adapter_proxy = _bt_hal_get_adapter_proxy();
364 if (adapter_proxy == NULL)
367 /* Need to stop searching */
368 DBG("Event though Bluez reported DIscovering stopped, we force stop Discovery ");
369 g_dbus_proxy_call_sync(adapter_proxy, "StopDiscovery",
371 G_DBUS_CALL_FLAGS_NONE,
375 ERR("Dbus Error : %s", err->message);
377 /* This error is thrown by Bluez, as Discovery is already stopped.
378 Discovery is stopped if user cancels on going discovery.
379 In order to maintain correct state of Bluetooth Discovery state,
380 simply send Discovery stopped event to HAL user */
381 struct hal_ev_discovery_state_changed ev;
382 ev.state = HAL_DISCOVERY_STATE_STOPPED;
383 event_cb(HAL_EV_DISCOVERY_STATE_CHANGED, &ev, sizeof(ev));
388 event_id = g_timeout_add(BT_HAL_DISCOVERY_FINISHED_DELAY,
389 (GSourceFunc)__bt_hal_discovery_finished_cb, NULL);
393 DBG("###### Adapter Has started Discovering ######");
394 struct hal_ev_discovery_state_changed ev;
395 ev.state = HAL_DISCOVERY_STATE_STARTED;
396 event_cb(HAL_EV_DISCOVERY_STATE_CHANGED, &ev, sizeof(ev));
399 } else if (!g_strcmp0(key, "LEDiscovering")) {
402 is_le_discovering = g_variant_get_boolean(value);
403 DBG("##LE Discovering = [%d]", is_le_discovering);
405 if (is_le_discovering)
408 adapter_proxy = _bt_hal_get_adapter_proxy();
409 if (adapter_proxy == NULL) {
410 ERR("adapter_proxy == NULL");
414 /* Need to stop searching */
415 result = g_dbus_proxy_call_sync(adapter_proxy, "StopLEDiscovery",
416 NULL, G_DBUS_CALL_FLAGS_NONE,
417 DBUS_TIMEOUT, NULL, &err);
419 ERR("Error occured in Proxy call");
421 ERR("(Error: %s)", err->message);
426 g_variant_unref(result);
427 } else if (!g_strcmp0(key, "Modalias")) {
428 char *modalias = NULL;
429 g_variant_get(value, "s", &modalias);
430 DBG("##Adapter ModAlias [%s]", modalias);
431 } else if (!g_strcmp0(key, "SupportedLEFeatures")) {
432 DBG("##LE Supported features");
435 GVariantIter *iter = NULL;
436 g_variant_get(value, "as", &iter);
441 while (g_variant_iter_next(iter, "&s", &name) &&
442 g_variant_iter_next(iter, "&s", &val)) {
443 DBG("name = %s, Value = %s", name, val);
444 if (FALSE == _bt_hal_update_le_feature_support(name, val))
445 ERR("Failed to update LE feature (name = %s, value = %s)", name, val);
448 g_variant_iter_free(iter);
449 } else if (!g_strcmp0(key, "IpspInitStateChanged")) {
450 g_variant_get(value, "b" , &ipsp_initialized);
451 DBG("##IPSP Initialized = %d", ipsp_initialized);
453 ERR("Unhandled Property:[%s]", key);
457 if (scan_mode_property_update) {
458 size += __bt_insert_hal_properties(buf + size,
459 HAL_PROP_ADAPTER_SCAN_MODE, sizeof(int), &scan_mode);
465 DBG("Send Adapter properties changed event to HAL user, Num Prop [%d] total size [%d]", ev->num_props, size);
466 event_cb(HAL_EV_ADAPTER_PROPS_CHANGED, buf, size);
472 void _bt_hal_handle_adapter_event(GVariant *msg, const char *member)
479 if (strcasecmp(member, "DeviceCreated") == 0) {
480 DBG("DeviceCreated: Unhandled");
481 } else if (strcasecmp(member, "InterfacesRemoved") == 0) {
482 DBG("InterfacesRemoved: Unhandled");
483 } else if (strcasecmp(member, "AdvertisingEnabled") == 0) {
484 DBG("AdvertisingEnabled");
485 DBG("Advertising Enabled");
487 gboolean status = FALSE;
488 g_variant_get(msg, "(ib)", &slot_id, &status);
489 DBG("Advertising Enabled : slot_id [%d] status [%d]", slot_id, status);
490 /* Send event to application */
491 _bt_hal_set_advertising_status(slot_id, status);
492 } else if (strcasecmp(member, "RssiEnabled") == 0) {
493 struct hal_ev_rssi_monitor_state_changed ev;
494 gboolean status = FALSE;
495 char *address = NULL;
498 g_variant_get(msg, "(sib)", &address, &link_type, &status);
499 DBG("RSSI monitoring %s for %s",
500 (status ? "Enabled" : "Disabled"), address);
502 _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
503 ev.link_type = link_type;
504 ev.state = (status ? HAL_RSSI_MONITORING_ENABLED : HAL_RSSI_MONITORING_DISABLED);
506 ERR("event_cb is NULL");
508 event_cb(HAL_EV_RSSI_MONITOR_STATE_CHANGED, &ev, sizeof(ev));
511 } else if (strcasecmp(member, "RssiAlert") == 0) {
512 struct hal_ev_rssi_alert_recieved ev;
516 char *address = NULL;
518 g_variant_get(msg, "(siii)", &address, &link_type, &alert_type, &rssi_dbm);
519 DBG("RSSI Alert: [Address %s LinkType %d] [Type %d DBM %d]",
520 address, alert_type, rssi_dbm);
522 _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
523 ev.link_type = link_type;
524 ev.alert_type = alert_type;
528 ERR("event_cb is NULL");
530 event_cb(HAL_EV_RSSI_ALERT_RECIEVED, &ev, sizeof(ev));
533 } else if (strcasecmp(member, "RawRssi") == 0) {
534 struct hal_ev_raw_rssi_recieved ev;
537 char *address = NULL;
539 g_variant_get(msg, "(sii)", &address, &link_type, &rssi_dbm);
540 DBG("Raw RSSI: [Address %s] [Link Type %d][RSSI DBM %d]",
541 address, link_type, rssi_dbm);
543 _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
544 ev.link_type = link_type;
548 ERR("event_cb is NULL");
550 event_cb(HAL_EV_RAW_RSSI_RECIEVED, &ev, sizeof(ev));
553 } else if (strcasecmp(member, BT_HAL_HARDWARE_ERROR) == 0) {
554 DBG("BT Hardware Error: Unhandled");
555 } else if (strcasecmp(member, BT_HAL_TX_TIMEOUT_ERROR) == 0) {
556 DBG("BT TX Timeout Error: Unhandled");
562 static gboolean __bt_hal_parse_device_properties(GVariant *item)
572 /* Buffer and propety count management */
573 uint8_t buf[BT_HAL_MAX_PROPERTY_BUF_SIZE];
574 struct hal_ev_device_found *ev = (void *) buf;
576 memset(buf, 0, sizeof(buf));
580 g_variant_iter_init(&iter, item);
581 while (g_variant_iter_loop(&iter, "{sv}", &key, &val)) {
583 if (strcasecmp(key, "Address") == 0) {
585 char * address = NULL;
586 address = g_variant_dup_string(val, &len);
588 _bt_hal_convert_addr_string_to_type(bdaddr, address);
590 size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_ADDR,
591 sizeof(bdaddr), bdaddr);
594 DBG("Device address [%s] property Num [%d]", address, ev->num_props);
596 } else if (strcasecmp(key, "Class") == 0) {
597 unsigned int class = g_variant_get_uint32(val);
598 size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_CLASS,
599 sizeof(unsigned int), &class);
601 DBG("Device class [%d] Property num [%d]", class, ev->num_props);
602 } else if (strcasecmp(key, "name") == 0) {
603 char *name = g_variant_dup_string(val, &len);
605 size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_NAME,
606 strlen(name) + 1, name);
608 DBG("Device Name [%s] Property num [%d]", name, ev->num_props);
610 } else if (strcasecmp(key, "Connected") == 0) {
611 unsigned int connected = g_variant_get_byte(val);
613 size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_CONNECTED,
614 sizeof(unsigned int), &connected);
616 DBG("Device connected [%u] Property num [%d]", connected, ev->num_props);
617 } else if (strcasecmp(key, "paired") == 0) {
618 uint8_t paired = (g_variant_get_boolean(val) ? 1 : 0);
619 size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_PAIRED,
620 sizeof(uint8_t), &paired);
622 DBG("Device Paired [%d] Property num [%d]", paired, ev->num_props);
623 } else if (strcasecmp(key, "Trusted") == 0) {
624 uint8_t trust = (g_variant_get_boolean(val) ? 1 : 0);
625 size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_TRUSTED,
626 sizeof(uint8_t), &trust);
628 DBG("Device trusted [%d] Property num [%d]", trust, ev->num_props);
629 } else if (strcasecmp(key, "RSSI") == 0) {
630 int rssi = g_variant_get_int16(val);
631 size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_RSSI,
634 DBG("Device RSSI [%d] Property num [%d]", rssi, ev->num_props);
635 } else if (strcasecmp(key, "LastAddrType") == 0) {
636 /* TODO: To be handled later*/
637 } else if (!g_strcmp0(key, "IsAliasSet")) {
638 uint8_t is_alias_set = (g_variant_get_boolean(val) ? 1 : 0);
639 DBG("IsAliasSet: %s", (is_alias_set ? "TRUE" : "FALSE"));
640 size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_IS_ALIAS_SET,
641 sizeof(uint8_t), &is_alias_set);
643 } else if (strcasecmp(key, "UUIDs") == 0) {
648 size1 = g_variant_get_size(val);
649 DBG("UUID count from size [%d]\n", size1);
650 int num_props_tmp = ev->num_props;
653 uuid_value = (char **)g_variant_get_strv(val, &size1);
654 for (i = 0; uuid_value[i] != NULL; i++)
656 DBG("UUID count [%d]\n", uuid_count);
657 /* UUID collection */
658 uint8_t uuids[BT_HAL_STACK_UUID_SIZE * uuid_count];
660 for (i = 0; uuid_value[i] != NULL; i++) {
662 char *uuid_str = NULL;
663 uint8_t uuid[BT_HAL_STACK_UUID_SIZE];
664 memset(uuid, 0x00, BT_HAL_STACK_UUID_SIZE);
666 DBG("UUID string from Bluez [%s]\n", uuid_value[i]);
667 uuid_str = g_strdup(uuid_value[i]);
668 DBG("UUID string [%s]\n", uuid_str);
669 _bt_hal_convert_uuid_string_to_type(uuid, uuid_str);
670 memcpy(uuids+i*BT_HAL_STACK_UUID_SIZE, uuid, BT_HAL_STACK_UUID_SIZE);
674 size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_UUIDS,
675 (BT_HAL_STACK_UUID_SIZE * uuid_count),
677 ev->num_props = num_props_tmp + 1;
681 } else if (strcasecmp(key, "LegacyManufacturerDataLen") == 0) {
682 /* TODO: To be handled later*/
683 } else if (strcasecmp(key, "LegacyManufacturerData") == 0) {
684 /* TODO: To be handled later*/
686 ERR("Unhandled Property:[%s]", key);
692 DBG("Send Device found event to HAL user, Num Prop [%d] total size [%d]", ev->num_props, size);
693 event_cb(HAL_EV_DEVICE_FOUND, (void*) buf, size);
699 static void __bt_hal_handle_avrcp_tg_events(GVariant *msg, const char *path)
702 GVariantIter value_iter;
703 char *property = NULL;
705 GVariant *val = NULL;
706 GVariant *child = NULL;
708 g_variant_iter_init(&value_iter, msg);
709 while ((child = g_variant_iter_next_value(&value_iter))) {
710 g_variant_get(child, "{sv}", &property, &val);
711 INFO("Property %s", property);
712 if (strcasecmp(property, "Connected") == 0) {
713 struct hal_ev_avrcp_tg_conn_state ev;
715 gboolean connected = FALSE;
717 g_variant_get(val, "b", &connected);
719 state = connected ? HAL_AVRCP_TG_STATE_CONNECTED :
720 HAL_AVRCP_TG_STATE_DISCONNECTED;
722 address = g_malloc0(BT_HAL_ADDRESS_STRING_SIZE);
724 _bt_hal_convert_device_path_to_address(path, address);
726 DBG("connected: %d", connected);
727 DBG("address: %s", address);
729 /* Prepare to send AVRCP Target connection state event */
730 memset(&ev, 0, sizeof(ev));
731 _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
733 if (!avrcp_tg_event_cb)
734 ERR("AVRCP target DBUS handler callback not registered");
736 avrcp_tg_event_cb(HAL_EV_AVRCP_TG_CONN_STATE, (void *)&ev, sizeof(ev));
740 g_variant_unref(child);
741 g_variant_unref(val);
747 static void __bt_hal_handle_property_changed_event(GVariant *msg, const char *object_path)
749 char *interface_name = NULL;
750 GVariant *val = NULL;
753 g_variant_get(msg, "(&s@a{sv}@as)", &interface_name, &val, NULL);
755 if (!interface_name) {
756 DBG("Failed to get interface name");
759 g_variant_unref(val);
763 if (strcasecmp(interface_name, BT_HAL_ADAPTER_INTERFACE) == 0) {
764 DBG("Event: Property Changed: Interface: BT_HAL_ADAPTER_INTERFACE");
765 __bt_hal_adapter_property_changed_event(val);
766 } else if (strcasecmp(interface_name, BT_HAL_DEVICE_INTERFACE) == 0) {
767 DBG("Event: Property Changed: Interface: BT_HAL_DEVICE_INTERFACE");
768 __bt_hal_device_property_changed_event(val, object_path);
769 } else if (strcasecmp(interface_name, BT_HAL_OBEX_TRANSFER_INTERFACE) == 0) {
770 DBG("Event: Property Changed: Interface: BT_HAL_OBEX_TRANSFER_INTERFACE");
771 /* TODO: Handle event */
772 } else if (strcasecmp(interface_name, BT_HAL_MEDIA_CONTROL_INTERFACE) == 0) {
773 DBG("Event: Property Changed: Interface: BT_HAL_MEDIA_CONTROL_INTERFACE");
774 /* Handle AVRCP target event */
775 __bt_hal_handle_avrcp_tg_events(val, object_path);
776 } else if (strcasecmp(interface_name, BT_HAL_PLAYER_CONTROL_INTERFACE) == 0) {
777 DBG("Event: Property Changed: Interface: BT_HAL_PLAYER_CONTROL_INTERFACE");
778 __bt_hal_handle_avrcp_ctrl_events(val, NULL, object_path);
779 } else if (strcasecmp(interface_name, BT_HAL_MEDIATRANSPORT_INTERFACE) == 0) {
780 DBG("Event: Property Changed: Interface: BT_HAL_MEDIATRANSPORT_INTERFACE");
781 __bt_hal_handle_avrcp_transport_events(val, NULL, object_path);
782 } else if (strcasecmp(interface_name, BT_HAL_NETWORK_CLIENT_INTERFACE) == 0) {
783 DBG("Event: Property Changed: Interface: BT_HAL_NETWORK_CLIENT_INTERFACE");
784 /* TODO: Handle event */
785 } else if (strcasecmp(interface_name, BT_HAL_GATT_CHAR_INTERFACE) == 0) {
786 DBG("Event: Property Changed: Interface: BT_HAL_GATT_CHAR_INTERFACE");
787 /* TODO: Handle event */
788 } else if (strcasecmp(interface_name, BT_HAL_INPUT_INTERFACE) == 0) {
789 DBG("Event: Property Changed: Interface: BT_HAL_INPUT_INTERFACE");
790 __bt_hal_handle_input_event(val, object_path);
792 g_variant_unref(val);
795 static void __bt_hal_handle_device_event(GVariant *value, GVariant *parameters)
799 if (__bt_hal_parse_interface(parameters) == FALSE) {
800 ERR("Fail to parse the properies");
801 g_variant_unref(value);
808 static void __bt_hal_send_hid_connection_state_event(
809 gboolean connected, char *address)
811 struct hal_ev_hidhost_conn_state ev;
813 ev.state = (connected == TRUE) ?
814 HAL_HIDHOST_STATE_CONNECTED :
815 HAL_HIDHOST_STATE_DISCONNECTED;
817 _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
820 ERR("HID event handler not registered");
822 hid_event_cb(HAL_EV_HIDHOST_CONN_STATE, &ev, sizeof(ev));
825 static void __bt_hal_handle_input_event(GVariant *msg, const char *path)
827 gboolean property_flag = FALSE;
828 GVariantIter value_iter;
829 char *property = NULL;
830 GVariant *child = NULL, *val = NULL;
833 g_variant_iter_init(&value_iter, msg);
834 while ((child = g_variant_iter_next_value(&value_iter))) {
835 g_variant_get(child, "{sv}", &property, &val);
837 if (property == NULL)
840 if (strcasecmp(property, "Connected") == 0) {
843 g_variant_get(val, "b", &property_flag);
844 address = g_malloc0(BT_HAL_ADDRESS_STRING_SIZE);
845 _bt_hal_convert_device_path_to_address(path, address);
846 __bt_hal_send_hid_connection_state_event(property_flag, address);
850 g_variant_unref(val);
851 g_variant_unref(child);
857 static gboolean __bt_hal_parse_interface(GVariant *msg)
860 GVariant *optional_param;
863 char *interface_name = NULL;
864 GVariant *inner_iter = NULL;
865 g_variant_get(msg, "(&o@a{sa{sv}})",
866 &path, &optional_param);
867 g_variant_iter_init(&iter, optional_param);
869 while ((child = g_variant_iter_next_value(&iter))) {
870 g_variant_get(child, "{&s@a{sv}}", &interface_name, &inner_iter);
871 if (g_strcmp0(interface_name, BT_HAL_DEVICE_INTERFACE) == 0) {
872 DBG("Found a device: %s", path);
873 if (__bt_hal_parse_device_properties(inner_iter) == FALSE) {
874 g_variant_unref(inner_iter);
875 g_variant_unref(child);
876 g_variant_unref(optional_param);
877 ERR("Fail to parse the properies");
880 g_variant_unref(inner_iter);
881 g_variant_unref(child);
882 g_variant_unref(optional_param);
886 g_variant_unref(inner_iter);
887 g_variant_unref(child);
890 g_variant_unref(optional_param);
895 static gboolean __bt_hal_event_manager(gpointer data)
897 bt_hal_event_type_t bt_event = 0x00;
899 char *obj_path = NULL;
901 bt_hal_main_event_data_t *param = (bt_hal_main_event_data_t*)data;
902 if (strcasecmp(param->signal_name, "InterfacesAdded") == 0) {
904 /*TODO: Handle Interfaces Added Signal from stack */
905 DBG("Manager Event: Signal Name: InterfacesAdded");
907 g_variant_get(param->parameters, "(&o@a{sa{sv}})", &obj_path, &value);
909 if (obj_path == NULL) {
910 DBG("obj_path is NULL");
914 if (strcasecmp(obj_path, BT_HAL_BLUEZ_HCI_PATH) == 0) {
915 /* TODO: Handle adapter added */
916 DBG("Manager Event: Signal Name: InterfiacesAdded: Adapter added in bluetoothd: path [hci0]");
918 bt_event = __bt_hal_parse_event(value);
919 if (bt_event == BT_HAL_DEVICE_EVENT) {
920 DBG("Device path : %s ", obj_path);
921 __bt_hal_handle_device_event(value, param->parameters);
922 } else if (bt_event == BT_HAL_AVRCP_CONTROL_EVENT) {
923 DBG("Device path : %s ", obj_path);
924 _bt_hal_set_control_device_path(obj_path);
927 g_variant_unref(value);
929 } else if (strcasecmp(param->signal_name, "InterfacesRemoved") == 0) {
933 /*TODO: Handle Interfaces Removed Signal from stack */
934 DBG("Manager Event: Signal Name: InterfacesRemoved");
936 g_variant_get(param->parameters, "(&oas)", &obj_path, &iter);
937 DBG("Device path : %s ", obj_path);
938 while (g_variant_iter_loop(iter, "s", &str)) {
939 if (g_strcmp0(str, BT_HAL_PLAYER_CONTROL_INTERFACE) == 0)
940 _bt_hal_remove_control_device_path(obj_path);
942 g_variant_iter_free(iter);
943 } else if (strcasecmp(param->signal_name, "NameOwnerChanged") == 0) {
945 char *previous = NULL;
946 char *current = NULL;
948 /* TODO: Handle Name Owener changed Signal */
949 if (__bt_hal_get_owner_info(param->parameters, &name, &previous, ¤t)) {
950 DBG("Fail to get the owner info");
953 if (current && *current != '\0') {
959 if (strcasecmp(name, BT_HAL_BLUEZ_NAME) == 0) {
960 DBG("Bluetoothd is terminated");
962 /* TODO: Handle Bluetoothd terminating scenario */
965 INFO("Name Owner changed [%s]", name);
970 } else if (g_strcmp0(param->interface_name, BT_HAL_PROPERTIES_INTERFACE) == 0) {
971 DBG("Manager Event: Interface Name: BT_HAL_PROPERTIES_INTERFACE");
972 __bt_hal_handle_property_changed_event(param->parameters, param->object_path);
973 } else if (g_strcmp0(param->interface_name, BT_HAL_ADAPTER_INTERFACE) == 0) {
974 DBG("Manager Event: Interface Name: BT_HAL_ADAPTER_INTERFACE");
975 _bt_hal_handle_adapter_event(param->parameters, param->signal_name);
976 } else if (g_strcmp0(param->interface_name, BT_HAL_INPUT_INTERFACE) == 0) {
977 DBG("Manager Event: Interface Name: BT_HAL_INPUT_INTERFACE");
978 __bt_hal_handle_input_event(param->parameters, param->object_path);
979 } else if (g_strcmp0(param->interface_name, BT_HAL_NETWORK_SERVER_INTERFACE) == 0) {
980 /* TODO: Handle Network Server events from stack */
981 DBG("Manager Event: Interface Name: BT_HAL_NETWORK_SERVER_INTERFACE");
982 } else if (g_strcmp0(param->interface_name, BT_HAL_HEADSET_INTERFACE) == 0) {
983 DBG("Manager Event: Interface Name: BT_HAL_HEADSET_INTERFACE");
984 __bt_hal_handle_headset_events(param->parameters, param->signal_name, param->object_path);
985 } else if (g_strcmp0(param->interface_name, BT_HAL_SINK_INTERFACE) == 0) {
986 /* TODO: Handle Sink interface events from stack */
987 DBG("Manager Event: Interface Name:BT_HAL_SINK_INTERFACE");
988 } else if (g_strcmp0(param->interface_name, BT_HAL_AGENT_INTERFACE) == 0) {
989 /* TODO: Handle Agent events from stack */
990 DBG("Manager Event: Interface Name:BT_HAL_AGENT_INTERFACE");
991 } else if (g_strcmp0(param->interface_name, BT_HAL_DEVICE_INTERFACE) == 0) {
992 DBG("Manager Event: Interface Name:BT_HAL_DEVICE_INTERFACE");
993 __bt_hal_handle_device_specific_events(param->parameters, param->signal_name, param->object_path);
994 } else if (g_strcmp0(param->interface_name, BT_HAL_PLAYER_CONTROL_INTERFACE) == 0) {
995 DBG("Manager Event: Interface Name: BT_HAL_PLAYER_CONTROL_INTERFACE");
996 __bt_hal_handle_avrcp_ctrl_events(param->parameters, param->signal_name, param->object_path);
997 } else if (g_strcmp0(param->interface_name, BT_HAL_MEDIATRANSPORT_INTERFACE) == 0) {
998 DBG("Manager Event: Interface Name: BT_HAL_MEDIATRANSPORT_INTERFACE");
999 __bt_hal_handle_avrcp_transport_events(param->parameters, param->signal_name, param->object_path);
1004 g_free(param->sender_name);
1005 g_free(param->object_path);
1006 g_free(param->interface_name);
1007 g_free(param->signal_name);
1008 g_variant_unref(param->parameters);
1013 static void __bt_hal_manager_event_filter(GDBusConnection *connection,
1014 const gchar *sender_name,
1015 const gchar *object_path,
1016 const gchar *interface_name,
1017 const gchar *signal_name,
1018 GVariant *parameters,
1021 if (signal_name == NULL)
1024 bt_hal_main_event_data_t *param = g_new0(bt_hal_main_event_data_t, 1);
1025 param->sender_name = g_strdup(sender_name);
1026 param->object_path = g_strdup(object_path);
1027 param->interface_name = g_strdup(interface_name);
1028 param->signal_name = g_strdup(signal_name);
1029 param->parameters = g_variant_ref(parameters);
1031 g_idle_add(__bt_hal_event_manager, (gpointer)param);
1035 static void __bt_hal_handle_headset_events(GVariant *msg, const char *member, const char *path)
1037 gboolean property_flag = FALSE;
1038 char *property = NULL;
1039 GVariant *value = NULL;
1040 g_variant_get(msg, "(sv)", &property, &value);
1042 if (property == NULL)
1045 DBG("Property = %s \n", property);
1046 /* We allow only 1 headset connection (HSP or HFP)*/
1047 if (strcasecmp(property, "Connected") == 0) {
1049 g_variant_get(value, "b", &property_flag);
1051 address = g_malloc0(BT_HAL_ADDRESS_STRING_SIZE);
1053 /* Fix : NULL_RETURNS */
1054 if (address == NULL)
1057 _bt_hal_convert_device_path_to_address(path, address);
1058 __bt_hal_send_hf_audio_connection_state_event(property_flag, address);
1060 } else if (strcasecmp(property, "State") == 0) {
1063 g_variant_get(value, "s", &state);
1065 /* This code assumes we support only 1 headset connection */
1066 /* Need to use the headset list, if we support multi-headsets */
1067 if (strcasecmp(state, "Playing") == 0) {
1068 DBG("Playing: Sco Connected");
1069 } else if (strcasecmp(state, "connected") == 0 ||
1070 strcasecmp(state, "disconnected") == 0) {
1071 if (strcasecmp(state, "connected") == 0)
1072 DBG("Sco Connected");
1074 DBG("Sco Disconnected");
1076 ERR("Not handled state - %s", state);
1081 } else if (strcasecmp(property, "SpeakerGain") == 0) {
1084 address = g_malloc0(BT_HAL_ADDRESS_STRING_SIZE);
1086 _bt_hal_convert_device_path_to_address(path, address);
1087 INFO("Speaker Gain for address [%s]", address);
1088 /* TODO Handle event sending to HAL */
1091 } else if (strcasecmp(property, "MicrophoneGain") == 0) {
1094 address = g_malloc0(BT_HAL_ADDRESS_STRING_SIZE);
1096 _bt_hal_convert_device_path_to_address(path, address);
1097 INFO("Microphone Gain for address [%s]", address);
1098 /* TODO Handle event sending to HAL */
1105 g_variant_unref(value);
1108 static int __bt_hal_register_manager_subscribe_signal(GDBusConnection *conn,
1114 static int subs_interface_added_id = -1;
1115 static int subs_interface_removed_id = -1;
1116 static int subs_name_owner_id = -1;
1117 static int subs_property_id = -1;
1118 static int subs_adapter_id = -1;
1123 if (subs_interface_added_id == -1) {
1124 subs_interface_added_id = g_dbus_connection_signal_subscribe(conn,
1125 NULL, BT_HAL_MANAGER_INTERFACE,
1126 BT_HAL_INTERFACES_ADDED, NULL, NULL, 0,
1127 __bt_hal_manager_event_filter,
1130 if (subs_interface_removed_id == -1) {
1131 subs_interface_removed_id = g_dbus_connection_signal_subscribe(conn,
1132 NULL, BT_HAL_MANAGER_INTERFACE,
1133 BT_HAL_INTERFACES_REMOVED, NULL, NULL, 0,
1134 __bt_hal_manager_event_filter,
1137 if (subs_name_owner_id == -1) {
1138 subs_name_owner_id = g_dbus_connection_signal_subscribe(conn,
1139 NULL, BT_HAL_FREEDESKTOP_INTERFACE,
1140 BT_HAL_NAME_OWNER_CHANGED, NULL, NULL, 0,
1141 __bt_hal_manager_event_filter,
1144 if (subs_property_id == -1) {
1145 subs_property_id = g_dbus_connection_signal_subscribe(conn,
1146 NULL, BT_HAL_PROPERTIES_INTERFACE,
1147 BT_HAL_PROPERTIES_CHANGED, NULL, NULL, 0,
1148 __bt_hal_manager_event_filter,
1151 if (subs_adapter_id == -1) {
1152 subs_adapter_id = g_dbus_connection_signal_subscribe(conn,
1153 NULL, BT_HAL_ADAPTER_INTERFACE,
1154 NULL, NULL, NULL, 0,
1155 __bt_hal_manager_event_filter,
1159 if (subs_interface_added_id != -1) {
1160 g_dbus_connection_signal_unsubscribe(conn,
1161 subs_interface_added_id);
1162 subs_interface_added_id = -1;
1164 if (subs_interface_removed_id != -1) {
1165 g_dbus_connection_signal_unsubscribe(conn,
1166 subs_interface_removed_id);
1167 subs_interface_removed_id = -1;
1169 if (subs_name_owner_id != -1) {
1170 g_dbus_connection_signal_unsubscribe(conn,
1171 subs_name_owner_id);
1172 subs_name_owner_id = -1;
1174 if (subs_property_id != -1) {
1175 g_dbus_connection_signal_unsubscribe(conn,
1177 subs_property_id = -1;
1179 if (subs_adapter_id == -1) {
1180 g_dbus_connection_signal_unsubscribe(conn, subs_adapter_id);
1181 subs_adapter_id = -1;
1189 static int __bt_hal_register_device_subscribe_signal(GDBusConnection *conn,
1192 static int subs_device_id = -1;
1199 if (subs_device_id == -1) {
1200 subs_device_id = g_dbus_connection_signal_subscribe(conn,
1201 NULL, BT_HAL_DEVICE_INTERFACE,
1202 NULL, NULL, NULL, 0,
1203 __bt_hal_manager_event_filter,
1207 if (subs_device_id != -1) {
1208 g_dbus_connection_signal_unsubscribe(conn,
1210 subs_device_id = -1;
1218 static int __bt_hal_register_input_subscribe_signal(GDBusConnection *conn, int subscribe)
1220 static int subs_input_id = -1;
1228 if (subs_input_id == -1) {
1229 subs_input_id = g_dbus_connection_signal_subscribe(conn,
1230 NULL, BT_HAL_INPUT_INTERFACE,
1231 NULL, NULL, NULL, 0,
1232 __bt_hal_manager_event_filter,
1236 if (subs_input_id != -1) {
1237 g_dbus_connection_signal_unsubscribe(conn,
1248 static int __bt_hal_register_service_event(GDBusConnection *g_conn, int event_type)
1253 return BT_HAL_ERROR_INTERNAL;
1255 /* TODO: Add more events in subsequent patches */
1256 switch (event_type) {
1257 case BT_HAL_MANAGER_EVENT:
1258 __bt_hal_register_manager_subscribe_signal(g_conn, TRUE);
1260 case BT_HAL_DEVICE_EVENT:
1261 __bt_hal_register_device_subscribe_signal(g_conn, TRUE);
1263 case BT_HAL_HID_EVENT:
1264 __bt_hal_register_input_subscribe_signal(g_conn, TRUE);
1266 case BT_HAL_HEADSET_EVENT:
1267 __bt_hal_register_audio_subscribe_signal(g_conn, TRUE);
1270 INFO_C("Register Event: event_type [%d]", event_type);
1271 return BT_HAL_ERROR_NOT_SUPPORT;
1274 return BT_HAL_ERROR_NONE;
1277 static int __bt_hal_register_audio_subscribe_signal(GDBusConnection *conn,
1283 static int subs_headset_id = -1;
1284 static int subs_sink_id = -1;
1287 if (subs_headset_id == -1) {
1288 subs_headset_id = g_dbus_connection_signal_subscribe(conn,
1289 NULL, BT_HAL_HEADSET_INTERFACE,
1290 NULL, NULL, NULL, 0,
1291 __bt_hal_manager_event_filter,
1294 if (subs_sink_id == -1) {
1295 subs_sink_id = g_dbus_connection_signal_subscribe(conn,
1296 NULL, BT_HAL_SINK_INTERFACE,
1297 NULL, NULL, NULL, 0,
1298 __bt_hal_manager_event_filter,
1302 if (subs_headset_id != -1) {
1303 g_dbus_connection_signal_unsubscribe(conn,
1305 subs_headset_id = -1;
1307 if (subs_sink_id != -1) {
1308 g_dbus_connection_signal_unsubscribe(conn,
1316 static int __bt_hal_initialize_manager_receiver(void)
1320 GError *error = NULL;
1322 if (manager_conn == NULL) {
1323 manager_conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
1324 if (error != NULL) {
1325 ERR_C("ERROR: Can't get on system bus [%s]", error->message);
1326 g_clear_error(&error);
1328 if (manager_conn == NULL)
1332 if (__bt_hal_register_service_event(manager_conn,
1333 BT_HAL_MANAGER_EVENT) != BT_HAL_ERROR_NONE)
1335 if (__bt_hal_register_service_event(manager_conn,
1336 BT_HAL_DEVICE_EVENT) != BT_HAL_ERROR_NONE)
1338 if (__bt_hal_register_service_event(manager_conn,
1339 BT_HAL_HID_EVENT) != BT_HAL_ERROR_NONE)
1341 if (__bt_hal_register_service_event(manager_conn,
1342 BT_HAL_HEADSET_EVENT) != BT_HAL_ERROR_NONE)
1344 return BT_HAL_ERROR_NONE;
1347 g_object_unref(manager_conn);
1348 manager_conn = NULL;
1353 return BT_HAL_ERROR_INTERNAL;
1356 /* To receive the event from bluez */
1357 int _bt_hal_initialize_event_receiver(handle_stack_msg cb)
1363 return BT_HAL_ERROR_INVALID_PARAM;
1365 result = __bt_hal_initialize_manager_receiver();
1367 DBG("Manager event receiver initialization result [%d]", result);
1368 if (result != BT_HAL_ERROR_NONE)
1371 /*TODO: Initialize Obexd Event receiver */
1376 return BT_HAL_ERROR_NONE;
1379 static void __bt_hal_device_property_changed_event(GVariant *msg, const char *path)
1381 GVariantIter value_iter;
1382 GVariant *value = NULL;
1384 g_variant_iter_init(&value_iter, msg);
1387 while (g_variant_iter_loop(&value_iter, "{sv}", &key, &value)) {
1388 if (!g_strcmp0(key, "Connected")) {
1389 guint connected = 0;
1390 g_variant_get(value, "i", &connected);
1391 DBG("Device property changed : Connected [%d]", connected);
1392 } else if (!g_strcmp0(key, "RSSI")) {
1393 DBG("Device property changed : RSSI");
1394 __bt_hal_dbus_device_found_properties(path);
1395 } else if (!g_strcmp0(key, "GattConnected")) {
1396 DBG("Device property changed : GattConnected");
1397 gboolean gatt_connected = FALSE;
1398 g_variant_get(value, "b", &gatt_connected);
1399 char *address = g_malloc0(BT_HAL_ADDRESS_STRING_SIZE);
1400 _bt_hal_convert_device_path_to_address(path, address);
1401 DBG("@@gatt_connected: %d", gatt_connected);
1402 DBG("@@address: %s", address);
1403 _bt_hal_gatt_connected_state_event(gatt_connected, address);
1404 _bt_hal_handle_gattc_connected_event(address, gatt_connected);
1406 } else if (!g_strcmp0(key, "Paired")) {
1407 gboolean paired = FALSE;
1408 struct hal_ev_bond_state_changed ev;
1409 char address[BT_HAL_ADDRESS_STRING_SIZE];
1411 g_variant_get(value, "b", &paired);
1412 DBG("Device property changed : Paired = %s", (paired ? "TRUE" : "FALSE"));
1414 _bt_hal_agent_set_canceled(FALSE);
1415 _bt_hal_convert_device_path_to_address(path, address);
1417 /* Prepare to send event to HAL bluetooth */
1418 ev.status = BT_STATUS_SUCCESS;
1419 ev.state = paired ? BT_BOND_STATE_BONDED : BT_BOND_STATE_NONE;
1420 _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
1423 ERR("Bluetooth HAL event handler not registered");
1425 DBG("Sending HAL_EV_BOND_STATE_CHANGED event");
1426 event_cb(HAL_EV_BOND_STATE_CHANGED, (void*)&ev, sizeof(ev));
1428 } else if (!g_strcmp0(key, "LegacyPaired")) {
1429 DBG("Device property changed : LegacyPaired");
1430 } else if (!g_strcmp0(key, "Trusted")) {
1431 DBG("Device property changed : Trusted");
1432 gboolean trusted = FALSE;
1433 gchar *address = NULL;
1434 g_variant_get(value, "b", &trusted);
1435 address = g_malloc0(BT_HAL_ADDRESS_STRING_SIZE);
1437 _bt_hal_convert_device_path_to_address(path, address);
1438 DBG("Device [%s] trusted: [%d]", address, trusted);
1440 __bt_hal_send_device_trust_state_event(trusted, address);
1442 } else if (!g_strcmp0(key, "IpspConnected")) {
1443 DBG("Device property changed : IpspConnected");
1444 } else if (!g_strcmp0(key, "IpspInitStateChanged")) {
1445 DBG("Device property changed : IpspInitStateChanged");
1446 } else if (!g_strcmp0(key, "TrustedProfiles")) {
1448 char address[BT_HAL_ADDRESS_STRING_SIZE];
1450 g_variant_get(value, "u", &trust_val);
1451 _bt_hal_convert_device_path_to_address(path, address);
1452 DBG("Address: %s, TrustedProfiles: 0x%X", address, trust_val);
1453 __bt_hal_send_device_trusted_profile_changed_event(trust_val, address);
1455 ERR("Unhandled Property:[%s]", key);
1461 static void __bt_hal_dbus_device_found_properties(const char *device_path)
1464 GError *error = NULL;
1465 GDBusProxy *device_proxy;
1466 GDBusConnection *conn;
1471 ERR("Invalid device path");
1475 conn = _bt_hal_get_system_gconn();
1477 ERR("_bt_hal_get_system_gconn failed");
1481 device_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
1485 BT_HAL_PROPERTIES_INTERFACE,
1488 if (!device_proxy) {
1489 ERR("Error creating device_proxy");
1493 result = g_dbus_proxy_call_sync(device_proxy,
1495 g_variant_new("(s)", BT_HAL_DEVICE_INTERFACE),
1496 G_DBUS_CALL_FLAGS_NONE,
1501 ERR("Error occured in Proxy call");
1502 if (error != NULL) {
1503 ERR("Error occured in Proxy call (Error: %s)", error->message);
1504 g_clear_error(&error);
1506 g_object_unref(device_proxy);
1510 address = g_malloc0(BT_HAL_ADDRESS_STRING_SIZE);
1511 _bt_hal_convert_device_path_to_address(device_path, address);
1513 __bt_hal_device_properties_lookup(result, address);
1515 g_object_unref(device_proxy);
1521 static void __bt_hal_device_properties_lookup(GVariant *result, char *address)
1523 /* Buffer and propety count management */
1524 uint8_t buf[BT_HAL_MAX_PROPERTY_BUF_SIZE];
1525 struct hal_ev_device_found *ev = (void *) buf;
1527 memset(buf, 0, sizeof(buf));
1531 GVariant *tmp_value;
1534 gchar *manufacturer_data = NULL;
1537 if (result != NULL) {
1538 g_variant_get(result , "(@a{sv})", &value);
1539 g_variant_unref(result);
1542 tmp_value = g_variant_lookup_value(value, "Alias", G_VARIANT_TYPE_STRING);
1544 g_variant_get(tmp_value, "s", &name);
1546 g_variant_unref(tmp_value);
1548 DBG_SECURE("Alias Name [%s]", name);
1549 size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_NAME,
1550 strlen(name) + 1, name);
1552 DBG("Device Name [%s] Property num [%d]", name, ev->num_props);
1555 tmp_value = g_variant_lookup_value(value, "Name", G_VARIANT_TYPE_STRING);
1556 g_variant_get(tmp_value, "s", &name);
1557 g_variant_unref(tmp_value);
1559 size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_NAME,
1560 strlen(name) + 1, name);
1562 DBG("Device Name [%s] Property num [%d]", name, ev->num_props);
1563 g_variant_get(tmp_value, "s", &name);
1567 tmp_value = g_variant_lookup_value(value, "Class", G_VARIANT_TYPE_UINT32);
1568 unsigned int class = tmp_value ? g_variant_get_uint32(tmp_value) : 0;
1569 size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_CLASS,
1570 sizeof(unsigned int), &class);
1573 g_variant_unref(tmp_value);
1577 tmp_value = g_variant_lookup_value(value, "Connected", G_VARIANT_TYPE_BOOLEAN);
1578 unsigned int connected = tmp_value ? g_variant_get_boolean(tmp_value) : 0;
1579 size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_CONNECTED,
1580 sizeof(unsigned int), &connected);
1582 DBG("Device connected [%u] Property num [%d]", connected, ev->num_props);
1584 g_variant_unref(tmp_value);
1587 tmp_value = g_variant_lookup_value(value, "Trusted", G_VARIANT_TYPE_BOOLEAN);
1588 uint8_t trust = tmp_value ? (g_variant_get_boolean(tmp_value) ? 1 : 0) : 0;
1589 size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_TRUSTED,
1590 sizeof(uint8_t), &trust);
1592 DBG("Device trusted [%d] Property num [%d]", trust, ev->num_props);
1594 g_variant_unref(tmp_value);
1597 tmp_value = g_variant_lookup_value(value, "Paired", G_VARIANT_TYPE_BOOLEAN);
1598 uint8_t paired = tmp_value ? (g_variant_get_boolean(tmp_value) ? 1 : 0) : 0;
1600 size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_PAIRED,
1601 sizeof(uint8_t), &paired);
1603 DBG("Device Paired [%d] Property num [%d]", paired, ev->num_props);
1605 g_variant_unref(tmp_value);
1608 tmp_value = g_variant_lookup_value(value, "RSSI", G_VARIANT_TYPE_INT32);
1609 int rssi = tmp_value ? g_variant_get_int32(tmp_value) : 0;
1610 size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_RSSI,
1611 sizeof(int), &rssi);
1613 DBG("Device RSSI [%d] Property num [%d]", rssi, ev->num_props);
1615 g_variant_unref(tmp_value);
1617 /* Last Addr Type */
1618 tmp_value = g_variant_lookup_value(value, "LastAddrType", G_VARIANT_TYPE_UINT32);
1619 unsigned int addr_type = tmp_value ? g_variant_get_uint32(tmp_value) : 0;
1621 g_variant_unref(tmp_value);
1622 DBG("Device Last Address Type [0x%x]", addr_type);
1625 tmp_value = g_variant_lookup_value(value, "IsAliasSet", G_VARIANT_TYPE_UINT32);
1626 uint8_t is_alias_set = tmp_value ? (g_variant_get_boolean(tmp_value) ? 1 : 0) : 0;
1627 size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_IS_ALIAS_SET,
1628 sizeof(uint8_t), &is_alias_set);
1630 DBG("IsAliasSet: [%s], Property num [%d]", (is_alias_set ? "TRUE" : "FALSE"), ev->num_props);
1632 g_variant_unref(tmp_value);
1635 tmp_value = g_variant_lookup_value(value, "UUIDs", G_VARIANT_TYPE_STRING_ARRAY);
1636 gsize uuid_count = g_variant_get_size(tmp_value);
1637 char **uuid_value = g_variant_dup_strv(tmp_value, &uuid_count);
1639 /* UUID collection */
1644 int num_props_tmp = ev->num_props;
1646 uint8_t uuids[BT_HAL_STACK_UUID_SIZE * uuid_count];
1648 for (i = 0; uuid_value[i] != NULL; i++) {
1650 char *uuid_str = NULL;
1651 uint8_t uuid[BT_HAL_STACK_UUID_SIZE];
1652 memset(uuid, 0x00, BT_HAL_STACK_UUID_SIZE);
1654 DBG("UUID string from Bluez [%s]\n", uuid_value[i]);
1655 uuid_str = g_strdup(uuid_value[i]);
1656 DBG("UUID string [%s]\n", uuid_str);
1658 _bt_hal_convert_uuid_string_to_type(uuid, uuid_str);
1660 for (z = 0; z < 16; z++)
1661 DBG("[0x%x]", uuid[z]);
1664 memcpy(uuids+i*BT_HAL_STACK_UUID_SIZE, uuid, BT_HAL_STACK_UUID_SIZE);
1668 size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_UUIDS,
1669 (BT_HAL_STACK_UUID_SIZE * uuid_count),
1671 ev->num_props = num_props_tmp + 1;
1674 g_variant_unref(tmp_value);
1676 /* LegacyManufacturerDataLen */
1677 tmp_value = g_variant_lookup_value(value, "LegacyManufacturerDataLen", G_VARIANT_TYPE_UINT32);
1678 unsigned int manufacturer_data_len = tmp_value ? g_variant_get_uint32(tmp_value) : 0;
1679 if (manufacturer_data_len > BT_HAL_MANUFACTURER_DATA_LENGTH_MAX) {
1680 ERR("manufacturer_data_len is too long(len = %d)", manufacturer_data_len);
1681 manufacturer_data_len = BT_HAL_MANUFACTURER_DATA_LENGTH_MAX;
1684 g_variant_unref(tmp_value);
1685 /*size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_MANUFACTURER_DATA_LEN,
1686 sizeof(unsigned int), &manufacturer_data_len);
1688 DBG("Device Legacy Manufacturer data length [%u]", manufacturer_data_len);
1690 /* ManufacturerData */
1691 tmp_value = g_variant_lookup_value(value, "LegacyManufacturerData", G_VARIANT_TYPE_BYTESTRING);
1692 manufacturer_data = value ? (gchar *)g_variant_get_bytestring(tmp_value) : NULL;
1693 if (manufacturer_data) {
1694 if (manufacturer_data_len > 0) {
1695 //size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_MANUFACTURER_DATA,
1696 size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_BLE_ADV_DATA,
1697 manufacturer_data_len, manufacturer_data);
1702 g_variant_unref(tmp_value);
1706 _bt_hal_convert_addr_string_to_type(bdaddr, address);
1707 size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_ADDR,
1708 sizeof(bdaddr), bdaddr);
1710 DBG("Device address [%s] property Num [%d]", address, ev->num_props);
1713 g_variant_unref(value);
1715 ERR("result is NULL\n");
1718 DBG("Send Device found event to HAL user, Num Prop [%d] total size [%d]", ev->num_props, size);
1719 event_cb(HAL_EV_DEVICE_FOUND, (void*) buf, size);
1724 static void __bt_hal_send_device_acl_connection_state_event(gboolean connected, const char *address)
1727 struct hal_ev_acl_state_changed ev;
1729 ev.status = BT_STATUS_SUCCESS;
1730 ev.state = (connected == TRUE) ?
1731 HAL_ACL_STATE_CONNECTED :
1732 HAL_ACL_STATE_DISCONNECTED;
1734 _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
1737 ERR("Bluetooth HAL event handler not registered");
1739 event_cb(HAL_EV_ACL_STATE_CHANGED, &ev, sizeof(ev));
1743 static void __bt_hal_send_device_le_connection_state_event(gboolean connected, const char *address)
1746 struct hal_ev_le_conn_state_changed ev;
1748 ev.status = BT_STATUS_SUCCESS;
1749 ev.state = (connected == TRUE) ?
1750 HAL_LE_STATE_CONNECTED :
1751 HAL_LE_STATE_DISCONNECTED;
1753 _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
1756 ERR("Bluetooth HAL event handler not registered");
1758 event_cb(HAL_EV_LE_CONN_STATE_CHANGED, &ev, sizeof(ev));
1762 static void __bt_hal_send_device_trust_state_event(gboolean is_trusted,
1763 const char *address)
1765 struct hal_ev_device_trust_state_changed ev;
1768 ev.trust = (is_trusted == TRUE) ?
1769 HAL_DEVICE_TRUSTED :
1770 HAL_DEVICE_UNTRUSTED;
1772 _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
1775 ERR("Bluetooth HAL event handler not registered");
1777 event_cb(HAL_EV_DEVICE_TRUST_CHANGED, &ev, sizeof(ev));
1781 static void __bt_hal_send_device_trusted_profile_changed_event(
1782 uint32_t trust_val, const char *address)
1784 struct hal_ev_device_trusted_profiles_changed ev;
1787 _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
1788 ev.trust_val = trust_val;
1791 ERR("Bluetooth HAL event handler not registered");
1793 event_cb(HAL_EV_DEVICE_TRUSTED_PROFILES_CHANGED, &ev, sizeof(ev));
1797 static void __bt_hal_handle_device_specific_events(GVariant *msg, const char *member,
1801 const char *property = NULL;
1805 if (strcasecmp(member, "PropertyChanged") == 0) {
1806 g_variant_get(msg, "(s)", &property);
1807 if (property == NULL)
1809 if (strcasecmp(property, "GattConnected") == 0) {
1810 INFO("GATT Connected");
1811 gboolean connected = FALSE;
1813 address = g_malloc0(BT_HAL_ADDRESS_STRING_SIZE);
1815 _bt_hal_convert_device_path_to_address(path, address);
1816 g_variant_get(msg, "(b)", &connected);
1818 INFO("Connected device address[%s] connnected[%d]", address, connected);
1820 } else if (strcasecmp(property, "Paired") == 0) {
1821 gboolean paired = FALSE;
1822 struct hal_ev_bond_state_changed ev;
1823 char address[BT_HAL_ADDRESS_STRING_SIZE];
1825 g_variant_get(msg, "(b)", &paired);
1826 DBG("Device property changed : Paired = %s", (paired ? "TRUE" : "FALSE"));
1828 _bt_hal_agent_set_canceled(FALSE);
1829 _bt_hal_convert_device_path_to_address(path, address);
1831 /* Prepare to send event to HAL bluetooth */
1832 ev.status = BT_STATUS_SUCCESS;
1833 ev.state = paired ? BT_BOND_STATE_BONDED : BT_BOND_STATE_NONE;
1834 _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
1837 ERR("Bluetooth HAL event handler not registered");
1839 DBG("Sending HAL_EV_BOND_STATE_CHANGED event");
1840 event_cb(HAL_EV_BOND_STATE_CHANGED, (void*)&ev, sizeof(ev));
1842 } else if (strcasecmp(property, "UUIDs") == 0) {
1845 } else if (strcasecmp(member, "DeviceConnected") == 0) {
1846 unsigned char addr_type = 0;
1848 g_variant_get(msg, "(y)", &addr_type);
1850 address = g_malloc0(BT_HAL_ADDRESS_STRING_SIZE);
1851 _bt_hal_convert_device_path_to_address(path, address);
1853 DBG("Member: [%s]", member);
1854 ERR_C("Connected [%s] [%s]", !addr_type ? "BREDR" : "LE", address);
1856 __bt_hal_send_device_acl_connection_state_event(TRUE, address);
1858 __bt_hal_send_device_le_connection_state_event(TRUE, address);
1860 } else if (strcasecmp(member, "Disconnected") == 0) {
1861 unsigned char disc_reason = 0;
1862 unsigned char addr_type = 0;
1865 g_variant_get(msg, "(yy&s)", &addr_type, &disc_reason, &name);
1867 address = g_malloc0(BT_HAL_ADDRESS_STRING_SIZE);
1868 _bt_hal_convert_device_path_to_address(path, address);
1870 DBG("Member: [%s]", member);
1871 ERR_C("DisConnected [%s] [%s]", !addr_type ? "BREDR" : "LE", address);
1872 DBG("Disconnect Reason: %d", disc_reason);
1873 DBG("Name: %s", name);
1875 __bt_hal_send_device_acl_connection_state_event(FALSE, address);
1877 __bt_hal_send_device_le_connection_state_event(FALSE, address);
1879 } else if (strcasecmp(member, "ProfileStateChanged") == 0) {
1881 char *profile_uuid = NULL;
1883 g_variant_get(msg, "(si)", &profile_uuid, &state);
1884 address = g_malloc0(BT_HAL_ADDRESS_STRING_SIZE);
1885 _bt_hal_convert_device_path_to_address(path, address);
1887 DBG("Address: %s", address);
1888 DBG("Profile UUID: %s", profile_uuid);
1889 DBG("State: %d", state);
1890 if (strncmp(profile_uuid, HID_UUID, strlen(HID_UUID)) == 0) {
1891 if (state == BT_HAL_PROFILE_STATE_CONNECTED)
1892 __bt_hal_send_hid_connection_state_event(TRUE, address);
1893 else if (state == BT_HAL_PROFILE_STATE_DISCONNECTED)
1894 __bt_hal_send_hid_connection_state_event(FALSE, address);
1896 DBG("Profile state: %d", state);
1898 } else if ((strncmp(profile_uuid, A2DP_SINK_UUID, strlen(A2DP_SINK_UUID)) == 0)) {
1899 if (state == BT_HAL_PROFILE_STATE_CONNECTED) {
1900 DBG("A2DP Profile state changed: BT_PROFILE_STATE_CONNECTED");
1901 __bt_hal_send_av_connection_state_event(TRUE, address);
1902 } else if (state == BT_HAL_PROFILE_STATE_DISCONNECTED) {
1903 DBG("A2DP Profile state changed: BT_PROFILE_STATE_DISCONNECTED");
1904 __bt_hal_send_av_connection_state_event(FALSE, address);
1905 } else if (state == BT_HAL_PROFILE_STATE_DISCONNECTING) {
1906 DBG("A2DP Profile state changed: BT_PROFILE_STATE_DISCONNECTING");
1907 } else if (state == BT_HAL_PROFILE_STATE_CONNECTING) {
1908 DBG("A2DP Profile state changed: BT_PROFILE_STATE_CONNECTING");
1910 ERR("A2DP Profile state: Invalid");
1912 } else if ((strncmp(profile_uuid, A2DP_SOURCE_UUID, strlen(A2DP_SOURCE_UUID)) == 0)) {
1913 if (state == BT_HAL_PROFILE_STATE_CONNECTED) {
1914 DBG("A2DP Sink Profile state changed: BT_HAL_PROFILE_STATE_CONNECTED");
1915 __bt_hal_send_a2dp_sink_connection_state_event(TRUE, address);
1916 } else if (state == BT_HAL_PROFILE_STATE_DISCONNECTED) {
1917 DBG("A2DP Sink Profile state changed: BT_HAL_PROFILE_STATE_DISCONNECTED");
1918 __bt_hal_send_a2dp_sink_connection_state_event(FALSE, address);
1919 } else if (state == BT_HAL_PROFILE_STATE_DISCONNECTING) {
1920 DBG("A2DP Sink Profile state changed: BT_HAL_PROFILE_STATE_DISCONNECTING");
1921 } else if (state == BT_HAL_PROFILE_STATE_CONNECTING) {
1922 DBG("A2DP Sink Profile state changed: BT_HAL_PROFILE_STATE_CONNECTING");
1924 } else if (strncmp(profile_uuid, HFP_HF_UUID, strlen(HFP_HF_UUID)) == 0) {
1925 if (state == BT_HAL_PROFILE_STATE_CONNECTING)
1926 DBG("HFP Profile state changed: BT_PROFILE_STATE_CONNECTING");
1927 else if (state == BT_HAL_PROFILE_STATE_CONNECTED) {
1928 DBG("HFP Profile state changed: BT_PROFILE_STATE_CONNECTED");
1929 __bt_hal_send_hf_connection_state_event(TRUE, address);
1930 } else if (state == BT_HAL_PROFILE_STATE_DISCONNECTED) {
1931 DBG("HFP Profile state changed: BT_PROFILE_STATE_DISCONNECTED");
1932 __bt_hal_send_hf_connection_state_event(FALSE, address);
1933 } else if (state == BT_HAL_PROFILE_STATE_DISCONNECTING) {
1934 DBG("HFP Profile state changed: BT_PROFILE_STATE_DISCONNECTING");
1936 ERR("HFP Profile state: Invalid");
1938 } else if ((strncmp(profile_uuid, AVRCP_TARGET_UUID, strlen(AVRCP_TARGET_UUID)) == 0)) {
1939 if (state == BT_HAL_PROFILE_STATE_CONNECTED) {
1940 DBG("AVRCP Controller Profile state changed: BT_HAL_PROFILE_STATE_CONNECTED");
1941 __bt_hal_send_avrcp_ctrl_connection_state_event(TRUE, address);
1942 } else if (state == BT_HAL_PROFILE_STATE_DISCONNECTED) {
1943 DBG("AVRCP Controller Profile state changed: BT_HAL_PROFILE_STATE_DISCONNECTED");
1944 __bt_hal_send_avrcp_ctrl_connection_state_event(FALSE, address);
1945 } else if (state == BT_HAL_PROFILE_STATE_DISCONNECTING) {
1946 DBG("AVRCP Controller Profile state changed: BT_HAL_PROFILE_STATE_DISCONNECTING");
1947 } else if (state == BT_HAL_PROFILE_STATE_CONNECTING) {
1948 DBG("AVRCP Controller Profile state changed: BT_HAL_PROFILE_STATE_CONNECTING");
1951 DBG("Profile[%s] State changed status [%d] ", profile_uuid, state);
1954 g_free(profile_uuid);
1955 } else if (strcasecmp(member, "AdvReport") == 0) {
1956 DBG("Member: [%s]", member);
1957 __bt_hal_handle_adv_report(msg, path);
1961 static void __bt_hal_handle_adv_report(GVariant *msg, const char *path)
1963 uint8_t buf[BT_HAL_MAX_PROPERTY_BUF_SIZE];
1964 struct hal_ev_gatt_client_scan_result *ev = (void *)buf;
1966 char *address = NULL;
1967 GVariant *value = NULL;
1968 char *buffer = NULL;
1971 uint8_t addr_type = 0;
1972 uint8_t adv_type = 0;
1978 memset(buf, 0, sizeof(buf));
1981 g_variant_get(msg, "(&syyii@ay)", &address, &addr_type,
1982 &adv_type, &rssi, &data_len, &value);
1984 buffer_len = g_variant_get_size(value);
1986 buffer = (char *)g_variant_get_data(value);
1988 if (data_len != buffer_len) {
1989 ERR("Unexpected: buffer_len: %d, data_len: %d",
1990 buffer_len, data_len);
1991 data_len = buffer_len;
1994 DBG("Address: %s, len: %d, rssi: %d, addr_type: 0x%02X, adv_type: 0x%02X",
1995 address, data_len, rssi, addr_type, adv_type);
1997 _bt_hal_convert_addr_string_to_type(ev->bd_addr, address);
1998 ev->addr_type = addr_type;
1999 ev->adv_type = adv_type;
2002 memcpy(ev->adv_data, buffer, data_len);
2005 DBG("Send le scan result event to HAL, size: [%d]", size);
2006 gatt_event_cb(HAL_EV_GATT_CLIENT_SCAN_RESULT, buf, size);
2007 g_variant_unref(value);
2010 /* AVRCP Controller Role(Remote:AVRCP Target) Events */
2011 static void __bt_hal_send_avrcp_ctrl_connection_state_event(gboolean connected, const char *address)
2014 struct hal_ev_avrcp_ctrl_conn_state ev;
2016 if (connected == TRUE)
2017 INFO("AVRCP(Controller) Profile Connected for address [%s]", address);
2019 INFO("AVRCP(Controller) Profile DisConnected for address [%s]", address);
2021 if (connected == TRUE)
2022 ev.state = HAL_AVRCP_CTRL_STATE_CONNECTED;
2024 ev.state = HAL_AVRCP_CTRL_STATE_DISCONNECTED;
2025 _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
2027 if (!a2dp_sink_event_cb)
2028 ERR("AV event handler not registered");
2030 avrcp_ctrl_event_cb(HAL_EV_AVRCP_CTRL_CONN_STATE, &ev, sizeof(ev));
2033 static int __bt_media_attr_to_type(const char *str)
2035 if (!strcasecmp(str, "Equalizer"))
2036 return HAL_PLAYER_ATTR_EQUALIZER;
2037 else if (!strcasecmp(str, "Repeat"))
2038 return HAL_PLAYER_ATTR_REPEAT;
2039 else if (!strcasecmp(str, "Shuffle"))
2040 return HAL_PLAYER_ATTR_SHUFFLE;
2041 else if (!strcasecmp(str, "Scan"))
2042 return HAL_PLAYER_ATTR_SCAN;
2048 static int __bt_hal_play_status_str_to_type(const char *value)
2050 if (!strcmp(value, "stopped"))
2051 return HAL_PLAYSTATE_STOPPED;
2052 else if (!strcmp(value, "playing"))
2053 return HAL_PLAYSTATE_PLAYING;
2054 else if (!strcmp(value, "paused"))
2055 return HAL_PLAYSTATE_PAUSED;
2056 else if (!strcmp(value, "forward-seek"))
2057 return HAL_PLAYSTATE_FWD_SEEK;
2058 else if (!strcmp(value, "reverse-seek"))
2059 return HAL_PLAYSTATE_REV_SEEK;
2061 return HAL_PLAYSTATE_ERROR;
2064 static void __bt_avrcp_control_parse_properties(struct hal_ev_track_changed *ev, GVariant *item)
2066 GVariant *value = NULL;
2068 char *value_string = NULL;
2069 const char *key = NULL;
2075 g_variant_iter_init(&iter, item);
2076 while (g_variant_iter_loop(&iter, "{sv}", &key, &value)) {
2077 if (strcasecmp(key, "Title") == 0) {
2078 value_string = (char *)g_variant_get_string(value, NULL);
2079 DBG("Value : %s ", value_string);
2080 ev->attr[i].attr_id = HAL_MEDIA_ATTR_ID_TITLE;
2081 g_strlcpy((gchar *)ev->attr[i].text, value_string, HAL_MAX_ATTR_STR_LEN);
2083 } else if (strcasecmp(key, "Artist") == 0) {
2084 value_string = (char *)g_variant_get_string(value, NULL);
2085 DBG("Value : %s ", value_string);
2086 ev->attr[i].attr_id = HAL_MEDIA_ATTR_ID_ARTIST;
2087 g_strlcpy((gchar *)ev->attr[i].text, value_string, HAL_MAX_ATTR_STR_LEN);
2089 } else if (strcasecmp(key, "Album") == 0) {
2090 value_string = (char *)g_variant_get_string(value, NULL);
2091 DBG("Value : %s ", value_string);
2092 ev->attr[i].attr_id = HAL_MEDIA_ATTR_ID_ALBUM;
2093 g_strlcpy((gchar *)ev->attr[i].text, value_string, HAL_MAX_ATTR_STR_LEN);
2095 } else if (strcasecmp(key, "Genre") == 0) {
2096 value_string = (char *)g_variant_get_string(value, NULL);
2097 DBG("Value : %s ", value_string);
2098 ev->attr[i].attr_id = HAL_MEDIA_ATTR_ID_GENRE;
2099 g_strlcpy((gchar *)ev->attr[i].text, value_string, HAL_MAX_ATTR_STR_LEN);
2101 } else if (strcasecmp(key, "Duration") == 0) {
2104 val = g_variant_get_uint32(value);
2105 DBG("Value : %d", val);
2106 ev->attr[i].attr_id = HAL_MEDIA_ATTR_ID_PLAYING_TIME;
2107 snprintf((char*)ev->attr[i].text, HAL_MAX_ATTR_STR_LEN, "%ld", val);
2109 } else if (strcasecmp(key, "NumberOfTracks") == 0) {
2112 val = g_variant_get_uint32(value);
2113 DBG("Value : %d", val);
2114 ev->attr[i].attr_id = HAL_MEDIA_ATTR_ID_NUM_TRACKS;
2115 snprintf((char*)ev->attr[i].text, HAL_MAX_ATTR_STR_LEN, "%ld", val);
2117 } else if (strcasecmp(key, "TrackNumber") == 0) {
2120 val = g_variant_get_uint32(value);
2121 DBG("Value : %d", val);
2122 ev->attr[i].attr_id = HAL_MEDIA_ATTR_ID_TRACK_NUM;
2123 snprintf((char*)ev->attr[i].text, HAL_MAX_ATTR_STR_LEN, "%ld", val);
2126 DBG("%s not supported, ignoring", key);
2129 if (i >= HAL_MAX_ATTR_NUM) {
2130 ERR(" Received max attribute [%d]", i);
2136 g_variant_iter_free(&iter);
2140 static int __bt_media_attrval_to_val(int type, const char *value)
2145 case HAL_PLAYER_ATTR_EQUALIZER:
2146 if (!strcmp(value, "off"))
2151 case HAL_PLAYER_ATTR_REPEAT:
2152 if (!strcmp(value, "off"))
2153 ret = BTRC_PLAYER_VAL_OFF_REPEAT;
2154 else if (!strcmp(value, "singletrack"))
2155 ret = BTRC_PLAYER_VAL_SINGLE_REPEAT;
2156 else if (!strcmp(value, "alltracks"))
2157 ret = BTRC_PLAYER_VAL_ALL_REPEAT;
2159 ret = BTRC_PLAYER_VAL_GROUP_REPEAT;
2161 case HAL_PLAYER_ATTR_SHUFFLE:
2162 if (!strcmp(value, "off"))
2163 ret = BTRC_PLAYER_VAL_OFF_SHUFFLE;
2164 else if (!strcmp(value, "alltracks"))
2165 ret = BTRC_PLAYER_VAL_ALL_SHUFFLE;
2167 ret = BTRC_PLAYER_VAL_GROUP_SHUFFLE;
2169 case HAL_PLAYER_ATTR_SCAN:
2170 if (!strcmp(value, "off"))
2172 else if (!strcmp(value, "alltracks"))
2178 ERR("Value not handled");
2184 static void __bt_hal_handle_avrcp_ctrl_events(GVariant *msg, const char *member,
2187 const char *property = NULL;
2188 GVariant *value = NULL;
2190 char address[BT_HAL_ADDRESS_STRING_SIZE];
2193 ERR("Error returned in method call\n");
2197 if (!avrcp_ctrl_event_cb) {
2198 ERR("AVRCP controller DBUS handler callback not registered");
2202 g_variant_iter_init(&iter, msg);
2204 _bt_hal_convert_device_path_to_address(path, address);
2206 while (g_variant_iter_loop(&iter, "{sv}", &property, &value)) {
2207 DBG("Property = %s \n", property);
2208 if ((strcasecmp(property, "Equalizer") == 0) ||
2209 (strcasecmp(property, "Repeat") == 0) ||
2210 (strcasecmp(property, "Shuffle") == 0) ||
2211 (strcasecmp(property, "Scan") == 0)) {
2212 struct hal_ev_player_setting ev;
2216 valstr = g_variant_get_string(value, NULL);
2217 DBG("Value : %s ", valstr);
2220 val = __bt_media_attrval_to_val(__bt_media_attr_to_type(property), valstr);
2223 memset(&ev, 0, sizeof(ev));
2224 _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
2226 ev.attr_ids[0] = __bt_media_attr_to_type(property);
2227 ev.attr_values[0] = val;
2229 /* Send event to application */
2230 avrcp_ctrl_event_cb(HAL_EV_AVRCP_CTRL_PLAYER_APP_SETTING_CHANGED, &ev, sizeof(ev));
2232 } else if ((strcasecmp(property, "Status") == 0)) {
2233 struct hal_ev_play_status_changed ev;
2236 valstr = g_variant_get_string(value, NULL);
2237 DBG("Value : %s ", valstr);
2239 memset(&ev, 0, sizeof(ev));
2240 _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
2242 ev.status = __bt_hal_play_status_str_to_type(valstr);
2244 /* Send event to application */
2245 avrcp_ctrl_event_cb(HAL_EV_AVRCP_CTRL_PLAY_STATUS_CHANGED, &ev, sizeof(ev));
2247 } else if (strcasecmp(property, "Position") == 0) {
2248 struct hal_ev_play_position ev;
2250 memset(&ev, 0, sizeof(ev));
2251 _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
2252 ev.pos = g_variant_get_uint32(value);
2253 DBG("Value : %d ", ev.pos);
2255 /* Send event to application */
2256 avrcp_ctrl_event_cb(HAL_EV_AVRCP_CTRL_PLAY_POSITION_CHANGED, &ev, sizeof(ev));
2257 } else if (strcasecmp(property, "Track") == 0) {
2258 struct hal_ev_track_changed ev;
2260 memset(&ev, 0, sizeof(ev));
2261 _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
2262 __bt_avrcp_control_parse_properties(&ev, value);
2264 /* Send event to application */
2265 avrcp_ctrl_event_cb(HAL_EV_AVRCP_CTRL_TRACK_CHANGED, &ev, sizeof(ev));
2267 DBG("Property not handled");
2271 g_free((char *)property);
2272 g_variant_unref(value);
2275 static void __bt_hal_handle_avrcp_transport_events(GVariant *msg, const char *member,
2278 const char *property = NULL;
2279 GVariant *value = NULL;
2281 char address[BT_HAL_ADDRESS_STRING_SIZE];
2285 ERR("Error returned in method call\n");
2289 if (!avrcp_tg_event_cb) {
2290 ERR("AVRCP target DBUS handler callback not registered");
2294 g_variant_iter_init(&iter, msg);
2296 _bt_hal_convert_device_path_to_address(path, address);
2298 while (g_variant_iter_loop(&iter, "{sv}", &property, &value)) {
2299 DBG("Property = %s \n", property);
2300 if ((strcasecmp(property, "Delay") == 0)) {
2301 struct hal_ev_avrcp_tg_delay_changed ev;
2304 memset(&ev, 0, sizeof(ev));
2305 _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
2307 val = g_variant_get_uint16(value);
2308 DBG("Value : %d", val);
2311 /* Send event to application */
2312 avrcp_tg_event_cb(HAL_EV_AVRCP_TG_DELAY_CHANGE, &ev, sizeof(ev));
2314 DBG("Property not handled");
2319 g_free((char *)property);
2320 g_variant_unref(value);
2323 /* A2DP Src Role(Remote:Sink) Events */
2324 static void __bt_hal_send_av_connection_state_event(gboolean connected, const char *address)
2327 struct hal_ev_a2dp_conn_state ev;
2329 if (connected == TRUE)
2330 INFO("A2DP(Src) Profile Connected for address [%s]", address);
2332 INFO("A2DP(Src) Profile DisConnected for address [%s]", address);
2334 ev.state = (connected == TRUE) ?
2335 HAL_EV_A2DP_STATE_CONNECTED :
2336 HAL_EV_A2DP_STATE_DISCONNECTED;
2338 _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
2341 ERR("AV event handler not registered");
2343 av_event_cb(HAL_EV_A2DP_CONN_STATE, &ev, sizeof(ev));
2346 /* A2DP Sink Role(Remote:Source) Events */
2347 static void __bt_hal_send_a2dp_sink_connection_state_event(gboolean connected, const char *address)
2350 struct hal_ev_a2dp_conn_state ev;
2352 if (connected == TRUE)
2353 INFO("A2DP(Sink) Profile Connected for address [%s]", address);
2355 INFO("A2DP(Sink) Profile DisConnected for address [%s]", address);
2357 ev.state = (connected == TRUE) ?
2358 HAL_EV_A2DP_STATE_CONNECTED :
2359 HAL_EV_A2DP_STATE_DISCONNECTED;
2361 _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
2363 if (!a2dp_sink_event_cb)
2364 ERR("AV event handler not registered");
2366 a2dp_sink_event_cb(HAL_EV_A2DP_SOURCE_CONN_STATE, &ev, sizeof(ev));
2369 /* HF(AG Role) Audio Events */
2370 static void __bt_hal_send_hf_audio_connection_state_event(gboolean connected,
2371 const char *address)
2374 struct hal_ev_handsfree_audio_state ev;
2376 if (connected == TRUE)
2377 INFO("AG Audio Connected for address [%s]", address);
2379 INFO("AG Audio DisConnected for address [%s]", address);
2381 ev.state = (connected == TRUE) ?
2382 HAL_EV_HANDSFREE_AUDIO_STATE_CONNECTED :
2383 HAL_EV_HANDSFREE_AUDIO_STATE_DISCONNECTED;
2385 _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
2388 ERR("HF event handler not registered");
2390 hf_event_cb(HAL_EV_HANDSFREE_AUDIO_STATE, &ev, sizeof(ev));
2393 /* HF(AG Role) Profile Events */
2394 static void __bt_hal_send_hf_connection_state_event(gboolean connected,
2395 const char *address)
2398 struct hal_ev_handsfree_conn_state ev;
2400 if (connected == TRUE)
2401 INFO("AG Profile Connected for address [%s]", address);
2403 INFO("AG Profile DisConnected for address [%s]", address);
2405 ev.state = (connected == TRUE) ?
2406 HAL_EV_HANDSFREE_CONN_STATE_CONNECTED :
2407 HAL_EV_HANDSFREE_CONN_STATE_DISCONNECTED;
2409 _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
2412 ERR("HF event handler not registered");
2414 hf_event_cb(HAL_EV_HANDSFREE_CONN_STATE, &ev, sizeof(ev));
2417 void _bt_hal_register_event_handler_cb(bt_hal_module_e module, handle_stack_msg cb)
2427 a2dp_sink_event_cb = cb;
2433 avrcp_tg_event_cb = cb;
2435 case HAL_AVRCP_CTRL:
2436 avrcp_ctrl_event_cb = cb;
2442 ERR("Unknown module: %d", module);
2446 void _bt_hal_unregister_event_handler_cb(bt_hal_module_e module)
2450 hid_event_cb = NULL;
2456 a2dp_sink_event_cb = NULL;
2462 avrcp_tg_event_cb = NULL;
2464 case HAL_AVRCP_CTRL:
2465 avrcp_ctrl_event_cb = NULL;
2468 gatt_event_cb = NULL;
2471 ERR("Unknown module: %d", module);
2475 bool _bt_hal_get_adapter_request_state(void)
2477 return is_adapter_activating;
2480 bool _bt_hal_get_le_request_state(void)
2482 return is_le_activating;
2485 void _bt_hal_set_adapter_request_state(bool enable)
2487 DBG("set_adapter_request_state %d", enable);
2488 is_adapter_activating = enable;
2491 void _bt_hal_set_le_request_state(bool enable)
2493 DBG("set_le_request_state %d", enable);
2494 is_le_activating = enable;