#include "bt-hal-adapter-le.h"
#include "bt-hal-gatt-server.h"
#include "bt-hal-gatt-client.h"
+#include "bt-hal-adapter-dbus-handler.h"
+
+#include "bt-internal-types.h"
#define BASELEN_PROP_CHANGED (sizeof(struct hal_ev_adapter_props_changed) \
+ sizeof(struct hal_property))
static GDBusConnection *manager_conn;
static handle_stack_msg event_cb = NULL;
static handle_stack_msg hid_event_cb = NULL;
+static handle_stack_msg hid_device_event_cb = NULL;
static handle_stack_msg av_event_cb = NULL;
static handle_stack_msg a2dp_sink_event_cb = NULL;
static handle_stack_msg hf_event_cb = NULL;
+static handle_stack_msg hf_client_event_cb = NULL;
static handle_stack_msg avrcp_ctrl_event_cb = NULL;
static handle_stack_msg avrcp_tg_event_cb = NULL;
static handle_stack_msg gatt_event_cb = NULL;
static void __bt_hal_send_hf_connection_state_event(gboolean connected, const char *address);
static void __bt_hal_send_device_trusted_profile_changed_event(uint32_t trust_val, const char *address);
static void __bt_hal_handle_adv_report(GVariant *msg, const char *path);
+static void __bt_hal_handle_gatts_mtu_changed_event(char *address, int mtu);
+static void __bt_hal_send_hf_client_connection_state_event(gboolean connected, const char *address);
+
static gboolean __bt_hal_discovery_finished_cb(gpointer user_data)
{
struct hal_ev_discovery_state_changed ev;
ev.state = HAL_DISCOVERY_STATE_STOPPED;
event_cb(HAL_EV_DISCOVERY_STATE_CHANGED, &ev, sizeof(ev));
- DBG("-");
return FALSE;
}
static int __bt_hal_get_owner_info(GVariant *msg, char **name, char **previous, char **current)
{
- g_variant_get(msg, "(sss)", name, previous, current);
+ g_variant_get(msg, "(&s&s&s)", name, previous, current);
return BT_HAL_ERROR_NONE;
}
const gchar *address = NULL;
gchar *name = NULL;
unsigned int cod = 0;
+ unsigned int a2dp_role = 0;
gboolean discoverable;
gboolean connectable;
unsigned int scan_mode = BT_SCAN_MODE_NONE;
ev->num_props = 0;
ev->status = BT_STATUS_SUCCESS;
- DBG("+");
-
while (g_variant_iter_loop(&value_iter, "{sv}", &key, &value)) {
if (!g_strcmp0(key, "Address")) {
uint8_t bdaddr[6];
/* TODO: Need to check this operation!! */
if (powered == FALSE) {
DBG("###### Adapter Powered Down ######");
- struct hal_ev_adapter_state_changed ev;
- ev.state = HAL_POWER_OFF;
- event_cb(HAL_EV_ADAPTER_STATE_CHANGED, &ev, sizeof(ev));
+
+ if (TIZEN_FEATURE_BT_USB_DONGLE) {
+ struct hal_ev_adapter_state_changed ev;
+ ev.state = HAL_POWER_OFF;
+ event_cb(HAL_EV_ADAPTER_STATE_CHANGED, &ev, sizeof(ev));
#ifdef TIZEN_BT_HAL
- struct hal_ev_le_state_changed le_ev;
- le_ev.state = HAL_POWER_OFF;
- event_cb(HAL_EV_LE_STATE_CHANGED, &le_ev, sizeof(le_ev));
+ struct hal_ev_le_state_changed le_ev;
+ le_ev.state = HAL_POWER_OFF;
+ event_cb(HAL_EV_LE_STATE_CHANGED, &le_ev, sizeof(le_ev));
#endif
- /* Destroy Agent */
- _bt_hal_destroy_adapter_agent();
+ /* Destroy Agent */
+ _bt_hal_destroy_adapter_agent();
+ } else {
+ DBG("Pending disalbed event after bluetoothd is terminated");
+ }
} else {
DBG("###### Adapter Powered Up ######");
- int is_flight_mode=1, ret = -1;
- ret = vconf_get_bool(VCONFKEY_TELEPHONY_FLIGHT_MODE, &is_flight_mode);
- if (ret != 0)
- ERR("vconf_get_bool failed");
- if (_bt_hal_get_adapter_request_state() || !is_flight_mode) {
+ if (_bt_hal_get_adapter_request_state()) {
DBG("Sending STATE CHANGE EVENT for Adapter... ");
_bt_hal_set_adapter_request_state(FALSE);
struct hal_ev_adapter_state_changed ev;
event_cb(HAL_EV_ADAPTER_STATE_CHANGED, &ev, sizeof(ev));
}
#ifdef TIZEN_BT_HAL
- if (_bt_hal_get_le_request_state() || !is_flight_mode) {
+ if (_bt_hal_get_le_request_state()) {
DBG("Sending STATE CHANGE EVENT for LE... ");
_bt_hal_set_le_request_state(FALSE);
struct hal_ev_le_state_changed ev;
DBG("##Discovering = [%d]", is_discovering);
if (is_discovering == FALSE) {
- DBG("###### Adapter Has stopped Discovering ######");
/* In Tizen Bluez, this actually does not mean Discovery is stopped
in Bluez. Tizen Bluez sends this event after a certain timeout,
Therefore, we must forecefully call StopDiscovery to stop discovery in BlueZ */
DBUS_TIMEOUT, NULL,
&err);
if (err) {
+ struct hal_ev_discovery_state_changed ev;
+
ERR("Dbus Error : %s", err->message);
+ if (g_strrstr(err->message, "No discovery started"))
+ continue;
+
/* This error is thrown by Bluez, as Discovery is already stopped.
Discovery is stopped if user cancels on going discovery.
In order to maintain correct state of Bluetooth Discovery state,
simply send Discovery stopped event to HAL user */
- struct hal_ev_discovery_state_changed ev;
ev.state = HAL_DISCOVERY_STATE_STOPPED;
event_cb(HAL_EV_DISCOVERY_STATE_CHANGED, &ev, sizeof(ev));
g_clear_error(&err);
}
} else {
- DBG("###### Adapter Has started Discovering ######");
struct hal_ev_discovery_state_changed ev;
ev.state = HAL_DISCOVERY_STATE_STARTED;
event_cb(HAL_EV_DISCOVERY_STATE_CHANGED, &ev, sizeof(ev));
is_le_discovering = g_variant_get_boolean(value);
DBG("##LE Discovering = [%d]", is_le_discovering);
- if (is_le_discovering)
+ if (is_le_discovering) {
+ /* Send LE discovering started event */
+ size += __bt_insert_hal_properties(buf + size,
+ HAL_PROP_ADAPTER_LE_DISCOVERY_STARTED, 0, NULL);
+ ev->num_props++;
continue;
+ }
adapter_proxy = _bt_hal_get_adapter_proxy();
if (adapter_proxy == NULL) {
ERR("(Error: %s)", err->message);
g_clear_error(&err);
}
- continue;
+ } else {
+ g_variant_unref(result);
}
- g_variant_unref(result);
+
+ /* Send LE discovering finished event */
+ size += __bt_insert_hal_properties(buf + size,
+ HAL_PROP_ADAPTER_LE_DISCOVERY_STOPPED, 0, NULL);
+ ev->num_props++;
} else if (!g_strcmp0(key, "Modalias")) {
char *modalias = NULL;
- g_variant_get(value, "s", &modalias);
+ g_variant_get(value, "&s", &modalias);
DBG("##Adapter ModAlias [%s]", modalias);
} else if (!g_strcmp0(key, "SupportedLEFeatures")) {
DBG("##LE Supported features");
} else if (!g_strcmp0(key, "IpspInitStateChanged")) {
g_variant_get(value, "b" , &ipsp_initialized);
DBG("##IPSP Initialized = %d", ipsp_initialized);
+ } else if (!g_strcmp0(key, "A2dpRole")) {
+ a2dp_role = g_variant_get_uint32(value);
+ DBG("##A2dp Role [%d]", a2dp_role);
+ size += __bt_insert_hal_properties(buf + size,
+ HAL_PROP_ADAPTER_A2DP_ROLE, sizeof(unsigned int), &a2dp_role);
+ ev->num_props++;
} else {
ERR("Unhandled Property:[%s]", key);
}
DBG("Send Adapter properties changed event to HAL user, Num Prop [%d] total size [%zd]", ev->num_props, size);
event_cb(HAL_EV_ADAPTER_PROPS_CHANGED, buf, size);
}
-
- DBG("-");
}
void _bt_hal_handle_adapter_event(GVariant *msg, const char *member)
{
- DBG("+");
-
if (member == NULL)
return;
if (strcasecmp(member, "DeviceCreated") == 0) {
DBG("DeviceCreated: Unhandled");
- } else if (strcasecmp(member, "InterfacesRemoved") == 0) {
- DBG("InterfacesRemoved: Unhandled");
} else if (strcasecmp(member, "AdvertisingEnabled") == 0) {
- DBG("AdvertisingEnabled");
- DBG("Advertising Enabled");
int slot_id;
gboolean status = FALSE;
g_variant_get(msg, "(ib)", &slot_id, &status);
- DBG("Advertising Enabled : slot_id [%d] status [%d]", slot_id, status);
+
/* Send event to application */
_bt_hal_set_advertising_status(slot_id, status);
} else if (strcasecmp(member, "RssiEnabled") == 0) {
g_free(address);
} else if (strcasecmp(member, BT_HAL_HARDWARE_ERROR) == 0) {
+#ifndef TIZEN_BT_HAL
DBG("BT Hardware Error: Unhandled");
+#else
+ struct hal_ev_controller_error_recieved info;
+
+ INFO("### BT Hardware Error");
+ info.code = HAL_CONTROLLER_ERROR_HW_ERROR;
+ event_cb(HAL_EV_CONTROLLER_ERROR_RECIEVED, &info, sizeof(info));
+#endif
} else if (strcasecmp(member, BT_HAL_TX_TIMEOUT_ERROR) == 0) {
- DBG("BT TX Timeout Error: Unhandled");
+#ifndef TIZEN_BT_HAL
+ DBG("BT Hardware Error: Unhandled");
+#else
+ struct hal_ev_controller_error_recieved info;
+ INFO("### BT TX Timeout Error");
+ info.code = HAL_CONTROLLER_ERROR_TX_TIMEOUT;
+ event_cb(HAL_EV_CONTROLLER_ERROR_RECIEVED, &info, sizeof(info));
+#endif
+ } else if (strcasecmp(member, BT_HAL_DBFW_PLUS_INFO) == 0) {
+#ifdef TIZEN_BT_HAL
+ DBG("### DBFW+ info received from BLUEZ");
+ struct hal_ev_dbfw_plus_info_recieved info;
+ int length;
+ char event_code;
+ unsigned char *buffer = NULL;
+ GVariant *value = NULL;
+
+ g_variant_get(msg, "(y@ay)", &event_code, &value);
+ if (value == NULL) {
+ ERR("g_variant_get fails");
+ } else {
+ length = g_variant_get_size(value);
+ if (length <= 0) {
+ ERR("Invalid g_variant len = %d", length);
+ } else {
+ info.event_code = event_code;
+ buffer = (unsigned char*)g_variant_get_data(value);
+ info.data = g_memdup(buffer, length);
+ info.data_len = length;
+ if (!event_cb)
+ ERR("event_cb is NULL");
+ else
+ event_cb(HAL_EV_DBFW_PLUS_INFO_RECIEVED, &info, sizeof(info));
+ g_free(info.data);
+ }
+ }
+#endif
}
- DBG("-");
}
static gboolean __bt_hal_parse_device_properties(GVariant *item)
gchar *key;
GVariant *val;
gsize len = 0;
+ gboolean is_bredr_dev = FALSE;
+
if (!item)
return FALSE;
- DBG("+");
/* Buffer and propety count management */
uint8_t buf[BT_HAL_MAX_PROPERTY_BUF_SIZE];
while (g_variant_iter_loop(&iter, "{sv}", &key, &val)) {
if (strcasecmp(key, "Address") == 0) {
-
char * address = NULL;
address = g_variant_dup_string(val, &len);
uint8_t bdaddr[6];
ev->num_props++;
DBG("Device address [%s] property Num [%d]", address, ev->num_props);
g_free(address);
+ } else if (strcasecmp(key, "AddressType") == 0) {
+ char *addresstype = g_variant_dup_string(val, &len);
+ if (addresstype)
+ DBG("AddressType [%s]", addresstype);
+ g_free(addresstype);
} else if (strcasecmp(key, "Class") == 0) {
unsigned int class = g_variant_get_uint32(val);
size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_CLASS,
sizeof(unsigned int), &class);
ev->num_props++;
DBG("Device class [%d] Property num [%d]", class, ev->num_props);
+ is_bredr_dev = TRUE;
} else if (strcasecmp(key, "name") == 0) {
char *name = g_variant_dup_string(val, &len);
if (name) {
} else if (strcasecmp(key, "LegacyManufacturerData") == 0) {
/* TODO: To be handled later*/
} else {
- ERR("Unhandled Property:[%s]", key);
+ DBG("Unhandled Property:[%s]", key);
}
}
- DBG("-");
- if (size > 1) {
+ if (size > 1 && is_bredr_dev) {
DBG("Send Device found event to HAL user, Num Prop [%d] total size [%zd]", ev->num_props, size);
event_cb(HAL_EV_DEVICE_FOUND, (void*) buf, size);
}
{
char *interface_name = NULL;
GVariant *val = NULL;
- DBG("+");
g_variant_get(msg, "(&s@a{sv}@as)", &interface_name, &val, NULL);
g_variant_unref(value);
return;
}
-
- DBG("-");
}
static void __bt_hal_send_hid_connection_state_event(
- gboolean connected, char *address)
+ gboolean connected, const char *address)
{
struct hal_ev_hidhost_conn_state ev;
hid_event_cb(HAL_EV_HIDHOST_CONN_STATE, &ev, sizeof(ev));
}
+static void __bt_hal_send_hid_device_connection_state_event(
+ gboolean connected, const char *address)
+{
+ struct hal_ev_hiddevice_conn_state ev;
+
+ ev.state = (connected == TRUE) ?
+ HAL_HIDDEVICE_STATE_CONNECTED :
+ HAL_HIDDEVICE_STATE_DISCONNECTED;
+
+ _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
+
+ if (!hid_device_event_cb)
+ ERR("HID device event handler not registered");
+ else
+ hid_device_event_cb(HAL_EV_HIDDEVICE_CONN_STATE, &ev, sizeof(ev));
+}
+
static void __bt_hal_handle_input_event(GVariant *msg, const char *path)
{
gboolean property_flag = FALSE;
g_variant_unref(val);
g_variant_unref(child);
}
-
- DBG("-");
}
static gboolean __bt_hal_parse_interface(GVariant *msg)
}
}
+static void __bt_hal_handle_gatt_service_event(GVariant *parameters, const char *signal_name)
+{
+ if (signal_name == NULL)
+ return;
+
+ if (strcasecmp(signal_name, "GattServiceAdded") == 0) {
+ char *path = NULL;
+ g_variant_get(parameters, "(&s)", &path);
+ _bt_hal_handle_gattc_service_changed_event(TRUE, path);
+ }
+}
static gboolean __bt_hal_event_manager(gpointer data)
{
if (strcasecmp(param->signal_name, "InterfacesAdded") == 0) {
/*TODO: Handle Interfaces Added Signal from stack */
- DBG("Manager Event: Signal Name: InterfacesAdded");
g_variant_get(param->parameters, "(&o@a{sa{sv}})", &obj_path, &value);
if (obj_path == NULL) {
- DBG("obj_path is NULL");
+ ERR("obj_path is NULL");
return FALSE;
}
} else {
bt_event = __bt_hal_parse_event(value);
if (bt_event == BT_HAL_DEVICE_EVENT) {
- DBG("Device path : %s ", obj_path);
+ DBG("InterfacesAdded %s ", obj_path);
__bt_hal_handle_device_event(value, param->parameters);
} else if (bt_event == BT_HAL_AVRCP_CONTROL_EVENT) {
- DBG("Device path : %s ", obj_path);
+ DBG("InterfacesAdded %s ", obj_path);
_bt_hal_set_control_device_path(obj_path);
}
}
GVariantIter *iter;
/*TODO: Handle Interfaces Removed Signal from stack */
- DBG("Manager Event: Signal Name: InterfacesRemoved");
g_variant_get(param->parameters, "(&oas)", &obj_path, &iter);
- DBG("Device path : %s ", obj_path);
+ DBG("InterfacesRemoved %s ", obj_path);
while (g_variant_iter_loop(iter, "s", &str)) {
if (g_strcmp0(str, BT_HAL_PLAYER_CONTROL_INTERFACE) == 0)
_bt_hal_remove_control_device_path(obj_path);
+ else if (g_strcmp0(str, BT_HAL_GATT_SERVICE_INTERFACE) == 0)
+ _bt_hal_handle_gattc_service_changed_event(FALSE, obj_path);
}
g_variant_iter_free(iter);
} else if (strcasecmp(param->signal_name, "NameOwnerChanged") == 0) {
char *previous = NULL;
char *current = NULL;
+ if (g_strcmp0(g_variant_get_type_string(param->parameters), "(sss)") != 0) {
+ ERR("Invalid variant format");
+ return FALSE;
+ }
+
/* TODO: Handle Name Owener changed Signal */
if (__bt_hal_get_owner_info(param->parameters, &name, &previous, ¤t)) {
- DBG("Fail to get the owner info");
+ ERR("Fail to get the owner info");
return FALSE;
}
- if (current && *current != '\0') {
- g_free(name);
- g_free(previous);
- g_free(current);
+
+ if (*current != '\0')
return FALSE;
- }
+
+ if (name == NULL)
+ return FALSE;
+
if (strcasecmp(name, BT_HAL_BLUEZ_NAME) == 0) {
- DBG("Bluetoothd is terminated");
+ struct hal_ev_adapter_state_changed ev;
+ struct hal_ev_le_state_changed le_ev;
+
+ INFO("Bluetoothd is terminated");
+
+ /* Send the disable event in here */
- /* TODO: Handle Bluetoothd terminating scenario */
+ ev.state = HAL_POWER_OFF;
+ le_ev.state = HAL_POWER_OFF;
+
+ event_cb(HAL_EV_ADAPTER_STATE_CHANGED, &ev, sizeof(ev));
+ event_cb(HAL_EV_LE_STATE_CHANGED, &le_ev, sizeof(le_ev));
+
+ /* Destroy Agent */
+ _bt_hal_destroy_adapter_agent();
_bt_hal_le_deinit();
}
- INFO("Name Owner changed [%s]", name);
- g_free(name);
- g_free(previous);
- g_free(current);
-
} else if (g_strcmp0(param->interface_name, BT_HAL_PROPERTIES_INTERFACE) == 0) {
- DBG("Manager Event: Interface Name: BT_HAL_PROPERTIES_INTERFACE");
__bt_hal_handle_property_changed_event(param->parameters, param->object_path);
} else if (g_strcmp0(param->interface_name, BT_HAL_ADAPTER_INTERFACE) == 0) {
DBG("Manager Event: Interface Name: BT_HAL_ADAPTER_INTERFACE");
} else if (g_strcmp0(param->interface_name, BT_HAL_GATT_CHAR_INTERFACE) == 0) {
DBG("Manager Event: Interface Name: BT_HAL_GATT_CHAR_INTERFACE");
__bt_hal_handle_gatt_char_event(param->parameters, param->signal_name);
+ } else if (g_strcmp0(param->interface_name, BT_HAL_GATT_SERVICE_INTERFACE) == 0) {
+ DBG("Manager Event: Interface Name: BT_HAL_GATT_SERVICE_INTERFACE");
+ __bt_hal_handle_gatt_service_event(param->parameters, param->signal_name);
}
-
/* Free data */
g_free(param->sender_name);
g_free(param->object_path);
static int subs_property_id = -1;
static int subs_adapter_id = -1;
- INFO_C("+");
-
if (subscribe) {
if (subs_interface_added_id == -1) {
subs_interface_added_id = g_dbus_connection_signal_subscribe(conn,
}
}
- INFO_C("-");
return 0;
}
{
static int subs_device_id = -1;
- DBG("+");
if (conn == NULL)
return -1;
}
}
- DBG("-");
return 0;
}
{
static int subs_input_id = -1;
- DBG("+");
-
if (conn == NULL)
return -1;
}
}
- DBG("-");
-
return 0;
}
static int __bt_hal_register_gatt_subscribe_signal(GDBusConnection *conn,
int subscribe)
{
- static int subs_gatt_id = -1;
-
- DBG("+");
+ static int subs_gatt_char_id = -1;
+ static int subs_gatt_service_id = -1;
if (subscribe) {
- if (subs_gatt_id == -1) {
- subs_gatt_id = g_dbus_connection_signal_subscribe(conn,
+ if (subs_gatt_char_id == -1) {
+ subs_gatt_char_id = g_dbus_connection_signal_subscribe(conn,
NULL, BT_HAL_GATT_CHAR_INTERFACE,
NULL, NULL, NULL, 0,
__bt_hal_manager_event_filter,
NULL, NULL);
}
+ if (subs_gatt_service_id == -1) {
+ subs_gatt_service_id = g_dbus_connection_signal_subscribe(conn,
+ NULL, BT_HAL_GATT_SERVICE_INTERFACE,
+ NULL, NULL, NULL, 0,
+ __bt_hal_manager_event_filter,
+ NULL, NULL);
+ }
} else {
- if (subs_gatt_id == -1) {
+ if (subs_gatt_char_id == -1) {
g_dbus_connection_signal_unsubscribe(conn,
- subs_gatt_id);
- subs_gatt_id = -1;
+ subs_gatt_char_id);
+ subs_gatt_char_id = -1;
+ }
+ if (subs_gatt_service_id == -1) {
+ g_dbus_connection_signal_unsubscribe(conn,
+ subs_gatt_service_id);
+ subs_gatt_service_id = -1;
}
}
static int __bt_hal_register_service_event(GDBusConnection *g_conn, int event_type)
{
- DBG("+");
-
if (g_conn == NULL)
return BT_HAL_ERROR_INTERNAL;
manager_conn = NULL;
}
- DBG("-");
-
return BT_HAL_ERROR_INTERNAL;
}
/*TODO: Initialize Obexd Event receiver */
event_cb = cb;
- DBG("-");
return BT_HAL_ERROR_NONE;
}
GVariant *value = NULL;
char *key = NULL;
g_variant_iter_init(&value_iter, msg);
- DBG("+");
while (g_variant_iter_loop(&value_iter, "{sv}", &key, &value)) {
if (!g_strcmp0(key, "Connected")) {
guint connected = 0;
g_variant_get(value, "i", &connected);
- DBG("Device property changed : Connected [%d]", connected);
+ INFO("Device property changed : Connected [%d]", connected);
} else if (!g_strcmp0(key, "RSSI")) {
DBG("Device property changed : RSSI");
__bt_hal_dbus_device_found_properties(path);
} else if (!g_strcmp0(key, "GattConnected")) {
- DBG("Device property changed : GattConnected");
gboolean gatt_connected = FALSE;
g_variant_get(value, "b", &gatt_connected);
+ INFO_C("Device property changed : GattConnected [%d]", gatt_connected);
+
char *address = g_malloc0(BT_HAL_ADDRESS_STRING_SIZE);
_bt_hal_convert_device_path_to_address(path, address);
- DBG("@@gatt_connected: %d", gatt_connected);
- DBG("@@address: %s", address);
_bt_hal_gatt_connected_state_event(gatt_connected, address);
_bt_hal_handle_gattc_connected_event(address, gatt_connected);
g_free(address);
if (!event_cb) {
ERR("Bluetooth HAL event handler not registered");
- } else {
- DBG("Sending HAL_EV_BOND_STATE_CHANGED event");
+ } else
event_cb(HAL_EV_BOND_STATE_CHANGED, (void*)&ev, sizeof(ev));
- }
} else if (!g_strcmp0(key, "LegacyPaired")) {
DBG("Device property changed : LegacyPaired");
} else if (!g_strcmp0(key, "Trusted")) {
DBG("Address: %s, TrustedProfiles: 0x%X", address, trust_val);
__bt_hal_send_device_trusted_profile_changed_event(trust_val, address);
} else {
- ERR("Unhandled Property:[%s]", key);
+ DBG("Unhandled Property:[%s]", key);
}
}
- DBG("-");
}
static void __bt_hal_dbus_device_found_properties(const char *device_path)
GDBusProxy *device_proxy;
GDBusConnection *conn;
GVariant *result;
- DBG("+");
if (!device_path) {
ERR("Invalid device path");
g_object_unref(device_proxy);
g_free(address);
-
- DBG("-");
}
static void __bt_hal_device_properties_lookup(GVariant *result, char *address)
(BT_HAL_STACK_UUID_SIZE * uuid_count),
uuids);
ev->num_props = num_props_tmp + 1;
- g_free(uuid_value);
+ g_strfreev(uuid_value);
}
g_variant_unref(tmp_value);
DBG("Send Device found event to HAL user, Num Prop [%d] total size [%zd]", ev->num_props, size);
event_cb(HAL_EV_DEVICE_FOUND, (void*) buf, size);
}
- DBG("-");
}
static void __bt_hal_send_device_acl_connection_state_event(int status, gboolean connected, const char *address)
{
- DBG("+");
struct hal_ev_acl_state_changed ev;
ev.status = status;
ERR("Bluetooth HAL event handler not registered");
else
event_cb(HAL_EV_ACL_STATE_CHANGED, &ev, sizeof(ev));
- DBG("-");
}
static void __bt_hal_send_device_le_connection_state_event(int status, gboolean connected, const char *address)
{
- DBG("+");
struct hal_ev_le_conn_state_changed ev;
ev.status = status;
ERR("Bluetooth HAL event handler not registered");
else
event_cb(HAL_EV_LE_CONN_STATE_CHANGED, &ev, sizeof(ev));
- DBG("-");
}
static void __bt_hal_send_device_trust_state_event(gboolean is_trusted,
const char *address)
{
struct hal_ev_device_trust_state_changed ev;
- DBG("+");
ev.trust = (is_trusted == TRUE) ?
HAL_DEVICE_TRUSTED :
ERR("Bluetooth HAL event handler not registered");
else
event_cb(HAL_EV_DEVICE_TRUST_CHANGED, &ev, sizeof(ev));
- DBG("-");
}
static void __bt_hal_send_device_trusted_profile_changed_event(
uint32_t trust_val, const char *address)
{
struct hal_ev_device_trusted_profiles_changed ev;
- DBG("+");
_bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
ev.trust_val = trust_val;
ERR("Bluetooth HAL event handler not registered");
else
event_cb(HAL_EV_DEVICE_TRUSTED_PROFILES_CHANGED, &ev, sizeof(ev));
- DBG("-");
}
static void __bt_hal_handle_device_specific_events(GVariant *msg, const char *member,
_bt_hal_convert_device_path_to_address(path, address);
DBG("Member: [%s]", member);
- ERR_C("Connected [%s] [%s]", !addr_type ? "BREDR" : "LE", address);
+ ERR_C("### Connected [%s] [%s]", !addr_type ? "BREDR" : "LE", address);
if (!addr_type)
__bt_hal_send_device_acl_connection_state_event(BT_STATUS_SUCCESS, TRUE, address);
else
address = g_malloc0(BT_HAL_ADDRESS_STRING_SIZE);
_bt_hal_convert_device_path_to_address(path, address);
- DBG("Member: [%s]", member);
+ ERR_C("### Disconnected [%s] [%d : %s] [%s] [%s]", !addr_type ? "BREDR" : "LE",
+ disc_reason, _bt_hal_convert_disc_reason_to_string(disc_reason), address, name);
- ERR_C("DisConnected [%s] [%s]", !addr_type ? "BREDR" : "LE", address);
- DBG("Disconnected Reason [%d : %s]", disc_reason, _bt_hal_convert_disc_reason_to_string(disc_reason));
- DBG("Name: %s", name);
if (!addr_type)
- __bt_hal_send_device_acl_connection_state_event(_bt_hal_convert_disc_reason_to_status(disc_reason), FALSE, address);
+ __bt_hal_send_device_acl_connection_state_event(disc_reason, FALSE, address);
else
- __bt_hal_send_device_le_connection_state_event(_bt_hal_convert_disc_reason_to_status(disc_reason), FALSE, address);
+ __bt_hal_send_device_le_connection_state_event(disc_reason, FALSE, address);
g_free(address);
} else if (strcasecmp(member, "ProfileStateChanged") == 0) {
int state = 0;
address = g_malloc0(BT_HAL_ADDRESS_STRING_SIZE);
_bt_hal_convert_device_path_to_address(path, address);
- DBG("Address: %s", address);
- DBG("Profile UUID: %s", profile_uuid);
- DBG("State: %d", state);
if (strncmp(profile_uuid, HID_UUID, strlen(HID_UUID)) == 0) {
+ DBG("HID Host Profile state: %d", state);
if (state == BT_HAL_PROFILE_STATE_CONNECTED)
__bt_hal_send_hid_connection_state_event(TRUE, address);
else if (state == BT_HAL_PROFILE_STATE_DISCONNECTED)
__bt_hal_send_hid_connection_state_event(FALSE, address);
else
- DBG("Profile state: %d", state);
-
- } else if ((strncmp(profile_uuid, A2DP_SINK_UUID, strlen(A2DP_SINK_UUID)) == 0)) {
+ DBG("HID Host Profile state: Invalid");
+ } else if (strcmp(profile_uuid, HID_DEVICE_UUID) == 0) {
+ DBG("HID Device Profile state: %d", state);
+ if (state == BT_HAL_PROFILE_STATE_CONNECTED)
+ __bt_hal_send_hid_device_connection_state_event(TRUE, address);
+ else if (state == BT_HAL_PROFILE_STATE_DISCONNECTED)
+ __bt_hal_send_hid_device_connection_state_event(FALSE, address);
+ else
+ DBG("HID Device Profile state: Invalid");
+ } else if ((strcmp(profile_uuid, A2DP_SINK_UUID) == 0)) {
if (state == BT_HAL_PROFILE_STATE_CONNECTED) {
DBG("A2DP Profile state changed: BT_PROFILE_STATE_CONNECTED");
__bt_hal_send_av_connection_state_event(TRUE, address);
} else {
ERR("A2DP Profile state: Invalid");
}
- } else if ((strncmp(profile_uuid, A2DP_SOURCE_UUID, strlen(A2DP_SOURCE_UUID)) == 0)) {
+ } else if ((strcmp(profile_uuid, A2DP_SOURCE_UUID) == 0)) {
if (state == BT_HAL_PROFILE_STATE_CONNECTED) {
DBG("A2DP Sink Profile state changed: BT_HAL_PROFILE_STATE_CONNECTED");
__bt_hal_send_a2dp_sink_connection_state_event(TRUE, address);
} else if (state == BT_HAL_PROFILE_STATE_CONNECTING) {
DBG("A2DP Sink Profile state changed: BT_HAL_PROFILE_STATE_CONNECTING");
}
- } else if (strncmp(profile_uuid, HFP_HF_UUID, strlen(HFP_HF_UUID)) == 0) {
+ } else if (strcmp(profile_uuid, HFP_HF_UUID) == 0) {
if (state == BT_HAL_PROFILE_STATE_CONNECTING)
DBG("HFP Profile state changed: BT_PROFILE_STATE_CONNECTING");
else if (state == BT_HAL_PROFILE_STATE_CONNECTED) {
} else {
ERR("HFP Profile state: Invalid");
}
- } else if ((strncmp(profile_uuid, AVRCP_TARGET_UUID, strlen(AVRCP_TARGET_UUID)) == 0)) {
+ } else if (strcmp(profile_uuid, HFP_AG_UUID) == 0) {
+ if (state == BT_HAL_PROFILE_STATE_CONNECTING)
+ DBG("HFP Client Profile state changed: BT_PROFILE_STATE_CONNECTING");
+ else if (state == BT_HAL_PROFILE_STATE_CONNECTED) {
+ DBG("HFP Client Profile state changed: BT_PROFILE_STATE_CONNECTED");
+ __bt_hal_send_hf_client_connection_state_event(TRUE, address);
+ } else if (state == BT_HAL_PROFILE_STATE_DISCONNECTED) {
+ DBG("HFP Client Profile state changed: BT_PROFILE_STATE_DISCONNECTED");
+ __bt_hal_send_hf_client_connection_state_event(FALSE, address);
+ } else if (state == BT_HAL_PROFILE_STATE_DISCONNECTING) {
+ DBG("HFP Client Profile state changed: BT_PROFILE_STATE_DISCONNECTING");
+ } else {
+ ERR("HFP Client Profile state: Invalid");
+ }
+ } else if ((strcmp(profile_uuid, AVRCP_TARGET_UUID) == 0)) {
if (state == BT_HAL_PROFILE_STATE_CONNECTED) {
DBG("AVRCP Controller Profile state changed: BT_HAL_PROFILE_STATE_CONNECTED");
__bt_hal_send_avrcp_ctrl_connection_state_event(TRUE, address);
DBG("AVRCP Controller Profile state changed: BT_HAL_PROFILE_STATE_CONNECTING");
}
} else {
- DBG("Profile[%s] State changed status [%d] ", profile_uuid, state);
+ DBG("Profile [%s] State changed [%d] [%s] ", profile_uuid, state, address);
}
g_free(address);
g_free(profile_uuid);
+ } else if (strcasecmp(member, "AttMtuChanged") == 0) {
+ char *address;
+ guint16 mtu = 0;
+
+ address = g_malloc0(BT_HAL_ADDRESS_STRING_SIZE);
+
+ _bt_hal_convert_device_path_to_address(path, address);
+ g_variant_get(msg, "(q)", &mtu);
+
+ __bt_hal_handle_gatts_mtu_changed_event(address, mtu);
+
+ g_free(address);
} else if (strcasecmp(member, "AdvReport") == 0) {
- DBG("Member: [%s]", member);
__bt_hal_handle_adv_report(msg, path);
}
}
memcpy(ev->adv_data, buffer, data_len);
size += data_len;
- DBG("Send le scan result event to HAL, size: [%zd]", size);
gatt_event_cb(HAL_EV_GATT_CLIENT_SCAN_RESULT, buf, size);
g_variant_unref(value);
}
+static void __bt_hal_handle_gatts_mtu_changed_event(char *address, int mtu)
+{
+ uint8_t buf[BT_HAL_MAX_PROPERTY_BUF_SIZE];
+ struct hal_ev_gatt_server_mtu_changed *ev = (void *)buf;
+ size_t size = 0;
+
+ if (!gatt_event_cb)
+ return;
+
+ memset(buf, 0, sizeof(buf));
+ size = sizeof(*ev);
+
+ ev->conn_id = _bt_get_remote_gatt_client_conn_id(address);
+ ev->mtu = mtu;
+
+ gatt_event_cb(HAL_EV_GATT_SERVER_MTU_CHANGED, buf, size);
+}
+
/* AVRCP Controller Role(Remote:AVRCP Target) Events */
static void __bt_hal_send_avrcp_ctrl_connection_state_event(gboolean connected, const char *address)
{
ev.state = HAL_AVRCP_CTRL_STATE_DISCONNECTED;
_bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
- if (!a2dp_sink_event_cb)
- ERR("AV event handler not registered");
+ if (!avrcp_ctrl_event_cb)
+ ERR("AVRCP controller handler not registered");
else
avrcp_ctrl_event_cb(HAL_EV_AVRCP_CTRL_CONN_STATE, &ev, sizeof(ev));
}
}
ev->num_attr = i;
- g_variant_iter_free(&iter);
return;
}
DBG("Property not handled");
}
}
-
- g_free((char *)property);
- g_variant_unref(value);
}
static void __bt_hal_handle_avrcp_transport_events(GVariant *msg, const char *member,
/* Send event to application */
avrcp_tg_event_cb(HAL_EV_AVRCP_TG_DELAY_CHANGE, &ev, sizeof(ev));
+ } else if ((strcasecmp(property, "Volume") == 0)) {
+ struct hal_ev_avrcp_tg_volume_changed ev;
+ uint16_t val;
+
+ memset(&ev, 0, sizeof(ev));
+ _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
+
+ val = g_variant_get_uint16(value);
+ DBG("Value : %d", val);
+ ev.volume = val;
+
+ /* Send event to application */
+ avrcp_tg_event_cb(HAL_EV_AVRCP_TG_VOLUME_CHANGE, &ev, sizeof(ev));
} else {
DBG("Property not handled");
}
}
-
- DBG("-");
- g_free((char *)property);
- g_variant_unref(value);
}
/* A2DP Src Role(Remote:Sink) Events */
static void __bt_hal_send_av_connection_state_event(gboolean connected, const char *address)
{
- DBG("+");
struct hal_ev_a2dp_conn_state ev;
if (connected == TRUE)
/* A2DP Sink Role(Remote:Source) Events */
static void __bt_hal_send_a2dp_sink_connection_state_event(gboolean connected, const char *address)
{
- DBG("+");
struct hal_ev_a2dp_conn_state ev;
if (connected == TRUE)
static void __bt_hal_send_hf_audio_connection_state_event(gboolean connected,
const char *address)
{
- DBG("+");
struct hal_ev_handsfree_audio_state ev;
if (connected == TRUE)
static void __bt_hal_send_hf_connection_state_event(gboolean connected,
const char *address)
{
- DBG("+");
struct hal_ev_handsfree_conn_state ev;
if (connected == TRUE)
hf_event_cb(HAL_EV_HANDSFREE_CONN_STATE, &ev, sizeof(ev));
}
+/* HF(Client Role) Profile Events */
+static void __bt_hal_send_hf_client_connection_state_event(gboolean connected,
+ const char *address)
+{
+ struct hal_ev_hf_client_conn_state ev;
+
+ if (connected == TRUE)
+ INFO("HF Client Profile Connected for address [%s]", address);
+ else
+ INFO("HF Client Profile DisConnected for address [%s]", address);
+
+ ev.state = (connected == TRUE) ?
+ HAL_EV_HF_CLIENT_CONN_STATE_CONNECTED :
+ HAL_EV_HF_CLIENT_CONN_STATE_DISCONNECTED;
+
+ _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
+
+ if (!hf_client_event_cb)
+ ERR("HF Client event handler not registered");
+ else
+ hf_client_event_cb(HAL_EV_HF_CLIENT_CONN_STATE, &ev, sizeof(ev));
+}
+
void _bt_hal_register_event_handler_cb(bt_hal_module_e module, handle_stack_msg cb)
{
switch (module) {
case HAL_HIDHOST:
hid_event_cb = cb;
break;
+ case HAL_HIDDEVICE:
+ hid_device_event_cb = cb;
+ break;
case HAL_A2DP_SRC:
av_event_cb = cb;
break;
case HAL_HF_AG:
hf_event_cb = cb;
break;
+ case HAL_HF_CLIENT:
+ hf_client_event_cb = cb;
+ break;
case HAL_AVRCP_TG:
avrcp_tg_event_cb = cb;
break;
case HAL_HF_AG:
hf_event_cb = NULL;
break;
+ case HAL_HF_CLIENT:
+ hf_client_event_cb = NULL;
+ break;
case HAL_AVRCP_TG:
avrcp_tg_event_cb = NULL;
break;
projects / platform / core / connectivity / bluetooth-frwk.git / blobdiff