g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
#ifdef TIZEN_GATT_CLIENT
- BT_INFO("Send GATT disconnect using Client Interface [%d]", client_id);
+ BT_DBG("Send GATT disconnect using Client Interface [%d]", client_id);
g_array_append_vals(in_param2, &client_id, sizeof(int));
#endif
user_info = _bt_get_user_data(BT_COMMON);
BT_EXPORT_API int bluetooth_gatt_free_service_property(bt_gatt_service_property_t *svc_pty)
{
- BT_DBG("+");
-
BT_CHECK_PARAMETER(svc_pty, return);
#ifdef TIZEN_GATT_CLIENT
memset(svc_pty, 0, sizeof(bt_gatt_service_property_t));
- BT_DBG("-");
return BLUETOOTH_ERROR_NONE;
}
BT_EXPORT_API int bluetooth_gatt_free_char_property(bt_gatt_char_property_t *char_pty)
{
- BT_DBG("+");
-
BT_CHECK_PARAMETER(char_pty, return);
g_free(char_pty->uuid);
memset(char_pty, 0, sizeof(bt_gatt_char_property_t));
- BT_DBG("-");
return BLUETOOTH_ERROR_NONE;
}
BT_EXPORT_API int bluetooth_gatt_free_desc_property(bt_gatt_char_descriptor_property_t *desc_pty)
{
- BT_DBG("+");
-
BT_CHECK_PARAMETER(desc_pty, return);
g_free(desc_pty->uuid);
memset(desc_pty, 0, sizeof(bt_gatt_char_descriptor_property_t));
- BT_DBG("-");
return BLUETOOTH_ERROR_NONE;
}
int fd = -1;
fd_list_array = g_unix_fd_list_steal_fds(out_fd_list, &len);
- BT_INFO("Num fds in fd_list is : %d, fd_list[0]: %d", len, fd_list_array[0]);
+ BT_DBG("Num fds in fd_list is : %d, fd_list[0]: %d", len, fd_list_array[0]);
fd = fd_list_array[0];
mtu = g_array_index(out_param, int, 0);
bt_bdaddr_t bd_addr;
memcpy(bd_addr.address, ev->bdaddr, 6);
- /* BD address */
- DBG("Address: [%02X:%02X:%02X:%02X:%02X:%02X]", bd_addr.address[0],
- bd_addr.address[1], bd_addr.address[2], bd_addr.address[3],
- bd_addr.address[4], bd_addr.address[5]);
- DBG("LE conn Status [0x%x]", ev->status);
- DBG("LE conn State [0x%x]", ev->state);
+
+ DBG("LE conn Status [0x%x] State [0x%x] [%02X:%02X:%02X:%02X:%02X:%02X]", ev->status, ev->state,
+ bd_addr.address[0], bd_addr.address[1], bd_addr.address[2],
+ bd_addr.address[3], bd_addr.address[4], bd_addr.address[5]);
#ifdef TIZEN_BT_HAL
if (!bt_hal_cbacks->le_conn_state_changed_cb) {
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("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")) {
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;
const char *address)
{
struct hal_ev_device_trust_state_changed ev;
- DBG("+");
ev.trust = (is_trusted == TRUE) ?
HAL_DEVICE_TRUSTED :
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;
address = g_malloc0(BT_HAL_ADDRESS_STRING_SIZE);
_bt_hal_convert_device_path_to_address(path, address);
- DBG("[%s] %s, state %d", address, profile_uuid, 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)
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);
address = g_malloc0(BT_HAL_ADDRESS_STRING_SIZE);
- DBG("Member: [%s]", member);
-
_bt_hal_convert_device_path_to_address(path, address);
g_variant_get(msg, "(q)", &mtu);
memset(buf, 0, sizeof(buf));
size = sizeof(*ev);
- DBG("Address: %s, mtu: %d", address, mtu);
-
ev->conn_id = _bt_get_remote_gatt_client_conn_id(address);
ev->mtu = mtu;
- DBG("Send GATT server mtu changed event to HAL, size: [%zd]", size);
gatt_event_cb(HAL_EV_GATT_SERVER_MTU_CHANGED, buf, size);
}
_bt_hal_convert_uuid_string_to_type(gattc_service->svc_uuid.uu, uuid_str);
gattc_service->is_primary = is_primary;
- INFO("[%d] [%s] [%s]", g_slist_length(conn_info->gatt_list_services), object_path + 15, uuid_str);
-
conn_info->gatt_list_services = g_slist_append(conn_info->gatt_list_services, gattc_service);
+ INFO("Toatal svc [%d] Added [%s] [%s]", g_slist_length(conn_info->gatt_list_services), object_path + 15, uuid_str);
return gattc_service;
}
int ret = BT_STATUS_SUCCESS;
hal_gattc_client_info_t *gattc_data;
- DBG("+");
-
if (NULL == bd_addr) {
ERR("bd_addr is NULL");
return BT_STATUS_PARM_INVALID;
ret = BT_STATUS_FAIL;
return ret;
}
- ERR("device_path:%s", device_path);
device_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
NULL, BT_HAL_BLUEZ_NAME,
memcpy(gattc_data->bd_addr.address, bd_addr->address,
BT_HAL_ADDRESS_LENGTH_MAX);
- DBG("Connect LE [%s]", device_address);
+ DBG("ConnectLE [%s]", device_address);
gattc_data->client_if = client_if;
struct hal_ev_gatt_client_connected ev;
hal_gattc_server_info_t *gatt_conn_info = NULL;
- DBG("+");
-
reply = g_dbus_proxy_call_finish(proxy, res, &g_error);
g_object_unref(proxy);
if (reply == NULL) {
g_variant_unref(reply);
if (NULL == gattc_data) {
- ERR("server_data is NULL");
+ ERR("gattc_data is NULL");
return;
}
goto fail;
}
- DBG("adding the server conn info in list");
+ DBG("LE connected. Adding the gattc server/client conn info in list");
gattc_data->conn_id = __hal_generate_conn_id() ;
gattc_data->inst_id = __hal_generate_server_instance_id();
gatt_conn_info->inst_id = gattc_data->inst_id;
hal_gattc_server_info_list = g_slist_append(hal_gattc_server_info_list, gatt_conn_info);
- DBG("-");
return;
fail:
if (!event_cb) {
ERR("gatt client callback not registered");
} else {
- DBG("sending gatt client connected status event");
event_cb(event, (void *)&ev, sizeof(ev));
}
while (g_variant_iter_loop(property_iter, "{sv}", &key, &value)) {
if (g_strcmp0(key, "UUID") == 0) {
uuid_str = g_variant_get_string(value, &len);
- DBG("UUID: %s", uuid_str);
} else if (g_strcmp0(key, "Primary") == 0) {
is_primary = g_variant_get_boolean(value);
- DBG("is_primary: %s", is_primary ? "TRUE" : "FALSE");
} else if (g_strcmp0(key, "Characteristics") == 0) {
g_variant_get(value, "ao", &char_iter);
if (char_iter != NULL) {
g_variant_iter_free(property_iter);
g_variant_unref(result);
g_object_unref(properties_proxy);
- DBG("-");
+
return BT_STATUS_SUCCESS;
}
if (request_type == BT_ASYNC_REQ ||
__bt_is_sync_function(service_function)) {
- BT_INFO("Do not send reply to bt-api over dbus,"
+ BT_DBG("Do not send reply to bt-api over dbus,"
" Invocation context is already saved in service_function");
goto done;
}
__bt_service_get_parameters(in_param3,
&client_id, sizeof(int));
- BT_INFO("GATT Client: client_id[%d]", client_id);
+ BT_DBG("GATT Client: client_id[%d]", client_id);
result = _bt_connect_le_device(&address, auto_connect, client_id);
if (BLUETOOTH_ERROR_NONE == result) {
-
addr = g_malloc0(BT_ADDRESS_STRING_SIZE);
- BT_INFO("GATT Client: Save Invocation data Connect LE app[%s]", sender);
-
_bt_convert_addr_type_to_string(addr, address.addr);
/* Save the informations to invocation */
_bt_save_invocation_context(context, result, sender,
function_name, (gpointer)addr);
} else {
- BT_ERR("GATT Client: gatt connect failed");
+ BT_ERR("GATT Client: gatt connect failed. client_id[%d]", client_id);
g_array_append_vals(*out_param1, &address,
sizeof(bluetooth_device_address_t));
}
gboolean _bt_utf8_validate(char *name)
{
- BT_DBG("+");
gunichar2 *u16;
glong items_written = 0;
if (items_written != g_utf8_strlen(name, -1))
return FALSE;
- BT_DBG("-");
return TRUE;
}
GSList *l;
invocation_info_t *req_info = NULL;
- BT_DBG("+");
-
retv_if(NULL == address, NULL);
/* Get method invocation context */
return req_info;
}
- BT_DBG("-");
return NULL;
}
{
bt_service_oal_event_data_t *oal_event = g_new0(bt_service_oal_event_data_t, 1);
- BT_INFO("event_type: [%d], data size: [%zu]", event_type, len);
+ BT_DBG("event_type: [%d], data size: [%zu]", event_type, len);
oal_event->type = event_type;
if (event_data)
#ifdef TIZEN_GATT_CLIENT
case BLUETOOTH_EVENT_GATT_SERVER_CONNECTED: /* GATT Server and Client */
signal = BT_GATT_SERVER_CONNECTED;
+ BT_INFO_C("### Connected [GATT server]");
break;
case BLUETOOTH_EVENT_GATT_SERVER_DISCONNECTED: /* GATT Client and Server */
signal = BT_GATT_SERVER_DISCONNECTED;
+ BT_INFO_C("### Disconnected [GATT server]");
break;
case BLUETOOTH_EVENT_GATT_CLIENT_CONNECTED: /* GATT Server and Client */
signal = BT_GATT_CLIENT_CONNECTED;
+ BT_INFO_C("### Connected [GATT client]");
break;
case BLUETOOTH_EVENT_GATT_CLIENT_DISCONNECTED: /* GATT Client and Server */
signal = BT_GATT_CLIENT_DISCONNECTED;
+ BT_INFO_C("### Disconnected [GATT client]");
break;
#else
case BLUETOOTH_EVENT_GATT_CONNECTED:
static void __bt_device_event_handler(int event_type, gpointer event_data)
{
int eventcheck = OAL_EVENT_DEVICE_PROPERTIES;
- BT_INFO("event [%d] Event check = [%d]", event_type, eventcheck);
+ BT_DBG("event [%d] Event check = [%d]", event_type, eventcheck);
switch (event_type) {
case OAL_EVENT_ADAPTER_INQUIRY_RESULT_BREDR_ONLY: {
GVariant *param = NULL;
bt_device_conn_info_t conn_info;
- BT_DBG("+");
_bt_convert_addr_type_to_string(address, acl_event->address.addr);
_bt_logging_connection(connected, type);
result = __bt_oal_status_to_bt_error(acl_event->status);
- BT_INFO("Result [0x%x]", result);
+ BT_DBG("Result [0x%x]", result);
if (connected) {
param = g_variant_new("(isy)", result, address, type);
#ifdef TIZEN_GATT_CLIENT
/*handle LE connected device info*/
- if (type) {
- BT_DBG("handle LE connected device info");
+ if (type)
_bt_handle_le_connected_dev_info(address, connected);
- }
#endif
- BT_DBG("-");
}
static void __bt_device_remote_device_found_callback(gpointer event_data, gboolean is_ble)
return;
}
-
static void _bt_handle_le_connected_dev_info(const char *address, gboolean connected)
{
- BT_DBG("+");
+ BT_DBG("update le_connected_dev_list");
if (connected)
_bt_add_le_connected_dev_info(address);
#ifndef GATT_DIRECT
case BT_GATT_SERVER_REGISTER: {
bt_service_app_info_t *param = (bt_service_app_info_t*)data;
- BT_INFO("Sender [%s] Request Sender [%s]", param->sender, req_info->sender);
+ BT_DBG("Sender [%s] Request Sender [%s]", param->sender, req_info->sender);
if (!g_strcmp0(req_info->sender, param->sender)) {
BT_DBG("GATT Server app found [%s]", req_info->sender);
case BT_GATT_SERVER_START_SERVICE:
case BT_GATT_SERVER_DELETE_SERVICE: {
bt_service_app_info_t *param = (bt_service_app_info_t*)data;
- BT_INFO("Sender [%s] Request Sender [%s]", param->sender, req_info->sender);
+ BT_DBG("Sender [%s] Request Sender [%s]", param->sender, req_info->sender);
int *saved_instance_id = (int*)req_info->user_data;
if (!g_strcmp0(req_info->sender, param->sender) && param->instance_id == *saved_instance_id) {
case BT_GATT_SERVER_ADD_DESCRIPTOR:
case BT_GATT_SERVER_ADD_CHARACTERISTIC: {
int *handle = (int*)data;
- BT_INFO("Characteristic added: Handle [%d]", *handle);
+ BT_DBG("Characteristic added: Handle [%d]", *handle);
out_param = g_array_new(FALSE, FALSE, sizeof(gchar));
g_array_append_vals(out_param, handle, sizeof(int));
#ifdef TIZEN_GATT_CLIENT
case BT_GATT_CLIENT_REGISTER: {
bt_service_app_info_t *param = (bt_service_app_info_t*)data;
- BT_INFO("Sender [%s] Request Sender [%s]", param->sender, req_info->sender);
+ BT_DBG("Sender [%s] Request Sender [%s]", param->sender, req_info->sender);
if (!g_strcmp0(req_info->sender, param->sender)) {
BT_DBG("GATT Client app found [%s] created client ID [%d]",
req_info->sender, param->client_id);
_bt_convert_addr_type_to_string(address,
(unsigned char *)(¶m->device_addr.addr));
- BT_INFO("Request Sender [%s] address [%s]", req_info->sender, address);
+ BT_DBG("Request Sender [%s] address [%s]", req_info->sender, address);
/* Match address to determine same request */
if (!g_strcmp0((char*)req_info->user_data, address)) {
bt_char_browse_info_t param;
memcpy((void*)¶m, data, sizeof(bt_char_browse_info_t));
//bt_char_browse_info_t *param = (bt_char_browse_info_t*)data;
- BT_INFO("Request Sender [%s]", req_info->sender);
+ BT_DBG("Request Sender [%s]", req_info->sender);
bluetooth_gatt_client_svc_prop_info_t *prop = (bluetooth_gatt_client_svc_prop_info_t*)req_info->user_data;
/* Match both address and service properties to determine same request */
sizeof(bluetooth_device_address_t)) &&
!memcmp(param.svc_uuid, prop->svc.uuid, BLUETOOTH_UUID_HEX_MAX_LEN) &&
param.svc_inst_id == prop->svc.instance_id) {
- BT_INFO("Returning Service properties");
+ BT_DBG("Returning Service properties");
out_param = g_array_new(FALSE, FALSE, sizeof(gchar));
g_array_append_vals(out_param, ¶m, sizeof(bt_char_browse_info_t));
case BT_GATT_GET_CHARACTERISTIC_PROPERTIES: {
bt_descriptor_browse_info_t *param = (bt_descriptor_browse_info_t*)data;
- BT_INFO("Request Sender [%s]", req_info->sender);
+ BT_DBG("Request Sender [%s]", req_info->sender);
bluetooth_gatt_client_char_prop_info_t *prop = (bluetooth_gatt_client_char_prop_info_t*)req_info->user_data;
/* Match both address, service properties &char properties to determine same request */
param->svc_inst_id == prop->svc.instance_id &&
!memcmp(param->char_uuid, prop->characteristic.uuid, BLUETOOTH_UUID_HEX_MAX_LEN) &&
param->char_inst_id == prop->characteristic.instance_id) {
- BT_INFO("Returning Characteristic properties");
+ BT_DBG("Returning Characteristic properties");
out_param = g_array_new(FALSE, FALSE, sizeof(gchar));
g_array_append_vals(out_param, param, sizeof(bt_descriptor_browse_info_t));
_bt_service_method_return(req_info->context, out_param, result);
case BT_GATT_WATCH_CHARACTERISTIC: {
bt_gatt_notif_reg_info_t *param = (bt_gatt_notif_reg_info_t*)data;
bluetooth_gatt_client_char_prop_info_t *prop = (bluetooth_gatt_client_char_prop_info_t*)req_info->user_data;
- BT_INFO("Request Sender [%s]", req_info->sender);
+ BT_DBG("Request Sender [%s]", req_info->sender);
/* Match both address, service properties &char properties to determine same request */
if (!memcmp(param->addr.addr,
prop->device_address.addr,
case BT_GATT_READ_CHARACTERISTIC:
case BT_GATT_WRITE_CHARACTERISTIC_VALUE_BY_TYPE: {
bluetooth_gatt_client_char_prop_info_t *param = (bluetooth_gatt_client_char_prop_info_t*)data;
- BT_INFO("Request Sender [%s]", req_info->sender);
+ BT_DBG("Request Sender [%s]", req_info->sender);
char *addr = g_malloc0(sizeof(char) * BT_ADDRESS_STRING_SIZE);
bluetooth_gatt_client_char_prop_info_t *prop = (bluetooth_gatt_client_char_prop_info_t*)req_info->user_data;
_bt_convert_addr_type_to_string(addr, prop->device_address.addr);
if (!memcmp(param, prop, sizeof(bluetooth_gatt_client_char_prop_info_t))) {
- BT_INFO("Gatt Char read or write request matched for address [%s]", addr);
+ BT_DBG("Gatt Char read or write request matched for address [%s]", addr);
out_param = g_array_new(FALSE, FALSE, sizeof(gchar));
g_array_append_vals(out_param, param, sizeof(bluetooth_gatt_client_char_prop_info_t));
_bt_service_method_return(req_info->context, out_param, result);
case BT_GATT_READ_DESCRIPTOR_VALUE:
case BT_GATT_WRITE_DESCRIPTOR_VALUE: {
bluetooth_gatt_client_desc_prop_info_t *param = (bluetooth_gatt_client_desc_prop_info_t*)data;
- BT_INFO("Request Sender [%s]", req_info->sender);
+ BT_DBG("Request Sender [%s]", req_info->sender);
char *addr = g_malloc0(sizeof(char) * BT_ADDRESS_STRING_SIZE);
bluetooth_gatt_client_desc_prop_info_t *prop = (bluetooth_gatt_client_desc_prop_info_t*)req_info->user_data;
_bt_convert_addr_type_to_string(addr, prop->device_address.addr);
if (!memcmp(param, prop, sizeof(bluetooth_gatt_client_desc_prop_info_t))) {
- BT_INFO("Descriptor read or write request matched for address [%s]", addr);
+ BT_DBG("Descriptor read or write request matched for address [%s]", addr);
out_param = g_array_new(FALSE, FALSE, sizeof(gchar));
g_array_append_vals(out_param, param, sizeof(bluetooth_gatt_client_desc_prop_info_t));
_bt_service_method_return(req_info->context, out_param, result);
bluetooth_device_address_t address;
if (!g_strcmp0(addr, (char*)data)) {
- BT_INFO("GATT Client BT_REQ_ATT_MTU call pending for app [%s] addr [%s]",
+ BT_DBG("GATT Client BT_REQ_ATT_MTU call pending for app [%s] addr [%s]",
req_info->sender, addr);
out_param = g_array_new(FALSE, FALSE, sizeof(gchar));
_bt_convert_addr_string_to_type(address.addr, addr);
break;
}
}
- BT_DBG("-");
}
static void __bt_handle_server_instance_registered(event_gatts_register_t *data)
struct gatt_client_info_t *conn_info = NULL;
GVariant *param = NULL;
guint8 status = 0;
- BT_INFO("GATT Server MTU changed event");
conn_info = __bt_find_remote_gatt_client_info_from_conn_id(event->conn_id);
if (conn_info == NULL) {
conn_info = g_new0(struct gatt_server_info_t, 1);
conn_info->addr = g_strdup(address);
conn_info->client_id = event_data->client_if;
- BT_INFO("Added GATT server addr[%s]", conn_info->addr);
conn_info->connection_id = event_data->conn_id;
gatt_server_info_list = g_slist_append(gatt_server_info_list, conn_info);
- BT_INFO("Total num of connected Remote GATT server devices [%d]",
+ BT_DBG("Total num of connected Remote GATT server devices [%d]",
g_slist_length(gatt_server_info_list));
#if 0
addr = g_malloc0(sizeof(char) * BT_ADDRESS_STRING_SIZE);
_bt_convert_addr_type_to_string(addr, address->addr);
- BT_INFO("GATT Client connect request for address [%s] client instance [%d]",
+ BT_DBG("GATT Client connect request for address [%s] client instance [%d]",
addr, client_id);
if (req_info) {
remote_address = (char*)req_info->user_data;
if (remote_address && !strcasecmp(remote_address, addr)) {/* Address matched */
- BT_INFO("Already Connection ongoing for same remote GATT Server address [%s]", remote_address);
+ BT_DBG("Already Connection ongoing for same remote GATT Server address [%s]", remote_address);
/* Return and wait for events to be sent to all apps */
g_free(addr);
return BLUETOOTH_ERROR_IN_PROGRESS;
/* Check if app sent 0 client id for connection, in such case, use default gatt client ID */
if (client_id == 0) {
- BT_INFO("GATT CLient connect request sent by an app without any client instance [%d]",
- client_id);
- BT_INFO("Assign default GATT client id [%d]", gatt_default_client);
+ /* GATT CLient connect request sent by an app without any client instance [0] */
+ BT_DBG("Assign default GATT client id [%d]", gatt_default_client);
client_id = gatt_default_client;
}
ret = gattc_connect(client_id, (bt_address_t*)(address), auto_connect);
if (ret != OAL_STATUS_SUCCESS) {
- BT_ERR("ret: %d", ret);
+ BT_ERR("gattc_connect is failed. ret: %d", ret);
g_free(addr);
return BLUETOOTH_ERROR_INTERNAL;
}
struct gatt_server_info_t *conn_info = NULL;
invocation_info_t *req_info = NULL;
int ret = OAL_STATUS_SUCCESS;
- BT_INFO("+");
+ BT_DBG("+");
/* Check if any app is already browsing primary services on the same remote GATT Server */
req_info = _bt_get_request_info_data(BT_GATT_GET_PRIMARY_SERVICES, address);
BT_CHECK_PARAMETER(address, return);
- BT_INFO("+");
-
addr = g_malloc0(sizeof(char) * BT_ADDRESS_STRING_SIZE);
_bt_convert_addr_type_to_string(addr, address->addr);
BT_INFO("GATT Client Disconnect request for address [%s]", addr);
if (req_info) {
remote_address = (char*)req_info->user_data;
if (remote_address && !strcasecmp(remote_address, addr)) {/* Address matched */
- BT_INFO("Already DisConnection ongoing for same remote GATT Server address [%s]", remote_address);
+ BT_DBG("Already DisConnection ongoing for same remote GATT Server address [%s]", remote_address);
/* Return success and wait for events to be sent to all apps */
g_free(addr);
return BLUETOOTH_ERROR_IN_PROGRESS;
static void __bt_device_property_changed_event(GVariant *msg, const char *path)
{
- BT_DBG("+");
-
int event;
int result = BLUETOOTH_ERROR_NONE;
GVariantIter value_iter;
g_free(address);
}
}
- BT_DBG("-");
}
void _bt_handle_ipsp_device_event(GVariant *msg, const char *member, const char *path)
void _bt_handle_device_event(GVariant *msg, const char *member, const char *path)
{
char *address;
- char secure_address[BT_ADDRESS_STRING_SIZE] = { 0 };
ret_if(path == NULL);
if (strcasecmp(member, "Disconnected") == 0) {
}
g_free(address);
g_free(dev_name);
- } else if (strcasecmp(member, "ProfileStateChanged") == 0) {
- int state = 0;
- char *profile_uuid = NULL;
- bluetooth_device_address_t bd_addr;
-
- g_variant_get(msg, "(si)", &profile_uuid, &state);
-
- address = g_malloc0(BT_ADDRESS_STRING_SIZE);
-
- _bt_convert_device_path_to_address(path, address);
- _bt_convert_addr_string_to_type(bd_addr.addr, address);
-
- _bt_convert_addr_string_to_secure_string(secure_address, address);
- BT_DBG("[%s] [%s] [%d]", secure_address, profile_uuid, state);
- g_free(address);
}
}
projects / platform / core / connectivity / bluetooth-frwk.git / commitdiff