BT_CHECK_PARAMETER(data, return);
- BT_INFO("### Requesting battery data");
retv_if(bluetooth_check_adapter() != BLUETOOTH_ADAPTER_ENABLED,
BLUETOOTH_ADAPTER_DISABLED);
&data_var);
g_strlcpy(char_prop.address, address, BT_ADDRESS_STRING_SIZE);
- BT_INFO("GATT Client Char value changed in remote Server [%s]", address);
- BT_INFO("GATT Client Char Val len: [%d]", char_prop.val_len);
+ BT_DBG("GATT Client Char value changed in remote Server [%s]", address);
+ BT_DBG("GATT Client Char Val len: [%d]", char_prop.val_len);
if (char_prop.val_len > 0) {
/* Copy Data */
g_variant_unref(svc_uuid_var);
g_variant_unref(char_uuid_var);
g_variant_unref(data_var);
-
} else if (strcasecmp(signal_name, BT_GATT_CLIENT_READ_CHAR) == 0) { /* Done */
/* Event: BLUETOOTH_EVENT_GATT_READ_CHAR */
BT_DBG("GATT Client event[BT_GATT_CLIENT_READ_CHAR]");
g_variant_unref(svc_uuid_var);
g_variant_unref(char_uuid_var);
g_variant_unref(data_var);
-
} else if (strcasecmp(signal_name, BT_GATT_CLIENT_WRITE_CHAR) == 0) { /* Done */
/* Event: BLUETOOTH_EVENT_GATT_WRITE_CHAR */
BT_DBG("GATT Client event[BT_GATT_CLIENT_WRITE_CHAR]");
g_variant_unref(svc_uuid_var);
g_variant_unref(char_uuid_var);
-
} else if (strcasecmp(signal_name, BT_GATT_CLIENT_READ_DESC) == 0) { /* Done */
/* Event: BLUETOOTH_EVENT_GATT_READ_DESC */
BT_DBG("GATT Client event[BT_GATT_CLIENT_READ_DESC]");
g_variant_unref(char_uuid_var);
g_variant_unref(desc_uuid_var);
g_variant_unref(data_var);
-
} else if (strcasecmp(signal_name, BT_GATT_CLIENT_WRITE_DESC) == 0) { /* Done */
/* Event: BLUETOOTH_EVENT_GATT_WRITE_DESC */
BT_DBG("GATT Client event[BT_GATT_CLIENT_WRITE_DESC]");
g_strlcpy(desc_prop.address, address, BT_ADDRESS_STRING_SIZE);
- BT_INFO("GATT Client Write Descriptor Callback from [%s]", address);
- BT_INFO("GATT Client Descriptor Val len: [%d]", desc_prop.val_len);
+ BT_DBG("GATT Client Write Descriptor Callback from [%s]", address);
+ BT_DBG("GATT Client Descriptor Val len: [%d]", desc_prop.val_len);
/* Copy Data */
memcpy(&desc_prop.prop.uuid, g_variant_get_data(desc_uuid_var), 16);
_bt_convert_addr_string_to_type(change.device_addr.addr, address_str);
if (_bluetooth_gatt_check_service_change_watcher_address(&change.device_addr) == FALSE) {
- BT_INFO("GATT Service changed, but no watcher for %s", address_str);
+ BT_DBG("GATT Service changed, but no watcher for %s", address_str);
return;
}
if (bluetooth_get_battery_monitor_state()) {
if (rx_tag == 0) {
- BT_INFO("Adding rfcomm rx timeout function for battery monitor");
+ BT_DBG("Adding rfcomm rx timeout function for battery monitor");
rx_tag = g_timeout_add_seconds(BATTERY_MONITOR_RFCOMM_INTERVAL, (GSourceFunc)__rfcomm_record_rx_data, NULL);
}
rx_data += len;
length, written, length - written); */
if (written > 0 && bluetooth_get_battery_monitor_state()) {
if (tx_tag == 0) {
- BT_INFO("Adding rfcomm tx timeout function for battery monitor");
+ BT_DBG("Adding rfcomm tx timeout function for battery monitor");
tx_tag = g_timeout_add_seconds(BATTERY_MONITOR_RFCOMM_INTERVAL, (GSourceFunc)__rfcomm_record_tx_data, NULL);
}
tx_data += written;
result = __write_all(fd, buf, length);
if (result > 0 && bluetooth_get_battery_monitor_state()) {
if (tx_tag == 0) {
- BT_INFO("Adding rfcomm tx timeout function for battery monitor");
+ BT_DBG("Adding rfcomm tx timeout function for battery monitor");
tx_tag = g_timeout_add_seconds(BATTERY_MONITOR_RFCOMM_INTERVAL, (GSourceFunc)__rfcomm_record_tx_data, NULL);
}
tx_data += written;
if (bluetooth_get_battery_monitor_state()) {
if (rx_tag == 0) {
- BT_INFO("Adding rfcomm rx timeout function for battery monitor");
+ BT_DBG("Adding rfcomm rx timeout function for battery monitor");
rx_tag = g_timeout_add_seconds(BATTERY_MONITOR_RFCOMM_INTERVAL, (GSourceFunc)__rfcomm_record_rx_data, NULL);
}
rx_data += len;
if ((a != BT_CHECK_PRIVILEGE && (a == BT_BLUEZ_SERVICE || a == BT_OBEX_SERVICE)) && \
(b != BT_GET_LOCAL_NAME && b != BT_GET_LOCAL_ADDRESS && \
b != BT_GET_BONDED_DEVICE && b != BT_IS_DEVICE_CONNECTED && \
+ b != BT_RFCOMM_SEND_RX_DETAILS && b != BT_RFCOMM_SEND_TX_DETAILS && \
+ b != BT_AVRCP_SET_PROPERTY && b != BT_BATTERY_READ_DATA && \
b != BT_GET_BONDED_DEVICES && b != BT_GET_DISCOVERABLE_MODE)) \
BT_INFO_C("Sync Request => type=%s, fn=%s(0x%x)", #a, #b, b); \
else \
GError *error = NULL;
GVariant *result;
- DBG("+");
-
if (!tx_time || !rx_time || !idle_time || !energy_used) {
ERR("Invalid parameter");
return BT_STATUS_FAIL;
g_variant_get(result, "(uuuu)", tx_time, rx_time, idle_time, energy_used);
- DBG("Tx time: %d", *tx_time);
- DBG("Rx time: %d", *rx_time);
- DBG("Idle time: %d", *idle_time);
+ DBG("Tx time: %d, Rx time: %d, Idle time: %d", *tx_time, *rx_time, *idle_time);
- DBG("-");
g_variant_unref(result);
return BT_STATUS_SUCCESS;
}
return FALSE;
}
- DBG("Buffer = %s", buffer);
-
lines = g_strsplit_set(buffer, BT_HAL_AGENT_NEW_LINE, 0);
g_free(buffer);
GError *error = NULL;
struct hal_ev_bond_state_changed ev;
memset(&ev, 0, sizeof(ev));
- DBG("+");
- DBG("Transport [0x%x] Add[0x%x] [0x%x][0x%x][0x%x][0x%x][0x%x]",
+ DBG("Transport [0x%x] Add [%02x:%02x:%02x:%02x:%02x:%02x]",
transport, bd_addr->address[0], bd_addr->address[1],
bd_addr->address[2], bd_addr->address[3],
bd_addr->address[4], bd_addr->address[5]);
conn = _bt_hal_get_system_gconn();
if (!conn) {
- DBG("Could not get DBUS connection!");
+ ERR("Could not get DBUS connection!");
return BT_STATUS_FAIL;
}
event_cb(HAL_EV_BOND_STATE_CHANGED, (void*)&ev, sizeof(ev));
}
- DBG("-");
return BT_STATUS_SUCCESS;
}
GVariant *value = NULL;
gboolean is_paired = FALSE;
- DBG("Add[0x%x] [0x%x][0x%x][0x%x][0x%x][0x%x]",
+ DBG("Add [%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]);
*/
g_idle_add(__bt_device_bonded_device_info_cb, (gpointer)result);
- DBG("-");
return BT_STATUS_SUCCESS;
}
{
int result;
- DBG("+");
-
if (remote_addr == NULL) {
ERR("Invalid parameters received");
return BT_STATUS_PARM_INVALID;
result = BT_STATUS_UNSUPPORTED;
}
- DBG("Result= [%d]", result);
- DBG("-");
+ DBG("Result [%d]", result);
return result;
}
}
_bt_hal_convert_addr_type_to_string(address, bd_addr->address);
- INFO("Address: %s", address);
+ DBG("Address: %s", address);
device_path = _bt_hal_get_device_object_path(address);
if (device_path == NULL) {
}
_bt_hal_convert_addr_type_to_string(address, bd_addr->address);
- INFO("Address: %s: Remote svc_id: %d", address, rem_svc_id);
+ INFO("Address: %s: Remote svc_id: %d", address + 12, rem_svc_id);
device_path = _bt_hal_get_device_object_path(address);
if (device_path == NULL) {
char *uuid = NULL;
gboolean trusted;
- DBG("+");
-
if (!bd_addr) {
ERR("bd_addr is NULL");
return BT_STATUS_PARM_INVALID;
}
_bt_hal_convert_addr_type_to_string(address, bd_addr->address);
- INFO("Address: %s: profile: %d, trusted: %d", address, profile, trust);
+ INFO("Address: %s: profile: %d, trusted: %d", address + 12, profile, trust);
device_path = _bt_hal_get_device_object_path(address);
if (device_path == NULL) {
g_variant_unref(result);
- DBG("-");
return BT_STATUS_SUCCESS;
}
static int __hal_get_trusted_value_from_flag(bt_trusted_profile_t profile,
uint32_t trusted_flag, uint32_t *trusted)
{
- DBG("+");
-
*trusted = 0;
switch (profile) {
case BT_TRUSTED_PROFILE_PBAP:
if (0 != *trusted)
*trusted = 1;
- DBG("-");
return BT_STATUS_SUCCESS;
}
}
_bt_hal_convert_addr_type_to_string(address, bd_addr->address);
- INFO("Address: %s: profile: %d", address, profile);
+ INFO("Address: %s: profile: %d", address + 12, profile);
device_path = _bt_hal_get_device_object_path(address);
if (device_path == NULL) {
#else
struct hal_ev_controller_error_recieved info;
- INFO("### BT Hardware Error");
+ ERR_C("### BT Hardware Error");
info.code = HAL_CONTROLLER_ERROR_HW_ERROR;
event_cb(HAL_EV_CONTROLLER_ERROR_RECIEVED, &info, sizeof(info));
#endif
#else
struct hal_ev_controller_error_recieved info;
- INFO("### BT TX Timeout Error");
+ ERR_C("### BT TX Timeout Error");
info.code = HAL_CONTROLLER_ERROR_TX_TIMEOUT;
event_cb(HAL_EV_CONTROLLER_ERROR_RECIEVED, &info, sizeof(info));
#endif
uuid_value = (char **)g_variant_get_strv(val, &size1);
for (i = 0; uuid_value[i] != NULL; i++)
uuid_count++;
- DBG("UUID count [%d]\n", uuid_count);
+
/* UUID collection */
uint8_t uuids[BT_HAL_STACK_UUID_SIZE * uuid_count];
uint8_t uuid[BT_HAL_STACK_UUID_SIZE];
memset(uuid, 0x00, BT_HAL_STACK_UUID_SIZE);
- DBG("UUID string from Bluez [%s]\n", uuid_value[i]);
uuid_str = g_strdup(uuid_value[i]);
- DBG("UUID string [%s]\n", uuid_str);
+ DBG("[%d] %s", i, uuid_str);
_bt_hal_convert_uuid_string_to_type(uuid, uuid_str);
memcpy(uuids+i*BT_HAL_STACK_UUID_SIZE, uuid, BT_HAL_STACK_UUID_SIZE);
g_free(uuid_str);
_bt_hal_convert_device_path_to_address(path, address);
- DBG("connected: %d", connected);
- DBG("address: %s", address);
+ DBG("connected: %d [%s]", connected, address);
/* Prepare to send AVRCP Target connection state event */
memset(&ev, 0, sizeof(ev));
g_variant_unref(child);
g_variant_unref(val);
}
-
- DBG("-");
}
static void __bt_hal_handle_property_changed_event(GVariant *msg, const char *object_path)
g_variant_get(msg, "(&s@a{sv}@as)", &interface_name, &val, NULL);
if (!interface_name) {
- DBG("Failed to get interface name");
+ ERR("Failed to get interface name");
if (val)
g_variant_unref(val);
_bt_hal_convert_device_path_to_address(path, address);
g_variant_get(msg, "(b)", &connected);
- INFO("Connected device address[%s] connnected[%d]", address, connected);
+ INFO("Connected device address[%s] connnected[%d]", address + 12, connected);
g_free(address);
} else if (strcasecmp(property, "Paired") == 0) {
gboolean paired = FALSE;
_bt_hal_convert_device_path_to_address(path, address);
DBG("Member: [%s]", member);
- ERR_C("### Connected [%s] [%s]", !addr_type ? "BREDR" : "LE", address);
+ ERR_C("### Connected [%s] [%s]", !addr_type ? "BREDR" : "LE", address + 12);
if (!addr_type)
__bt_hal_send_device_acl_connection_state_event(BT_STATUS_SUCCESS, TRUE, address);
else
_bt_hal_convert_device_path_to_address(path, address);
ERR_C("### Disconnected [%s] [%d : %s] [%s] [%s]", !addr_type ? "BREDR" : "LE",
- disc_reason, _bt_hal_convert_disc_reason_to_string(disc_reason), address, name);
+ disc_reason, _bt_hal_convert_disc_reason_to_string(disc_reason), address + 12, name);
if (!addr_type)
__bt_hal_send_device_acl_connection_state_event(disc_reason, FALSE, address);
struct hal_ev_a2dp_conn_state ev;
if (connected == TRUE)
- INFO("A2DP(Src) Profile Connected for address [%s]", address);
+ INFO("A2DP(Src) Profile Connected for address [%s]", address + 12);
else
- INFO("A2DP(Src) Profile DisConnected for address [%s]", address);
+ INFO("A2DP(Src) Profile DisConnected for address [%s]", address + 12);
ev.state = (connected == TRUE) ?
HAL_EV_A2DP_STATE_CONNECTED :
struct hal_ev_a2dp_conn_state ev;
if (connected == TRUE)
- INFO("A2DP(Sink) Profile Connected for address [%s]", address);
+ INFO("A2DP(Sink) Profile Connected for address [%s]", address + 12);
else
- INFO("A2DP(Sink) Profile DisConnected for address [%s]", address);
+ INFO("A2DP(Sink) Profile DisConnected for address [%s]", address + 12);
ev.state = (connected == TRUE) ?
HAL_EV_A2DP_STATE_CONNECTED :
struct hal_ev_handsfree_audio_state ev;
if (connected == TRUE)
- INFO("AG Audio Connected for address [%s]", address);
+ INFO("AG Audio Connected for address [%s]", address + 12);
else
- INFO("AG Audio DisConnected for address [%s]", address);
+ INFO("AG Audio DisConnected for address [%s]", address + 12);
ev.state = (connected == TRUE) ?
HAL_EV_HANDSFREE_AUDIO_STATE_CONNECTED :
struct hal_ev_handsfree_conn_state ev;
if (connected == TRUE)
- INFO("AG Profile Connected for address [%s]", address);
+ INFO("AG Profile Connected for address [%s]", address + 12);
else
- INFO("AG Profile DisConnected for address [%s]", address);
+ INFO("AG Profile DisConnected for address [%s]", address + 12);
ev.state = (connected == TRUE) ?
HAL_EV_HANDSFREE_CONN_STATE_CONNECTED :
struct hal_ev_hf_client_conn_state ev;
if (connected == TRUE)
- INFO("HF Client Profile Connected for address [%s]", address);
+ INFO("HF Client Profile Connected for address [%s]", address + 12);
else
- INFO("HF Client Profile DisConnected for address [%s]", address);
+ INFO("HF Client Profile DisConnected for address [%s]", address + 12);
ev.state = (connected == TRUE) ?
HAL_EV_HF_CLIENT_CONN_STATE_CONNECTED :
return BT_STATUS_FAIL;
}
- INFO("Request LeConnUpdate");
+ DBG("Request LeConnUpdate");
reply = g_dbus_proxy_call_sync(device_proxy, "LeConnUpdate",
g_variant_new("(uuuu)", min_int, max_int, latency, timeout),
G_DBUS_CALL_FLAGS_NONE,
/* Save Connection info */
conn_info = g_new0(struct gatt_client_info_t, 1);
conn_info->addr = g_strdup(address);
- INFO("Added GATT client addr[%s]", conn_info->addr);
+ DBG("Added GATT client addr[%s]", conn_info->addr);
conn_info->connection_id = ++hal_gatt_conn_id;
conn_info->instance_id = instance;
gatt_client_info_list = g_slist_append(gatt_client_info_list, conn_info);
if (event != OAL_EVENT_BLE_REMOTE_DEVICE_FOUND) {
if (address) {
bdstr_t bdstr;
- EVENT_TRACE("[%s] %s", bdt_bd2str(address, &bdstr), str_event[event]);
+ EVENT_TRACE("[%s] %s", bdt_bd2str(address, &bdstr) + 12, str_event[event]);
} else
EVENT_TRACE(" %s", str_event[event]);
}
for (i = 0; i < num_properties; i++) {
bt_property_t prop;
memcpy(&prop, properties + i, sizeof(prop));
- BT_INFO("prop: %s\n", convert_bt_property_2_str(&prop));
+ BT_DBG("prop: %s", convert_bt_property_2_str(&prop));
}
}
{
int ret;
- API_TRACE();
-
CHECK_OAL_INITIALIZED();
OAL_CHECK_PARAMETER(tx_time, return);
OAL_CHECK_PARAMETER(idle_time, return);
OAL_CHECK_PARAMETER(energy_used, return);
- BT_INFO("Get Adapter Energy Info");
+ BT_DBG("Get Adapter Energy Info");
#ifdef TIZEN_BT_HAL
ret = blued_api->get_adapter_energy_info(tx_time, rx_time, idle_time, energy_used);
bdstr_t bdstr;
CHECK_OAL_INITIALIZED();
- API_TRACE();
- BT_INFO("BT remote device Address: %s", bdt_bd2str(device_address, &bdstr));
+ BT_INFO("BT remote device Address: %s", bdt_bd2str(device_address, &bdstr) + 12);
ret = blued_api->adapter_le_set_white_list((bt_bdaddr_t*)device_address, address_type, is_add);
if (ret != BT_STATUS_SUCCESS) {
bt_status_t status;
bdstr_t bdstr;
- API_TRACE();
+ API_TRACE("Audio connect");
CHECK_OAL_AUDIO_ENABLED();
OAL_CHECK_PARAMETER(device_address, return);
- BT_INFO("BT Audio Address: %s", bdt_bd2str(device_address, &bdstr));
+ BT_INFO("BT Audio Address: %s", bdt_bd2str(device_address, &bdstr) + 12);
/* Call connect function of Bluedroid*/
status = blued_a2dp_interface->connect((bt_bdaddr_t *)device_address);
bdstr_t bdstr;
bt_status_t status;
- API_TRACE();
+ API_TRACE("Audio disconnect");
CHECK_OAL_AUDIO_ENABLED();
OAL_CHECK_PARAMETER(device_address, return);
- BT_INFO("BT Audio Address: %s", bdt_bd2str(device_address, &bdstr));
+ BT_INFO("BT Audio Address: %s", bdt_bd2str(device_address, &bdstr) + 12);
/* call Disconnect function of Bluedroid */
status = blued_a2dp_interface->disconnect((bt_bdaddr_t *)device_address);
oal_event_t event;
ret_if(bd_addr == NULL);
- BT_INFO("state = %d, BT Address = %s", state, bdt_bd2str((bt_address_t*)bd_addr, &bdstr));
+ BT_INFO("state = %d, BT Address = %s", state, bdt_bd2str((bt_address_t*)bd_addr, &bdstr) + 12);
event_data = g_new0(bt_address_t, 1);
memcpy(event_data->addr, bd_addr->address, BT_ADDRESS_BYTES_NUM);
bdstr_t bdstr;
ret_if(bd_addr == NULL);
- BT_INFO("A2DP state = %d, BT Address = %s", state, bdt_bd2str((bt_address_t*)bd_addr, &bdstr));
+ BT_INFO("A2DP state = %d, BT Address = %s", state, bdt_bd2str((bt_address_t*)bd_addr, &bdstr) + 12);
if (state == BTAV_AUDIO_STATE_REMOTE_SUSPEND) {
BT_INFO("Audio Streaming Suspended");
OAL_CHECK_PARAMETER(addr, return);
- API_TRACE("[%s]", bdt_bd2str(addr, &bdstr));
+ API_TRACE("[%s]", bdt_bd2str(addr, &bdstr) + 12);
res = blued_api->get_remote_device_properties((bt_bdaddr_t *)addr);
if (res != BT_STATUS_SUCCESS) {
OAL_CHECK_PARAMETER(addr, return);
- API_TRACE("[%s]", bdt_bd2str(addr, &bdstr));
+ API_TRACE("[%s]", bdt_bd2str(addr, &bdstr) + 12);
res = blued_api->get_remote_services((bt_bdaddr_t *)addr);
if (res != BT_STATUS_SUCCESS) {
OAL_CHECK_PARAMETER(addr, return);
OAL_CHECK_PARAMETER(alias, return);
- API_TRACE("%s ->Alias: %s", bdt_bd2str(addr, &bdstr), alias);
+ API_TRACE("%s ->Alias: %s", bdt_bd2str(addr, &bdstr) + 12, alias);
prop.type = BT_PROPERTY_REMOTE_FRIENDLY_NAME;
prop.len = strlen(alias);
OAL_CHECK_PARAMETER(addr, return);
- API_TRACE("[%s]", bdt_bd2str(addr, &bdstr));
+ API_TRACE("[%s]", bdt_bd2str(addr, &bdstr) + 12);
res = blued_api->create_bond((bt_bdaddr_t *)addr, transport);
if (res != BT_STATUS_SUCCESS) {
OAL_CHECK_PARAMETER(addr, return);
- API_TRACE("[%s]", bdt_bd2str(addr, &bdstr));
+ API_TRACE("[%s]", bdt_bd2str(addr, &bdstr) + 12);
res = blued_api->remove_bond((bt_bdaddr_t *)addr);
if (res != BT_STATUS_SUCCESS) {
OAL_CHECK_PARAMETER(addr, return);
- API_TRACE("[%s]", bdt_bd2str(addr, &bdstr));
+ API_TRACE("[%s]", bdt_bd2str(addr, &bdstr) + 12);
res = blued_api->cancel_bond((bt_bdaddr_t *)addr);
if (res != BT_STATUS_SUCCESS) {
OAL_CHECK_PARAMETER(addr, return);
OAL_CHECK_PARAMETER(pin, return);
- API_TRACE("[%s] PIN: %s", bdt_bd2str(addr, &bdstr), pin);
+ API_TRACE("[%s] PIN: %s", bdt_bd2str(addr, &bdstr) + 12, pin);
res = blued_api->pin_reply((bt_bdaddr_t *)addr, TRUE, strlen(pin), (bt_pin_code_t *)pin);
if (res != BT_STATUS_SUCCESS) {
OAL_CHECK_PARAMETER(addr, return);
- API_TRACE("[%s]", bdt_bd2str(addr, &bdstr));
+ API_TRACE("[%s]", bdt_bd2str(addr, &bdstr) + 12);
res = blued_api->pin_reply((bt_bdaddr_t *)addr, FALSE, 0, NULL);
if (res != BT_STATUS_SUCCESS) {
OAL_CHECK_PARAMETER(addr, return);
- API_TRACE("[%s] Passkey: %d", bdt_bd2str(addr, &bdstr), passkey);
+ API_TRACE("[%s] Passkey: %d", bdt_bd2str(addr, &bdstr) + 12, passkey);
res = blued_api->ssp_reply((bt_bdaddr_t *)addr, BT_SSP_VARIANT_PASSKEY_ENTRY, TRUE, passkey);
if (res != BT_STATUS_SUCCESS) {
OAL_CHECK_PARAMETER(addr, return);
- API_TRACE("[%s]", bdt_bd2str(addr, &bdstr));
+ API_TRACE("[%s]", bdt_bd2str(addr, &bdstr) + 12);
res = blued_api->ssp_reply((bt_bdaddr_t *)addr, BT_SSP_VARIANT_PASSKEY_ENTRY, FALSE, 0);
if (res != BT_STATUS_SUCCESS) {
OAL_CHECK_PARAMETER(addr, return);
- API_TRACE("[%s] accept: %d", bdt_bd2str(addr, &bdstr), accept);
+ API_TRACE("[%s] accept: %d", bdt_bd2str(addr, &bdstr) + 12, accept);
res = blued_api->ssp_reply((bt_bdaddr_t *)addr, BT_SSP_VARIANT_PASSKEY_CONFIRMATION, accept, 0);
if (res != BT_STATUS_SUCCESS) {
OAL_CHECK_PARAMETER(addr, return);
- API_TRACE("[%s] %d", bdt_bd2str(addr, &bdstr), accept);
+ API_TRACE("[%s] %d", bdt_bd2str(addr, &bdstr) + 12, accept);
res = blued_api->ssp_reply((bt_bdaddr_t *)addr, BT_SSP_VARIANT_CONSENT, accept, 0);
if (res != BT_STATUS_SUCCESS) {
OAL_CHECK_PARAMETER(addr, return);
- API_TRACE("[%s] Accept: %d, always: %d, service_type: %d", bdt_bd2str(addr, &bdstr), accept, always, service_type);
+ API_TRACE("[%s] Accept: %d, always: %d, service_type: %d", bdt_bd2str(addr, &bdstr) + 12, accept, always, service_type);
res = blued_api->authorize_response((bt_bdaddr_t *)addr, service_type, accept, always);
if (res != BT_STATUS_SUCCESS) {
OAL_CHECK_PARAMETER(addr, return);
- API_TRACE("[%s] %d", bdt_bd2str(addr, &bdstr), authorize);
+ API_TRACE("[%s] %d", bdt_bd2str(addr, &bdstr) + 12, authorize);
res = blued_api->set_authorization((bt_bdaddr_t *)addr, authorize);
if (res != BT_STATUS_SUCCESS) {
CHECK_OAL_INITIALIZED();
OAL_CHECK_PARAMETER(addr, return);
- API_TRACE("[%s]", bdt_bd2str(addr, &bdstr));
+ API_TRACE("[%s]", bdt_bd2str(addr, &bdstr) + 12);
res = blued_api->get_connection_state((bt_bdaddr_t *)addr);
BT_ERR("get_connection_state returned: [%s]", res ? "TRUE" : "FALSE");
CHECK_OAL_INITIALIZED();
OAL_CHECK_PARAMETER(addr, return);
- API_TRACE("[%s] %d", bdt_bd2str(addr, &bdstr), svc_id);
+ API_TRACE("[%s] %d", bdt_bd2str(addr, &bdstr) + 12, svc_id);
#ifdef TIZEN_BT_HAL
res = blued_api->get_service_connection_state((bt_bdaddr_t *)addr, svc_id);
OAL_CHECK_PARAMETER(addr, return);
- API_TRACE("[%s]", bdt_bd2str(addr, &bdstr));
+ API_TRACE("[%s]", bdt_bd2str(addr, &bdstr) + 12);
#ifdef TIZEN_BT_HAL
res = blued_api->set_trusted_profile((bt_bdaddr_t *)addr, profile, (trust ? 1 : 0));
OAL_CHECK_PARAMETER(addr, return);
- API_TRACE("[%s]", bdt_bd2str(addr, &bdstr));
+ API_TRACE("[%s]", bdt_bd2str(addr, &bdstr) + 12);
#ifdef TIZEN_BT_HAL
res = blued_api->get_trusted_profile((bt_bdaddr_t *)addr, profile, trusted);
OAL_CHECK_PARAMETER(addr, return);
- API_TRACE("[%s]", bdt_bd2str(addr, &bdstr));
+ API_TRACE("[%s]", bdt_bd2str(addr, &bdstr) + 12);
#ifdef TIZEN_BT_HAL
res = blued_api->enable_rssi_monitoring((bt_bdaddr_t *)addr, link_type,
OAL_CHECK_PARAMETER(addr, return);
- API_TRACE("[%s]", bdt_bd2str(addr, &bdstr));
+ API_TRACE("[%s]", bdt_bd2str(addr, &bdstr) + 12);
#ifdef TIZEN_BT_HAL
res = blued_api->get_connected_link_rssi_strength((bt_bdaddr_t *)addr, link_type);
OAL_CHECK_PARAMETER(addr, return);
- API_TRACE("[%s]", bdt_bd2str(addr, &bdstr));
+ API_TRACE("[%s]", bdt_bd2str(addr, &bdstr) + 12);
res = blued_api->device_disconnect((bt_bdaddr_t *)addr);
if (res != BT_STATUS_SUCCESS) {
gsize size = 0;
bdstr_t bdstr;
- BT_DBG("[%s]status: [%d] num properties [%d]", bdt_bd2str((bt_address_t*)bd_addr, &bdstr),
+ BT_DBG("[%s]status: [%d] num properties [%d]", bdt_bd2str((bt_address_t*)bd_addr, &bdstr) + 12,
status, num_properties);
dev_info = g_new0(remote_device_t, 1);
case BT_PROPERTY_UUIDS: {
event_dev_services_t *services_info;
bt_uuid_t *uuids = (bt_uuid_t *) properties[0].val;
- BT_INFO("Properties len [%d] event structure size [%zu]", properties[0].len, sizeof(event_dev_services_t));
+ BT_DBG("Properties len [%d] event structure size [%zu]", properties[0].len, sizeof(event_dev_services_t));
services_info = g_malloc(sizeof(event_dev_services_t) + properties[0].len);
services_info->address = dev_info->address;
memcpy(services_info->service_list, uuids, properties[0].len);
services_info->num = properties[0].len/sizeof(bt_uuid_t);
- BT_INFO("Number of UUID [%d]", services_info->num);
+ BT_DBG("Number of UUID [%d]", services_info->num);
event = OAL_EVENT_DEVICE_SERVICES;
event_data = services_info;
size = sizeof(event_dev_services_t) + properties[0].len;
if (dev_info->type != DEV_TYPE_BREDR) {
int i;
- BT_INFO("BLE Device");
+ BT_DBG("BLE Device");
/* BLE Single or DUAL mode found, so it should have Adv data */
dev_props_event->adv_len = adv_info.len;
if (dev_props_event->adv_len > 0)
adv_info.adv_data, adv_info.len);
for (i = 0; i < dev_props_event->adv_len; i++)
- BT_INFO("Adv Data[%d] = [0x%x]",
+ BT_DBG("Adv Data[%d] = [0x%x]",
i, dev_props_event->adv_data[i]);
memcpy(&dev_props_event->device_info,
dev_info, sizeof(remote_device_t));
} else {
- BT_INFO("BREDR type Device");
+ BT_DBG("BREDR type Device");
memcpy(&dev_props_event->device_info,
dev_info, sizeof(remote_device_t));
}
{
char uuid_str1[2*BT_UUID_STRING_MAX];
char uuid_str2[2*BT_UUID_STRING_MAX];
- BT_INFO("BTGATT Client Read Charcateristic Callback, conn_id:%d, read_status:%d", conn_id, status);
+ BT_DBG("BTGATT Client Read Charcateristic Callback, conn_id:%d, read_status:%d", conn_id, status);
event_gattc_read_data *event = g_new0(event_gattc_read_data, 1);
event->uuid_status.conn_status.conn_id = conn_id;
if (status == 0) {
uuid_to_stringname((oal_uuid_t *)&(p_data->srvc_id.id.uuid), uuid_str1);
uuid_to_stringname((oal_uuid_t *)&(p_data->char_id.uuid), uuid_str2);
- BT_INFO("Service=> [%s], Inst_id [%u], Type [%s]", uuid_str1,
+ BT_DBG("Service=> [%s], Inst_id [%u], Type [%s]", uuid_str1,
p_data->srvc_id.id.inst_id, p_data->srvc_id.is_primary ? "Primary" : "Secondary");
- BT_INFO("Charac => [%s], Inst_id [%u]", uuid_str2, p_data->char_id.inst_id);
+ BT_DBG("Charac => [%s], Inst_id [%u]", uuid_str2, p_data->char_id.inst_id);
BT_DBG("Len: %u, value_type: %u", p_data->value.len, p_data->value_type);
if (p_data->value.len > 0 && event->value_type == GATTC_READ_VALUE_TYPE_VALUE) {
event->data_len = p_data->value.len;
char uuid_str1[2*BT_UUID_STRING_MAX];
char uuid_str2[2*BT_UUID_STRING_MAX];
char uuid_str3[2*BT_UUID_STRING_MAX];
- BT_INFO("BTGATT Client Write Descriptor Callback, conn_id:%d, write_status:%d", conn_id, status);
+ BT_DBG("BTGATT Client Write Descriptor Callback, conn_id:%d, write_status:%d", conn_id, status);
event_gattc_write_data *event = g_new0(event_gattc_write_data, 1);
event->conn_status.conn_id = conn_id;
bdstr_t bdstr;
OAL_CHECK_PARAMETER(device_address, return);
- API_TRACE("Client Connect: [%s]", bdt_bd2str(device_address, &bdstr));
+ API_TRACE("Client Connect: [%s]", bdt_bd2str(device_address, &bdstr) + 12);
CHECK_OAL_GATT_ENABLED();
CHECK_CLIENT_REGISTRATION(client_id);
bdstr_t bdstr;
OAL_CHECK_PARAMETER(device_address, return);
- API_TRACE("Client Disconnect: [%s]", bdt_bd2str(device_address, &bdstr));
+ API_TRACE("Client Disconnect: [%s]", bdt_bd2str(device_address, &bdstr) + 12);
CHECK_OAL_GATT_ENABLED();
CHECK_CLIENT_REGISTRATION(client_id);
CHECK_CLIENT_CONNECTION(conn_id);
bdstr_t bdstr;
OAL_CHECK_PARAMETER(address, return);
- API_TRACE("Conn Param Update: [%s]", bdt_bd2str(address, &bdstr));
CHECK_OAL_GATT_ENABLED();
- BT_INFO("[%s] min[%d] max[%d] latency[%d] timeout[%d]", bdt_bd2str(address, &bdstr), min, max, latency, timeout);
+ BT_DBG("[%s] min[%d] max[%d] latency[%d] timeout[%d]", bdt_bd2str(address, &bdstr), min, max, latency, timeout);
ret = gatt_api->client->conn_parameter_update((bt_bdaddr_t *)address, min, max, latency, timeout);
if (ret != BT_STATUS_SUCCESS) {
BT_ERR("error: %s", status2string(ret));
bdstr_t bdstr;
OAL_CHECK_PARAMETER(device_address, return);
- API_TRACE("Add connection info: [%s]", bdt_bd2str(device_address, &bdstr));
+ API_TRACE("Add connection info: [%s]", bdt_bd2str(device_address, &bdstr) + 12);
CHECK_OAL_GATT_ENABLED();
CHECK_SERVER_INSTANCE(instance_id);
if (__gatts_find_server_instance(instance_id) == NULL)
CHECK_OAL_HFP_CLIENT_ENABLED();
OAL_CHECK_PARAMETER(device_address, return);
- BT_INFO("BT remote AG Device Address: %s", bdt_bd2str(device_address, &bdstr));
+ BT_INFO("BT remote AG Device Address: %s", bdt_bd2str(device_address, &bdstr) + 12);
/* Call connect function of Bluedroid*/
status = blued_hf_client_interface->connect((bt_bdaddr_t *)device_address);
if ((status != BT_STATUS_SUCCESS) && (status != BT_STATUS_DONE)) {
CHECK_OAL_HFP_CLIENT_ENABLED();
OAL_CHECK_PARAMETER(device_address, return);
- BT_INFO("BT remote AG Address: %s", bdt_bd2str(device_address, &bdstr));
+ BT_INFO("BT remote AG Address: %s", bdt_bd2str(device_address, &bdstr) + 12);
/* call Disconnect function of Bluedroid */
status = blued_hf_client_interface->disconnect((bt_bdaddr_t *)device_address);
if ((status != BT_STATUS_SUCCESS) && (status != BT_STATUS_DONE)) {
}
memcpy(event_data->addr, bd_addr->address, BT_ADDRESS_BYTES_NUM);
- BT_INFO("HFP Client Profile state = [%d], BT Address = [%s]", state, bdt_bd2str((bt_address_t*)bd_addr, &bdstr));
+ BT_INFO("HFP Client Profile state = [%d], BT Address = [%s]", state, bdt_bd2str((bt_address_t*)bd_addr, &bdstr) + 12);
switch (state) {
case BTHF_CLIENT_CONNECTION_STATE_DISCONNECTED: {
event_type = OAL_EVENT_HF_CLIENT_DISCONNECTED;
CHECK_OAL_HF_ENABLED();
OAL_CHECK_PARAMETER(device_address, return);
- BT_INFO("BT HF Address: %s", bdt_bd2str(device_address, &bdstr));
+ BT_INFO("BT HF Address: %s", bdt_bd2str(device_address, &bdstr) + 12);
/* Call connect function of Bluedroid*/
status = blued_hfp_interface->connect((bt_bdaddr_t *)device_address);
if ((status != BT_STATUS_SUCCESS) && (status != BT_STATUS_DONE)) {
CHECK_OAL_HF_ENABLED();
OAL_CHECK_PARAMETER(device_address, return);
- BT_INFO("BT HF Address: %s", bdt_bd2str(device_address, &bdstr));
+ BT_INFO("BT HF Address: %s", bdt_bd2str(device_address, &bdstr) + 12);
/* call Disconnect function of Bluedroid */
status = blued_hfp_interface->disconnect((bt_bdaddr_t *)device_address);
if ((status != BT_STATUS_SUCCESS) && (status != BT_STATUS_DONE)) {
CHECK_OAL_HF_ENABLED();
OAL_CHECK_PARAMETER(device_address, return);
- BT_INFO("BT HF Address: %s", bdt_bd2str(device_address, &bdstr));
+ BT_INFO("BT HF Address: %s", bdt_bd2str(device_address, &bdstr) + 12);
status = blued_hfp_interface->connect_audio((bt_bdaddr_t *)device_address);
if (status != BT_STATUS_SUCCESS) {
OAL_CHECK_PARAMETER(device_address, return);
- BT_INFO("BT HF Address: %s", bdt_bd2str(device_address, &bdstr));
+ BT_INFO("BT HF Address: %s", bdt_bd2str(device_address, &bdstr) + 12);
status = blued_hfp_interface->disconnect_audio((bt_bdaddr_t *)device_address);
if (status != BT_STATUS_SUCCESS) {
}
memcpy(event_data->addr, bd_addr->address, BT_ADDRESS_BYTES_NUM);
- BT_INFO("HFP Profile state = [%d], BT Address = [%s]", state, bdt_bd2str((bt_address_t*)bd_addr, &bdstr));
+ BT_INFO("HFP Profile state = [%d], BT Address = [%s]", state, bdt_bd2str((bt_address_t*)bd_addr, &bdstr) + 12);
switch (state) {
case BTHF_CONNECTION_STATE_DISCONNECTED: {
event_type = OAL_EVENT_HFP_DISCONNECTED;
}
memcpy(event_data->addr, bd_addr->address, BT_ADDRESS_BYTES_NUM);
- BT_INFO("HFP Audio state = [%d], BT Address = [%s]", state, bdt_bd2str((bt_address_t*)bd_addr, &bdstr));
+ BT_INFO("HFP Audio state = [%d], BT Address = [%s]", state, bdt_bd2str((bt_address_t*)bd_addr, &bdstr) + 12);
switch (state) {
case BTHF_AUDIO_STATE_DISCONNECTED: {
int result = BLUETOOTH_ERROR_NONE;
ret_if(NULL == address);
- BT_INFO("+");
_bt_convert_addr_type_to_string(addr, address->addr);
- BT_INFO("Address of connected device [%s]", addr);
+ BT_INFO("Address of connected device [%s]", addr + 12);
/* Set VCONF Key for A2DP Connected status */
_bt_set_device_values(TRUE, VCONFKEY_BT_DEVICE_A2DP_HEADSET_CONNECTED);
connected = _bt_is_headset_type_connected(BT_AUDIO_A2DP, connected_address);
if (connected) {
- BT_INFO("connected_address: %s", connected_address);
+ BT_INFO("connected_address: %s", connected_address + 12);
if (g_strcmp0(connected_address, addr) != 0) {
_bt_convert_addr_string_to_type(
device_address.addr,
else {
if (wait_device != NULL) {
BT_INFO("A2DP Profile connected for device [%s] but another device [%s]is waiting to be connnected type [%d]",
- addr, wait_device->address, wait_device->type);
+ addr, wait_device->address + 12, wait_device->type);
BT_INFO("Trigger connect for the waiting device [%s], audio type [%d]",
- wait_device->address, wait_device->type);
+ wait_device->address + 12, wait_device->type);
_bt_convert_addr_string_to_type(wait_device_address.addr,
wait_device->address);
_bt_audio_connect(wait_device->type, &wait_device_address);
BT_INFO("AV Connect request & Audio All connect not found or possibly already replied");
return;
} else {
- BT_INFO("Audio All connect request found for address [%s]", addr);
+ BT_INFO("Audio All connect request found for address [%s]", addr + 12);
/* TODO Delete the search info if present */
data = _bt_get_pending_audio_conn_info(addr);
if (data) {
g_array_free(out_param, TRUE);
g_free(req_info->user_data);
_bt_free_info_from_invocation_list(req_info);
- BT_INFO("-");
}
static void __bt_handle_av_disconnected_state(bluetooth_device_address_t *address)
GVariant *param;
invocation_info_t *req_info = NULL;
ret_if(NULL == address);
- BT_INFO("+");
_bt_convert_addr_type_to_string(addr, address->addr);
#endif
req_info = _bt_get_request_info_data(BT_AV_DISCONNECT, addr);
- BT_INFO("Address of disconnected device[%s]", addr);
+ BT_DBG("Address of disconnected device[%s]", addr);
if (NULL == req_info) {
- BT_INFO("AV DisConnect request not found or possibly already replied");
+ BT_DBG("AV DisConnect request not found or possibly already replied");
req_info = _bt_get_request_info_data(BT_AV_CONNECT, addr);
if (NULL == req_info) {
/* This means, AV Disconnect request has successfully passed, and real disconnect is completed */
- BT_INFO("Neither AV Connect or AV Disconnect request is found..means, AV Profile is disconnected");
+ BT_DBG("Neither AV Connect or AV Disconnect request is found..means, AV Profile is disconnected");
req_info = _bt_get_request_info_data(BT_AUDIO_CONNECT, addr);
if (req_info == NULL) {
- BT_INFO("Audio Connect All request is also Not found..");
+ BT_DBG("Audio Connect All request is also Not found..");
/* Send A2DP(SRC Role) disconnected event to Application */
param = g_variant_new("(is)", result, addr);
req_info = _bt_get_request_info_data(BT_AUDIO_DISCONNECT, addr);
if (req_info == NULL) {
- BT_INFO("Audio DisConnect All request is also Not found..");
+ BT_DBG("Audio DisConnect All request is also Not found..");
} else {
- BT_INFO("Audio DisConnect All request is found..");
+ BT_DBG("Audio DisConnect All request is found..");
/* Check if HFP profile is also connected, if yes, disconnect it too */
_bt_audio_check_pending_disconnection(addr, BT_AUDIO_HSP);
}
} else {
- BT_INFO("Audio Connect All request is found..");
+ BT_DBG("Audio Connect All request is found..");
result = BLUETOOTH_ERROR_INTERNAL;
data = _bt_get_pending_audio_conn_info(addr);
if (data) {
- BT_INFO("Pending connect is found, delete it..");
+ BT_DBG("Pending connect is found, delete it..");
_bt_cleanup_audio_pending_conn_info_and_reply_pending_req(data, result);
req_info = NULL;
} else {
- BT_INFO("Pending connect is Not found..");
+ BT_DBG("Pending connect is Not found..");
}
/* Delete waiting device data if present for this device */
static void __bt_handle_av_audio_stopped(bluetooth_device_address_t *address)
{
- BT_INFO("Currently not handled..");
+ BT_DBG("Currently not handled..");
}
static void __bt_handle_av_audio_started(bluetooth_device_address_t *address)
{
- BT_INFO("Currently not handled..");
+ BT_DBG("Currently not handled..");
}
void _bt_a2dp_source_event_handler(int oal_event, gpointer event_data)
{
- BT_INFO("+");
bluetooth_device_address_t * bd_addr = (bluetooth_device_address_t*)event_data;
switch (oal_event) {
BT_INFO("Invalid Event = %d", oal_event);
break;
}
- BT_INFO("-");
}
void _bt_a2dp_src_handle_incoming_authorization(char *address, int service_id)
gboolean connected;
bluetooth_device_address_t device_address;
oal_status_t res = OAL_STATUS_SUCCESS;
- BT_INFO("+");
_bt_convert_addr_string_to_type(device_address.addr, address);
BT_ERR("Invalid Audio Service ID..");
}
- BT_INFO("-");
}
g_strlcpy(connected_device->device_address, address,
sizeof(connected_device->device_address));
g_connected_list = g_list_append(g_connected_list, connected_device);
- BT_INFO("Added device[%s] in connected list, device state [%d] Device Type [%d]",
+ BT_DBG("Added device[%s] in connected list, device state [%d] Device Type [%d]",
address, connected_device->device_state, connected_device->type);
}
/* Check if any other headset is connected */
GList *node = NULL;
- BT_INFO("Checking if any Headset connected or not: current device [%s] current audio type [%s]",
+ BT_DBG("Checking if any Headset connected or not: current device [%s] current audio type [%s]",
address, __convert_audio_type_to_string(current_conn_type));
node = g_list_first(g_connected_list);
while (node != NULL) {
connected_device = node->data;
- BT_INFO("A Device is already connected found in list [%s] audio type [%s]",
+ BT_DBG("A Device is already connected found in list [%s] audio type [%s]",
connected_device->device_address, __convert_audio_type_to_string(connected_device->type));
if ((connected_device->type & current_conn_type)) {
g_strlcpy(connected_address, connected_device->device_address,
}
if (!connected) {
- BT_INFO("There is no connected device with connection type [%s]",
+ BT_DBG("There is no connected device with connection type [%s]",
__convert_audio_type_to_string(current_conn_type));
return BLUETOOTH_ERROR_NOT_CONNECTED;
}
if (value == BLUETOOTH_ERROR_NONE) {
if (g_wait_data != NULL) {
if (g_strcmp0(g_wait_data->address, address) != 0) {
- BT_INFO("Already one device was waiting for connection [%s], remove it", g_wait_data->address);
+ BT_INFO("Already one device was waiting for connection [%s], remove it", g_wait_data->address + 12);
__bt_remove_device_from_wait_list(g_wait_data->address);
__bt_free_wait_data();
}
}
if (g_wait_data == NULL) {
- BT_INFO("Add current device [%s] into waiting list", address);
+ BT_INFO("Add current device [%s] into waiting list", address + 12);
g_wait_data = g_malloc0(sizeof(bt_headset_wait_t));
g_wait_data->address = g_strdup(address);
g_wait_data->type = current_conn_type;
{
char addr[BT_ADDRESS_STRING_SIZE] = { 0 };
int result = BLUETOOTH_ERROR_NONE;
- BT_INFO("+");
+ BT_DBG("type %s", __convert_audio_type_to_string(type));
_bt_convert_addr_type_to_string(addr,
(unsigned char *)address->addr);
} else {
BT_ERR("Profile [%s] connect failed!!", __convert_audio_type_to_string(type));
}
- BT_INFO("-");
return result;
}
char addr[BT_ADDRESS_STRING_SIZE] = { 0 };
int result = BLUETOOTH_ERROR_NONE;
GList *node;
- BT_INFO("+");
+ BT_DBG("type %s", __convert_audio_type_to_string(type));
_bt_convert_addr_type_to_string(addr,
(unsigned char *)address->addr);
} else {
BT_ERR("Profile [%s] disconnect failed!!", __convert_audio_type_to_string(type));
}
- BT_INFO("-");
+
return result;
}
static void __bt_audio_event_handler(int oal_event, gpointer event_data)
{
- BT_INFO("+");
-
switch (oal_event) {
case OAL_EVENT_ADAPTER_DISABLED: {
BT_INFO("Adapter Disabled..cleanup resources");
break;
}
default:
- BT_ERR("Unknown event..[%d]", oal_event);
+ BT_DBG("Unknown event..[%d]", oal_event);
+ break;
}
- BT_INFO("-");
}
static void __bt_audio_cleanup_resources(void)
GList *node;
GSList *l;
bt_pending_audio_conn_t *info = NULL;
- BT_INFO("+");
/* Remove connected device list */
node = g_list_first(g_connected_list);
info = NULL;
}
}
-
- BT_INFO("-");
}
static int __bt_process_audio_connect_all(bt_pending_audio_conn_t *info)
bluetooth_device_address_t device_address;
int result = BLUETOOTH_ERROR_NONE;
int type = BT_AUDIO_ALL;
- BT_INFO("+");
+
+ BT_DBG("");
_bt_convert_addr_string_to_type(device_address.addr, info->address);
result = _bt_connect_remote_hfp(&device_address);
if (info->is_a2dp_sink_supported)
- BT_INFO("A2DP is supported by [%s]", info->address);
+ BT_DBG("A2DP is supported by [%s]", info->address);
else
- BT_INFO("A2DP is not supported");
+ BT_DBG("A2DP is not supported");
} else if (info->is_a2dp_sink_supported) {
type = BT_AUDIO_A2DP;
result = _bt_a2dp_connect_remote_sink(&device_address);
} else {
BT_ERR("Profile connect failed!!");
}
- BT_INFO("-");
return result;
}
bt_pending_audio_conn_t* _bt_get_pending_audio_conn_info(char *address)
{
- BT_INFO("+");
bt_pending_audio_conn_t *info = NULL;
GSList *l;
info = (bt_pending_audio_conn_t*)l->data;
if (g_strcmp0(info->address, address) == 0 && info->search_status == SERVICE_SEARCH_DONE) {
- BT_INFO("Pending data found for addr [%s]", info->address);
+ BT_INFO("Pending data found for addr [%s]", info->address + 12);
return info;
}
}
{
bt_pending_audio_conn_t *data = NULL;
bluetooth_device_address_t device_address;
- BT_INFO("+");
data = _bt_get_pending_audio_conn_info(address);
} else {
BT_INFO("A2DP Connection is not pending..");
}
- BT_INFO("-");
return FALSE;
}
{
int ret = BLUETOOTH_ERROR_NONE;
bluetooth_device_address_t device_address;
- BT_INFO("+");
if (_bt_is_service_connected(address, type)) {
BT_INFO("Service [%s] is connected with device [%s], disconnect it...",
- __convert_audio_type_to_string(type), address);
+ __convert_audio_type_to_string(type), address + 12);
_bt_convert_addr_string_to_type(device_address.addr, address);
ret = __bt_process_audio_profile_disconnect(type, &device_address);
if (ret != BLUETOOTH_ERROR_NONE)
BT_ERR("Disconnecting service [%s] with device [%s] failed!!",
- __convert_audio_type_to_string(type), address);
+ __convert_audio_type_to_string(type), address + 12);
} else {
BT_INFO("Service [%s] is Not connected with device [%s],..",
- __convert_audio_type_to_string(type), address);
+ __convert_audio_type_to_string(type), address + 12);
}
- BT_INFO("-");
}
int __bt_handle_audio_all_connect(bt_pending_audio_conn_t *info)
int ret;
int indx;
- BT_DBG("+");
-
retv_if(NULL == info, BLUETOOTH_ERROR_INTERNAL);
retv_if(NULL == info->address, BLUETOOTH_ERROR_INTERNAL);
goto fail;
}
- BT_INFO("AUDIO_CONNECT_ALL request for [%s]", info->address);
+ BT_INFO("AUDIO_CONNECT_ALL request for [%s]", info->address + 12);
info->search_status = SERVICE_SEARCH_DONE;
/* Give preference to HFP over A2DP for outgoing connection sequence for AUDIO_ALL_CONNECT */
ret = __bt_is_headset_connected(info->type, info->address);
if (ret == BLUETOOTH_ERROR_ALREADY_CONNECT) {
BT_ERR("Can't start Audio All connect for [%s], reason: [%s]",
- info->address, "Already connected...");
+ info->address + 12, "Already connected...");
goto fail;
}
if (ret == BLUETOOTH_ERROR_IN_PROGRESS) {
BT_ERR("Can't start Audio All connect for [%s], reason: [%s]",
- info->address, "Already in progress...");
+ info->address + 12, "Already in progress...");
goto fail;
}
if (ret == BLUETOOTH_ERROR_NOT_CONNECTED) {
- BT_ERR("Great, can start Audio All connect for [%s]", info->address);
+ BT_ERR("Great, can start Audio All connect for [%s]", info->address + 12);
ret = __bt_is_headset_connecting(info->type);
if (ret != BLUETOOTH_ERROR_NONE) {
BT_ERR("Can't start Audio All connect for [%s], reason: [%s]",
- info->address, "some other device conn in progress");
+ info->address + 12, "some other device conn in progress");
ret = BLUETOOTH_ERROR_IN_PROGRESS;
goto fail;
}
/* If multiple profiles are supported, queue pending connection info */
if ((info->is_hfp_supported && info->is_a2dp_sink_supported) ||
(info->is_hfp_supported && info->is_a2dp_src_supported)) {
- BT_INFO("[%s] Supports HFP and (A2DP_Src or, A2DP_Snk)", info->address);
+ BT_INFO("[%s] Supports HFP and (A2DP_Src or, A2DP_Snk)", info->address + 12);
pending_audio_conn_list = g_slist_append(pending_audio_conn_list, (gpointer)info);
} else {
- BT_INFO("[%s] Supports one profile only", info->address);
+ BT_INFO("[%s] Supports one profile only", info->address + 12);
/*
* It means, we dont need pending connect info as only A2DP (Src/Snk) or
* HFP will be connected for present device, so lets free pending info.
if ((info->is_hfp_supported && info->is_a2dp_sink_supported) ||
(info->is_hfp_supported && info->is_a2dp_src_supported)) {
- BT_INFO("[%s] Supports HFP and (A2DP_Src or, A2DP_Snk)", info->address);
+ BT_INFO("[%s] Supports HFP and (A2DP_Src or, A2DP_Snk)", info->address + 12);
pending_audio_conn_list = g_slist_append(pending_audio_conn_list, (gpointer)info);
} else {
- BT_INFO("[%s] Supports one profile only", info->address);
+ BT_INFO("[%s] Supports one profile only", info->address + 12);
/*
* It means, we dont need pending connect info as only A2DP (Src/Snk) or
* HFP will be connected for present device, so lets free pending info.
}
}
- BT_DBG("-");
return BLUETOOTH_ERROR_NONE;
fail:
bt_pending_audio_conn_t *info = data;
char address[BT_ADDRESS_STRING_SIZE];
- BT_DBG("+");
-
retv_if(NULL == info, FALSE);
retv_if(NULL == info->address, FALSE);
goto failed;
}
- BT_DBG("-");
return FALSE;
failed:
__bt_reply_pending_audio_connect_req(address, BLUETOOTH_ERROR_INTERNAL);
char address[BT_ADDRESS_STRING_SIZE] = { 0 };
bt_pending_audio_conn_t *info = NULL;
- BT_INFO("+");
-
BT_CHECK_PARAMETER(device_address, return);
_bt_convert_addr_type_to_string(address, device_address->addr);
BT_INFO("Audio Connect Request: type[%s] address [%s]",
- __convert_audio_type_to_string(type), address);
+ __convert_audio_type_to_string(type), address + 12);
/*
* If type is BT_AUDIO_ALL or BT_AUDIO_HFP_SOURCE, enqueue search info in
_bt_convert_addr_type_to_string(address, device_address->addr);
BT_INFO("Audio Diconnect Request: type[%s] address [%s]",
- __convert_audio_type_to_string(type), address);
+ __convert_audio_type_to_string(type), address + 12);
if (type == BT_AUDIO_ALL) {
if (_bt_is_service_connected(address, BT_AUDIO_A2DP)) {
{
GList *node;
- BT_DBG("_bt_remove_headset_from_list \n");
+ BT_DBG("type %s", __convert_audio_type_to_string(type));
node = g_list_first(g_connected_list);
while (node != NULL) {
static void __bt_reply_hf_disconnection_pending_request(bt_address_t *address)
{
- BT_DBG("+");
char addr[BT_ADDRESS_STRING_SIZE] = { 0 };
bluetooth_device_address_t device_address;
GArray *out_param;
/* Find Async request information*/
req_info = _bt_get_request_info_data(BT_AG_DISCONNECT, addr);
if (NULL == req_info) {
- BT_INFO("AG DisConnect request not found or possibly already replied..");
+ BT_DBG("AG DisConnect request not found or possibly already replied..");
req_info = _bt_get_request_info_data(BT_AG_CONNECT, addr);
if (req_info == NULL) {
- BT_INFO("AG Connect request also not found..");
+ BT_DBG("AG Connect request also not found..");
req_info = _bt_get_request_info_data(BT_AUDIO_DISCONNECT, addr);
if (req_info == NULL) {
- BT_INFO("AUDIO Disconnect request also not found..");
+ BT_DBG("AUDIO Disconnect request also not found..");
req_info = _bt_get_request_info_data(BT_AUDIO_CONNECT, addr);
if (req_info == NULL) {
- BT_INFO("AUDIO Connect request also not found..");
+ BT_DBG("AUDIO Connect request also not found..");
return;
} else {
- BT_INFO("AG Audio All Connect request found..");
+ BT_DBG("AG Audio All Connect request found..");
result = BLUETOOTH_ERROR_INTERNAL;
}
} else {
- BT_INFO("Audio All DisConnect request found..");
+ BT_DBG("Audio All DisConnect request found..");
}
} else {
- BT_INFO("AG Connect request found..");
+ BT_DBG("AG Connect request found..");
result = BLUETOOTH_ERROR_INTERNAL;
}
} else {
- BT_INFO("AG DisConnect request found..");
+ BT_DBG("AG DisConnect request found..");
}
/* Cleanup device service search info if Aysnc request was Audio Connect All */
/* Check if pending connect was present */
data = _bt_get_pending_audio_conn_info(addr);
if (data) {
- BT_INFO("HF Connection failed during Audio All connect, & pending connect present");
+ BT_DBG("HF Connection failed during Audio All connect, & pending connect present");
_bt_cleanup_audio_pending_conn_info_and_reply_pending_req(data, BLUETOOTH_ERROR_INTERNAL);
goto try_waiting_device;
} else {
- BT_INFO("Abnormal:HF Connection failed during Audio All connect, but pending connect not present");
+ BT_DBG("Abnormal:HF Connection failed during Audio All connect, but pending connect not present");
}
}
_bt_convert_addr_string_to_type(device_address.addr,
wait_list->address);
BT_INFO("Trigger connect for the waiting device [%s], audio type [%d]",
- wait_list->address, wait_list->type);
+ wait_list->address + 12, wait_list->type);
_bt_audio_connect(wait_list->type, &device_address);
_bt_rel_wait_data();
}
unsigned int result = BLUETOOTH_ERROR_NONE;
invocation_info_t *req_info;
GVariant *param;
- BT_INFO("+");
_bt_convert_addr_type_to_string(address, bd_addr->addr);
BT_INFO("HF(AG Role) Connected for address [%s]", address);
wait_list = _bt_get_audio_wait_data();
if (wait_list != NULL &&
(g_strcmp0(wait_list->address, address) == 0)) {
- BT_INFO("Same Device [%s] is under wait, connection type [%d], going to delete it",
+ BT_DBG("Same Device [%s] is under wait, connection type [%d], going to delete it",
wait_list->address, wait_list->type);
_bt_rel_wait_data();
} else {
if (wait_list != NULL)
- BT_INFO("Some Device [%s] is under wait, connection type [%d], ", wait_list->address, wait_list->type);
+ BT_DBG("Some Device [%s] is under wait, connection type [%d], ", wait_list->address, wait_list->type);
}
/* DBUS Context return */
req_info = _bt_get_request_info_data(BT_AUDIO_CONNECT, address);
if (NULL != req_info) {
- BT_INFO("Audio All Connect request found");
+ BT_DBG("Audio All Connect request found");
goto check_pending_a2dp_connect;
} else {
- BT_INFO("Audio All Connect Request not found..");
+ BT_DBG("Audio All Connect Request not found..");
req_info = _bt_get_request_info_data(BT_AG_CONNECT, address);
if (req_info) {
- BT_INFO("AG Connect Request found..");
+ BT_DBG("AG Connect Request found..");
goto dbus_return;
} else {
BT_ERR("AG Connect Request also not found..Abnormal Case!!!");
check_pending_a2dp_connect:
/* Check pending A2DP connection */
- BT_INFO("Check A2DP pending connect");
+ BT_DBG("Check A2DP pending connect");
if (_bt_audio_check_pending_connection(address) == TRUE) {
- BT_INFO("Pending A2DP connect is present..dont return DBUS for AUDIO_CONNECT_ALL");
+ BT_DBG("Pending A2DP connect is present..dont return DBUS for AUDIO_CONNECT_ALL");
return;
}
- BT_INFO("Pending A2DP connect is Not present..return DBUS for AUDIO_CONNECT_ALL");
+ BT_DBG("Pending A2DP connect is Not present..return DBUS for AUDIO_CONNECT_ALL");
dbus_return:
out_param = g_array_new(FALSE, FALSE, sizeof(gchar));
g_array_append_vals(out_param, address, BT_ADDRESS_STRING_SIZE);
/* This event handler process events for HF (AG role) */
void _bt_hf_event_handler(int oal_event, gpointer event_data)
{
- BT_INFO("+");
bt_address_t * bt_addr = event_data;
switch (oal_event) {
{
oal_status_t status = OAL_STATUS_SUCCESS;
int result = BLUETOOTH_ERROR_NONE;
- BT_INFO("+");
+ BT_DBG("+");
status = hfp_connect((bt_address_t *)device_address);
if (status != OAL_STATUS_SUCCESS) {
{
oal_status_t status = OAL_STATUS_SUCCESS;
int result = BLUETOOTH_ERROR_NONE;
- BT_INFO("+");
+ BT_DBG("+");
status = hfp_disconnect((bt_address_t *)device_address);
if (status != OAL_STATUS_SUCCESS) {
{
GSList *l;
invocation_info_t *info;
+
ret_if(NULL == req_info);
ret_if(NULL == req_info->sender);
__bt_service_get_parameters(in_param1, &uid, sizeof(uid_t));
__bt_service_get_parameters(in_param2, &pid, sizeof(pid_t));
__bt_service_get_parameters(in_param3, &size, sizeof(unsigned int));
- BT_DBG("Sending details to bluetooth battery monitor: %ld, %ld, %d", (long int)uid, (long int)pid, size);
_bt_bm_add_transaction_details(uid, pid, size, RX_DATA);
break;
}
__bt_service_get_parameters(in_param1, &uid, sizeof(uid_t));
__bt_service_get_parameters(in_param2, &pid, sizeof(pid_t));
__bt_service_get_parameters(in_param3, &size, sizeof(unsigned int));
- BT_DBG("Sending details to bluetooth battery monitor: %ld, %ld, %d", (long int)uid, (long int)pid, size);
_bt_bm_add_transaction_details(uid, pid, size, TX_DATA);
break;
}
unsigned int value;
sender = (char *)g_dbus_method_invocation_get_sender(context);
- BT_INFO("Sender %s", sender);
__bt_service_get_parameters(in_param1,
&type, sizeof(int));
}
if (g_strcmp0(sender, current_sender_playing) == 0 ||
current_sender_playing == NULL) {
- BT_INFO("Current Player Status %d type %d", value, type);
+ BT_INFO("Current Player Status %d type %d Sender %s", value, type, sender);
} else {
- BT_INFO("Current Player and this sender are different");
+ BT_INFO("Current Player and this sender (%s) are different", sender);
result = BLUETOOTH_ERROR_NONE;
break;
}
case BT_DISABLE_ADAPTER:
{
bt_status_t status;
+
status = _bt_adapter_get_status();
if (status == BT_DEACTIVATING) {
BT_DBG("Disabling in progress");
return FALSE;
}
- BT_DBG("Buffer = %s", buffer);
-
lines = g_strsplit_set(buffer, BT_AGENT_NEW_LINE, 0);
g_free(buffer);
{
GSList *l = NULL;
_bt_battery_app_data_t *t;
- BT_INFO("Checking Memory location %p", start);
+ BT_DBG("Checking Memory location %p", start);
for (l=start; l != NULL; l = g_slist_next(l)) {
t = (_bt_battery_app_data_t *)(l->data);
if (t->uid == uid && t->pid == pid) {
- BT_INFO("App details already exist");
+ BT_DBG("App details already exist");
return l;
}
}
_bt_battery_app_data_t *app_data = NULL;
if (t == NULL) {
- BT_INFO("Match not found, adding new node...");
+ BT_DBG("Match not found, adding new node...");
app_data = g_malloc0(sizeof(_bt_battery_app_data_t));
app_data->uid = uid;
app_data->pid = pid;
current_session_data->atm_list = g_slist_append(current_session_data->atm_list, app_data);
}
else {
- BT_INFO("Match found, updating existing node...");
+ BT_DBG("Match found, updating existing node...");
app_data = (_bt_battery_app_data_t *)(t->data);
if (type == RX_DATA)
app_data->rx_bytes += value;
static bool __bt_bm_session_timeout_cb(void)
{
- BT_INFO("No data read calls during the time.");
+ BT_DBG("No data read calls during the time.");
__bt_stop_session_time();
/* Find the regacy scan app for Inquiry stop */
if (type == SCAN_REGACY && t->type != SCAN_LE) {
- BT_INFO("app already exist");
+ BT_DBG("app already exist");
return l;
}
if (t->uid == uid && t->pid == pid) {
- BT_INFO("app already exist");
+ BT_DBG("app already exist");
return l;
}
}
static void __bt_notify_battery_data(void)
{
- BT_INFO("+");
+ BT_DBG("+");
_bt_battery_data_t *data = NULL;
int result;
g_slist_free_full(data->atm_list, g_free);
g_free(data);
g_array_free(info, TRUE);
- BT_INFO("-");
+ BT_DBG("-");
}
void _bt_bm_event_handler(gpointer data)
dev_info->address = g_new0(char, BT_ADDRESS_STRING_SIZE);
_bt_convert_addr_type_to_string(dev_info->address, oal_device->address.addr);
- BT_INFO("Address [%s]", dev_info->address);
if (strlen(oal_device->name) == 0)
dev_info->name = NULL;
else {
dev_info->name = g_strdup(oal_device->name);
_bt_truncate_non_utf8_chars(dev_info->name);
- BT_INFO("Name [%s]", dev_info->name);
}
if (strlen(oal_device->alias) == 0) {
dev_info->class = oal_device->cod;
dev_info->paired = oal_device->is_bonded;
- BT_INFO("Is Bonded [%d]", dev_info->paired);
dev_info->connected = oal_device->is_connected;
- BT_INFO("iS Connected [%d]", dev_info->connected);
dev_info->rssi = oal_device->rssi;
dev_info->addr_type = oal_device->type;
dev_info->uuid_count = oal_device->uuid_count;
BT_INFO("UUID Count [%d]", dev_info->uuid_count);
dev_info->trust = ((oal_device->is_trusted == 0) ? FALSE : TRUE);
+ BT_DBG("[%s] link type [0x%x] name [%s] bonded [%d]", dev_info->address,
+ dev_info->connected, dev_info->name, dev_info->paired);
+
if (dev_info->uuid_count > 0)
dev_info->uuids = g_new0(char *, dev_info->uuid_count);
retv_if(event_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
- BT_DBG("event_type [%d], event [%d]", event_type, event);
-
switch (event_type) {
case BT_ADAPTER_EVENT:
path = BT_ADAPTER_PATH;
return BLUETOOTH_ERROR_INTERNAL;
}
- BT_DBG("Path : %s", path);
- BT_INFO_C("Signal : %s", signal);
+ BT_DBG("event_type [%d], event [%d] path [%s]", event_type, event, path);
+
+ if (event != BLUETOOTH_EVENT_DISCOVERABLE_TIMEOUT_CHANGED)
+ BT_INFO_C("Signal : %s", signal);
msg1 = g_dbus_message_new_signal(path, BT_EVENT_SERVICE, signal);
g_dbus_message_set_body(msg1, param);
return BLUETOOTH_ERROR_INTERNAL;
}
- BT_INFO_C("Signal : %s", signal);
+ if (event != BLUETOOTH_EVENT_REMOTE_LE_DEVICE_FOUND)
+ BT_INFO_C("Signal : %s", signal);
+ else
+ BT_DBG("Signal : %s", signal);
if (!g_dbus_connection_emit_signal(event_conn, dest, path, BT_EVENT_SERVICE,
signal, param, &error)) {
ret_if(str == NULL);
ret_if(uuid == NULL);
- BT_DBG("+");
-
memcpy(uuid, BT_SERVICE_BASE_UUID, BT_UUID_LENGTH_MAX);
while (*ptr && i < BT_UUID_LENGTH_MAX) {
i++;
ptr += 2;
}
-
- BT_DBG("-");
}
char * _bt_service_convert_hex_to_string(unsigned char *hex, int len)
BT_ERR("Unexpected: Info request pending for a different address!!");
return;
} else {
- BT_INFO("Found info request addr [%s]", (char*)req_info->user_data);
+ BT_DBG("Found info request addr [%s]", (char*)req_info->user_data);
bt_sdp_info_t sdp_info;
memset(&sdp_info, 0x00, sizeof(bt_sdp_info_t));
BT_ERR("Unexpected: Info request pending for a different address!!");
return;
} else {
- BT_INFO("Found info request addr [%s]", (char*)req_info->user_data);
+ BT_DBG("Found info request addr [%s]", (char*)req_info->user_data);
bluetooth_device_info_t dev_info;
memset(&dev_info, 0x00, sizeof(bluetooth_device_info_t));
_bt_convert_addr_string_to_type(dev_info.device_address.addr,
BT_ERR("Unexpected: Info request pending for a different address!!");
return;
} else {
- BT_INFO("Found info request addr [%s]", (char*)req_info->user_data);
+ BT_DBG("Found info request addr [%s]", (char*)req_info->user_data);
bluetooth_device_address_t dev_addr;
_bt_convert_addr_string_to_type(dev_addr.addr, address);
out_param = g_array_new(FALSE, FALSE, sizeof(gchar));
break;
}
}
- BT_INFO("-");
+ BT_DBG("-");
}
/*
{
bt_remote_dev_info_t *rem_info = NULL;
- BT_DBG("+");
rem_info = g_malloc0(sizeof(bt_remote_dev_info_t));
_bt_copy_remote_dev(rem_info, &(oal_dev_props->device_info));
/* a. Check if bonding is on-going, if yes, we MUST update the bonding device properties */
if (trigger_bond_info && !strcmp(trigger_bond_info->addr, rem_info->address)) {
- BT_INFO("Bonding is ongoing, try update properties");
+ BT_DBG("Bonding is ongoing, try update properties");
if (!trigger_bond_info->dev_info ||
(!trigger_bond_info->dev_info->name &&
!trigger_bond_info->dev_info->alias) ||
!trigger_bond_info->dev_info->address ||
trigger_bond_info->dev_info->uuid_count == 0) {
- BT_INFO("Complete data is not present, Assigning rem_info");
+ BT_DBG("Complete data is not present, Assigning rem_info");
if (!trigger_bond_info->dev_info)
trigger_bond_info->dev_info = g_malloc0(sizeof(bt_remote_dev_info_t));
_bt_copy_remote_dev_info(trigger_bond_info->dev_info, rem_info);
BT_DBG("Bonding dev addr has matched with remote dev properties address [%s]", rem_info->address);
__bt_handle_ongoing_bond(trigger_bond_info->dev_info, FALSE);
} else if (incoming_bond_info && !g_strcmp0(incoming_bond_info->addr, rem_info->address)) {
- BT_INFO("Incoming Bond is ongoing, try update properties");
+ BT_DBG("Incoming Bond is ongoing, try update properties");
if (!incoming_bond_info->dev_info ||
(!incoming_bond_info->dev_info->name &&
!incoming_bond_info->dev_info->alias) ||
!incoming_bond_info->dev_info->address ||
incoming_bond_info->dev_info->uuid_count == 0) {
- BT_INFO("Complete data is not present, Assigning rem_info");
+ BT_DBG("Complete data is not present, Assigning rem_info");
if (!incoming_bond_info->dev_info)
incoming_bond_info->dev_info = g_malloc0(sizeof(bt_remote_dev_info_t));
_bt_copy_remote_dev_info(incoming_bond_info->dev_info, rem_info);
}
_bt_free_remote_dev(rem_info);
- BT_DBG("-");
}
static int __get_oal_trusted_profile(bluetooth_trusted_profile_t profile)
_bt_convert_addr_type_to_string(address, auth_event->address.addr);
- BT_INFO("service_d: %d", service_d);
+ BT_DBG("service_d: %d", service_d);
switch (service_d) {
case HID_SERVICE_ID:
- BT_INFO("Incoming HID Profile conn Req from device addr [%s]", address);
+ BT_DBG("Incoming HID Profile conn Req from device addr [%s]", address);
break;
case A2DP_SERVICE_ID:
- BT_INFO("Incoming A2DP(Remote Sink) profile conn Req from device addr [%s]", address);
+ BT_DBG("Incoming A2DP(Remote Sink) profile conn Req from device addr [%s]", address);
_bt_a2dp_src_handle_incoming_authorization(address, service_d);
return;
case A2DP_SRC_SERVICE_ID:
- BT_INFO("Incoming A2DP(Remote Source) Profile conn Req from device addr [%s]", address);
+ BT_DBG("Incoming A2DP(Remote Source) Profile conn Req from device addr [%s]", address);
_bt_a2dp_sink_handle_incoming_authorization(address, service_d);
break;
case AVRCP_SERVICE_ID:
- BT_INFO("Incoming AVRCP (Remote) Profile conn Req from device addr [%s]", address);
+ BT_DBG("Incoming AVRCP (Remote) Profile conn Req from device addr [%s]", address);
break;
case AVRCP_CT_SERVICE_ID:
- BT_INFO("Incoming AVRCP (Controller) Profile conn Req from device addr [%s]", address);
+ BT_DBG("Incoming AVRCP (Controller) Profile conn Req from device addr [%s]", address);
break;
#ifdef TIZEN_FEATURE_BT_OBEX
case OPP_SERVICE_ID: {
name = g_strdup(address);
- BT_INFO("Incoming OPP conn Req from device addr [%s]", address);
+ BT_DBG("Incoming OPP conn Req from device addr [%s]", address);
_bt_obex_server_set_pending_conn_auth_device_addr(address);
param = g_variant_new("(iss)", BLUETOOTH_ERROR_NONE, address, name);
_bt_send_event(BT_OPP_SERVER_EVENT,
}
#endif
case HSP_SERVICE_ID:
- BT_INFO("Incoming HSP_SERVICE_ID conn Req from device addr [%s]", address);
+ BT_DBG("Incoming HSP_SERVICE_ID conn Req from device addr [%s]", address);
break;
case HFP_SERVICE_ID:
- BT_INFO("Incoming HFP_SERVICE_ID conn Req from device addr [%s]", address);
+ BT_DBG("Incoming HFP_SERVICE_ID conn Req from device addr [%s]", address);
break;
case SAP_SERVICE_ID:
- BT_INFO("Incoming SAP_SERVICE_ID conn Req from device addr [%s]", address);
+ BT_DBG("Incoming SAP_SERVICE_ID conn Req from device addr [%s]", address);
break;
case HSP_HS_SERVICE_ID:
- BT_INFO("Incoming HSP_HS_SERVICE_ID conn Req from device addr [%s]", address);
+ BT_DBG("Incoming HSP_HS_SERVICE_ID conn Req from device addr [%s]", address);
break;
case HFP_HS_SERVICE_ID:
- BT_INFO("Incoming HFP_HS_SERVICE_ID conn Req from device addr [%s]", address);
+ BT_DBG("Incoming HFP_HS_SERVICE_ID conn Req from device addr [%s]", address);
break;
#ifdef TIZEN_BT_HAL
case IOTIVITY_SERVICE_ID:
- BT_INFO("Incoming IOTIVITY_SERVICE_ID conn Req from device addr [%s]", address);
+ BT_DBG("Incoming IOTIVITY_SERVICE_ID conn Req from device addr [%s]", address);
break;
#endif
default:
/* For now, reject authorization for any service apart from above switch cases */
- BT_INFO("Incoming Profile conn req with service ID [%d] from device addr [%s]", service_d, address);
+ BT_DBG("Incoming Profile conn req with service ID [%d] from device addr [%s]", service_d, address);
res = device_reply_auth_request((bt_address_t*)&auth_event->address, service_d, FALSE, FALSE);
if (res != OAL_STATUS_SUCCESS)
BT_ERR("authorize_response: %d", res);
res = device_reply_auth_request((bt_address_t*)&auth_event->address, service_d, TRUE, FALSE);
if (res != OAL_STATUS_SUCCESS)
BT_ERR("authorize_response: %d", res);
- BT_INFO("-");
}
static void __bt_handle_ongoing_bond(bt_remote_dev_info_t *remote_dev_info, gboolean incoming_bond)
BLUETOOTH_EVENT_BONDING_FINISHED,
param);
BT_PERMANENT_LOG("Paired %s", remote_dev_info->address + 12);
- BT_INFO_C("### Paired %s", remote_dev_info->address);
+ BT_INFO_C("### Paired %s", remote_dev_info->address + 12);
if (incoming_bond) {
__bt_free_bond_info(BT_DEVICE_INCOMING_BOND_INFO);
} else {
return;
}
- BT_INFO("Bonding successfully completed");
/* Bonding state will be cleaned up & BONDING FINISHED EVENT
will be sent only when Properties are fetched from stack
Till that time lets not free trigger_bond_info.
trigger_bond_info->addr);
if (_bt_device_get_bonded_device_info(&dev_addr) == BLUETOOTH_ERROR_NONE) {
- BT_DBG("BOnded device info query posted to stack successfully");
+ BT_DBG("Bonded device info query posted to stack successfully");
__bt_device_handle_pending_requests(BLUETOOTH_ERROR_NONE, BT_BOND_DEVICE,
trigger_bond_info->addr, BT_ADDRESS_STRING_SIZE);
} else {
{
char address[BT_ADDRESS_STRING_SIZE];
- BT_INFO("+");
-
_bt_convert_addr_type_to_string(address, bd_addr->addr);
_bt_service_remove_device_from_bonded_list(address);
if (trigger_unbond_info) {
- BT_INFO("Bond removal request successfully handled, return DBUS and send event");
+ BT_DBG("Bond removal request successfully handled, return DBUS and send event");
GVariant *param = NULL;
__bt_device_handle_pending_requests(BLUETOOTH_ERROR_NONE, BT_UNBOND_DEVICE,
trigger_unbond_info->addr, BT_ADDRESS_STRING_SIZE);
BT_ERR("Bonding was removed");
__bt_device_handle_bond_state();
}
- BT_INFO("-");
}
static void __bt_device_handle_bond_failed_event(event_dev_bond_failed_t* bond_fail_event)
static int __bt_device_handle_bond_state(void)
{
- BT_INFO("Current Bond state: %d", bt_device_bond_state);
+ BT_DBG("Current Bond state: %d", bt_device_bond_state);
int ret = OAL_STATUS_INTERNAL_ERROR;
switch (bt_device_bond_state) {
int result;
bt_address_t bd_addr;
- BT_DBG("+");
-
retv_if(!addr, BLUETOOTH_ERROR_INVALID_PARAM);
memcpy(bd_addr.addr, addr, BLUETOOTH_ADDRESS_LENGTH);
return BLUETOOTH_ERROR_INTERNAL;
}
- BT_DBG("-");
return BLUETOOTH_ERROR_NONE;
}
int ret;
char address[BT_ADDRESS_STRING_SIZE];
- BT_DBG("+");
BT_CHECK_PARAMETER(alias, return);
ret = device_set_alias((bt_address_t *)device_address, (char *)alias);
_bt_convert_addr_type_to_string(address, device_address->addr);
_bt_update_remote_dev_property(address, DEV_PROP_ALIAS, (void *)alias);
- BT_DBG("-");
return BLUETOOTH_ERROR_NONE;
}
char address[BT_ADDRESS_STRING_SIZE] = { 0 };
bluetooth_device_info_t dev_info;
const char *stack_name = NULL;
- BT_DBG("+");
retv_if(device_address == NULL, BLUETOOTH_ERROR_INVALID_PARAM);
if (result != BLUETOOTH_ERROR_NONE)
goto fail;
- BT_DBG("-");
return result;
fail:
sizeof(bluetooth_device_info_t));
__bt_free_bond_info(BT_DEVICE_BOND_INFO);
- BT_DBG("-");
return result;
}
int result = OAL_STATUS_SUCCESS;
char address[BT_ADDRESS_STRING_SIZE] = { 0 };
bluetooth_device_info_t dev_info;
- BT_INFO("+");
retv_if(device_address == NULL, BLUETOOTH_ERROR_INVALID_PARAM);
max = interval_max / BT_LE_CONN_INTERVAL_SPLIT;
to = time_out / BT_LE_CONN_TO_SPLIT;
- BT_INFO("updating: Min interval: %d, Max interval: %d, Latency: %d, Supervision timeout: %d",
+ BT_DBG("updating: Min interval: %d, Max interval: %d, Latency: %d, Supervision timeout: %d",
min, max, latency, to);
_bt_convert_addr_string_to_type(dev_addr.addr, address);
BT_CHECK_PARAMETER(device_address, return);
- BT_INFO("Sender %s, Min interval: %f, Max interval: %f, Latency: %u, Supervision timeout: %u",
+ BT_DBG("Sender %s, Min interval: %f, Max interval: %f, Latency: %u, Supervision timeout: %u",
sender, interval_min, interval_max, latency, time_out);
if (interval_min > interval_max ||
return FALSE;
}
- BT_DBG("Buffer = %s\n", buffer);
-
lines = g_strsplit_set(buffer, BT_AGENT_NEW_LINE, 0);
g_free(buffer);
projects / platform / core / connectivity / bluetooth-frwk.git / commitdiff