#include "bt-service-proximity.h"
#include "bt-service-opp-client.h"
+#include "bt-service-map-client.h"
+#include "bt-service-tds.h"
+#include "bt-service-otp.h"
#ifdef TIZEN_FEATURE_BT_DPM
#include "bt-service-dpm.h"
static GDBusConnection *manager_conn;
static GDBusConnection *obexd_conn;
static GDBusConnection *opc_obexd_conn;
+static GDBusConnection *map_obexd_conn;
static GList *p_cache_list = NULL;
OBEX_PCSUITE = (1 << 6),
OBEX_SYNCEVOLUTION = (1 << 7),
OBEX_MAS = (1 << 8),
+ OBEX_MAP = (1 << 9),
} bluetooth_obex_connection_type_t;
void _bt_handle_property_changed_event(GVariant *msg, const char *object_path);
void _bt_opc_property_changed_event(GVariant *msg, char *path);
+void _bt_map_property_changed_event(GVariant *msg, const char *path);
int _bt_register_service_event(GDBusConnection *g_conn, int event_type);
void _bt_unregister_service_event(GDBusConnection *g_conn, int event_type);
void _bt_opp_client_event_deinit(void);
+void _bt_map_client_event_deinit(void);
void _bt_handle_network_client_event(GVariant *msg_iter,
const char *path);
void __bt_gatt_char_property_changed_event(GVariant *msg_iter,
const char *path);
+void _bt_map_on_transfer_finished(const char *transfer_object_path, const int error);
static void __bt_free_bt_le_adv_info_t(gpointer data)
{
event,
param);
- if (event == BLUETOOTH_EVENT_ADVERTISING_STOPPED)
+ if (event == BLUETOOTH_EVENT_ADVERTISING_STOPPED) {
+ char *name = g_strdup(sender);
+
_bt_unregister_adv_slot_owner(slot_id);
+
+ /* Advertising disabled, notify TDS */
+ _bt_tds_handle_adv_disabled(name, adv_handle);
+ g_free(name);
+ }
} else if (strcasecmp(member, "RssiEnabled") == 0) {
BT_DBG("RSSI Enabled");
gboolean status = FALSE;
param);
g_free(address);
} else if (strcasecmp(member, BT_HARDWARE_ERROR) == 0) {
- BT_ERR_C("Hardware error received from BLUEZ");
+ BT_ERR_C("### Hardware error received from BLUEZ");
/* Don't add the recovery logic into platform */
#if 0
_bt_recover_adapter();
#endif
} else if (strcasecmp(member, BT_TX_TIMEOUT_ERROR) == 0) {
- BT_ERR_C("Tx timeout error received from BLUEZ");
+ BT_ERR_C("### Tx timeout error received from BLUEZ");
/* Don't add the recovery logic into platform */
#if 0
_bt_recover_adapter();
_bt_obex_transfer_progress(path, transferred);
}
+ /* TODO: MAP, "Complete"? see above */
g_free(property);
g_variant_unref(val);
g_variant_unref(child);
_bt_convert_device_path_to_address(path, address);
BT_DBG("address: %s", address);
+ g_free(address);
+
remote_dev_info = _bt_get_remote_device_info_by_object_path(path);
if (remote_dev_info == NULL) {
g_free(property);
g_variant_unref(val);
- g_free(address);
return;
}
BT_DBG("Address type %d", remote_dev_info->addr_type);
_bt_free_device_info(remote_dev_info);
g_free(property);
g_variant_unref(val);
- g_free(address);
return;
}
}
_bt_send_event(BT_ADAPTER_EVENT,
BLUETOOTH_EVENT_REMOTE_DEVICE_FOUND,
param);
- g_free(address);
}
_bt_free_device_info(remote_dev_info);
} else if (strcasecmp(property, "GattConnected") == 0) {
}
BT_DBG("LegacyPairing Failed with %s. Show Error Popup", remote_dev_info->name);
- _bt_launch_system_popup(BT_AGENT_EVENT_LEGACY_PAIR_FAILED_FROM_REMOTE,
+ if (headed_plugin_info->plugin_headed_enabled)
+ headed_plugin_info->headed_plugin->bt_launch_system_popup(BT_AGENT_EVENT_LEGACY_PAIR_FAILED_FROM_REMOTE,
remote_dev_info->name, auth_info, NULL, NULL, NULL);
_bt_free_device_info(remote_dev_info);
{
int result = BLUETOOTH_ERROR_NONE;
int service_type;
- int alert_lvl;
+ int alert_lvl = -1;
GVariantIter value_iter;
char *property = NULL;
char *address;
service_type = BT_PXP_PROPERTY_IAS;
g_variant_get(val, "s", &alert_str);
- alert_lvl = get_alert_level_enum(alert_str);
+ if (alert_str)
+ alert_lvl = get_alert_level_enum(alert_str);
param = g_variant_new("(isiii)", result, address,
role, service_type, alert_lvl);
GVariant *child = NULL;
g_variant_iter_init(&value_iter, msg);
- while ((child = g_variant_iter_next_value(&value_iter))) {
+ if ((child = g_variant_iter_next_value(&value_iter))) {
g_variant_get(child, "{sv}", &property, &val);
ret_if(property == NULL);
}
+void __bt_map_property_changed_event(GVariant *msg,
+ const char *path)
+{
+ BT_DBG("Entered");
+ GVariantIter value_iter;
+ char *property = NULL;
+ GVariant *val = NULL;
+ GVariant *child = NULL;
+
+ g_variant_iter_init(&value_iter, msg);
+ while ((child = g_variant_iter_next_value(&value_iter))) {
+ g_variant_get(child, "{sv}", &property, &val);
+ ret_if(property == NULL);
+
+ if (strcasecmp(property, "Status") == 0) {
+ char *status = NULL;
+ g_variant_get(val, "s", &status);
+ BT_DBG("Status is %s", status);
+
+ if (strcasecmp(status, "active") == 0) {
+ BT_DBG("EVENT : STARTED");
+ // currently doing nothing
+ } else if (strcasecmp(status, "complete") == 0) {
+ BT_DBG("EVENT : COMPLETED");
+ _bt_map_on_transfer_finished(path, BLUETOOTH_ERROR_NONE);
+ } else if (strcasecmp(status, "error") == 0) {
+ BT_DBG("EVENT : FAILED");
+ _bt_map_on_transfer_finished(path, BLUETOOTH_ERROR_INTERNAL);
+ }
+ g_free(status);
+ } else if (strcasecmp(property, "Transferred") == 0) {
+ guint64 transferred = 0;
+ g_variant_get(val, "t", &transferred);
+
+ BT_DBG("EVENT : PROGRESS CALLBACK");
+ // currently doing nothing - progress callback type is not used
+ } else {
+ BT_DBG("OTHER EVENT : property : [%s]", property);
+ }
+ g_free(property);
+ g_variant_unref(child);
+ g_variant_unref(val);
+ }
+}
+
+void _bt_map_property_changed_event(GVariant *msg, const char *path)
+{
+ BT_DBG("Entered _bt_map_property_changed_event");
+ char *interface_name = NULL;
+ GVariant *value = NULL;
+ g_variant_get(msg, "(&s@a{sv}@as)", &interface_name, &value, NULL);
+ BT_INFO("interface_name = %s", interface_name);
+ if (strcasecmp(interface_name, BT_OBEX_TRANSFER_INTERFACE) == 0) {
+ __bt_map_property_changed_event(value,
+ path);
+ } else {
+ BT_DBG("interface_name : [%s]", interface_name);
+ }
+ g_variant_unref(value);
+}
+
+
void _bt_handle_input_event(GVariant *msg, const char *path)
{
int result = BLUETOOTH_ERROR_NONE;
{
GVariantIter value_iter;
char *property = NULL;
- char * char_handle = NULL;
GVariant *val = NULL;
- int result = BLUETOOTH_ERROR_NONE;
- GVariant *param = NULL;
g_variant_iter_init(&value_iter, msg);
- char_handle = g_strdup(path);
while ((g_variant_iter_loop(&value_iter, "{sv}", &property, &val))) {
BT_INFO("Property %s", property);
BT_DBG("notifying is enabled");
else
BT_DBG("notifying is disabled");
- } else if (strcasecmp(property, "ChangedValue") == 0) {
- int len = 0;
- GByteArray *gp_byte_array = NULL;
- BT_INFO("Type '%s'\n", g_variant_get_type_string(val));
-
- if (val) {
- gp_byte_array = g_byte_array_new();
- len = g_variant_get_size(val);
- BT_DBG("Len = %d", len);
- g_byte_array_append(gp_byte_array,
- (const guint8 *) g_variant_get_data(val), len);
- if (gp_byte_array->len != 0) {
- GVariant *byte_array = NULL;
- byte_array = g_variant_new_from_data(
- G_VARIANT_TYPE_BYTESTRING,
- gp_byte_array->data,
- gp_byte_array->len,
- TRUE, NULL, NULL);
- param = g_variant_new("(is@ay)", result, char_handle,
- byte_array);
-
- /* Send event only registered client */
- _bt_send_char_value_changed_event(param);
- }
- g_byte_array_free(gp_byte_array, TRUE);
- }
}
}
- g_free(char_handle);
}
void _bt_handle_gatt_event(GVariant *msg, const char *member, const char *path)
{
ret_if(path == NULL);
-
if (strcasecmp(member, "GattValueChanged") == 0) {
-
-#if 0 // Debug Only
- /*** Debug only ***/
- GVariant *value = NULL;
- int value_len = 0;
- char *buffer = NULL;
-
- g_variant_get(msg, "(is@ay)", NULL, NULL, &value);
- value_len = g_variant_get_size(value);
- if (value_len > 0) {
- char buf[8 * 5 + 1] = { 0 };
- int i;
- int to;
- buffer = (char *)g_variant_get_data(value);
- to = value_len > (sizeof(buf) / 5) ? sizeof(buf) / 5 : value_len;
-
- for (i = 0; i < to; i++)
- snprintf(&buf[i * 5], 6, "0x%02x ", buffer[i]);
- buf[i * 5] = '\0';
- BT_DBG("GATT Val[%d] %s", value_len, buf);
- }
- g_variant_unref(value);
- /******/
+ /* Check TDS seekers waiting for Indication */
+ _bt_tds_check_indication(path, msg);
+#ifdef TIZEN_FEATURE_BT_OTP
+ _bt_otp_check_indication(path, msg);
#endif
-
- /* Send event only registered client */
- _bt_send_char_value_changed_event(msg);
+ } else {
+ BT_INFO("Unhandled event");
}
}
-
void _bt_handle_device_event(GVariant *msg, const char *member, const char *path)
{
int event = 0;
_bt_opp_client_is_sending(&sending);
if (sending == TRUE)
_bt_opp_client_check_pending_transfer(address);
+ /* TODO: MAP? see above */
}
param = g_variant_new("(isy)", result, address, addr_type);
_bt_send_event(BT_DEVICE_EVENT,
(state == BT_PROFILE_STATE_CONNECTED)) {
int event = BLUETOOTH_EVENT_AV_CONNECTED;
- char connected_address[BT_ADDRESS_STRING_SIZE + 1];
+#ifndef TIZEN_BT_DUAL_HEADSET_CONNECT
bluetooth_device_address_t device_address;
+ char connected_address[BT_ADDRESS_STRING_SIZE + 1];
gboolean connected;
+#endif
bt_headset_wait_t *wait_list;
guint restricted = 0x0;
param = g_variant_new("(is)", result, address);
_bt_send_event(BT_HEADSET_EVENT, event,
param);
+#ifdef TIZEN_BT_DUAL_HEADSET_CONNECT
+ _bt_check_already_connected_headset(BT_AUDIO_A2DP,
+ address);
+#else
connected = _bt_is_headset_type_connected(BT_AUDIO_A2DP,
connected_address);
if (connected) {
&device_address, NULL);
}
}
-
+#endif
_bt_add_headset_to_list(BT_AUDIO_A2DP,
BT_STATE_CONNECTED, address);
param = g_variant_new("(is)", result, address);
_bt_send_event(BT_HID_EVENT, event,
param);
+
+ /* Set the vconf value for device */
+ if (state == BT_PROFILE_STATE_CONNECTED) {
+ hid_connected_device_count++;
+ __bt_set_device_values(TRUE,
+ VCONFKEY_BT_DEVICE_HID_CONNECTED);
+ } else {
+ hid_connected_device_count--;
+ if (hid_connected_device_count == 0)
+ __bt_set_device_values(FALSE,
+ VCONFKEY_BT_DEVICE_HID_CONNECTED);
+ }
} else if (strcmp(profile_uuid, HID_DEVICE_UUID) == 0) {
if (state == BT_PROFILE_STATE_CONNECTED) {
int event;
&le_dev_info->adv_data_len,
&value);
- ret_if(value == NULL);
+ if (value == NULL) {
+ _bt_free_le_device_info(le_dev_info);
+ return;
+ }
_bt_convert_device_path_to_address(path, le_dev_info->address);
} else if (strcasecmp(member, "IpspStateChanged") == 0) {
gboolean connected = FALSE;
char *ifname = NULL;
+ GVariant *ipsp_param = NULL;
g_variant_get(msg, "(bs)", &connected, &ifname);
BT_DBG("Ipsp BT Interface Name: %s", ifname);
BT_DBG("address: %s", address);
param = g_variant_new("(iss)", result, address, ifname);
+ ipsp_param = g_variant_new("(ss)", ifname, address);
+
+ /* Set Ipv6 Addr */
+ GDBusProxy *ipsp_proxy;
+ if (connected) {
+ BT_DBG("IPSP connected, Set Ipv6 Addr");
+ ipsp_proxy = _bt_get_ipsp_proxy();
+ if (ipsp_proxy == NULL) {
+ BT_ERR("can not get ipsp proxy");
+ g_free(address);
+ return;
+ }
+
+ g_dbus_proxy_call(ipsp_proxy, "SetIpv6Addr",
+ ipsp_param, G_DBUS_CALL_FLAGS_NONE,
+ -1, NULL, NULL, NULL);
+ } else {
+ BT_DBG("IPSP disconnected");
+ ipsp_proxy = _bt_get_ipsp_proxy();
+ if (ipsp_proxy == NULL) {
+ BT_ERR("can not get ipsp proxy");
+ g_free(address);
+ return;
+ }
+
+ g_dbus_proxy_call(ipsp_proxy, "DisableIpsp",
+ NULL, G_DBUS_CALL_FLAGS_NONE,
+ -1, NULL, NULL, NULL);
+ }
/* Send event to application */
_bt_send_event(BT_DEVICE_EVENT,
event,
param);
g_free(address);
+ } else if (strcasecmp(member, "AttMtuChanged") == 0) {
+ int result = BLUETOOTH_ERROR_NONE;
+ guint16 mtu = 0;
+ guint8 status = 0;
+
+ g_variant_get(msg, "(q)", &mtu);
+
+ address = g_malloc0(BT_ADDRESS_STRING_SIZE);
+
+ _bt_convert_device_path_to_address(path, address);
+ _bt_convert_addr_string_to_secure_string(secure_address, address);
+ BT_DBG("Address : %s MTU changed : %d", secure_address, mtu);
+
+ param = g_variant_new("(isqy)",
+ result,
+ address,
+ mtu,
+ status);
+
+ /* Send the event to application */
+ _bt_send_event(BT_DEVICE_EVENT,
+ BLUETOOTH_EVENT_GATT_ATT_MTU_CHANGED,
+ param);
+
+ g_free(address);
}
}
_bt_send_event(BT_OPP_SERVER_EVENT,
BLUETOOTH_EVENT_OBEX_SERVER_CONNECTION_AUTHORIZE,
param);
+ /* TODO: MAP? see above */
g_free(address);
g_free(name);
} else if (strcasecmp(member, "RfcommAuthorize") == 0) {
}
}
+void _bt_handle_tds_provider_event(GVariant *msg, const char *member, const char *path)
+{
+ BT_INFO("member: %s, path: %s", member, path);
+
+ ret_if(path == NULL);
+
+ if (strcasecmp(member, "TdsActivationRequested") == 0) {
+ GVariant *value = NULL;
+ int len = 0;
+ unsigned char *buffer = NULL;
+ unsigned char org_id;
+
+ g_variant_get(msg, "(y@ay)", &org_id, &value);
+ BT_DBG("org_id: %.2x", org_id);
+ len = g_variant_get_size(value);
+ if (len > 0) {
+ int i;
+ buffer = (unsigned char *)g_variant_get_data(value);
+ for (i = 0; i < len; i++)
+ BT_DBG("%.2x", buffer[i]);
+ }
+
+ /* Send event only registered client */
+ _bt_tds_handle_activation_request(path, org_id, buffer, len);
+ g_variant_unref(value);
+ }
+}
+
static int __bt_get_object_path(GVariant *msg, char **path)
{
g_variant_get(msg, "(o*)", path, NULL);
/* Stop the Proximity reporter service */
_bt_proximity_reporter_stop_by_terminated_process(name);
+ /* Stop the Transport Discovery service */
+ _bt_tds_stop_by_terminated_process(name);
+
g_free(name);
g_free(previous);
g_free(current);
_bt_handle_agent_event(parameters, signal_name);
} else if (g_strcmp0(interface_name, BT_DEVICE_INTERFACE) == 0) {
_bt_handle_device_event(parameters, signal_name, object_path);
+ } else if (g_strcmp0(interface_name, BT_TDS_PROVIDER_INTERFACE) == 0) {
+ _bt_handle_tds_provider_event(parameters, signal_name, object_path);
} else if (g_strcmp0(interface_name, BT_GATT_CHAR_INTERFACE) == 0) {
_bt_handle_gatt_event(parameters, signal_name, object_path);
}
BT_INFO("object_path = [%s]", obj_path);
/*Handle OPP_SERVER_CONNECTED_EVENT here */
+ /* TODO: MAP? see above */
if (strncmp(obj_path, BT_SESSION_BASEPATH_SERVER,
strlen(BT_SESSION_BASEPATH_SERVER)) != 0) {
g_free(obj_path);
g_free(obj_path);
} else if (strcasecmp(member, "InterfacesRemoved") == 0) {
/*Handle OPP_SERVER_DISCONNECTED_EVENT here */
+ /* TODO: MAP? see above */
if (__bt_get_object_path(parameters, &obj_path)) {
BT_ERR("Fail to get the path");
return;
}
}
+static void __bt_map_event_filter(GDBusConnection *connection,
+ const gchar *sender_name,
+ const gchar *object_path,
+ const gchar *interface_name,
+ const gchar *signal_name,
+ GVariant *parameters,
+ gpointer user_data)
+{
+ BT_DBG("Entered __bt_map_event_filter");
+ const char *member = signal_name;
+
+ if (strcasecmp(member, "InterfacesAdded") == 0) {
+ BT_DBG("------------------------------------ADDED------------------------------------");
+ // currently doing nothing
+ } else if (strcasecmp(member, "InterfacesRemoved") == 0) {
+ BT_DBG("------------------------------------REMOVED------------------------------------");
+ // TODO check if something should be called here?
+ //_bt_map_on_transfer_finished(object_path, error);
+ } else if (__bt_is_obexd_client_event(parameters, interface_name) == TRUE) {
+ BT_DBG("------------------------------------CLIENT EVENT------------------------------------");
+ _bt_map_property_changed_event(parameters, object_path);
+ }
+
+ return;
+}
+
+int _bt_map_client_event_init(void)
+{
+ GError *error = NULL;
+
+ if (map_obexd_conn == NULL) {
+ map_obexd_conn = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, &error);
+
+ if (!map_obexd_conn) {
+ if (error) {
+ BT_ERR("Unable to connect to dbus: %s", error->message);
+ g_clear_error(&error);
+ }
+ return BLUETOOTH_ERROR_INTERNAL;
+ }
+ }
+
+ if (_bt_register_service_event(map_obexd_conn,
+ BT_MAP_CLIENT_EVENT) != BLUETOOTH_ERROR_NONE) {
+ g_object_unref(map_obexd_conn);
+ map_obexd_conn = NULL;
+ return BLUETOOTH_ERROR_INTERNAL;
+ }
+
+ return BLUETOOTH_ERROR_NONE;
+}
+
+void _bt_map_client_event_deinit(void)
+{
+ if (map_obexd_conn) {
+ _bt_unregister_service_event(map_obexd_conn,
+ BT_MAP_CLIENT_EVENT);
+ g_object_unref(map_obexd_conn);
+ map_obexd_conn = NULL;
+ }
+}
+
int _bt_register_manager_subscribe_signal(GDBusConnection *conn,
int subscribe)
{
return 0;
}
+int _bt_register_map_client_subscribe_signal(GDBusConnection *conn,
+ int subscribe)
+{
+ if (conn == NULL)
+ return -1;
+
+ static int subs_map_client_interface_added_id = -1;
+ static int subs_map_client_interface_removed_id = -1;
+ static int subs_map_client_property_id = -1;
+
+
+ if (subscribe) {
+ if (subs_map_client_interface_added_id == -1) {
+ subs_map_client_interface_added_id = g_dbus_connection_signal_subscribe(conn,
+ NULL, BT_MANAGER_INTERFACE,
+ BT_INTERFACES_ADDED, NULL, NULL, 0,
+ __bt_map_event_filter,
+ NULL, NULL);
+ }
+ if (subs_map_client_interface_removed_id == -1) {
+ subs_map_client_interface_removed_id = g_dbus_connection_signal_subscribe(conn,
+ NULL, BT_MANAGER_INTERFACE,
+ BT_INTERFACES_REMOVED, NULL, NULL, 0,
+ __bt_map_event_filter,
+ NULL, NULL);
+ }
+ if (subs_map_client_property_id == -1) {
+ subs_map_client_property_id = g_dbus_connection_signal_subscribe(conn,
+ NULL, BT_PROPERTIES_INTERFACE,
+ BT_PROPERTIES_CHANGED, NULL, NULL, 0,
+ __bt_map_event_filter,
+ NULL, NULL);
+ }
+ } else {
+ if (subs_map_client_interface_added_id != -1) {
+ g_dbus_connection_signal_unsubscribe(conn,
+ subs_map_client_interface_added_id);
+ subs_map_client_interface_added_id = -1;
+ }
+ if (subs_map_client_interface_removed_id != -1) {
+ g_dbus_connection_signal_unsubscribe(conn,
+ subs_map_client_interface_removed_id);
+ subs_map_client_interface_removed_id = -1;
+ }
+ if (subs_map_client_property_id != -1) {
+ g_dbus_connection_signal_unsubscribe(conn,
+ subs_map_client_property_id);
+ subs_map_client_property_id = -1;
+ }
+ }
+ return 0;
+}
+
int _bt_register_a2dp_subscribe_signal(GDBusConnection *conn,
int subscribe)
{
return 0;
}
+int _bt_register_tds_provider_subscribe_signal(GDBusConnection *conn, int subscribe)
+{
+ if (conn == NULL)
+ return -1;
+
+ static int subs_custom_id = -1;
+
+ if (subscribe) {
+ if (subs_custom_id == -1) {
+ subs_custom_id = g_dbus_connection_signal_subscribe(conn,
+ NULL, BT_TDS_PROVIDER_INTERFACE,
+ NULL, NULL, NULL, 0,
+ __bt_manager_event_filter,
+ NULL, NULL);
+ }
+ } else {
+ if (subs_custom_id != -1) {
+ g_dbus_connection_signal_unsubscribe(conn,
+ subs_custom_id);
+ subs_custom_id = -1;
+ }
+ }
+
+ return 0;
+}
+
static void __bt_dump_event_filter(GDBusConnection *connection,
const gchar *sender_name,
const gchar *object_path,
case BT_HEADSET_EVENT:
_bt_register_audio_subscribe_signal(g_conn, TRUE);
break;
-
case BT_OPP_SERVER_EVENT:
BT_ERR("BT_OPP_SERVER_EVENT: register service event");
_bt_register_opp_server_subscribe_signal(g_conn, TRUE);
break;
+
case BT_OPP_CLIENT_EVENT:
BT_ERR("BT_OPP_CLIENT_EVENT: register service event");
_bt_register_opp_client_subscribe_signal(g_conn, TRUE);
break;
+ case BT_MAP_CLIENT_EVENT:
+ BT_ERR("BT_MAP_CLIENT_EVENT: register service event");
+ _bt_register_map_client_subscribe_signal(g_conn, TRUE);
+ break;
case BT_A2DP_SOURCE_EVENT:
BT_INFO("A2dp Source event");
_bt_register_a2dp_subscribe_signal(g_conn, TRUE);
break;
+ case BT_TDS_EVENT:
+ BT_INFO("TDS provider event");
+ _bt_register_tds_provider_subscribe_signal(g_conn, TRUE);
+ break;
default:
BT_ERR("Unknown event");
return BLUETOOTH_ERROR_INTERNAL;
case BT_OPP_CLIENT_EVENT:
_bt_register_opp_client_subscribe_signal(g_conn, FALSE);
break;
+ case BT_MAP_CLIENT_EVENT:
+ _bt_register_map_client_subscribe_signal(g_conn, FALSE);
+ break;
default:
BT_ERR("Unknown event");
return;
BT_NETWORK_EVENT) != BLUETOOTH_ERROR_NONE)
goto fail;
+ if (_bt_register_service_event(manager_conn,
+ BT_TDS_EVENT) != BLUETOOTH_ERROR_NONE)
+ goto fail;
+
__bt_register_dump_subscribe_signal(manager_conn, TRUE);
return BLUETOOTH_ERROR_NONE;
fail: