#include "bt-service-device.h"
#include "bt-service-obex-server.h"
#include "bt-service-rfcomm-server.h"
+#include "bt-service-opp-client.h"
#include "bt-service-audio.h"
-static DBusGConnection *manager_conn;
-static DBusGConnection *obexd_conn;
+static DBusGConnection *manager_conn = NULL;
+static DBusGConnection *obexd_conn = NULL;
+static DBusGConnection *opc_obexd_conn = NULL;
+static GList *g_list = NULL;
static guint event_id;
-static gboolean __bt_parse_device_properties(DBusMessageIter *item_iter,
- bt_remote_dev_info_t *dev_info)
+static bt_remote_dev_info_t *__bt_parse_device_properties(DBusMessageIter *item_iter)
{
DBusMessageIter value_iter;
char *value;
-
- if (dbus_message_iter_get_arg_type(item_iter) != DBUS_TYPE_ARRAY)
- return FALSE;
+ bt_remote_dev_info_t *dev_info;
dbus_message_iter_recurse(item_iter, &value_iter);
+ if (dbus_message_iter_get_arg_type(&value_iter) != DBUS_TYPE_DICT_ENTRY) {
+ BT_DBG("No entry");
+ return NULL;
+ }
+
+ dev_info = g_malloc0(sizeof(bt_remote_dev_info_t));
+
while (dbus_message_iter_get_arg_type(&value_iter) ==
DBUS_TYPE_DICT_ENTRY) {
char *key;
dbus_message_iter_recurse(&value_iter, &dict_entry);
dbus_message_iter_get_basic(&dict_entry, &key);
+
if (key == NULL) {
dbus_message_iter_next(&value_iter);
continue;
continue;
}
dbus_message_iter_recurse(&dict_entry, &iter_dict_val);
- if (strcasecmp(key, "Class") == 0) {
+
+ if (strcasecmp(key, "Address") == 0) {
+ const char *address = NULL;
+ dbus_message_iter_get_basic(&iter_dict_val, &address);
+ dev_info->address = g_strdup(address);
+ } else if (strcasecmp(key, "Class") == 0) {
dbus_message_iter_get_basic(&iter_dict_val, &dev_info->class);
- } else if (strcasecmp(key, "name") == 0) {
+ } else if (strcasecmp(key, "Name") == 0) {
dbus_message_iter_get_basic(&iter_dict_val, &value);
if (dev_info->name == NULL)
dev_info->name = g_strdup(value);
} else if (strcasecmp(key, "Connected") == 0) {
dbus_message_iter_get_basic(&iter_dict_val,
&dev_info->connected);
- } else if (strcasecmp(key, "paired") == 0) {
+ } else if (strcasecmp(key, "Paired") == 0) {
dbus_message_iter_get_basic(&iter_dict_val,
&dev_info->paired);
} else if (strcasecmp(key, "Trusted") == 0) {
dev_info->uuids = g_new0(char *,
dev_info->uuid_count + 1);
} else {
+ dbus_message_iter_next(&value_iter);
continue;
}
dbus_message_iter_next(&value_iter);
}
- return TRUE;
+ return dev_info;
+}
+
+void __bt_parse_media_properties(DBusMessageIter *item_iter)
+{
+ DBusMessageIter value_iter;
+ char *address = NULL;
+ char *uuid = NULL;
+ int result = BLUETOOTH_ERROR_NONE;
+
+ dbus_message_iter_recurse(item_iter, &value_iter);
+
+ if (dbus_message_iter_get_arg_type(&value_iter) !=
+ DBUS_TYPE_DICT_ENTRY) {
+ BT_DBG("No entry");
+ return;
+ }
+
+ while (dbus_message_iter_get_arg_type(&value_iter) ==
+ DBUS_TYPE_DICT_ENTRY) {
+ char *key;
+ DBusMessageIter dict_entry;
+ DBusMessageIter iter_dict_val;
+
+ dbus_message_iter_recurse(&value_iter, &dict_entry);
+ dbus_message_iter_get_basic(&dict_entry, &key);
+
+ if (key == NULL) {
+ dbus_message_iter_next(&value_iter);
+ continue;
+ }
+
+ if (!dbus_message_iter_next(&dict_entry)) {
+ dbus_message_iter_next(&value_iter);
+ continue;
+ }
+
+ dbus_message_iter_recurse(&dict_entry, &iter_dict_val);
+
+ BT_DBG("key: %s", key);
+
+ if (strcasecmp(key, "Device") == 0) {
+ char *object_path = NULL;
+
+ dbus_message_iter_get_basic(&iter_dict_val, &object_path);
+ address = g_malloc0(BT_ADDRESS_STRING_SIZE);
+ _bt_convert_device_path_to_address(object_path, address);
+
+ }else if (strcasecmp(key, "UUID") == 0) {
+ dbus_message_iter_get_basic(&iter_dict_val, &uuid);
+ }
+
+ dbus_message_iter_next(&value_iter);
+ }
+
+ if (address != NULL && uuid != NULL){
+ int event = BLUETOOTH_EVENT_AV_CONNECTED;
+ char connected_address[BT_ADDRESS_STRING_SIZE + 1];
+ bluetooth_device_address_t device_address;
+ gboolean connected;
+
+ _bt_send_event(BT_HEADSET_EVENT, event,
+ DBUS_TYPE_INT32, &result,
+ DBUS_TYPE_STRING, &address,
+ DBUS_TYPE_INVALID);
+
+ connected = _bt_is_headset_type_connected(BT_AUDIO_A2DP,
+ connected_address);
+ if (connected) {
+ if (g_strcmp0(connected_address, address) != 0) {
+ _bt_convert_addr_string_to_type(
+ device_address.addr,
+ connected_address);
+ _bt_audio_disconnect(0, BT_AUDIO_A2DP,
+ &device_address, NULL);
+ }
+ }
+
+ _bt_add_headset_to_list(BT_AUDIO_A2DP,
+ BT_STATE_CONNECTED, address);
+
+ g_free(address);
+ }
+}
+
+static void __bt_parse_audio_properties(DBusMessage *msg)
+{
+ DBusMessageIter msg_iter;
+ DBusMessageIter value_iter;
+
+ ret_if(dbus_message_iter_init(msg, &msg_iter) == FALSE);
+
+ /* object array (oa) */
+ ret_if(dbus_message_iter_next(&msg_iter) == FALSE);
+ ret_if(dbus_message_iter_get_arg_type(&msg_iter) !=
+ DBUS_TYPE_ARRAY);
+
+ dbus_message_iter_recurse(&msg_iter, &value_iter);
+
+ /* string array (sa) */
+ while (dbus_message_iter_get_arg_type(&value_iter) ==
+ DBUS_TYPE_DICT_ENTRY) {
+ char *interface_name = NULL;
+ DBusMessageIter interface_iter;
+
+ dbus_message_iter_recurse(&value_iter, &interface_iter);
+
+ ret_if(dbus_message_iter_get_arg_type(&interface_iter) !=
+ DBUS_TYPE_STRING);
+
+ dbus_message_iter_get_basic(&interface_iter, &interface_name);
+
+ ret_if(dbus_message_iter_next(&interface_iter) == FALSE);
+
+ ret_if(dbus_message_iter_get_arg_type(&interface_iter) !=
+ DBUS_TYPE_ARRAY);
+
+ BT_DBG("interface: %s", interface_name);
+
+ if (g_strcmp0(interface_name,
+ "org.bluez.MediaTransport1") == 0) {
+ __bt_parse_media_properties(&interface_iter);
+ return;
+ }
+ dbus_message_iter_next(&value_iter);
+ }
+
+ return;
+}
+
+static int __bt_parse_event(DBusMessage *msg)
+{
+ DBusMessageIter msg_iter;
+ DBusMessageIter value_iter;
+
+ retv_if(dbus_message_iter_init(msg, &msg_iter) == FALSE, 0);
+
+ /* object array (oa) */
+ retv_if(dbus_message_iter_next(&msg_iter) == FALSE, 0);
+ retv_if(dbus_message_iter_get_arg_type(&msg_iter) !=
+ DBUS_TYPE_ARRAY, 0);
+
+ dbus_message_iter_recurse(&msg_iter, &value_iter);
+
+ /* string array (sa) */
+ while (dbus_message_iter_get_arg_type(&value_iter) ==
+ DBUS_TYPE_DICT_ENTRY) {
+ char *interface_name = NULL;
+ DBusMessageIter interface_iter;
+
+ dbus_message_iter_recurse(&value_iter, &interface_iter);
+
+ retv_if(dbus_message_iter_get_arg_type(&interface_iter) !=
+ DBUS_TYPE_STRING, 0);
+
+ dbus_message_iter_get_basic(&interface_iter,
+ &interface_name);
+
+ retv_if(dbus_message_iter_next(&interface_iter) == FALSE,
+ 0);
+
+ retv_if(dbus_message_iter_get_arg_type(&interface_iter) !=
+ DBUS_TYPE_ARRAY, 0);
+
+ BT_DBG("interface: %s", interface_name);
+
+ if (g_strcmp0(interface_name,
+ "org.bluez.Device1") == 0) {
+ return BT_DEVICE_EVENT;
+ }else if (g_strcmp0(interface_name,
+ "org.bluez.MediaTransport1") == 0) {
+ return BT_MEDIA_TRANSFER_EVENT;
+ }
+ dbus_message_iter_next(&value_iter);
+ }
+
+ return 0;
+}
+
+static int __bt_parse_remove_event(DBusMessage *msg)
+{
+ DBusMessageIter msg_iter;
+ DBusMessageIter value_iter;
+
+ retv_if(dbus_message_iter_init(msg, &msg_iter) ==
+ FALSE, 0);
+
+ retv_if(dbus_message_iter_next(&msg_iter) == FALSE,
+ 0);
+ retv_if(dbus_message_iter_get_arg_type(&msg_iter) !=
+ DBUS_TYPE_ARRAY, 0);
+
+ dbus_message_iter_recurse(&msg_iter, &value_iter);
+
+ while (dbus_message_iter_get_arg_type(&value_iter)
+ != DBUS_TYPE_INVALID) {
+ char *key;
+
+ dbus_message_iter_get_basic(&value_iter, &key);
+
+ if (key == NULL) {
+ dbus_message_iter_next(&value_iter);
+ continue;
+ }
+
+ BT_DBG("key = %s", key);
+
+ if (g_strcmp0(key, "org.bluez.MediaTransport1") == 0) {
+ return BT_MEDIA_TRANSFER_EVENT;
+ }else if (g_strcmp0(key, "org.bluez.Device1") == 0) {
+ return BT_DEVICE_EVENT;
+ }
+ dbus_message_iter_next(&value_iter);
+ }
+
+ return 0;
+}
+
+gboolean _bt_parse_audio_remove_properties(DBusMessage *msg)
+{
+ DBusMessageIter msg_iter;
+ DBusMessageIter value_iter;
+ char *object_path = NULL;
+ char *address = NULL;
+ int result = BLUETOOTH_ERROR_NONE;
+ bt_headset_wait_t *wait_list;
+
+ retv_if(dbus_message_iter_init(msg, &msg_iter) == FALSE, FALSE);
+
+ dbus_message_iter_get_basic(&msg_iter, &object_path);
+ retv_if(object_path == NULL, FALSE);
+
+ address = g_malloc0(BT_ADDRESS_STRING_SIZE);
+ _bt_convert_device_path_to_address(object_path, address);
+
+ retv_if(dbus_message_iter_next(&msg_iter) == FALSE, FALSE);
+ retv_if(dbus_message_iter_get_arg_type(&msg_iter) !=
+ DBUS_TYPE_ARRAY, FALSE);
+
+ dbus_message_iter_recurse(&msg_iter, &value_iter);
+
+ while (dbus_message_iter_get_arg_type(&value_iter)
+ != DBUS_TYPE_INVALID) {
+ char *key;
+
+ dbus_message_iter_get_basic(&value_iter, &key);
+
+ if (key == NULL) {
+ dbus_message_iter_next(&value_iter);
+ continue;
+ }
+
+ BT_DBG("key = %s", key);
+
+ if (g_strcmp0(key, "org.bluez.MediaTransport1") == 0) {
+ int event = BLUETOOTH_EVENT_AV_DISCONNECTED;
+
+ _bt_send_event(BT_HEADSET_EVENT, event,
+ DBUS_TYPE_INT32, &result,
+ DBUS_TYPE_STRING, &address,
+ DBUS_TYPE_INVALID);
+
+ /* Remove data from the connected list */
+ _bt_remove_headset_from_list(BT_AUDIO_A2DP, address);
+ wait_list = _bt_get_audio_wait_data();
+
+ if (wait_list == NULL) {
+ g_free(address);
+ return TRUE;
+ }
+
+ if (((wait_list->type == BT_AUDIO_ALL) &&
+ (wait_list->ag_flag == TRUE)) ||
+ (wait_list->type == BT_AUDIO_A2DP) ||
+ (wait_list->disconnection_type == BT_AUDIO_A2DP)) {
+ bluetooth_device_address_t device_address;
+ _bt_convert_addr_string_to_type(
+ device_address.addr,
+ wait_list->address);
+
+ _bt_audio_connect(wait_list->req_id,
+ wait_list->type,
+ &device_address,
+ wait_list->out_param1);
+ }
+
+ g_free(address);
+ return TRUE;
+ }
+ dbus_message_iter_next(&value_iter);
+ }
+
+ g_free(address);
+ return FALSE;
+}
+
+static bt_remote_dev_info_t *__bt_parse_interface(DBusMessage *msg)
+{
+ DBusMessageIter msg_iter;
+ DBusMessageIter value_iter;
+ char *object_path = NULL;
+ bt_remote_dev_info_t *dev_info = NULL;
+
+ retv_if(dbus_message_iter_init(msg, &msg_iter) == FALSE, NULL);
+
+ dbus_message_iter_get_basic(&msg_iter, &object_path);
+ retv_if(object_path == NULL, NULL);
+
+ /* object array (oa) */
+ retv_if(dbus_message_iter_next(&msg_iter) == FALSE, NULL);
+ retv_if(dbus_message_iter_get_arg_type(&msg_iter) !=
+ DBUS_TYPE_ARRAY, NULL);
+
+ dbus_message_iter_recurse(&msg_iter, &value_iter);
+
+ /* string array (sa) */
+ while (dbus_message_iter_get_arg_type(&value_iter) ==
+ DBUS_TYPE_DICT_ENTRY) {
+ char *interface_name = NULL;
+ DBusMessageIter interface_iter;
+
+ dbus_message_iter_recurse(&value_iter, &interface_iter);
+
+ retv_if(dbus_message_iter_get_arg_type(&interface_iter) !=
+ DBUS_TYPE_STRING, NULL);
+
+ dbus_message_iter_get_basic(&interface_iter, &interface_name);
+
+ retv_if(dbus_message_iter_next(&interface_iter) == FALSE, NULL);
+
+ retv_if(dbus_message_iter_get_arg_type(&interface_iter) !=
+ DBUS_TYPE_ARRAY, NULL);
+
+ BT_DBG("interface: %s", interface_name);
+
+ if (g_strcmp0(interface_name, "org.bluez.Device1") == 0) {
+ BT_DBG("Found a device: %s", object_path);
+
+ dev_info = __bt_parse_device_properties(&interface_iter);
+
+ if (dev_info == NULL) {
+ BT_ERR("Fail to parse the properies");
+ return NULL;
+ }
+ }
+
+ dbus_message_iter_next(&value_iter);
+ }
+
+ return dev_info;
}
char *__bt_get_headset_name(char *address)
return BLUETOOTH_ERROR_NONE;
}
-gboolean _bt_discovery_finished_cb(gpointer user_data)
+gboolean _bt_stop_discovery_timeout_cb(gpointer user_data)
{
- int result = BLUETOOTH_ERROR_NONE;
+ DBusGProxy *adapter_proxy;
+
event_id = 0;
- if (_bt_get_discoverying_property() == FALSE) {
- if (_bt_get_cancel_by_user() == TRUE) {
- result = BLUETOOTH_ERROR_CANCEL_BY_USER;
- }
+ adapter_proxy = _bt_get_adapter_proxy();
+ retv_if(adapter_proxy == NULL, FALSE);
- _bt_set_cancel_by_user(FALSE);
- _bt_set_discovery_status(FALSE);
- _bt_send_event(BT_ADAPTER_EVENT,
- BLUETOOTH_EVENT_DISCOVERY_FINISHED,
- DBUS_TYPE_INT32, &result,
- DBUS_TYPE_INVALID);
+ /* Need to stop searching */
+ dbus_g_proxy_call(adapter_proxy,
+ "StopDiscovery",
+ NULL,
+ G_TYPE_INVALID,
+ G_TYPE_INVALID);
+
+ return FALSE;
+}
+
+void _bt_stop_discovery_timeout(void)
+{
+ if (event_id > 0)
+ return;
+
+ event_id = g_timeout_add(BT_STOP_DISCOVERY_TIMEOUT,
+ (GSourceFunc)_bt_stop_discovery_timeout_cb, NULL);
+}
+
+static gboolean __bt_discovery_finished()
+{
+ int result = BLUETOOTH_ERROR_NONE;
+
+ if (_bt_get_cancel_by_user() == TRUE) {
+ result = BLUETOOTH_ERROR_CANCEL_BY_USER;
}
+ _bt_set_cancel_by_user(FALSE);
+ _bt_set_discovery_status(FALSE);
+ _bt_send_event(BT_ADAPTER_EVENT,
+ BLUETOOTH_EVENT_DISCOVERY_FINISHED,
+ DBUS_TYPE_INT32, &result,
+ DBUS_TYPE_INVALID);
+
return FALSE;
}
-void _bt_handle_adapter_event(DBusMessage *msg)
+void __bt_adapter_property_changed_event(DBusMessageIter *msg_iter, const char *path)
{
int mode = 0;
int result = BLUETOOTH_ERROR_NONE;
- DBusGProxy *adapter_proxy;
- DBusMessageIter item_iter;
DBusMessageIter value_iter;
+ DBusMessageIter dict_iter;
+ DBusMessageIter item_iter;
GValue timeout = { 0 };
- const char *member = dbus_message_get_member(msg);
const char *property = NULL;
- ret_if(member == NULL);
+ dbus_message_iter_recurse(msg_iter, &item_iter);
- if (strcasecmp(member, "PropertyChanged") == 0) {
- dbus_message_iter_init(msg, &item_iter);
+ if (dbus_message_iter_get_arg_type(&item_iter)
+ != DBUS_TYPE_DICT_ENTRY) {
+ BT_ERR("This is bad format dbus\n");
+ return;
+ }
- if (dbus_message_iter_get_arg_type(&item_iter)
- != DBUS_TYPE_STRING) {
- BT_ERR("This is bad format dbus\n");
- return;
+ dbus_message_iter_recurse(&item_iter, &dict_iter);
+
+ dbus_message_iter_get_basic(&dict_iter, &property);
+ ret_if(property == NULL);
+
+ ret_if(!dbus_message_iter_next(&dict_iter));
+
+ if (strcasecmp(property, "Discovering") == 0) {
+ gboolean discovering = FALSE;
+
+ dbus_message_iter_recurse(&dict_iter, &value_iter);
+ dbus_message_iter_get_basic(&value_iter, &discovering);
+
+ /* Send event to application */
+ if (discovering == TRUE) {
+ _bt_set_discovery_status(TRUE);
+ _bt_send_event(BT_ADAPTER_EVENT,
+ BLUETOOTH_EVENT_DISCOVERY_STARTED,
+ DBUS_TYPE_INT32, &result,
+ DBUS_TYPE_INVALID);
+ _bt_get_temp_remote_devinfo();
+ } else {
+ if (event_id > 0){
+ g_source_remove(event_id);
+ event_id = 0;
+ }
+ __bt_discovery_finished();
}
+ } else if (strcasecmp(property, "Alias") == 0) {
+ char *name = NULL;
- dbus_message_iter_get_basic(&item_iter, &property);
- BT_DBG("member = PropertyChanged[%s]", property);
+ dbus_message_iter_recurse(&dict_iter, &value_iter);
+ dbus_message_iter_get_basic(&value_iter, &name);
- ret_if(property == NULL);
+ /* Send event to application */
+ _bt_send_event(BT_ADAPTER_EVENT,
+ BLUETOOTH_EVENT_LOCAL_NAME_CHANGED,
+ DBUS_TYPE_INT32, &result,
+ DBUS_TYPE_STRING, &name,
+ DBUS_TYPE_INVALID);
+ } else if (strcasecmp(property, "Powered") == 0) {
+ gboolean power = FALSE;
- if (strcasecmp(property, "Discovering") == 0) {
- gboolean discovering = FALSE;
- dbus_message_iter_next(&item_iter);
- dbus_message_iter_recurse(&item_iter, &value_iter);
- dbus_message_iter_get_basic(&value_iter, &discovering);
+ dbus_message_iter_recurse(&dict_iter, &value_iter);
+ dbus_message_iter_get_basic(&value_iter, &power);
- /* Send event to application */
- if (discovering == TRUE) {
- _bt_set_discovery_status(TRUE);
- _bt_send_event(BT_ADAPTER_EVENT,
- BLUETOOTH_EVENT_DISCOVERY_STARTED,
- DBUS_TYPE_INT32, &result,
- DBUS_TYPE_INVALID);
- } else {
- ret_if(event_id > 0);
+ BT_DBG("power state changed: %d", power);
+
+ if (power == TRUE)
+ _bt_set_enabled();
+ else
+ _bt_set_disabled();
+
+ } else if (strcasecmp(property, "Discoverable") == 0) {
+ gboolean discoverable = FALSE;
+
+ dbus_message_iter_recurse(&dict_iter, &value_iter);
+ dbus_message_iter_get_basic(&value_iter, &discoverable);
- adapter_proxy = _bt_get_adapter_proxy();
+ if (discoverable == FALSE) {
+ if (_bt_get_discoverable_timeout_property() > 0) {
+ DBusGProxy *adapter_proxy;
+ g_value_init(&timeout, G_TYPE_UINT);
+ g_value_set_uint(&timeout, 0);
+
+ adapter_proxy = _bt_get_adapter_properties_proxy();
ret_if(adapter_proxy == NULL);
- /* Need to stop searching */
- dbus_g_proxy_call(adapter_proxy,
- "StopDiscovery",
- NULL,
- G_TYPE_INVALID,
- G_TYPE_INVALID);
+ dbus_g_proxy_call_no_reply(adapter_proxy, "Set",
+ G_TYPE_STRING, BT_ADAPTER_INTERFACE,
+ G_TYPE_STRING, "DiscoverableTimeout",
+ G_TYPE_VALUE, &timeout,
+ G_TYPE_INVALID);
- event_id = g_timeout_add(BT_DISCOVERY_FINISHED_DELAY,
- (GSourceFunc)_bt_discovery_finished_cb, NULL);
+ g_value_unset(&timeout);
}
- } else if (strcasecmp(property, "Name") == 0) {
- char *name = NULL;
- dbus_message_iter_next(&item_iter);
- dbus_message_iter_recurse(&item_iter, &value_iter);
- dbus_message_iter_get_basic(&value_iter, &name);
+
+ mode = BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE;
/* Send event to application */
_bt_send_event(BT_ADAPTER_EVENT,
- BLUETOOTH_EVENT_LOCAL_NAME_CHANGED,
+ BLUETOOTH_EVENT_DISCOVERABLE_MODE_CHANGED,
DBUS_TYPE_INT32, &result,
- DBUS_TYPE_STRING, &name,
+ DBUS_TYPE_INT16, &mode,
DBUS_TYPE_INVALID);
- } else if (strcasecmp(property, "Discoverable") == 0) {
- gboolean discoverable = FALSE;
- dbus_message_iter_next(&item_iter);
- dbus_message_iter_recurse(&item_iter, &value_iter);
- dbus_message_iter_get_basic(&value_iter, &discoverable);
+ } else {
+ _bt_get_discoverable_mode(&mode);
+
+ /* Event will be sent by "DiscoverableTimeout" signal */
+ ret_if(mode != BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE);
+
+ /* Send event to application */
+ _bt_send_event(BT_ADAPTER_EVENT,
+ BLUETOOTH_EVENT_DISCOVERABLE_MODE_CHANGED,
+ DBUS_TYPE_INT32, &result,
+ DBUS_TYPE_INT16, &mode,
+ DBUS_TYPE_INVALID);
+ }
+ } else if (strcasecmp(property, "DiscoverableTimeout") == 0) {
+ _bt_get_discoverable_mode(&mode);
+
+ /* Event was already sent by "Discoverable" signal */
+ ret_if(mode == BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE);
+
+ /* Send event to application */
+ _bt_send_event(BT_ADAPTER_EVENT,
+ BLUETOOTH_EVENT_DISCOVERABLE_MODE_CHANGED,
+ DBUS_TYPE_INT32, &result,
+ DBUS_TYPE_INT16, &mode,
+ DBUS_TYPE_INVALID);
+ }
+}
+
+static void __bt_device_remote_connected_properties(
+ bt_remote_dev_info_t *remote_dev_info,
+ char *address, gboolean connected)
+{
+ int result = BLUETOOTH_ERROR_NONE;
+
+ BT_DBG("+");
+
+ if (remote_dev_info->uuid_count > 0 ) {
+ for (int i = 0; i<remote_dev_info->uuid_count; i++) {
+ char *uuid = remote_dev_info->uuids[i];
+ if (strcasecmp(uuid, HID_UUID) == 0){
+ int event = (connected == TRUE) ?
+ BLUETOOTH_HID_CONNECTED :
+ BLUETOOTH_HID_DISCONNECTED;
+
+ _bt_send_event(BT_HID_EVENT, event,
+ DBUS_TYPE_INT32, &result,
+ DBUS_TYPE_STRING, &address,
+ DBUS_TYPE_INVALID);
+ break;
+ }
+ }
+ }
+
+ BT_DBG("-");
+}
+
+void __bt_device_property_changed_event(DBusMessageIter *msg_iter, const char *path)
+{
+ int event;
+ int result = BLUETOOTH_ERROR_NONE;
+ DBusMessageIter value_iter;
+ DBusMessageIter dict_iter;
+ DBusMessageIter item_iter;
+ const char *property = NULL;
+ char *address;
+ bt_remote_dev_info_t *remote_dev_info;
+
+ dbus_message_iter_recurse(msg_iter, &item_iter);
+
+ do {
+ if (dbus_message_iter_get_arg_type(&item_iter)
+ != DBUS_TYPE_DICT_ENTRY) {
+ BT_ERR("This is bad format dbus\n");
+ return;
+ }
+
+ dbus_message_iter_recurse(&item_iter, &dict_iter);
- if (discoverable == FALSE) {
- if (_bt_get_discoverable_timeout_property() > 0) {
- g_value_init(&timeout, G_TYPE_UINT);
- g_value_set_uint(&timeout, 0);
+ dbus_message_iter_get_basic(&dict_iter, &property);
+ ret_if(property == NULL);
- adapter_proxy = _bt_get_adapter_proxy();
- ret_if(adapter_proxy == NULL);
+ ret_if(!dbus_message_iter_next(&dict_iter));
- dbus_g_proxy_call_no_reply(adapter_proxy, "SetProperty",
- G_TYPE_STRING, "DiscoverableTimeout",
- G_TYPE_VALUE, &timeout,
- G_TYPE_INVALID);
+ if (strcasecmp(property, "Connected") == 0) {
+ gboolean connected = FALSE;
- g_value_unset(&timeout);
- }
+ dbus_message_iter_recurse(&dict_iter, &value_iter);
+ dbus_message_iter_get_basic(&value_iter, &connected);
- mode = BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE;
+ event = connected ? BLUETOOTH_EVENT_DEVICE_CONNECTED :
+ BLUETOOTH_EVENT_DEVICE_DISCONNECTED;
- /* Send event to application */
- _bt_send_event(BT_ADAPTER_EVENT,
- BLUETOOTH_EVENT_DISCOVERABLE_MODE_CHANGED,
- DBUS_TYPE_INT32, &result,
- DBUS_TYPE_INT16, &mode,
- DBUS_TYPE_INVALID);
- } else {
- _bt_get_discoverable_mode(&mode);
+ address = g_malloc0(BT_ADDRESS_STRING_SIZE);
- /* Event will be sent by "DiscoverableTimeout" signal */
- ret_if(mode != BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE);
+ _bt_convert_device_path_to_address(path, address);
- /* Send event to application */
- _bt_send_event(BT_ADAPTER_EVENT,
- BLUETOOTH_EVENT_DISCOVERABLE_MODE_CHANGED,
- DBUS_TYPE_INT32, &result,
- DBUS_TYPE_INT16, &mode,
- DBUS_TYPE_INVALID);
- }
- } else if (strcasecmp(property, "DiscoverableTimeout") == 0) {
- _bt_get_discoverable_mode(&mode);
+ BT_DBG("connected: %d", connected);
+ BT_DBG("address: %s", address);
- /* Event was already sent by "Discoverable" signal */
- ret_if(mode == BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE);
+ remote_dev_info = _bt_get_remote_device_info(address);
+
+ if (remote_dev_info != NULL) {
+ __bt_device_remote_connected_properties(
+ remote_dev_info, address, connected);
+ }
/* Send event to application */
- _bt_send_event(BT_ADAPTER_EVENT,
- BLUETOOTH_EVENT_DISCOVERABLE_MODE_CHANGED,
+ _bt_send_event(BT_DEVICE_EVENT,
+ event,
DBUS_TYPE_INT32, &result,
- DBUS_TYPE_INT16, &mode,
+ DBUS_TYPE_STRING, &address,
DBUS_TYPE_INVALID);
- } else if (strcasecmp(property, "Powered") == 0) {
- gboolean powered = FALSE;
- dbus_message_iter_next(&item_iter);
- dbus_message_iter_recurse(&item_iter, &value_iter);
- dbus_message_iter_get_basic(&value_iter, &powered);
- BT_DBG("Powered = %d", powered);
- if (powered == FALSE)
- _bt_disable_adapter();
- }
- } else if (strcasecmp(member, "DeviceFound") == 0) {
- const char *bdaddr;
- bt_remote_dev_info_t *dev_info;
-
- ret_if(_bt_is_discovering() == FALSE);
- dev_info = g_malloc0(sizeof(bt_remote_dev_info_t));
+ g_free(address);
- dbus_message_iter_init(msg, &item_iter);
- dbus_message_iter_get_basic(&item_iter, &bdaddr);
- dbus_message_iter_next(&item_iter);
+ } else if (strcasecmp(property, "Paired") == 0) {
+ gboolean paired = FALSE;
- dev_info->address = g_strdup(bdaddr);
+ GList *node;
+ bt_remote_dev_info_t *new_dev_info;
- if (__bt_parse_device_properties(&item_iter, dev_info) == FALSE) {
- BT_ERR("Fail to parse the properies");
- _bt_free_device_info(dev_info);
- return;
- }
+ dbus_message_iter_recurse(&dict_iter, &value_iter);
+ dbus_message_iter_get_basic(&value_iter, &paired);
- if (dev_info->name == NULL)
- dev_info->name = g_strdup("");
+ ret_if(paired == FALSE);
- _bt_send_event(BT_ADAPTER_EVENT,
- BLUETOOTH_EVENT_REMOTE_DEVICE_FOUND,
- DBUS_TYPE_INT32, &result,
- DBUS_TYPE_STRING, &dev_info->address,
- DBUS_TYPE_UINT32, &dev_info->class,
- DBUS_TYPE_INT16, &dev_info->rssi,
- DBUS_TYPE_STRING, &dev_info->name,
- DBUS_TYPE_BOOLEAN, &dev_info->paired,
- DBUS_TYPE_BOOLEAN, &dev_info->connected,
- DBUS_TYPE_BOOLEAN, &dev_info->trust,
- DBUS_TYPE_ARRAY, DBUS_TYPE_STRING,
- &dev_info->uuids, dev_info->uuid_count,
- DBUS_TYPE_INVALID);
+ /* BlueZ sends paired signal for each paired device */
+ /* during activation, We should ignore this, otherwise*/
+ /* application thinks that a new device got paired */
+ if (_bt_adapter_get_status() != BT_ACTIVATED) {
+ BT_DBG("BT is not activated, so ignore this");
+ return;
+ }
- _bt_free_device_info(dev_info);
- } else if (strcasecmp(member, "DeviceCreated") == 0) {
- const char *object_path = NULL;
- char *address;
- bt_remote_dev_info_t *remote_dev_info;
+ address = g_malloc0(BT_ADDRESS_STRING_SIZE);
- ret_if(_bt_is_device_creating() == FALSE);
+ _bt_convert_device_path_to_address(path, address);
- /* Bonding from remote device */
- address = g_malloc0(BT_ADDRESS_STRING_SIZE);
+ remote_dev_info = _bt_get_remote_device_info(address);
+ if (remote_dev_info == NULL) {
+ g_free(address);
+ return;
+ }
- dbus_message_iter_init(msg, &item_iter);
- dbus_message_iter_get_basic(&item_iter, &object_path);
- dbus_message_iter_next(&item_iter);
+ node = g_list_first(g_list);
+
+ while (node != NULL) {
+ bt_remote_dev_info_t *dev_info;
+ dev_info = (bt_remote_dev_info_t *)node->data;
+ if (strcasecmp(dev_info->address, address) == 0) {
+ g_list = g_list_remove(g_list, dev_info);
+ _bt_free_device_info(dev_info);
+
+ new_dev_info = _bt_get_remote_device_info(address);
+ if (new_dev_info == NULL) {
+ g_free(address);
+ return;
+ }
+ g_list = g_list_append(g_list, new_dev_info);
+ }
+ node = g_list_next(node);
+ }
- _bt_convert_device_path_to_address(object_path, address);
+ if (_bt_is_device_creating() == TRUE) {
+ BT_DBG("Try to Pair by me or already paired");
+ } else {
+ _bt_send_event(BT_ADAPTER_EVENT,
+ BLUETOOTH_EVENT_BONDING_FINISHED,
+ DBUS_TYPE_INT32, &result,
+ DBUS_TYPE_STRING, &address,
+ DBUS_TYPE_UINT32, &remote_dev_info->class,
+ DBUS_TYPE_INT16, &remote_dev_info->rssi,
+ DBUS_TYPE_STRING, &remote_dev_info->name,
+ DBUS_TYPE_BOOLEAN, &remote_dev_info->paired,
+ DBUS_TYPE_BOOLEAN, &remote_dev_info->connected,
+ DBUS_TYPE_BOOLEAN, &remote_dev_info->trust,
+ DBUS_TYPE_ARRAY, DBUS_TYPE_STRING,
+ &remote_dev_info->uuids, remote_dev_info->uuid_count,
+ DBUS_TYPE_INVALID);
+ }
- remote_dev_info = _bt_get_remote_device_info(address);
- if (remote_dev_info == NULL) {
+ _bt_free_device_info(remote_dev_info);
g_free(address);
- return;
}
+ } while (dbus_message_iter_next(&item_iter));
+}
- _bt_free_device_info(remote_dev_info);
- g_free(address);
- } else if (strcasecmp(member, "DeviceRemoved") == 0) {
- const char *object_path = NULL;
- char *address;
+void __bt_obex_property_changed_event(DBusMessageIter *msg_iter, const char *path)
+{
+ DBusMessageIter value_iter;
+ DBusMessageIter dict_iter;
+ DBusMessageIter item_iter;
+ const char *property = NULL;
- /* Bonding from remote device */
- address = g_malloc0(BT_ADDRESS_STRING_SIZE);
+ dbus_message_iter_recurse(msg_iter, &item_iter);
- dbus_message_iter_init(msg, &item_iter);
- dbus_message_iter_get_basic(&item_iter, &object_path);
- dbus_message_iter_next(&item_iter);
+ if (dbus_message_iter_get_arg_type(&item_iter)
+ != DBUS_TYPE_DICT_ENTRY) {
+ BT_ERR("This is bad format dbus\n");
+ return;
+ }
- _bt_convert_device_path_to_address(object_path, address);
+ dbus_message_iter_recurse(&item_iter, &dict_iter);
- _bt_send_event(BT_ADAPTER_EVENT,
- BLUETOOTH_EVENT_BONDED_DEVICE_REMOVED,
- DBUS_TYPE_INT32, &result,
- DBUS_TYPE_STRING, &address,
- DBUS_TYPE_INVALID);
+ dbus_message_iter_get_basic(&dict_iter, &property);
+ ret_if(property == NULL);
- g_free(address);
+ ret_if(!dbus_message_iter_next(&dict_iter));
+
+ if (strcasecmp(property, "Status") == 0) {
+ const char *status;
+ dbus_message_iter_recurse(&dict_iter, &value_iter);
+ dbus_message_iter_get_basic(&value_iter, &status);
+
+ if (strcasecmp(status, "active") == 0){
+ _bt_obex_transfer_started(path);
+ }else if (strcasecmp(status, "complete") == 0) {
+ _bt_obex_transfer_completed(path, TRUE);
+ }else if (strcasecmp(status, "error") == 0){
+ _bt_obex_transfer_completed(path, FALSE);
+ }
+ } else if (strcasecmp(property, "Transferred") == 0) {
+ static int transferred = 0;
+ dbus_message_iter_recurse(&dict_iter, &value_iter);
+ dbus_message_iter_get_basic(&value_iter, &transferred);
+
+ _bt_obex_transfer_progress(path,transferred);
}
}
ret_if(property == NULL);
if (strcasecmp(property, "Connected") == 0) {
- int event = BLUETOOTH_EVENT_NONE;
+ int event;
char *address;
dbus_message_iter_next(&item_iter);
}
}
-void _bt_handle_network_client_event(DBusMessage *msg)
+void __bt_handle_network_client_event(DBusMessageIter *msg_iter, const char *path)
{
int result = BLUETOOTH_ERROR_NONE;
DBusMessageIter item_iter;
DBusMessageIter value_iter;
+ DBusMessageIter dict_iter;
gboolean property_flag = FALSE;
- const char *member = dbus_message_get_member(msg);
- const char *path = dbus_message_get_path(msg);
const char *property = NULL;
- ret_if(member == NULL);
-
- dbus_message_iter_init(msg, &item_iter);
+ dbus_message_iter_recurse(msg_iter, &item_iter);
if (dbus_message_iter_get_arg_type(&item_iter)
- != DBUS_TYPE_STRING) {
+ != DBUS_TYPE_DICT_ENTRY) {
BT_ERR("This is bad format dbus\n");
return;
}
- dbus_message_iter_get_basic(&item_iter, &property);
+ dbus_message_iter_recurse(&item_iter, &dict_iter);
+ dbus_message_iter_get_basic(&dict_iter, &property);
ret_if(property == NULL);
+ ret_if(!dbus_message_iter_next(&dict_iter));
+
if (strcasecmp(property, "Connected") == 0) {
int event = BLUETOOTH_EVENT_NONE;
char *address;
- dbus_message_iter_next(&item_iter);
- dbus_message_iter_recurse(&item_iter, &value_iter);
+ dbus_message_iter_recurse(&dict_iter, &value_iter);
dbus_message_iter_get_basic(&value_iter, &property_flag);
address = g_malloc0(BT_ADDRESS_STRING_SIZE);
void _bt_handle_device_event(DBusMessage *msg)
{
- int event;
int result = BLUETOOTH_ERROR_NONE;
DBusMessageIter item_iter;
DBusMessageIter value_iter;
ret_if(property == NULL);
if (strcasecmp(property, "Connected") == 0) {
+ int event;
gboolean connected = FALSE;
dbus_message_iter_next(&item_iter);
dbus_message_iter_recurse(&item_iter, &value_iter);
}
}
+void __bt_handle_media_control_event(DBusMessageIter *msg_iter,
+ const char *path)
+{
+ int result = BLUETOOTH_ERROR_NONE;
+ DBusMessageIter item_iter;
+ DBusMessageIter value_iter;
+ DBusMessageIter dict_iter;
+ gboolean property_flag = FALSE;
+ const char *property = NULL;
+
+ dbus_message_iter_recurse(msg_iter, &item_iter);
+
+ if (dbus_message_iter_get_arg_type(&item_iter)
+ != DBUS_TYPE_DICT_ENTRY) {
+ BT_ERR("This is bad format dbus\n");
+ return;
+ }
+
+ dbus_message_iter_recurse(&item_iter, &dict_iter);
+
+ dbus_message_iter_get_basic(&dict_iter, &property);
+ ret_if(property == NULL);
+
+ ret_if(!dbus_message_iter_next(&dict_iter));
+
+ if (strcasecmp(property, "Connected") == 0) {
+ int event;
+ char *address;
+
+ dbus_message_iter_recurse(&dict_iter, &value_iter);
+ dbus_message_iter_get_basic(&value_iter, &property_flag);
+
+ address = g_malloc0(BT_ADDRESS_STRING_SIZE);
+
+ _bt_convert_device_path_to_address(path, address);
+
+ event = (property_flag == TRUE) ?
+ BLUETOOTH_EVENT_AV_CONNECTED :
+ BLUETOOTH_EVENT_AV_DISCONNECTED;
+
+ _bt_send_event(BT_AVRCP_EVENT, event,
+ DBUS_TYPE_INT32, &result,
+ DBUS_TYPE_STRING, &address,
+ DBUS_TYPE_INVALID);
+
+ g_free(address);
+ }
+}
+
+void _bt_handle_property_changed_event(DBusMessage *msg)
+{
+ DBusMessageIter item_iter;
+ const char *member = dbus_message_get_member(msg);
+ const char *interface_name = NULL;
+
+ ret_if(member == NULL);
+
+ dbus_message_iter_init(msg, &item_iter);
+
+ if (dbus_message_iter_get_arg_type(&item_iter)
+ != DBUS_TYPE_STRING) {
+ BT_ERR("This is bad format dbus\n");
+ return;
+ }
+
+ dbus_message_iter_get_basic(&item_iter, &interface_name);
+
+ ret_if(interface_name == NULL);
+
+ BT_DBG("interface: %s", interface_name);
+
+ ret_if(dbus_message_iter_next(&item_iter) == FALSE);
+
+ ret_if(dbus_message_iter_get_arg_type(&item_iter) != DBUS_TYPE_ARRAY);
+
+ if (strcasecmp(interface_name, BT_ADAPTER_INTERFACE) == 0) {
+ __bt_adapter_property_changed_event(&item_iter,
+ dbus_message_get_path(msg));
+ } else if (strcasecmp(interface_name, BT_DEVICE_INTERFACE) == 0) {
+ __bt_device_property_changed_event(&item_iter,
+ dbus_message_get_path(msg));
+ } else if (strcasecmp(interface_name,
+ BT_OBEX_TRANSFER_INTERFACE) == 0) {
+ __bt_obex_property_changed_event(&item_iter,
+ dbus_message_get_path(msg));
+ } else if (strcasecmp(interface_name,
+ BT_MEDIA_CONTROL_INTERFACE) == 0) {
+ __bt_handle_media_control_event(&item_iter,
+ dbus_message_get_path(msg));
+ } else if (strcasecmp(interface_name,
+ BT_NETWORK_CLIENT_INTERFACE) == 0) {
+ __bt_handle_network_client_event(&item_iter,
+ dbus_message_get_path(msg));
+ } else {
+ BT_DBG("No bluez interface");
+ }
+}
+
void __bt_set_audio_values(gboolean connected, char *address)
{
char *name = NULL;
ret_if(property == NULL);
- BT_DBG("Property = %s \n", property);
-
/* We allow only 1 headset connection (HSP or HFP)*/
if (strcasecmp(property, "Connected") == 0) {
int event = BLUETOOTH_EVENT_NONE;
- bt_headset_wait_t *wait_list;
char *address;
dbus_message_iter_next(&item_iter);
DBUS_TYPE_STRING, &address,
DBUS_TYPE_INVALID);
- if (event == BLUETOOTH_EVENT_AG_DISCONNECTED) {
- /* Remove data from the connected list */
- _bt_remove_headset_from_list(BT_AUDIO_HSP, address);
-
- wait_list = _bt_get_audio_wait_data();
- if (wait_list == NULL) {
- g_free(address);
- return;
- }
-
- bluetooth_device_address_t device_address;
-
- _bt_set_audio_wait_data_flag(TRUE);
-
- _bt_convert_addr_string_to_type(device_address.addr,
- wait_list->address);
- _bt_audio_connect(wait_list->req_id, wait_list->type,
- &device_address, wait_list->out_param1);
- } else if (event == BLUETOOTH_EVENT_AG_CONNECTED) {
- /* Add data to the connected list */
- _bt_add_headset_to_list(BT_AUDIO_HSP,
- BT_STATE_CONNECTED, address);
- }
g_free(address);
} else if (strcasecmp(property, "State") == 0) {
int event = BLUETOOTH_EVENT_NONE;
/* This code assumes we support only 1 headset connection */
/* Need to use the headset list, if we support multi-headsets */
- if (strcasecmp(state, "Playing") == 0) {
+ if (strcasecmp(property, "Playing") == 0) {
event = BLUETOOTH_EVENT_AG_AUDIO_CONNECTED;
sco_connected = TRUE;
- } else if (strcasecmp(state, "connected") == 0 ||
- strcasecmp(state, "disconnected") == 0) {
+ } else if (strcasecmp(property, "connected") == 0 ||
+ strcasecmp(property, "disconnected") == 0) {
event = BLUETOOTH_EVENT_AG_AUDIO_DISCONNECTED;
sco_connected = FALSE;
} else {
- BT_ERR("Not handled state - %s", state);
+ BT_ERR("Not handled state");
g_free(address);
return;
}
dbus_message_iter_next(&item_iter);
dbus_message_iter_recurse(&item_iter, &value_iter);
- dbus_message_iter_get_basic(&value_iter, &mic_gain);
-
- _bt_send_event(BT_HEADSET_EVENT, BLUETOOTH_EVENT_AG_MIC_GAIN,
- DBUS_TYPE_INT32, &result,
- DBUS_TYPE_STRING, &address,
- DBUS_TYPE_UINT16, &mic_gain,
- DBUS_TYPE_INVALID);
-
- g_free(address);
- }
-}
-
-void _bt_handle_sink_event(DBusMessage *msg)
-{
- int result = BLUETOOTH_ERROR_NONE;
- DBusMessageIter item_iter;
- DBusMessageIter value_iter;
- gboolean property_flag = FALSE;
- const char *member = dbus_message_get_member(msg);
- const char *path = dbus_message_get_path(msg);
- const char *property = NULL;
-
- bt_headset_wait_t *wait_list;
-
- ret_if(member == NULL);
-
- dbus_message_iter_init(msg, &item_iter);
-
- if (dbus_message_iter_get_arg_type(&item_iter)
- != DBUS_TYPE_STRING) {
- BT_ERR("This is bad format dbus\n");
- return;
- }
-
- dbus_message_iter_get_basic(&item_iter, &property);
-
- ret_if(property == NULL);
-
- if (strcasecmp(property, "Connected") == 0) {
- int event = BLUETOOTH_EVENT_NONE;
- char *address;
-
- dbus_message_iter_next(&item_iter);
- dbus_message_iter_recurse(&item_iter, &value_iter);
- dbus_message_iter_get_basic(&value_iter, &property_flag);
-
- address = g_malloc0(BT_ADDRESS_STRING_SIZE);
-
- _bt_convert_device_path_to_address(path, address);
-
- event = (property_flag == TRUE) ?
- BLUETOOTH_EVENT_AV_CONNECTED :
- BLUETOOTH_EVENT_AV_DISCONNECTED;
-
- _bt_send_event(BT_HEADSET_EVENT, event,
- DBUS_TYPE_INT32, &result,
- DBUS_TYPE_STRING, &address,
- DBUS_TYPE_INVALID);
-
- _bt_send_event(BT_AVRCP_EVENT, event,
- DBUS_TYPE_INT32, &result,
- DBUS_TYPE_STRING, &address,
- DBUS_TYPE_INVALID);
-
- if (event == BLUETOOTH_EVENT_AV_DISCONNECTED) {
- /* Remove data from the connected list */
- _bt_remove_headset_from_list(BT_AUDIO_A2DP, address);
- wait_list = _bt_get_audio_wait_data();
- if (wait_list == NULL) {
- g_free(address);
- return;
- }
-
- if (((wait_list->type == BT_AUDIO_ALL) &&
- (wait_list->ag_flag == TRUE)) ||
- (wait_list->type == BT_AUDIO_A2DP) ||
- (wait_list->disconnection_type == BT_AUDIO_A2DP)) {
- bluetooth_device_address_t device_address;
- _bt_convert_addr_string_to_type(
- device_address.addr,
- wait_list->address);
+ dbus_message_iter_get_basic(&value_iter, &mic_gain);
- _bt_audio_connect(wait_list->req_id,
- wait_list->type,
- &device_address,
- wait_list->out_param1);
- }
- } else if (event == BLUETOOTH_EVENT_AV_CONNECTED){
- /* Check for existing Media device to disconnect */
- char connected_address[BT_ADDRESS_STRING_SIZE + 1];
- bluetooth_device_address_t device_address;
- gboolean connected;
-
- connected = _bt_is_headset_type_connected(BT_AUDIO_A2DP,
- connected_address);
- if (connected) {
- /* Match connected device address */
- if (g_strcmp0(connected_address, address) != 0) {
- /* Convert BD adress from string type */
- _bt_convert_addr_string_to_type(
- device_address.addr,
- connected_address);
- _bt_audio_disconnect(0, BT_AUDIO_A2DP,
- &device_address, NULL);
- }
- }
+ _bt_send_event(BT_HEADSET_EVENT, BLUETOOTH_EVENT_AG_MIC_GAIN,
+ DBUS_TYPE_INT32, &result,
+ DBUS_TYPE_STRING, &address,
+ DBUS_TYPE_UINT16, &mic_gain,
+ DBUS_TYPE_INVALID);
- /* Add data to the connected list */
- _bt_add_headset_to_list(BT_AUDIO_A2DP,
- BT_STATE_CONNECTED, address);
- }
g_free(address);
}
}
}
}
+static int __bt_get_object_path(DBusMessage *msg, char **path)
+{
+ DBusMessageIter item_iter;
+
+ dbus_message_iter_init(msg, &item_iter);
+
+ if (dbus_message_iter_get_arg_type(&item_iter)
+ != DBUS_TYPE_OBJECT_PATH) {
+ BT_ERR("This is bad format dbus\n");
+ return BLUETOOTH_ERROR_INTERNAL;
+ }
+
+ dbus_message_iter_get_basic(&item_iter, path);
+
+ if (*path == NULL)
+ return BLUETOOTH_ERROR_INTERNAL;
+
+ return BLUETOOTH_ERROR_NONE;
+}
+
+static void __bt_devices_list_free()
+{
+ GList *node;
+
+ node = g_list_first(g_list);
+
+ while (node != NULL){
+ bt_remote_dev_info_t *dev_info;
+ dev_info = (bt_remote_dev_info_t *)node->data;
+
+ g_list = g_list_remove(g_list, dev_info);
+ _bt_free_device_info(dev_info);
+
+ node = g_list_next(node);
+ }
+}
+
static DBusHandlerResult __bt_manager_event_filter(DBusConnection *conn,
DBusMessage *msg, void *data)
{
const char *member = dbus_message_get_member(msg);
+ bt_event_type_t bt_event;
if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_SIGNAL)
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
retv_if(member == NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
- if (strcasecmp(member, "AdapterAdded") == 0) {
- BT_DBG("AdapterAdded");
- _bt_handle_adapter_added();
- } else if (strcasecmp(member, "AdapterRemoved") == 0) {
- BT_DBG("AdapterRemoved");
+ BT_DBG("interface: %s | member: %s", dbus_message_get_interface(msg), member);
+
+ if (strcasecmp(member, "InterfacesAdded") == 0) {
+ char *object_path = NULL;
+
+ if (__bt_get_object_path(msg, &object_path)) {
+ BT_ERR("Fail to get the path");
+ return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+ }
+
+ bt_event = __bt_parse_event(msg);
+
+ if (bt_event == BT_DEVICE_EVENT) {
+ bt_remote_dev_info_t *dev_info;
+ int result = BLUETOOTH_ERROR_NONE;
+
+ retv_if(_bt_is_discovering() == FALSE,
+ DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
+
+ dev_info = __bt_parse_interface(msg);
+
+ if (dev_info == NULL) {
+ BT_ERR("Fail to parse the properies");
+ return
+ DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+ }
+
+ if (dev_info->name == NULL)
+ dev_info->name = g_strdup("");
+
+ _bt_send_event(BT_ADAPTER_EVENT,
+ BLUETOOTH_EVENT_REMOTE_DEVICE_FOUND,
+ DBUS_TYPE_INT32, &result,
+ DBUS_TYPE_STRING, &dev_info->address,
+ DBUS_TYPE_UINT32, &dev_info->class,
+ DBUS_TYPE_INT16, &dev_info->rssi,
+ DBUS_TYPE_STRING, &dev_info->name,
+ DBUS_TYPE_BOOLEAN, &dev_info->paired,
+ DBUS_TYPE_BOOLEAN,
+ &dev_info->connected,
+ DBUS_TYPE_BOOLEAN, &dev_info->trust,
+ DBUS_TYPE_ARRAY, DBUS_TYPE_STRING,
+ &dev_info->uuids, dev_info->uuid_count,
+ DBUS_TYPE_INVALID);
+ g_list = g_list_append(g_list, dev_info);
+ } else if (bt_event == BT_MEDIA_TRANSFER_EVENT) {
+ __bt_parse_audio_properties(msg);
+ }
+
+ } else if (strcasecmp(member, "InterfacesRemoved") == 0) {
+
+ bt_event = __bt_parse_remove_event(msg);
+
+ if (bt_event == BT_MEDIA_TRANSFER_EVENT){
+ _bt_parse_audio_remove_properties(msg);
+ } else if (bt_event == BT_DEVICE_EVENT) {
+ char *object_path = NULL;
+ if (__bt_get_object_path(msg, &object_path)) {
+ BT_ERR("Fail to get the path");
+ return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+ }
+
+ if (strncasecmp(object_path, BT_BLUEZ_HCI_DEV_PATH, strlen(BT_BLUEZ_HCI_DEV_PATH)) == 0) {
+ int result = BLUETOOTH_ERROR_NONE;
+ char *address;
+ bt_remote_dev_info_t * dev_info;
+ GList * node;
+
+ BT_DBG("device interface removed | path: %s", object_path);
+
+ /* Remove bonding from remote device */
+ address = g_malloc0(BT_ADDRESS_STRING_SIZE);
+
+ _bt_convert_device_path_to_address(object_path, address);
+
+ node = g_list_first(g_list);
+
+ while (node != NULL){
+ dev_info = (bt_remote_dev_info_t *)node->data;
+ if (strcasecmp(dev_info->address, address) == 0) {
+ if (dev_info->paired) {
+ BT_DBG("send bt bond destroy event");
+ _bt_send_event(BT_ADAPTER_EVENT,
+ BLUETOOTH_EVENT_BONDED_DEVICE_REMOVED,
+ DBUS_TYPE_INT32, &result,
+ DBUS_TYPE_STRING, &address,
+ DBUS_TYPE_INVALID);
+ } else {
+ BT_DBG("Bluez removes device %s, send device disappear event", dev_info->name);
+ _bt_send_event(BT_ADAPTER_EVENT,
+ BLUETOOTH_EVENT_REMOTE_DEVICE_DISAPPEARED,
+ DBUS_TYPE_INT32, &result,
+ DBUS_TYPE_STRING, &dev_info->address,
+ DBUS_TYPE_UINT32, &dev_info->class,
+ DBUS_TYPE_INT16, &dev_info->rssi,
+ DBUS_TYPE_STRING, &dev_info->name,
+ DBUS_TYPE_BOOLEAN, &dev_info->paired,
+ DBUS_TYPE_BOOLEAN, &dev_info->connected,
+ DBUS_TYPE_BOOLEAN, &dev_info->trust,
+ DBUS_TYPE_ARRAY, DBUS_TYPE_STRING,
+ &dev_info->uuids, dev_info->uuid_count,
+ DBUS_TYPE_INVALID);
+ }
+ g_list = g_list_remove(g_list, dev_info);
+ _bt_free_device_info(dev_info);
+ break;
+ }
+ node = g_list_next(node);
+ }
+
+ g_free(address);
+ }
+ } else {
+ char *object_path = NULL;
+ if (__bt_get_object_path(msg, &object_path)) {
+ BT_ERR("Fail to get the path");
+ return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+ }
+ }
} else if (strcasecmp(member, "NameOwnerChanged") == 0) {
gboolean value;
char *name = NULL;
char *previous = NULL;
char *current = NULL;
+ BT_DBG("NameOwnerChanged");
+
if (__bt_get_owner_info(msg, &name, &previous, ¤t)) {
BT_ERR("Fail to get the owner info");
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
if (strcasecmp(name, "org.bluez") == 0) {
BT_DBG("Bluetoothd is terminated");
_bt_handle_adapter_removed();
+ __bt_devices_list_free();
}
_bt_obex_server_check_allocation(&value);
/* The obex server was terminated abnormally */
_bt_rfcomm_server_check_termination(name);
}
- } else if (dbus_message_has_interface(msg, BT_ADAPTER_INTERFACE)) {
- _bt_handle_adapter_event(msg);
+ } else if (dbus_message_has_interface(msg, BT_PROPERTIES_INTERFACE)) {
+ _bt_handle_property_changed_event(msg);
} else if (dbus_message_has_interface(msg, BT_INPUT_INTERFACE)) {
_bt_handle_input_event(msg);
} else if (dbus_message_has_interface(msg, BT_NETWORK_SERVER_INTERFACE)) {
_bt_handle_network_server_event(msg);
- } else if (dbus_message_has_interface(msg, BT_NETWORK_CLIENT_INTERFACE)) {
- _bt_handle_network_client_event(msg);
- } else if (dbus_message_has_interface(msg, BT_HEADSET_INTERFACE)) {
+ } else if (dbus_message_has_interface(msg, BT_HFP_AGENT_INTERFACE)) {
_bt_handle_headset_event(msg);
- } else if (dbus_message_has_interface(msg, BT_SINK_INTERFACE)) {
- _bt_handle_sink_event(msg);
} else if (dbus_message_has_interface(msg, BT_AGENT_INTERFACE)) {
_bt_handle_agent_event(msg);
} else if (dbus_message_has_interface(msg, BT_DEVICE_INTERFACE)) {
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
-static DBusHandlerResult __bt_obexd_event_filter(DBusConnection *conn,
- DBusMessage *msg, void *data)
+static gboolean __bt_is_obexd_event(DBusMessage *msg)
+{
+ const char *member = dbus_message_get_member(msg);
+
+ if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_SIGNAL)
+ return FALSE;
+
+ retv_if(member == NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
+
+ if (dbus_message_has_interface(msg, BT_PROPERTIES_INTERFACE)) {
+
+ DBusMessageIter item_iter;
+ const char *interface_name = NULL;
+
+ dbus_message_iter_init(msg, &item_iter);
+
+ if (dbus_message_iter_get_arg_type(&item_iter)
+ != DBUS_TYPE_STRING) {
+ BT_ERR("This is bad format dbus\n");
+ return FALSE;
+ }
+
+ dbus_message_iter_get_basic(&item_iter, &interface_name);
+
+ retv_if(interface_name == NULL, FALSE);
+
+ BT_DBG("interface: %s", interface_name);
+
+ retv_if(dbus_message_iter_next(&item_iter) == FALSE, FALSE);
+
+ retv_if(dbus_message_iter_get_arg_type(&item_iter) != DBUS_TYPE_ARRAY,
+ FALSE);
+
+ if (strcasecmp(interface_name, BT_OBEX_TRANSFER_INTERFACE) == 0)
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+void __bt_opc_property_changed_event(DBusMessageIter *msg_iter,
+ const char *path)
+{
+ DBusMessageIter value_iter;
+ DBusMessageIter dict_iter;
+ DBusMessageIter item_iter;
+ const char *property = NULL;
+
+ dbus_message_iter_recurse(msg_iter, &item_iter);
+
+ if (dbus_message_iter_get_arg_type(&item_iter)
+ != DBUS_TYPE_DICT_ENTRY) {
+ BT_ERR("This is bad format dbus\n");
+ return;
+ }
+
+ dbus_message_iter_recurse(&item_iter, &dict_iter);
+
+ dbus_message_iter_get_basic(&dict_iter, &property);
+ ret_if(property == NULL);
+
+ ret_if(!dbus_message_iter_next(&dict_iter));
+
+ if (strcasecmp(property, "Status") == 0) {
+ const char *status = NULL;
+ dbus_message_iter_recurse(&dict_iter, &value_iter);
+ dbus_message_iter_get_basic(&value_iter, &status);
+
+ if(strcasecmp(status, "active") == 0){
+ _bt_obex_client_started(path);
+ }else if (strcasecmp(status, "complete") == 0) {
+ _bt_obex_client_completed(TRUE);
+ }else if (strcasecmp(status, "error") == 0){
+ _bt_obex_client_completed(FALSE);
+ }
+ } else if (strcasecmp(property, "Transferred") == 0) {
+ static int transferred = 0;
+ dbus_message_iter_recurse(&dict_iter, &value_iter);
+ dbus_message_iter_get_basic(&value_iter, &transferred);
+
+ _bt_obex_client_progress(transferred);
+ }
+}
+
+void _bt_opc_property_changed_event(DBusMessage *msg)
+{
+ DBusMessageIter item_iter;
+ const char *member = dbus_message_get_member(msg);
+ const char *interface_name = NULL;
+
+ ret_if(member == NULL);
+
+ dbus_message_iter_init(msg, &item_iter);
+
+ if (dbus_message_iter_get_arg_type(&item_iter)
+ != DBUS_TYPE_STRING) {
+ BT_ERR("This is bad format dbus\n");
+ return;
+ }
+
+ dbus_message_iter_get_basic(&item_iter, &interface_name);
+
+ ret_if(interface_name == NULL);
+
+ BT_DBG("interface: %s", interface_name);
+
+ ret_if(dbus_message_iter_next(&item_iter) == FALSE);
+
+ ret_if(dbus_message_iter_get_arg_type(&item_iter) != DBUS_TYPE_ARRAY);
+
+ if (strcasecmp(interface_name, BT_OBEX_TRANSFER_INTERFACE) == 0) {
+ __bt_opc_property_changed_event(&item_iter,
+ dbus_message_get_path(msg));
+ } else {
+ BT_DBG("No bluez interface");
+ }
+}
+
+static gboolean __bt_is_obexd_client_event(DBusMessage *msg)
+{
+ const char *member = dbus_message_get_member(msg);
+
+ if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_SIGNAL)
+ return FALSE;
+
+ retv_if(member == NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
+
+ if (dbus_message_has_interface(msg, BT_PROPERTIES_INTERFACE)) {
+ DBusMessageIter item_iter;
+ const char *interface_name = NULL;
+
+ dbus_message_iter_init(msg, &item_iter);
+
+ if (dbus_message_iter_get_arg_type(&item_iter)
+ != DBUS_TYPE_STRING) {
+ BT_ERR("This is bad format dbus\n");
+ return FALSE;
+ }
+
+ dbus_message_iter_get_basic(&item_iter, &interface_name);
+
+ retv_if(interface_name == NULL, FALSE);
+
+ BT_DBG("interface: %s", interface_name);
+
+ retv_if(dbus_message_iter_next(&item_iter) == FALSE,
+ FALSE);
+
+ retv_if(dbus_message_iter_get_arg_type(&item_iter)
+ != DBUS_TYPE_ARRAY, FALSE);
+
+ if (strcasecmp(interface_name,
+ BT_OBEX_TRANSFER_INTERFACE) == 0)
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+static DBusHandlerResult __bt_opc_event_filter(DBusConnection *conn,
+ DBusMessage *msg, void *data)
{
- const char *path = dbus_message_get_path(msg);
const char *member = dbus_message_get_member(msg);
if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_SIGNAL)
retv_if(member == NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
- if (strcasecmp(member, "TransferStarted") == 0) {
- char *transfer_path = NULL;
+ if (strcasecmp(member, "InterfacesAdded") == 0) {
+ BT_DBG("InterfacesAdded");
+ }else if (strcasecmp(member, "InterfacesRemoved") == 0) {
+ char *object_path = NULL;
- if (!dbus_message_get_args(msg, NULL,
- DBUS_TYPE_OBJECT_PATH, &transfer_path,
- DBUS_TYPE_INVALID)) {
- BT_ERR("Unexpected parameters in signal");
+ if (__bt_get_object_path(msg, &object_path)) {
+ BT_ERR("Fail to get the path");
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
- _bt_obex_transfer_started(transfer_path);
- } else if (strcasecmp(member, "Progress") == 0) {
- gint total = 0;
- gint transfer = 0;
+ BT_DBG("object_path =%s",object_path);
- if (!dbus_message_get_args(msg, NULL,
- DBUS_TYPE_INT32, &total,
- DBUS_TYPE_INT32, &transfer,
- DBUS_TYPE_INVALID)) {
- BT_ERR("Unexpected parameters in signal");
+ if (strncmp(object_path, BT_SESSION_BASEPATH_CLIENT,
+ strlen(BT_SESSION_BASEPATH_CLIENT)) != 0
+ || strstr(object_path, "transfer") == NULL)
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
- }
- _bt_obex_transfer_progress(path, total, transfer);
- } else if (strcasecmp(member, "TransferCompleted") == 0) {
- char *transfer_path = NULL;
- gboolean success;
+ _bt_sending_files();
- if (!dbus_message_get_args(msg, NULL,
- DBUS_TYPE_OBJECT_PATH, &transfer_path,
- DBUS_TYPE_BOOLEAN, &success,
- DBUS_TYPE_INVALID)) {
- BT_ERR("Unexpected parameters in signal");
+ }else if (__bt_is_obexd_client_event(msg) == TRUE){
+ const char *path = dbus_message_get_path(msg);
+
+ if (strncmp(path, BT_SESSION_BASEPATH_CLIENT,
+ strlen(BT_SESSION_BASEPATH_CLIENT)) != 0)
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
- }
- _bt_obex_transfer_completed(transfer_path, success);
+ _bt_opc_property_changed_event(msg);
+ }
+
+ return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+}
+
+static DBusHandlerResult __bt_obexd_event_filter(DBusConnection *conn,
+ DBusMessage *msg, void *data)
+{
+ const char *member = dbus_message_get_member(msg);
+
+ if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_SIGNAL)
+ return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+
+ retv_if(member == NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
+
+ if (__bt_is_obexd_event(msg) == TRUE){
+ const char *path = dbus_message_get_path(msg);
+
+ if (strncmp(path, BT_SESSION_BASEPATH_SERVER,
+ strlen(BT_SESSION_BASEPATH_SERVER)) != 0)
+ return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+
+ _bt_handle_property_changed_event(msg);
}
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
DBusError dbus_error;
char *match1 = NULL;
char *match2 = NULL;
+ char *match3 = NULL;
+ char *match4 = NULL;
DBusConnection *conn;
DBusHandleMessageFunction event_func = NULL;
event_func = __bt_manager_event_filter;
match1 = g_strdup_printf(MANAGER_EVENT_MATCH_RULE,
BT_MANAGER_INTERFACE,
- BT_MANAGER_PATH);
+ BT_INTERFACES_ADDED);
match2 = g_strdup_printf(MANAGER_EVENT_MATCH_RULE,
+ BT_MANAGER_INTERFACE,
+ BT_INTERFACES_REMOVED);
+
+ match3 = g_strdup_printf(MANAGER_EVENT_MATCH_RULE,
BT_FREEDESKTOP_INTERFACE,
- BT_FREEDESKTOP_PATH);
+ BT_NAME_OWNER_CHANGED);
+
+ match4 = g_strdup_printf(MANAGER_EVENT_MATCH_RULE,
+ BT_PROPERTIES_INTERFACE,
+ BT_PROPERTIES_CHANGED);
break;
case BT_DEVICE_EVENT:
match1 = g_strdup_printf(EVENT_MATCH_RULE,
break;
case BT_HEADSET_EVENT:
match1 = g_strdup_printf(EVENT_MATCH_RULE,
- BT_HEADSET_INTERFACE);
+ BT_HFP_AGENT_INTERFACE);
match2 = g_strdup_printf(EVENT_MATCH_RULE,
BT_SINK_INTERFACE);
case BT_OPP_SERVER_EVENT:
event_func = __bt_obexd_event_filter;
match1 = g_strdup_printf(MANAGER_EVENT_MATCH_RULE,
- BT_OBEXD_MANAGER_INTERFACE,
- BT_MANAGER_PATH);
+ BT_PROPERTIES_INTERFACE,
+ BT_PROPERTIES_CHANGED);
+ break;
+ case BT_OPP_CLIENT_EVENT:
+ event_func = __bt_opc_event_filter;
+ match1 = g_strdup_printf(MANAGER_EVENT_MATCH_RULE,
+ BT_PROPERTIES_INTERFACE,
+ BT_PROPERTIES_CHANGED);
- match2 = g_strdup_printf(EVENT_MATCH_RULE,
- BT_OBEXD_TRANSFER_INTERFACE);
+ match2 = g_strdup_printf(MANAGER_EVENT_MATCH_RULE,
+ BT_MANAGER_INTERFACE,
+ BT_INTERFACES_ADDED);
+
+ match3 = g_strdup_printf(MANAGER_EVENT_MATCH_RULE,
+ BT_MANAGER_INTERFACE,
+ BT_INTERFACES_REMOVED);
break;
default:
BT_ERR("Unknown event");
goto fail;
}
+ if (match3)
+ dbus_bus_add_match(conn, match3, &dbus_error);
+
+ if (dbus_error_is_set(&dbus_error)) {
+ BT_ERR("Fail to add match: %s\n", dbus_error.message);
+ dbus_error_free(&dbus_error);
+ goto fail;
+ }
+
+ if (match4)
+ dbus_bus_add_match(conn, match4, &dbus_error);
+
+ if (dbus_error_is_set(&dbus_error)) {
+ BT_ERR("Fail to add match: %s\n", dbus_error.message);
+ dbus_error_free(&dbus_error);
+ goto fail;
+ }
+
g_free(match1);
g_free(match2);
+ g_free(match3);
+ g_free(match4);
return BLUETOOTH_ERROR_NONE;
fail:
g_free(match1);
g_free(match2);
+ g_free(match3);
+ g_free(match4);
return BLUETOOTH_ERROR_INTERNAL;
}
case BT_OPP_SERVER_EVENT:
event_func = __bt_obexd_event_filter;
break;
+ case BT_OPP_CLIENT_EVENT:
+ event_func = __bt_opc_event_filter;
+ break;
default:
BT_ERR("Unknown event");
return;
if (event_id > 0)
g_source_remove(event_id);
}
+
+int _bt_opp_client_event_init(void)
+{
+ GError *error = NULL;
+
+ if (opc_obexd_conn == NULL) {
+ opc_obexd_conn = dbus_g_bus_get(DBUS_BUS_SESSION, &error);
+ if (error != NULL) {
+ BT_ERR("ERROR: Can't get on session bus [%s]",
+ error->message);
+ g_error_free(error);
+ }
+
+ retv_if(opc_obexd_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
+ }
+
+ if (_bt_register_service_event(opc_obexd_conn,
+ BT_OPP_CLIENT_EVENT) != BLUETOOTH_ERROR_NONE) {
+ dbus_g_connection_unref(opc_obexd_conn);
+ opc_obexd_conn = NULL;
+ return BLUETOOTH_ERROR_INTERNAL;
+ }
+
+ return BLUETOOTH_ERROR_NONE;
+}
+
+void _bt_opp_client_event_deinit(void)
+{
+ if (opc_obexd_conn) {
+ _bt_unregister_service_event(opc_obexd_conn,
+ BT_OPP_CLIENT_EVENT);
+ dbus_g_connection_unref(opc_obexd_conn);
+ opc_obexd_conn = NULL;
+ }
+}
+
+void _bt_get_temp_remote_devinfo(void)
+{
+ bt_remote_dev_info_t *dev_info;
+ GList *node;
+ int result = BLUETOOTH_ERROR_NONE;
+
+ node = g_list_first(g_list);
+
+ while (node != NULL) {
+ dev_info = (bt_remote_dev_info_t *)node->data;
+ /* do not search paired devices.
+ * Paired devices are in g_list in order to trig device disappear
+ * or remove bonding events */
+ if (!dev_info->paired) {
+ _bt_send_event(BT_ADAPTER_EVENT,
+ BLUETOOTH_EVENT_REMOTE_DEVICE_FOUND,
+ DBUS_TYPE_INT32, &result,
+ DBUS_TYPE_STRING, &dev_info->address,
+ DBUS_TYPE_UINT32, &dev_info->class,
+ DBUS_TYPE_INT16, &dev_info->rssi,
+ DBUS_TYPE_STRING, &dev_info->name,
+ DBUS_TYPE_BOOLEAN, &dev_info->paired,
+ DBUS_TYPE_BOOLEAN, &dev_info->connected,
+ DBUS_TYPE_BOOLEAN, &dev_info->trust,
+ DBUS_TYPE_ARRAY, DBUS_TYPE_STRING,
+ &dev_info->uuids, dev_info->uuid_count,
+ DBUS_TYPE_INVALID);
+ }
+ node = g_list_next(node);
+ }
+}
projects / platform / core / connectivity / bluetooth-frwk.git / blobdiff