static void good_bye(void)
{
- DBG("Good bye! %s\n", get_client_name());
+ _D("Good bye! %s\n", get_client_name());
clean_up();
}
static void set_power_save_state_cb(void)
{
if (g_power_save_state_cb_cnt < 0)
- ERR("g_power_save_state_cb_cnt(%d) is wrong", g_power_save_state_cb_cnt);
+ _E("g_power_save_state_cb_cnt(%d) is wrong", g_power_save_state_cb_cnt);
++g_power_save_state_cb_cnt;
if (g_power_save_state_cb_cnt == 1) {
- DBG("Power save callback is registered");
+ _D("Power save callback is registered");
g_power_save_state = get_power_save_state();
- DBG("power_save_state = [%d]", g_power_save_state);
+ _D("power_save_state = [%d]", g_power_save_state);
vconf_notify_key_changed(VCONFKEY_PM_STATE, power_save_state_cb, NULL);
}
}
--g_power_save_state_cb_cnt;
if (g_power_save_state_cb_cnt < 0)
- ERR("g_power_save_state_cb_cnt(%d) is wrong", g_power_save_state_cb_cnt);
+ _E("g_power_save_state_cb_cnt(%d) is wrong", g_power_save_state_cb_cnt);
if (g_power_save_state_cb_cnt == 0) {
- DBG("Power save callback is unregistered");
+ _D("Power save callback is unregistered");
vconf_ignore_key_changed(VCONFKEY_PM_STATE, power_save_state_cb);
}
}
cur_power_save_state = get_power_save_state();
if (cur_power_save_state == g_power_save_state) {
- DBG("g_power_save_state NOT changed : [%d]", cur_power_save_state);
+ _D("g_power_save_state NOT changed : [%d]", cur_power_save_state);
return;
}
g_power_save_state = cur_power_save_state;
- DBG("power_save_state: %d noti to %s", g_power_save_state, get_client_name());
+ _D("power_save_state: %d noti to %s", g_power_save_state, get_client_name());
client_info.get_listening_sensors(sensors);
{
AUTOLOCK(lock);
- INFO("Trying to restore session for %s", get_client_name());
+ _I("Trying to restore session for %s", get_client_name());
command_channel *cmd_channel;
int client_id;
retm_if (!cmd_channel, "Failed to allocate memory");
if (!cmd_channel->create_channel()) {
- ERR("%s failed to create command channel for %s", get_client_name(), get_sensor_name(*it_sensor));
+ _E("%s failed to create command channel for %s", get_client_name(), get_sensor_name(*it_sensor));
delete cmd_channel;
goto FAILED;
}
if (first_connection) {
first_connection = false;
if (!cmd_channel->cmd_get_id(client_id)) {
- ERR("Failed to get client id");
+ _E("Failed to get client id");
goto FAILED;
}
cmd_channel->set_client_id(client_id);
if (!cmd_channel->cmd_hello(*it_sensor)) {
- ERR("Sending cmd_hello(%s, %d) failed for %s", get_sensor_name(*it_sensor), client_id, get_client_name());
+ _E("Sending cmd_hello(%s, %d) failed for %s", get_sensor_name(*it_sensor), client_id, get_client_name());
goto FAILED;
}
client_info.get_sensor_rep(*it_sensor, cur_rep);
if (!change_sensor_rep(*it_sensor, prev_rep, cur_rep)) {
- ERR("Failed to change rep(%s) for %s", get_sensor_name(*it_sensor), get_client_name());
+ _E("Failed to change rep(%s) for %s", get_sensor_name(*it_sensor), get_client_name());
goto FAILED;
}
++it_sensor;
}
- INFO("Succeeded to restore session for %s", get_client_name());
+ _I("Succeeded to restore session for %s", get_client_name());
return;
FAILED:
event_listener.clear();
- ERR("Failed to restore session for %s", get_client_name());
+ _E("Failed to restore session for %s", get_client_name());
}
static bool get_events_diff(event_type_vector &a_vec, event_type_vector &b_vec, event_type_vector &add_vec, event_type_vector &del_vec)
event_type_vector add_event_types, del_event_types;
if (!client_info.get_command_channel(sensor_id, &cmd_channel)) {
- ERR("client %s failed to get command channel for %s", get_client_name(), get_sensor_name(sensor_id));
+ _E("client %s failed to get command channel for %s", get_client_name(), get_sensor_name(sensor_id));
return false;
}
if (cur_rep.active) {
if (prev_rep.option != cur_rep.option) {
if (!cmd_channel->cmd_set_option(cur_rep.option)) {
- ERR("Sending cmd_set_option(%d, %s, %d) failed for %s", client_id, get_sensor_name(sensor_id), cur_rep.option, get_client_name());
+ _E("Sending cmd_set_option(%d, %s, %d) failed for %s", client_id, get_sensor_name(sensor_id), cur_rep.option, get_client_name());
return false;
}
}
if ( (prev_rep.interval != cur_rep.interval) || (prev_rep.latency != cur_rep.latency)) {
if (!cmd_channel->cmd_set_batch(cur_rep.interval, cur_rep.latency)) {
- ERR("Sending cmd_set_batch(%d, %s, %d, %d) failed for %s", client_id, get_sensor_name(sensor_id), cur_rep.interval, cur_rep.latency, get_client_name());
+ _E("Sending cmd_set_batch(%d, %s, %d, %d) failed for %s", client_id, get_sensor_name(sensor_id), cur_rep.interval, cur_rep.latency, get_client_name());
return false;
}
}
if (!add_event_types.empty()) {
if (!cmd_channel->cmd_register_events(add_event_types)) {
- ERR("Sending cmd_register_events(%d, add_event_types) failed for %s", client_id, get_client_name());
+ _E("Sending cmd_register_events(%d, add_event_types) failed for %s", client_id, get_client_name());
return false;
}
}
if (prev_rep.active && !del_event_types.empty()) {
if (!cmd_channel->cmd_unregister_events(del_event_types)) {
- ERR("Sending cmd_unregister_events(%d, del_event_types) failed for %s", client_id, get_client_name());
+ _E("Sending cmd_unregister_events(%d, del_event_types) failed for %s", client_id, get_client_name());
return false;
}
}
if (prev_rep.active != cur_rep.active) {
if (cur_rep.active) {
if (!cmd_channel->cmd_start()) {
- ERR("Sending cmd_start(%d, %s) failed for %s", client_id, get_sensor_name(sensor_id), get_client_name());
+ _E("Sending cmd_start(%d, %s) failed for %s", client_id, get_sensor_name(sensor_id), get_client_name());
return false;
}
} else {
if (!cmd_channel->cmd_unset_batch()) {
- ERR("Sending cmd_unset_interval(%d, %s) failed for %s", client_id, get_sensor_name(sensor_id), get_client_name());
+ _E("Sending cmd_unset_interval(%d, %s) failed for %s", client_id, get_sensor_name(sensor_id), get_client_name());
return false;
}
if (!cmd_channel->cmd_stop()) {
- ERR("Sending cmd_stop(%d, %s) failed for %s", client_id, get_sensor_name(sensor_id), get_client_name());
+ _E("Sending cmd_stop(%d, %s) failed for %s", client_id, get_sensor_name(sensor_id), get_client_name());
return false;
}
}
command_channel cmd_channel;
if (!cmd_channel.create_channel()) {
- ERR("%s failed to create command channel", get_client_name());
+ _E("%s failed to create command channel", get_client_name());
return false;
}
handle = client_info.create_handle(sensor_id);
if (handle == MAX_HANDLE_REACHED) {
- ERR("Maximum number of handles reached, sensor: %s in client %s", get_sensor_name(sensor_id), get_client_name());
+ _E("Maximum number of handles reached, sensor: %s in client %s", get_sensor_name(sensor_id), get_client_name());
return OP_ERROR;
}
retvm_if (!cmd_channel, OP_ERROR, "Failed to allocate memory");
if (!cmd_channel->create_channel()) {
- ERR("%s failed to create command channel for %s", get_client_name(), get_sensor_name(sensor_id));
+ _E("%s failed to create command channel for %s", get_client_name(), get_sensor_name(sensor_id));
client_info.delete_handle(handle);
delete cmd_channel;
return OP_ERROR;
}
if (!client_info.get_command_channel(sensor_id, &cmd_channel)) {
- ERR("%s failed to get command channel for %s", get_client_name(), get_sensor_name(sensor_id));
+ _E("%s failed to get command channel for %s", get_client_name(), get_sensor_name(sensor_id));
client_info.delete_handle(handle);
return OP_ERROR;
}
if (!client_info.has_client_id()) {
first_connection = true;
if(!cmd_channel->cmd_get_id(client_id)) {
- ERR("Sending cmd_get_id() failed for %s", get_sensor_name(sensor_id));
+ _E("Sending cmd_get_id() failed for %s", get_sensor_name(sensor_id));
client_info.close_command_channel(sensor_id);
client_info.delete_handle(handle);
return OP_ERROR;
}
client_info.set_client_id(client_id);
- INFO("%s gets client_id [%d]", get_client_name(), client_id);
+ _I("%s gets client_id [%d]", get_client_name(), client_id);
event_listener.start_event_listener();
- INFO("%s starts listening events with client_id [%d]", get_client_name(), client_id);
+ _I("%s starts listening events with client_id [%d]", get_client_name(), client_id);
}
client_id = client_info.get_client_id();
cmd_channel->set_client_id(client_id);
- INFO("%s[%d] connects with %s[%d]", get_client_name(), client_id, get_sensor_name(sensor_id), handle);
+ _I("%s[%d] connects with %s[%d]", get_client_name(), client_id, get_sensor_name(sensor_id), handle);
client_info.set_sensor_params(handle, SENSOR_STATE_STOPPED, SENSOR_OPTION_DEFAULT);
if (!sensor_registered) {
if(!cmd_channel->cmd_hello(sensor_id)) {
- ERR("Sending cmd_hello(%s, %d) failed for %s", get_sensor_name(sensor_id), client_id, get_client_name());
+ _E("Sending cmd_hello(%s, %d) failed for %s", get_sensor_name(sensor_id), client_id, get_client_name());
client_info.close_command_channel(sensor_id);
client_info.delete_handle(handle);
if (first_connection) {
if (!client_info.get_sensor_state(handle, sensor_state)||
!client_info.get_sensor_id(handle, sensor_id)) {
- ERR("client %s failed to get handle information", get_client_name());
+ _E("client %s failed to get handle information", get_client_name());
return false;
}
if (!client_info.get_command_channel(sensor_id, &cmd_channel)) {
- ERR("client %s failed to get command channel for %s", get_client_name(), get_sensor_name(sensor_id));
+ _E("client %s failed to get command channel for %s", get_client_name(), get_sensor_name(sensor_id));
return false;
}
client_id = client_info.get_client_id();
retvm_if ((client_id < 0), false, "Invalid client id : %d, handle: %d, %s, %s", client_id, handle, get_sensor_name(sensor_id), get_client_name());
- INFO("%s disconnects with %s[%d]", get_client_name(), get_sensor_name(sensor_id), handle);
+ _I("%s disconnects with %s[%d]", get_client_name(), get_sensor_name(sensor_id), handle);
if (sensor_state != SENSOR_STATE_STOPPED) {
- WARN("%s[%d] for %s is not stopped before disconnecting.",
+ _W("%s[%d] for %s is not stopped before disconnecting.",
get_sensor_name(sensor_id), handle, get_client_name());
sensord_stop(handle);
}
if (!client_info.is_sensor_registered(sensor_id)) {
if(!cmd_channel->cmd_byebye()) {
- ERR("Sending cmd_byebye(%d, %s) failed for %s", client_id, get_sensor_name(sensor_id), get_client_name());
+ _E("Sending cmd_byebye(%d, %s) failed for %s", client_id, get_sensor_name(sensor_id), get_client_name());
return false;
}
client_info.close_command_channel(sensor_id);
}
if (!client_info.is_active()) {
- INFO("Stop listening events for client %s with client id [%d]", get_client_name(), client_info.get_client_id());
+ _I("Stop listening events for client %s with client id [%d]", get_client_name(), client_info.get_client_id());
event_listener.stop_event_listener();
}
AUTOLOCK(lock);
if (!client_info.get_sensor_id(handle, sensor_id)) {
- ERR("client %s failed to get handle information", get_client_name());
+ _E("client %s failed to get handle information", get_client_name());
return false;
}
if (interval == 0)
interval = DEFAULT_INTERVAL;
- INFO("%s registers event %s[0x%x] for sensor %s[%d] with interval: %d, latency: %d, cb: 0x%x, user_data: 0x%x",
+ _I("%s registers event %s[0x%x] for sensor %s[%d] with interval: %d, latency: %d, cb: 0x%x, user_data: 0x%x",
get_client_name(), get_event_name(event_type), event_type, get_sensor_name(sensor_id),
handle, interval, max_batch_latency, cb, user_data);
AUTOLOCK(lock);
if (!client_info.get_sensor_id(handle, sensor_id)) {
- ERR("client %s failed to get handle information", get_client_name());
+ _E("client %s failed to get handle information", get_client_name());
return false;
}
- INFO("%s unregisters event %s[0x%x] for sensor %s[%d]", get_client_name(), get_event_name(event_type),
+ _I("%s unregisters event %s[0x%x] for sensor %s[%d]", get_client_name(), get_event_name(event_type),
event_type, get_sensor_name(sensor_id), handle);
client_info.get_sensor_rep(sensor_id, prev_rep);
client_info.get_event_info(handle, event_type, prev_interval, prev_latency, prev_cb_type, prev_cb, prev_user_data);
if (!client_info.unregister_event(handle, event_type)) {
- ERR("%s try to unregister non registered event %s[0x%x] for sensor %s[%d]",
+ _E("%s try to unregister non registered event %s[0x%x] for sensor %s[%d]",
get_client_name(),get_event_name(event_type), event_type, get_sensor_name(sensor_id), handle);
return false;
}
AUTOLOCK(lock);
if (!client_info.get_sensor_id(handle, sensor_id)) {
- ERR("client %s failed to get handle information", get_client_name());
+ _E("client %s failed to get handle information", get_client_name());
return false;
}
- INFO("%s registers accuracy_changed_cb for sensor %s[%d] with cb: 0x%x, user_data: 0x%x",
+ _I("%s registers accuracy_changed_cb for sensor %s[%d] with cb: 0x%x, user_data: 0x%x",
get_client_name(), get_sensor_name(sensor_id), handle, cb, user_data);
client_info.register_accuracy_cb(handle, cb , user_data);
AUTOLOCK(lock);
if (!client_info.get_sensor_id(handle, sensor_id)) {
- ERR("client %s failed to get handle information", get_client_name());
+ _E("client %s failed to get handle information", get_client_name());
return false;
}
- INFO("%s unregisters accuracy_changed_cb for sensor %s[%d]",
+ _I("%s unregisters accuracy_changed_cb for sensor %s[%d]",
get_client_name(), get_sensor_name(sensor_id), handle);
client_info.unregister_accuracy_cb(handle);
AUTOLOCK(lock);
if (!client_info.get_sensor_id(handle, sensor_id)) {
- ERR("client %s failed to get handle information", get_client_name());
+ _E("client %s failed to get handle information", get_client_name());
return false;
}
retvm_if ((option < 0) || (option >= SENSOR_OPTION_END), false, "Invalid option value : %d, handle: %d, %s, %s",
option, handle, get_sensor_name(sensor_id), get_client_name());
- INFO("%s starts %s[%d], with option: %d, power save state: %d", get_client_name(), get_sensor_name(sensor_id),
+ _I("%s starts %s[%d], with option: %d, power save state: %d", get_client_name(), get_sensor_name(sensor_id),
handle, option, g_power_save_state);
if (g_power_save_state && !(g_power_save_state & option)) {
if (!client_info.get_sensor_state(handle, sensor_state)||
!client_info.get_sensor_id(handle, sensor_id)) {
- ERR("client %s failed to get handle information", get_client_name());
+ _E("client %s failed to get handle information", get_client_name());
return false;
}
get_client_name(), get_sensor_name(sensor_id), handle);
- INFO("%s stops sensor %s[%d]", get_client_name(), get_sensor_name(sensor_id), handle);
+ _I("%s stops sensor %s[%d]", get_client_name(), get_sensor_name(sensor_id), handle);
client_info.get_sensor_rep(sensor_id, prev_rep);
client_info.get_sensor_params(handle, prev_state, prev_option);
AUTOLOCK(lock);
if (!client_info.get_sensor_id(handle, sensor_id)) {
- ERR("client %s failed to get handle information", get_client_name());
+ _E("client %s failed to get handle information", get_client_name());
return false;
}
- INFO("%s changes batch of event %s[0x%x] for %s[%d] to (%d, %d)", get_client_name(), get_event_name(event_type),
+ _I("%s changes batch of event %s[0x%x] for %s[%d] to (%d, %d)", get_client_name(), get_event_name(event_type),
event_type, get_sensor_name(sensor_id), handle, interval, latency);
client_info.get_sensor_rep(sensor_id, prev_rep);
AUTOLOCK(lock);
if (!client_info.get_event_info(handle, event_type, prev_interval, prev_latency, prev_cb_type, prev_cb, prev_user_data)) {
- ERR("Failed to get event info with handle = %d, event_type = 0x%x", handle, event_type);
+ _E("Failed to get event info with handle = %d, event_type = 0x%x", handle, event_type);
return false;
}
- INFO("handle = %d, event_type = 0x%x, interval = %d, prev_latency = %d", handle, event_type, interval, prev_latency);
+ _I("handle = %d, event_type = 0x%x, interval = %d, prev_latency = %d", handle, event_type, interval, prev_latency);
return change_event_batch(handle, event_type, interval, prev_latency);
}
AUTOLOCK(lock);
if (!client_info.get_event_info(handle, event_type, prev_interval, prev_latency, prev_cb_type, prev_cb, prev_user_data)) {
- ERR("Failed to get event info with handle = %d, event_type = 0x%x", handle, event_type);
+ _E("Failed to get event info with handle = %d, event_type = 0x%x", handle, event_type);
return false;
}
AUTOLOCK(lock);
if (!client_info.set_event_maincontext(handle, event_type, maincontext)) {
- ERR("Failed to get event info with handle = %d, event_type = 0x%x, maincontext = 0x%x", handle, event_type, maincontext);
+ _E("Failed to get event info with handle = %d, event_type = 0x%x, maincontext = 0x%x", handle, event_type, maincontext);
return false;
}
- INFO("handle = %d, event_type = 0x%x, maincontext = 0x%x", handle, event_type, maincontext);
+ _I("handle = %d, event_type = 0x%x, maincontext = 0x%x", handle, event_type, maincontext);
return true;
}
if (!client_info.get_sensor_state(handle, sensor_state)||
!client_info.get_sensor_id(handle, sensor_id)) {
- ERR("client %s failed to get handle information", get_client_name());
+ _E("client %s failed to get handle information", get_client_name());
return false;
}
AUTOLOCK(lock);
if (!client_info.get_sensor_id(handle, sensor_id)) {
- ERR("client %s failed to get handle information", get_client_name());
+ _E("client %s failed to get handle information", get_client_name());
return false;
}
client_info.set_sensor_wakeup(handle, wakeup);
if (!client_info.get_command_channel(sensor_id, &cmd_channel)) {
- ERR("client %s failed to get command channel for %s", get_client_name(), get_sensor_name(sensor_id));
+ _E("client %s failed to get command channel for %s", get_client_name(), get_sensor_name(sensor_id));
return false;
}
retvm_if ((client_id < 0), false, "Invalid client id : %d, handle: %d, %s, %s", client_id, handle, get_sensor_name(sensor_id), get_client_name());
if (!cmd_channel->cmd_set_wakeup(wakeup)) {
- ERR("Sending cmd_set_wakeup(%d, %s, %d) failed for %s", client_id, get_sensor_name(sensor_id), wakeup, get_client_name());
+ _E("Sending cmd_set_wakeup(%d, %s, %d) failed for %s", client_id, get_sensor_name(sensor_id), wakeup, get_client_name());
return false;
}
AUTOLOCK(lock);
if (!client_info.get_sensor_id(handle, sensor_id)) {
- ERR("client %s failed to get handle information", get_client_name());
+ _E("client %s failed to get handle information", get_client_name());
return false;
}
if (!client_info.get_command_channel(sensor_id, &cmd_channel)) {
- ERR("client %s failed to get command channel for %s", get_client_name(), get_sensor_name(sensor_id));
+ _E("client %s failed to get command channel for %s", get_client_name(), get_sensor_name(sensor_id));
return false;
}
client_id, handle, get_sensor_name(sensor_id), get_client_name());
if (!cmd_channel->cmd_set_attribute_int(attribute, value)) {
- ERR("Sending cmd_set_attribute_int(%d, %d) failed for %s",
+ _E("Sending cmd_set_attribute_int(%d, %d) failed for %s",
client_id, value, get_client_name);
return false;
}
AUTOLOCK(lock);
if (!client_info.get_sensor_id(handle, sensor_id)) {
- ERR("client %s failed to get handle information", get_client_name());
+ _E("client %s failed to get handle information", get_client_name());
return false;
}
if (!client_info.get_command_channel(sensor_id, &cmd_channel)) {
- ERR("client %s failed to get command channel for %s",
+ _E("client %s failed to get command channel for %s",
get_client_name(), get_sensor_name(sensor_id));
return false;
}
client_id, handle, get_sensor_name(sensor_id), get_client_name());
if (!cmd_channel->cmd_set_attribute_str(attribute, value, value_len)) {
- ERR("Sending cmd_set_attribute_str(%d, %d, 0x%x) failed for %s",
+ _E("Sending cmd_set_attribute_str(%d, %d, 0x%x) failed for %s",
client_id, value_len, value, get_client_name);
return false;
}
if (!client_info.get_sensor_state(handle, sensor_state)||
!client_info.get_sensor_id(handle, sensor_id)) {
- ERR("client %s failed to get handle information", get_client_name());
+ _E("client %s failed to get handle information", get_client_name());
return false;
}
if (!client_info.get_command_channel(sensor_id, &cmd_channel)) {
- ERR("client %s failed to get command channel for %s", get_client_name(), get_sensor_name(sensor_id));
+ _E("client %s failed to get command channel for %s", get_client_name(), get_sensor_name(sensor_id));
return false;
}
retvm_if ((client_id < 0), false, "Invalid client id : %d, handle: %d, %s, %s", client_id, handle, get_sensor_name(sensor_id), get_client_name());
if (sensor_state != SENSOR_STATE_STARTED) {
- ERR("Sensor %s is not started for client %s with handle: %d, sensor_state: %d", get_sensor_name(sensor_id), get_client_name(), handle, sensor_state);
+ _E("Sensor %s is not started for client %s with handle: %d, sensor_state: %d", get_sensor_name(sensor_id), get_client_name(), handle, sensor_state);
return false;
}
if(!cmd_channel->cmd_get_data(data_id, sensor_data)) {
- ERR("cmd_get_data(%d, %d, 0x%x) failed for %s", client_id, data_id, sensor_data, get_client_name());
+ _E("cmd_get_data(%d, %d, 0x%x) failed for %s", client_id, data_id, sensor_data, get_client_name());
return false;
}
auto iter = g_log_maps[id].find(type);
if (iter == g_log_maps[id].end()) {
- INFO("Unknown type value: 0x%x", type);
+ _I("Unknown type value: 0x%x", type);
return p_unknown;
}
return;
}
- INFO("%s receives %s with %s[%d][state: %d, option: %d count: %d]", get_client_name(), log_attr->name,
+ _I("%s receives %s with %s[%d][state: %d, option: %d count: %d]", get_client_name(), log_attr->name,
get_sensor_name(sensor_handle_info.m_sensor_id), sensor_handle_info.m_handle, sensor_handle_info.m_sensor_state,
sensor_handle_info.m_sensor_option, log_attr->cnt);
- INFO("0x%x(cb_event_type = %s, &user_data, client_data = 0x%x)\n", event_info->m_cb,
+ _I("0x%x(cb_event_type = %s, &user_data, client_data = 0x%x)\n", event_info->m_cb,
log_attr->name, event_info->m_user_data);
}
bool command_channel::command_handler(cpacket *packet, void **return_payload)
{
if (!m_command_socket.is_valid()) {
- ERR("Command socket(%d) is not valid for client %s", m_command_socket.get_socket_fd(), get_client_name());
+ _E("Command socket(%d) is not valid for client %s", m_command_socket.get_socket_fd(), get_client_name());
return false;
}
if (packet->size() == 0) {
- ERR("Packet is not valid for client %s", get_client_name());
+ _E("Packet is not valid for client %s", get_client_name());
return false;
}
if (m_command_socket.send(packet->packet(), packet->size()) <= 0) {
m_command_socket.close();
- ERR("Failed to send command in client %s", get_client_name());
+ _E("Failed to send command in client %s", get_client_name());
return false;
}
if (m_command_socket.recv(&header, sizeof(header)) <= 0) {
m_command_socket.close();
- ERR("Failed to receive header for reply packet in client %s", get_client_name());
+ _E("Failed to receive header for reply packet in client %s", get_client_name());
return false;
}
if (m_command_socket.recv(buffer, header.size) <= 0) {
m_command_socket.close();
- ERR("Failed to receive reply packet in client %s", get_client_name());
+ _E("Failed to receive reply packet in client %s", get_client_name());
delete[] buffer;
return false;
}
return false;
if (!m_command_socket.connect(COMMAND_CHANNEL_PATH)) {
- ERR("Failed to connect command channel for client %s, command socket fd[%d]", get_client_name(), m_command_socket.get_socket_fd());
+ _E("Failed to connect command channel for client %s, command socket fd[%d]", get_client_name(), m_command_socket.get_socket_fd());
return false;
}
get_proc_name(getpid(), cmd_get_id->name);
- INFO("%s send cmd_get_id()", get_client_name());
+ _I("%s send cmd_get_id()", get_client_name());
if (!command_handler(packet, (void **)&cmd_get_id_done)) {
- ERR("Client %s failed to send/receive command", get_client_name());
+ _E("Client %s failed to send/receive command", get_client_name());
delete packet;
return false;
}
if (cmd_get_id_done->client_id < 0) {
- ERR("Client %s failed to get client_id[%d] from server",
+ _E("Client %s failed to get client_id[%d] from server",
get_client_name(), cmd_get_id_done->client_id);
delete[] (char *)cmd_get_id_done;
delete packet;
packet.set_payload_size(sizeof(cmd_get_sensor_list_t));
packet.set_cmd(CMD_GET_SENSOR_LIST);
- INFO("%s send cmd_get_sensor_list", get_client_name());
+ _I("%s send cmd_get_sensor_list", get_client_name());
if (!command_handler(&packet, (void **)&cmd_get_sensor_list_done)) {
- ERR("Client %s failed to send/receive command", get_client_name());
+ _E("Client %s failed to send/receive command", get_client_name());
return false;
}
info = new(std::nothrow) sensor_info;
if (!info) {
- ERR("Failed to allocate memory");
+ _E("Failed to allocate memory");
delete[] (char *)cmd_get_sensor_list_done;
return false;
}
cmd_hello->client_id = m_client_id;
cmd_hello->sensor = sensor;
- INFO("%s send cmd_hello(client_id=%d, %s)",
+ _I("%s send cmd_hello(client_id=%d, %s)",
get_client_name(), m_client_id, get_sensor_name(sensor));
if (!command_handler(packet, (void **)&cmd_done)) {
- ERR("Client %s failed to send/receive command for sensor[%s]",
+ _E("Client %s failed to send/receive command for sensor[%s]",
get_client_name(), get_sensor_name(sensor));
delete packet;
return false;
}
if (cmd_done->value < 0) {
- ERR("client %s got error[%d] from server with sensor [%s]",
+ _E("client %s got error[%d] from server with sensor [%s]",
get_client_name(), cmd_done->value, get_sensor_name(sensor));
delete[] (char *)cmd_done;
packet->set_cmd(CMD_BYEBYE);
- INFO("%s send cmd_byebye(client_id=%d, %s)",
+ _I("%s send cmd_byebye(client_id=%d, %s)",
get_client_name(), m_client_id, get_sensor_name(m_sensor_id));
if (!command_handler(packet, (void **)&cmd_done)) {
- ERR("Client %s failed to send/receive command for sensor[%s] with client_id [%d]",
+ _E("Client %s failed to send/receive command for sensor[%s] with client_id [%d]",
get_client_name(), get_sensor_name(m_sensor_id), m_client_id);
delete packet;
return false;
}
if (cmd_done->value < 0) {
- ERR("Client %s got error[%d] from server for sensor[%s] with client_id [%d]",
+ _E("Client %s got error[%d] from server for sensor[%s] with client_id [%d]",
get_client_name(), cmd_done->value, get_sensor_name(m_sensor_id), m_client_id);
delete[] (char *)cmd_done;
packet->set_cmd(CMD_START);
- INFO("%s send cmd_start(client_id=%d, %s)",
+ _I("%s send cmd_start(client_id=%d, %s)",
get_client_name(), m_client_id, get_sensor_name(m_sensor_id));
if (!command_handler(packet, (void **)&cmd_done)) {
- ERR("Client %s failed to send/receive command for sensor[%s] with client_id [%d]",
+ _E("Client %s failed to send/receive command for sensor[%s] with client_id [%d]",
get_client_name(), get_sensor_name(m_sensor_id), m_client_id);
delete packet;
return false;
}
if (cmd_done->value < 0) {
- ERR("Client %s got error[%d] from server for sensor[%s] with client_id [%d]",
+ _E("Client %s got error[%d] from server for sensor[%s] with client_id [%d]",
get_client_name(), cmd_done->value, get_sensor_name(m_sensor_id), m_client_id);
delete[] (char *)cmd_done;
packet->set_cmd(CMD_STOP);
- INFO("%s send cmd_stop(client_id=%d, %s)",
+ _I("%s send cmd_stop(client_id=%d, %s)",
get_client_name(), m_client_id, get_sensor_name(m_sensor_id));
if (!command_handler(packet, (void **)&cmd_done)) {
- ERR("Client %s failed to send/receive command for sensor[%s] with client_id [%d]",
+ _E("Client %s failed to send/receive command for sensor[%s] with client_id [%d]",
get_client_name(), get_sensor_name(m_sensor_id), m_client_id);
delete packet;
return false;
}
if (cmd_done->value < 0) {
- ERR("Client %s got error[%d] from server for sensor[%s] with client_id [%d]",
+ _E("Client %s got error[%d] from server for sensor[%s] with client_id [%d]",
get_client_name(), cmd_done->value, get_sensor_name(m_sensor_id), m_client_id);
delete[] (char *)cmd_done;
cmd_set_option = (cmd_set_option_t*)packet->data();
cmd_set_option->option = option;
- INFO("%s send cmd_set_option(client_id=%d, %s, option=%d)",
+ _I("%s send cmd_set_option(client_id=%d, %s, option=%d)",
get_client_name(), m_client_id, get_sensor_name(m_sensor_id), option);
if (!command_handler(packet, (void **)&cmd_done)) {
- ERR("Client %s failed to send/receive command for sensor[%s] with client_id [%d], option[%d]",
+ _E("Client %s failed to send/receive command for sensor[%s] with client_id [%d], option[%d]",
get_client_name(), get_sensor_name(m_sensor_id), m_client_id, option);
delete packet;
return false;
}
if (cmd_done->value < 0) {
- ERR("Client %s got error[%d] from server for sensor[%s] with client_id [%d], option[%d]",
+ _E("Client %s got error[%d] from server for sensor[%s] with client_id [%d], option[%d]",
get_client_name(), cmd_done->value, get_sensor_name(m_sensor_id), m_client_id, option);
delete[] (char *)cmd_done;
cmd_set_wakeup = (cmd_set_wakeup_t*)packet->data();
cmd_set_wakeup->wakeup = wakeup;
- INFO("%s send cmd_set_wakeup(client_id=%d, %s, wakeup=%d)",
+ _I("%s send cmd_set_wakeup(client_id=%d, %s, wakeup=%d)",
get_client_name(), m_client_id, get_sensor_name(m_sensor_id), wakeup);
if (!command_handler(packet, (void **)&cmd_done)) {
- ERR("Client %s failed to send/receive command for sensor[%s] with client_id [%d], wakeup[%d]",
+ _E("Client %s failed to send/receive command for sensor[%s] with client_id [%d], wakeup[%d]",
get_client_name(), get_sensor_name(m_sensor_id), m_client_id, wakeup);
delete packet;
return false;
}
if (cmd_done->value < 0) {
- ERR("Client %s got error[%d] from server for sensor[%s] with client_id [%d], wakeup[%d]",
+ _E("Client %s got error[%d] from server for sensor[%s] with client_id [%d], wakeup[%d]",
get_client_name(), cmd_done->value, get_sensor_name(m_sensor_id), m_client_id, wakeup);
delete[] (char *)cmd_done;
cmd_reg = (cmd_reg_t*)packet->data();
cmd_reg->event_type = event_type;
- INFO("%s send cmd_register_event(client_id=%d, %s)",
+ _I("%s send cmd_register_event(client_id=%d, %s)",
get_client_name(), m_client_id, get_event_name(event_type));
if (!command_handler(packet, (void **)&cmd_done)) {
- ERR("Client %s failed to send/receive command with client_id [%d], event_type[%s]",
+ _E("Client %s failed to send/receive command with client_id [%d], event_type[%s]",
get_client_name(), m_client_id, get_event_name(event_type));
delete packet;
return false;
}
if (cmd_done->value < 0) {
- ERR("Client %s got error[%d] from server with client_id [%d], event_type[%s]",
+ _E("Client %s got error[%d] from server with client_id [%d], event_type[%s]",
get_client_name(), cmd_done->value, m_client_id, get_event_name(event_type));
delete[] (char *)cmd_done;
cmd_unreg = (cmd_unreg_t*)packet->data();
cmd_unreg->event_type = event_type;
- INFO("%s send cmd_unregister_event(client_id=%d, %s)",
+ _I("%s send cmd_unregister_event(client_id=%d, %s)",
get_client_name(), m_client_id, get_event_name(event_type));
if (!command_handler(packet, (void **)&cmd_done)) {
- ERR("Client %s failed to send/receive command with client_id [%d], event_type[%s]",
+ _E("Client %s failed to send/receive command with client_id [%d], event_type[%s]",
get_client_name(), m_client_id, get_event_name(event_type));
delete packet;
return false;
}
if (cmd_done->value < 0) {
- ERR("Client %s got error[%d] from server with client_id [%d], event_type[%s]",
+ _E("Client %s got error[%d] from server with client_id [%d], event_type[%s]",
get_client_name(), cmd_done->value, m_client_id, get_event_name(event_type));
delete[] (char *)cmd_done;
cmd_set_batch->interval = interval;
cmd_set_batch->latency = latency;
- INFO("%s send cmd_set_batch(client_id=%d, %s, interval=%d, latency = %d)",
+ _I("%s send cmd_set_batch(client_id=%d, %s, interval=%d, latency = %d)",
get_client_name(), m_client_id, get_sensor_name(m_sensor_id), interval, latency);
if (!command_handler(packet, (void **)&cmd_done)) {
- ERR("%s failed to send/receive command for sensor[%s] with client_id [%d], interval[%d], latency[%d]",
+ _E("%s failed to send/receive command for sensor[%s] with client_id [%d], interval[%d], latency[%d]",
get_client_name(), get_sensor_name(m_sensor_id), m_client_id, interval, latency);
delete packet;
return false;
}
if (cmd_done->value < 0) {
- ERR("%s got error[%d] from server for sensor[%s] with client_id [%d], interval[%d], latency[%d]",
+ _E("%s got error[%d] from server for sensor[%s] with client_id [%d], interval[%d], latency[%d]",
get_client_name(), cmd_done->value, get_sensor_name(m_sensor_id), m_client_id, interval, latency);
delete[] (char *)cmd_done;
packet->set_cmd(CMD_UNSET_BATCH);
- INFO("%s send cmd_unset_batch(client_id=%d, %s)",
+ _I("%s send cmd_unset_batch(client_id=%d, %s)",
get_client_name(), m_client_id, get_sensor_name(m_sensor_id));
if (!command_handler(packet, (void **)&cmd_done)) {
- ERR("Client %s failed to send/receive command for sensor[%s] with client_id [%d]",
+ _E("Client %s failed to send/receive command for sensor[%s] with client_id [%d]",
get_client_name(), get_sensor_name(m_sensor_id), m_client_id);
delete packet;
return false;
}
if (cmd_done->value < 0) {
- ERR("Client %s got error[%d] from server for sensor[%s] with client_id [%d]",
+ _E("Client %s got error[%d] from server for sensor[%s] with client_id [%d]",
get_client_name(), cmd_done->value, get_sensor_name(m_sensor_id), m_client_id);
delete[] (char *)cmd_done;
cmd_get_data->type = type;
if (!command_handler(packet, (void **)&cmd_get_data_done)) {
- ERR("Client %s failed to send/receive command with client_id [%d], data_id[%s]",
+ _E("Client %s failed to send/receive command with client_id [%d], data_id[%s]",
get_client_name(), m_client_id, get_data_name(type));
delete packet;
return false;
}
if (cmd_get_data_done->state < 0 ) {
- ERR("Client %s got error[%d] from server with client_id [%d], data_id[%s]",
+ _E("Client %s got error[%d] from server with client_id [%d], data_id[%s]",
get_client_name(), cmd_get_data_done->state, m_client_id, get_data_name(type));
sensor_data->accuracy = SENSOR_ACCURACY_UNDEFINED;
sensor_data->timestamp = 0;
cmd_set_attribute_int->attribute = attribute;
cmd_set_attribute_int->value = value;
- INFO("%s send cmd_set_attribute_int(client_id=%d, %s, 0x%x, %d)",
+ _I("%s send cmd_set_attribute_int(client_id=%d, %s, 0x%x, %d)",
get_client_name(), m_client_id, get_sensor_name(m_sensor_id), attribute, value);
if (!command_handler(packet, (void **)&cmd_done)) {
- ERR("Client %s failed to send/receive command for sensor[%s] with client_id [%d], property[0x%x], value[%d]",
+ _E("Client %s failed to send/receive command for sensor[%s] with client_id [%d], property[0x%x], value[%d]",
get_client_name(), get_sensor_name(m_sensor_id), m_client_id, attribute, value);
delete packet;
return false;
}
if (cmd_done->value < 0) {
- ERR("Client %s got error[%d] from server for sensor[%s] with property[0x%x], value[%d]",
+ _E("Client %s got error[%d] from server for sensor[%s] with property[0x%x], value[%d]",
get_client_name(), cmd_done->value, get_sensor_name(m_sensor_id), attribute, value);
delete[] (char *)cmd_done;
cmd_set_attribute_str->value_len = value_len;
memcpy(cmd_set_attribute_str->value, value, value_len);
- INFO("%s send cmd_set_attribute_str(client_id=%d, value_len = %d, buffer = 0x%x)",
+ _I("%s send cmd_set_attribute_str(client_id=%d, value_len = %d, buffer = 0x%x)",
get_client_name(), m_client_id, value_len, value);
if (!command_handler(packet, (void **)&cmd_done)) {
- ERR("%s failed to send/receive command with client_id [%d]",
+ _E("%s failed to send/receive command with client_id [%d]",
get_client_name(), m_client_id);
delete packet;
return false;
}
if (cmd_done->value < 0) {
- ERR("%s got error[%d] from server with client_id [%d]",
+ _E("%s got error[%d] from server with client_id [%d]",
get_client_name(), cmd_done->value, m_client_id);
delete[] (char *)cmd_done;
handle++;
if (handle == MAX_HANDLE) {
- ERR("Handles of client %s are full", get_client_name());
+ _E("Handles of client %s are full", get_client_name());
return MAX_HANDLE_REACHED;
}
auto it_handle = m_sensor_handle_infos.find(handle);
if (it_handle == m_sensor_handle_infos.end()) {
- ERR("Handle[%d] is not found for client %s", handle, get_client_name());
+ _E("Handle[%d] is not found for client %s", handle, get_client_name());
return false;
}
auto it_handle = m_sensor_handle_infos.find(handle);
if (it_handle == m_sensor_handle_infos.end()) {
- ERR("Handle[%d] is not found for client %s", handle, get_client_name());
+ _E("Handle[%d] is not found for client %s", handle, get_client_name());
return false;
}
auto it_handle = m_sensor_handle_infos.find(handle);
if (it_handle == m_sensor_handle_infos.end()) {
- ERR("Handle[%d] is not found for client %s", handle, get_client_name());
+ _E("Handle[%d] is not found for client %s", handle, get_client_name());
return false;
}
auto it_handle = m_sensor_handle_infos.find(handle);
if (it_handle == m_sensor_handle_infos.end()) {
- ERR("Handle[%d] is not found for client %s", handle, get_client_name());
+ _E("Handle[%d] is not found for client %s", handle, get_client_name());
return false;
}
auto it_handle = m_sensor_handle_infos.find(handle);
if (it_handle == m_sensor_handle_infos.end()) {
- ERR("Handle[%d] is not found for client %s", handle, get_client_name());
+ _E("Handle[%d] is not found for client %s", handle, get_client_name());
return false;
}
auto it_handle = m_sensor_handle_infos.find(handle);
if (it_handle == m_sensor_handle_infos.end()) {
- ERR("Handle[%d] is not found for client %s", handle, get_client_name());
+ _E("Handle[%d] is not found for client %s", handle, get_client_name());
return false;
}
auto it_handle = m_sensor_handle_infos.find(handle);
if (it_handle == m_sensor_handle_infos.end()) {
- ERR("Handle[%d] is not found for client %s", handle, get_client_name());
+ _E("Handle[%d] is not found for client %s", handle, get_client_name());
return false;
}
auto it_handle = m_sensor_handle_infos.find(handle);
if (it_handle == m_sensor_handle_infos.end()) {
- ERR("Handle[%d] is not found for client %s", handle, get_client_name());
+ _E("Handle[%d] is not found for client %s", handle, get_client_name());
return false;
}
auto it_handle = m_sensor_handle_infos.find(handle);
if (it_handle == m_sensor_handle_infos.end()) {
- ERR("Handle[%d] is not found for client %s", handle, get_client_name());
+ _E("Handle[%d] is not found for client %s", handle, get_client_name());
return false;
}
auto it_handle = m_sensor_handle_infos.find(handle);
if (it_handle == m_sensor_handle_infos.end()) {
- ERR("Handle[%d] is not found for client %s", handle, get_client_name());
+ _E("Handle[%d] is not found for client %s", handle, get_client_name());
return false;
}
auto it_handle = m_sensor_handle_infos.find(handle);
if (it_handle == m_sensor_handle_infos.end()) {
- ERR("Handle[%d] is not found for client %s", handle, get_client_name());
+ _E("Handle[%d] is not found for client %s", handle, get_client_name());
return false;
}
auto it_handle = m_sensor_handle_infos.find(handle);
if (it_handle == m_sensor_handle_infos.end()) {
- ERR("Handle[%d] is not found for client %s", handle, get_client_name());
+ _E("Handle[%d] is not found for client %s", handle, get_client_name());
return false;
}
auto it_handle = m_sensor_handle_infos.find(handle);
if (it_handle == m_sensor_handle_infos.end()) {
- ERR("Handle[%d] is not found for client %s", handle, get_client_name());
+ _E("Handle[%d] is not found for client %s", handle, get_client_name());
return false;
}
auto it_handle = m_sensor_handle_infos.find(handle);
if (it_handle == m_sensor_handle_infos.end()) {
- ERR("Handle[%d] is not found for client %s", handle, get_client_name());
+ _E("Handle[%d] is not found for client %s", handle, get_client_name());
return false;
}
auto it_channel = m_command_channels.find(sensor);
if (it_channel != m_command_channels.end()) {
- ERR("%s alreay has command_channel for %s", get_client_name(), get_sensor_name(sensor));
+ _E("%s alreay has command_channel for %s", get_client_name(), get_sensor_name(sensor));
return false;
}
auto it_channel = m_command_channels.find(sensor);
if (it_channel == m_command_channels.end()) {
- ERR("%s doesn't have command_channel for %s", get_client_name(), get_sensor_name(sensor));
+ _E("%s doesn't have command_channel for %s", get_client_name(), get_sensor_name(sensor));
return false;
}
auto it_channel = m_command_channels.find(sensor_id);
if (it_channel == m_command_channels.end()) {
- ERR("%s doesn't have command_channel for %s", get_client_name(), get_sensor_name(sensor_id));
+ _E("%s doesn't have command_channel for %s", get_client_name(), get_sensor_name(sensor_id));
return false;
}
}
if (!active_sensor_found) {
- DBG("Active sensor[0x%llx] is not found for client %s", sensor, get_client_name());
+ _D("Active sensor[0x%llx] is not found for client %s", sensor, get_client_name());
return false;
}
}
if (!active_sensor_found)
- DBG("Active sensor[0x%llx] is not found for client %s", sensor, get_client_name());
+ _D("Active sensor[0x%llx] is not found for client %s", sensor, get_client_name());
return active_option;
}
auto it_handle = m_sensor_handle_infos.find(handle);
if (it_handle == m_sensor_handle_infos.end()) {
- ERR("Handle[%d] is not found for client %s", handle, get_client_name());
+ _E("Handle[%d] is not found for client %s", handle, get_client_name());
return false;
}
auto it_handle = m_sensor_handle_infos.find(handle);
if (it_handle == m_sensor_handle_infos.end()) {
- ERR("Handle[%d] is not found for client %s", handle, get_client_name());
+ _E("Handle[%d] is not found for client %s", handle, get_client_name());
return false;
}
auto it_handle = m_sensor_handle_infos.find(handle);
if (it_handle == m_sensor_handle_infos.end()) {
- ERR("Handle[%d] is not found for client %s", handle, get_client_name());
+ _E("Handle[%d] is not found for client %s", handle, get_client_name());
return false;
}
auto it_handle = m_sensor_handle_infos.find(handle);
if (it_handle == m_sensor_handle_infos.end()) {
- ERR("Handle[%d] is not found for client %s", handle, get_client_name());
+ _E("Handle[%d] is not found for client %s", handle, get_client_name());
return false;
}
!(it_handle->second.m_sensor_option & power_save_state)) {
m_client_info.set_sensor_state(it_handle->first, SENSOR_STATE_PAUSED);
- INFO("%s's %s[%d] is paused", get_client_name(), get_sensor_name(sensor), it_handle->first);
+ _I("%s's %s[%d] is paused", get_client_name(), get_sensor_name(sensor), it_handle->first);
} else if ((it_handle->second.m_sensor_state == SENSOR_STATE_PAUSED) &&
(!power_save_state || (it_handle->second.m_sensor_option & power_save_state))) {
m_client_info.set_sensor_state(it_handle->first, SENSOR_STATE_STARTED);
- INFO("%s's %s[%d] is resumed", get_client_name(), get_sensor_name(sensor), it_handle->first);
+ _I("%s's %s[%d] is resumed", get_client_name(), get_sensor_name(sensor), it_handle->first);
}
}
callback_info = get_callback_info(sensor_id, event_info, sensor_data, event);
if (!callback_info) {
- ERR("Failed to get callback_info");
+ _E("Failed to get callback_info");
continue;
}
else if (cb_info->cb_type == SENSOR_LEGACY_CB)
((sensor_legacy_cb_t) cb_info->cb)(cb_info->event_type, (sensor_event_data_t *) cb_info->sensor_data, cb_info->user_data);
} else {
- WARN("Discard invalid callback cb(0x%x)(%s, 0x%x, 0x%x) with id: %llu",
+ _W("Discard invalid callback cb(0x%x)(%s, 0x%x, 0x%x) with id: %llu",
cb_info->cb, get_event_name(cb_info->event_type), cb_info->sensor_data,
cb_info->user_data, cb_info->event_id);
}
len = m_event_socket.recv(buffer, buffer_len);
if (!len) {
- INFO("%s failed to read after poll!", get_client_name());
+ _I("%s failed to read after poll!", get_client_name());
return -1;
}
}
if (len < 0) {
- INFO("%s failed to recv event from event socket", get_client_name());
+ _I("%s failed to recv event from event socket", get_client_name());
return -1;
}
void *buffer = malloc(EVENT_BUFFER_SIZE);
if (!buffer) {
- ERR("Failed to allocate memory");
+ _E("Failed to allocate memory");
break;
}
len = sensor_event_poll(buffer, EVENT_BUFFER_SIZE, event);
if (len <= 0) {
- INFO("sensor_event_poll failed");
+ _I("sensor_event_poll failed");
free(buffer);
break;
}
void *buffer_shrinked = realloc(buffer, len);
if (!buffer_shrinked) {
- ERR("Failed to allocate memory");
+ _E("Failed to allocate memory");
free(buffer);
break;
}
m_thread_cond.notify_one();
}
- INFO("Event listener thread is terminated.");
+ _I("Event listener thread is terminated.");
if (m_client_info.has_client_id() && (event.events & EPOLLHUP)) {
if (m_hup_observer)
return false;
if (!m_event_socket.connect(EVENT_CHANNEL_PATH)) {
- ERR("Failed to connect event channel for client %s, event socket fd[%d]", get_client_name(), m_event_socket.get_socket_fd());
+ _E("Failed to connect event channel for client %s, event socket fd[%d]", get_client_name(), m_event_socket.get_socket_fd());
return false;
}
if (!m_event_socket.set_connection_mode()) {
- ERR("Failed to set connection mode for client %s", get_client_name());
+ _E("Failed to set connection mode for client %s", get_client_name());
return false;
}
client_id = m_client_info.get_client_id();
if (m_event_socket.send(&client_id, sizeof(client_id)) <= 0) {
- ERR("Failed to send client id for client %s on event socket[%d]", get_client_name(), m_event_socket.get_socket_fd());
+ _E("Failed to send client id for client %s on event socket[%d]", get_client_name(), m_event_socket.get_socket_fd());
return false;
}
if (m_event_socket.recv(&event_channel_ready, sizeof(event_channel_ready)) <= 0) {
- ERR("%s failed to recv event_channel_ready packet on event socket[%d] with client id [%d]",
+ _E("%s failed to recv event_channel_ready packet on event socket[%d] with client id [%d]",
get_client_name(), m_event_socket.get_socket_fd(), client_id);
return false;
}
if ((event_channel_ready.magic != EVENT_CHANNEL_MAGIC) || (event_channel_ready.client_id != client_id)) {
- ERR("Event_channel_ready packet is wrong, magic = 0x%x, client id = %d",
+ _E("Event_channel_ready packet is wrong, magic = 0x%x, client id = %d",
event_channel_ready.magic, event_channel_ready.client_id);
return false;
}
- INFO("Event channel is established for client %s on socket[%d] with client id : %d",
+ _I("Event channel is established for client %s on socket[%d] with client id : %d",
get_client_name(), m_event_socket.get_socket_fd(), client_id);
return true;
if (m_thread_state != THREAD_STATE_TERMINATE) {
m_thread_state = THREAD_STATE_STOP;
- DBG("%s is waiting listener thread[state: %d] to be terminated", get_client_name(), m_thread_state);
+ _D("%s is waiting listener thread[state: %d] to be terminated", get_client_name(), m_thread_state);
if (m_thread_cond.wait_for(u, std::chrono::seconds(THREAD_TERMINATING_TIMEOUT))
== std::cv_status::timeout)
- ERR("Fail to stop listener thread after waiting %d seconds", THREAD_TERMINATING_TIMEOUT);
+ _E("Fail to stop listener thread after waiting %d seconds", THREAD_TERMINATING_TIMEOUT);
else
- DBG("Listener thread for %s is terminated", get_client_name());
+ _D("Listener thread for %s is terminated", get_client_name());
}
}
bool sensor_event_listener::start_event_listener(void)
{
if (!create_event_channel()) {
- ERR("Event channel is not established for %s", get_client_name());
+ _E("Event channel is not established for %s", get_client_name());
return false;
}
auto it_event = m_reg_event_infos.find(event_type);
if (it_event == m_reg_event_infos.end()) {
- DBG("Event %s[0x%x] is not registered for client %s", get_event_name(event_type), event_type, get_client_name());
+ _D("Event %s[0x%x] is not registered for client %s", get_event_name(event_type), event_type, get_client_name());
return NULL;
}
auto it_event = m_reg_event_infos.find(event_type);
if (it_event != m_reg_event_infos.end()) {
- ERR("Event %s[0x%x] is already registered for client %s", get_event_name(event_type), event_type, get_client_name());
+ _E("Event %s[0x%x] is already registered for client %s", get_event_name(event_type), event_type, get_client_name());
return false;
}
auto it_event = m_reg_event_infos.find(event_type);
if (it_event == m_reg_event_infos.end()) {
- ERR("Event %s[0x%x] is not registered for client %s", get_event_name(event_type), event_type, get_client_name());
+ _E("Event %s[0x%x] is not registered for client %s", get_event_name(event_type), event_type, get_client_name());
return false;
}
auto it_event = m_reg_event_infos.find(event_type);
if (it_event == m_reg_event_infos.end()) {
- ERR("Event %s[0x%x] is not registered for client %s", get_event_name(event_type), event_type, get_client_name());
+ _E("Event %s[0x%x] is not registered for client %s", get_event_name(event_type), event_type, get_client_name());
return false;
}
auto it_event = m_reg_event_infos.find(event_type);
if (it_event == m_reg_event_infos.end()) {
- ERR("Event %s[0x%x] is not registered for client %s", get_event_name(event_type), event_type, get_client_name());
+ _E("Event %s[0x%x] is not registered for client %s", get_event_name(event_type), event_type, get_client_name());
return false;
}
void sensor_handle_info::get_batch(unsigned int &interval, unsigned int &latency)
{
if (m_reg_event_infos.empty()) {
- DBG("No events are registered for client %s", get_client_name());
+ _D("No events are registered for client %s", get_client_name());
interval = POLL_MAX_HZ_MS;
latency = 0;
return;
auto it_record = m_clients.find(client_id);
if (it_record == m_clients.end()) {
- ERR("Client[%d] is not found", client_id);
+ _E("Client[%d] is not found", client_id);
return false;
}
auto it_record = m_clients.find(client_id);
if (it_record == m_clients.end()) {
- ERR("Client[%d] is not found", client_id);
+ _E("Client[%d] is not found", client_id);
return false;
}
auto it_record = m_clients.find(client_id);
if (it_record == m_clients.end()) {
- ERR("Client[%d] is not found", client_id);
+ _E("Client[%d] is not found", client_id);
return false;
}
auto it_record = m_clients.find(client_id);
if (it_record == m_clients.end()) {
- ERR("Client[%d] is not found", client_id);
+ _E("Client[%d] is not found", client_id);
return false;
}
auto it_record = m_clients.find(client_id);
if (it_record == m_clients.end()) {
- ERR("Client[%d] is not found", client_id);
+ _E("Client[%d] is not found", client_id);
return false;
}
auto it_record = m_clients.find(client_id);
if (it_record == m_clients.end()) {
- ERR("Client[%d] is not found", client_id);
+ _E("Client[%d] is not found", client_id);
return false;
}
auto it_record = m_clients.find(client_id);
if (it_record == m_clients.end()) {
- ERR("Client[%d] is not found", client_id);
+ _E("Client[%d] is not found", client_id);
return false;
}
auto it_record = m_clients.find(client_id);
if (it_record == m_clients.end()) {
- ERR("Client[%d] is not found", client_id);
+ _E("Client[%d] is not found", client_id);
return false;
}
auto it_record = m_clients.find(client_id);
if (it_record == m_clients.end()) {
- ERR("Client[%d] is not found", client_id);
+ _E("Client[%d] is not found", client_id);
return false;
}
client_id++;
if (client_id == MAX_HANDLE) {
- ERR("Sensor records of clients are full");
+ _E("Sensor records of clients are full");
return MAX_HANDLE_REACHED;
}
auto it_record = m_clients.find(client_id);
if (it_record == m_clients.end()) {
- ERR("Client[%d] is not found", client_id);
+ _E("Client[%d] is not found", client_id);
return false;
}
m_clients.erase(it_record);
- INFO("Client record for client[%d] is removed from client info manager", client_id);
+ _I("Client record for client[%d] is removed from client info manager", client_id);
return true;
}
auto it_record = m_clients.find(client_id);
if (it_record == m_clients.end()) {
- ERR("Client[%d] is not found", client_id);
+ _E("Client[%d] is not found", client_id);
return;
}
auto it_record = m_clients.find(client_id);
if (it_record == m_clients.end()) {
- DBG("Client[%d] is not found", client_id);
+ _D("Client[%d] is not found", client_id);
return NULL;
}
auto it_record = m_clients.find(client_id);
if (it_record == m_clients.end()) {
- DBG("Client[%d] is not found", client_id);
+ _D("Client[%d] is not found", client_id);
return false;
}
auto it_record = m_clients.find(client_id);
if (it_record == m_clients.end()) {
- DBG("Client[%d] is not found", client_id);
+ _D("Client[%d] is not found", client_id);
return false;
}
auto it_record = m_clients.find(client_id);
if (it_record == m_clients.end()) {
- ERR("Client record[%d] is not registered", client_id);
+ _E("Client record[%d] is not registered", client_id);
return false;
}
auto it_record = m_clients.find(client_id);
if (it_record == m_clients.end()) {
- ERR("Client[%d] is not found", client_id);
+ _E("Client[%d] is not found", client_id);
return false;
}
auto it_record = m_clients.find(client_id);
if (it_record == m_clients.end()) {
- DBG("Client[%d] is not found", client_id);
+ _D("Client[%d] is not found", client_id);
return false;
}
auto it_record = m_clients.find(client_id);
if (it_record == m_clients.end()) {
- DBG("Client[%d] is not found", client_id);
+ _D("Client[%d] is not found", client_id);
return false;
}
auto it_record = m_clients.find(client_id);
if (it_record == m_clients.end()) {
- ERR("Client[%d] is not found", client_id);
+ _E("Client[%d] is not found", client_id);
return false;
}
auto it_record = m_clients.find(client_id);
if (it_record == m_clients.end()) {
- ERR("Client[%d] is not found", client_id);
+ _E("Client[%d] is not found", client_id);
return false;
}
}
if (!it_usage->second.register_event(event_type)) {
- ERR("Event[0x%x] is already registered", event_type);
+ _E("Event[0x%x] is already registered", event_type);
return false;
}
auto it_usage = m_sensor_usages.find(sensor_id);
if (it_usage == m_sensor_usages.end()) {
- ERR("Sensor[0x%x] is not registered", sensor_id);
+ _E("Sensor[0x%x] is not registered", sensor_id);
return false;
}
if (!it_usage->second.unregister_event(event_type)) {
- ERR("Event[0x%x] is already registered", event_type);
+ _E("Event[0x%x] is already registered", event_type);
return false;
}
auto it_usage = m_sensor_usages.find(sensor_id);
if (it_usage == m_sensor_usages.end()) {
- ERR("Sensor[0x%x] is not found", sensor_id);
+ _E("Sensor[0x%x] is not found", sensor_id);
return false;
}
auto it_usage = m_sensor_usages.find(sensor_id);
if (it_usage != m_sensor_usages.end()) {
- ERR("Sensor[0x%x] is already registered", sensor_id);
+ _E("Sensor[0x%x] is already registered", sensor_id);
return false;
}
auto it_usage = m_sensor_usages.find(sensor_id);
if (it_usage == m_sensor_usages.end()) {
- ERR("Sensor[0x%x] is not found", sensor_id);
+ _E("Sensor[0x%x] is not found", sensor_id);
return false;
}
m_sensor_usages.erase(it_usage);
auto it_usage = m_sensor_usages.find(sensor_id);
if (it_usage == m_sensor_usages.end()) {
- DBG("Sensor[0x%x] is not found", sensor_id);
+ _D("Sensor[0x%x] is not found", sensor_id);
return false;
}
auto it_usage = m_sensor_usages.find(sensor_id);
if (it_usage == m_sensor_usages.end()) {
- DBG("Sensor[0x%x] is not found", sensor_id);
+ _D("Sensor[0x%x] is not found", sensor_id);
return false;
}
if (inst->m_socket.recv(&header, sizeof(header)) <= 0) {
string info;
inst->get_info(info);
- DBG("%s failed to receive header", info.c_str());
+ _D("%s failed to receive header", info.c_str());
return false;
}
if (inst->m_socket.recv(payload, header.size) <= 0) {
string info;
inst->get_info(info);
- DBG("%s failed to receive data of packet", info.c_str());
+ _D("%s failed to receive data of packet", info.c_str());
delete[] payload;
return false;
}
command_worker *inst = (command_worker *)ctx;
inst->get_info(info);
- INFO("%s is stopped", info.c_str());
+ _I("%s is stopped", info.c_str());
if ((inst->m_module) && (inst->m_client_id != CLIENT_ID_INVALID)) {
if (get_client_info_manager().is_started(inst->m_client_id, inst->m_sensor_id)) {
- WARN("Does not receive cmd_stop before connection broken for [%s]!!", inst->m_module->get_name());
+ _W("Does not receive cmd_stop before connection broken for [%s]!!", inst->m_module->get_name());
inst->m_module->delete_interval(inst->m_client_id, false);
inst->m_module->stop();
}
if (inst->m_sensor_id) {
if (get_client_info_manager().has_sensor_record(inst->m_client_id, inst->m_sensor_id)) {
- INFO("Removing sensor[0x%llx] record for client_id[%d]", inst->m_sensor_id, inst->m_client_id);
+ _I("Removing sensor[0x%llx] record for client_id[%d]", inst->m_sensor_id, inst->m_client_id);
get_client_info_manager().remove_sensor_record(inst->m_client_id, inst->m_sensor_id);
}
}
int ret = false;
if (!(cmd > 0 && cmd < CMD_CNT)) {
- ERR("Unknown command: %d", cmd);
+ _E("Unknown command: %d", cmd);
} else {
cmd_handler_t cmd_handler;
cmd_handler = command_worker::m_cmd_handlers[cmd];
cmd_done->value = value;
if (m_socket.send(ret_packet->packet(), ret_packet->size()) <= 0) {
- ERR("Failed to send a cmd_done to client_id [%d] with value [%ld]", m_client_id, value);
+ _E("Failed to send a cmd_done to client_id [%d] with value [%ld]", m_client_id, value);
delete ret_packet;
return false;
}
cmd_get_id_done->client_id = client_id;
if (m_socket.send(ret_packet->packet(), ret_packet->size()) <= 0) {
- ERR("Failed to send a cmd_get_id_done with client_id [%d]", client_id);
+ _E("Failed to send a cmd_get_id_done with client_id [%d]", client_id);
delete ret_packet;
return false;
}
memcpy(&cmd_get_data_done->base_data , data, sizeof(sensor_data_t));
if (m_socket.send(ret_packet->packet(), ret_packet->size()) <= 0) {
- ERR("Failed to send a cmd_get_data_done");
+ _E("Failed to send a cmd_get_data_done");
delete ret_packet;
return false;
}
int permission = get_permission();
- INFO("permission = 0x%x", permission);
+ _I("permission = 0x%x", permission);
get_sensor_list(permission, sensor_list);
if (m_socket.send(sensor_list.packet(), sensor_list.size()) <= 0) {
- ERR("Failed to send a cmd_get_sensor_list_done");
+ _E("Failed to send a cmd_get_sensor_list_done");
return false;
}
struct ucred cr;
socklen_t opt_len = sizeof(cr);
- DBG("CMD_GET_ID Handler invoked\n");
+ _D("CMD_GET_ID Handler invoked\n");
cmd = (cmd_get_id_t*)payload;
if (getsockopt(m_socket.get_socket_fd(), SOL_SOCKET, SO_PEERCRED, &cr, &opt_len)) {
- ERR("Failed to get socket option with SO_PEERCRED");
+ _E("Failed to get socket option with SO_PEERCRED");
return false;
}
m_permission = get_permission();
get_client_info_manager().set_permission(client_id, m_permission);
- INFO("New client id [%d] created", client_id);
+ _I("New client id [%d] created", client_id);
if (!send_cmd_get_id_done(client_id))
- ERR("Failed to send cmd_done to a client");
+ _E("Failed to send cmd_done to a client");
return true;
}
bool command_worker::cmd_get_sensor_list(void *payload)
{
- DBG("CMD_GET_SENSOR_LIST Handler invoked\n");
+ _D("CMD_GET_SENSOR_LIST Handler invoked\n");
if (!send_cmd_get_sensor_list_done())
- ERR("Failed to send cmd_get_sensor_list_done to a client");
+ _E("Failed to send cmd_get_sensor_list_done to a client");
return true;
}
cmd_hello_t *cmd;
long ret_value = OP_ERROR;
- DBG("CMD_HELLO Handler invoked\n");
+ _D("CMD_HELLO Handler invoked\n");
cmd = (cmd_hello_t*)payload;
m_sensor_id = cmd->sensor;
m_module = (sensor_base *)sensor_loader::get_instance().get_sensor(cmd->sensor);
if (!m_module) {
- ERR("Sensor type[%d] is not supported", cmd->sensor);
+ _E("Sensor type[%d] is not supported", cmd->sensor);
if (!get_client_info_manager().has_sensor_record(m_client_id))
get_client_info_manager().remove_client_record(m_client_id);
}
if (!is_permission_allowed()) {
- ERR("Permission denied to connect sensor[0x%llx] for client [%d]", m_sensor_id, m_client_id);
+ _E("Permission denied to connect sensor[0x%llx] for client [%d]", m_sensor_id, m_client_id);
ret_value = OP_ERROR;
goto out;
}
- DBG("Hello sensor [0x%llx], client id [%d]", m_sensor_id, m_client_id);
+ _D("Hello sensor [0x%llx], client id [%d]", m_sensor_id, m_client_id);
get_client_info_manager().create_sensor_record(m_client_id, m_sensor_id);
- INFO("New sensor record created for sensor [0x%llx], sensor name [%s] on client id [%d]\n", m_sensor_id, m_module->get_name(), m_client_id);
+ _I("New sensor record created for sensor [0x%llx], sensor name [%s] on client id [%d]\n", m_sensor_id, m_module->get_name(), m_client_id);
ret_value = OP_SUCCESS;
out:
if (!send_cmd_done(ret_value))
- ERR("Failed to send cmd_done to a client");
+ _E("Failed to send cmd_done to a client");
return true;
}
long ret_value = OP_ERROR;
if (!is_permission_allowed()) {
- ERR("Permission denied to stop sensor[0x%llx] for client [%d]", m_sensor_id, m_client_id);
+ _E("Permission denied to stop sensor[0x%llx] for client [%d]", m_sensor_id, m_client_id);
ret_value = OP_ERROR;
goto out;
}
- DBG("CMD_BYEBYE for client [%d], sensor [0x%llx]", m_client_id, m_sensor_id);
+ _D("CMD_BYEBYE for client [%d], sensor [0x%llx]", m_client_id, m_sensor_id);
if (!get_client_info_manager().remove_sensor_record(m_client_id, m_sensor_id)) {
- ERR("Error removing sensor_record for client [%d]", m_client_id);
+ _E("Error removing sensor_record for client [%d]", m_client_id);
ret_value = OP_ERROR;
goto out;
}
out:
if (!send_cmd_done(ret_value))
- ERR("Failed to send cmd_done to a client");
+ _E("Failed to send cmd_done to a client");
if (ret_value == OP_SUCCESS)
return false;
long ret_value = OP_ERROR;
if (!is_permission_allowed()) {
- ERR("Permission denied to start sensor[0x%llx] for client [%d]", m_sensor_id, m_client_id);
+ _E("Permission denied to start sensor[0x%llx] for client [%d]", m_sensor_id, m_client_id);
ret_value = OP_ERROR;
goto out;
}
- DBG("START Sensor [0x%llx], called from client [%d]", m_sensor_id, m_client_id);
+ _D("START Sensor [0x%llx], called from client [%d]", m_sensor_id, m_client_id);
if (m_module->start()) {
get_client_info_manager().set_start(m_client_id, m_sensor_id, true);
get_event_dispathcher().request_last_event(m_client_id, m_sensor_id);
ret_value = OP_SUCCESS;
} else {
- ERR("Failed to start sensor [0x%llx] for client [%d]", m_sensor_id, m_client_id);
+ _E("Failed to start sensor [0x%llx] for client [%d]", m_sensor_id, m_client_id);
ret_value = OP_ERROR;
}
out:
if (!send_cmd_done(ret_value))
- ERR("Failed to send cmd_done to a client");
+ _E("Failed to send cmd_done to a client");
return true;
}
long ret_value = OP_ERROR;
if (!is_permission_allowed()) {
- ERR("Permission denied to stop sensor[0x%llx] for client [%d]", m_sensor_id, m_client_id);
+ _E("Permission denied to stop sensor[0x%llx] for client [%d]", m_sensor_id, m_client_id);
ret_value = OP_ERROR;
goto out;
}
- DBG("STOP Sensor [0x%llx], called from client [%d]", m_sensor_id, m_client_id);
+ _D("STOP Sensor [0x%llx], called from client [%d]", m_sensor_id, m_client_id);
if (m_module->stop()) {
get_client_info_manager().set_start(m_client_id, m_sensor_id, false);
ret_value = OP_SUCCESS;
} else {
- ERR("Failed to stop sensor [0x%llx] for client [%d]", m_sensor_id, m_client_id);
+ _E("Failed to stop sensor [0x%llx] for client [%d]", m_sensor_id, m_client_id);
ret_value = OP_ERROR;
}
out:
if (!send_cmd_done(ret_value))
- ERR("Failed to send cmd_done to a client");
+ _E("Failed to send cmd_done to a client");
return true;
}
cmd = (cmd_reg_t*)payload;
if (!is_permission_allowed()) {
- ERR("Permission denied to register event [0x%x] for client [%d] to client info manager",
+ _E("Permission denied to register event [0x%x] for client [%d] to client info manager",
cmd->event_type, m_client_id);
ret_value = OP_ERROR;
goto out;
}
if (!get_client_info_manager().register_event(m_client_id, m_sensor_id, cmd->event_type)) {
- INFO("Failed to register event [0x%x] for client [%d] to client info manager",
+ _I("Failed to register event [0x%x] for client [%d] to client info manager",
cmd->event_type, m_client_id);
ret_value = OP_ERROR;
goto out;
insert_priority_list(cmd->event_type);
ret_value = OP_SUCCESS;
- DBG("Registering Event [0x%x] is done for client [%d]", cmd->event_type, m_client_id);
+ _D("Registering Event [0x%x] is done for client [%d]", cmd->event_type, m_client_id);
out:
if (!send_cmd_done(ret_value))
- ERR("Failed to send cmd_done to a client");
+ _E("Failed to send cmd_done to a client");
return true;
}
cmd = (cmd_unreg_t*)payload;
if (!is_permission_allowed()) {
- ERR("Permission denied to unregister event [0x%x] for client [%d] to client info manager",
+ _E("Permission denied to unregister event [0x%x] for client [%d] to client info manager",
cmd->event_type, m_client_id);
ret_value = OP_ERROR;
goto out;
}
if (!get_client_info_manager().unregister_event(m_client_id, m_sensor_id, cmd->event_type)) {
- ERR("Failed to unregister event [0x%x] for client [%d] from client info manager",
+ _E("Failed to unregister event [0x%x] for client [%d] from client info manager",
cmd->event_type, m_client_id);
ret_value = OP_ERROR;
goto out;
}
ret_value = OP_SUCCESS;
- DBG("Unregistering Event [0x%x] is done for client [%d]",
+ _D("Unregistering Event [0x%x] is done for client [%d]",
cmd->event_type, m_client_id);
out:
if (!send_cmd_done(ret_value))
- ERR("Failed to send cmd_done to a client");
+ _E("Failed to send cmd_done to a client");
return true;
}
cmd = (cmd_set_batch_t*)payload;
if (!is_permission_allowed()) {
- ERR("Permission denied to set batch for client [%d], for sensor [0x%llx] with batch [%d, %d] to client info manager",
+ _E("Permission denied to set batch for client [%d], for sensor [0x%llx] with batch [%d, %d] to client info manager",
m_client_id, m_sensor_id, cmd->interval, cmd->latency);
ret_value = OP_ERROR;
goto out;
}
if (!get_client_info_manager().set_batch(m_client_id, m_sensor_id, cmd->interval, cmd->latency)) {
- ERR("Failed to set batch for client [%d], for sensor [0x%llx] with batch [%d, %d] to client info manager",
+ _E("Failed to set batch for client [%d], for sensor [0x%llx] with batch [%d, %d] to client info manager",
m_client_id, m_sensor_id, cmd->interval, cmd->latency);
ret_value = OP_ERROR;
goto out;
}
if (!m_module->add_interval(m_client_id, cmd->interval, false)) {
- ERR("Failed to set interval for client [%d], for sensor [0x%llx] with interval [%d]",
+ _E("Failed to set interval for client [%d], for sensor [0x%llx] with interval [%d]",
m_client_id, m_sensor_id, cmd->interval);
ret_value = OP_ERROR;
goto out;
}
if (!m_module->add_batch(m_client_id, cmd->latency)) {
- ERR("Failed to set latency for client [%d], for sensor [0x%llx] with latency [%d]",
+ _E("Failed to set latency for client [%d], for sensor [0x%llx] with latency [%d]",
m_client_id, m_sensor_id, cmd->latency);
ret_value = OP_ERROR;
goto out;
out:
if (!send_cmd_done(ret_value))
- ERR("Failed to send cmd_done to a client");
+ _E("Failed to send cmd_done to a client");
return true;
}
long ret_value = OP_ERROR;
if (!is_permission_allowed()) {
- ERR("Permission denied to unset batch for client [%d], for sensor [0x%llx] to client info manager",
+ _E("Permission denied to unset batch for client [%d], for sensor [0x%llx] to client info manager",
m_client_id, m_sensor_id);
ret_value = OP_ERROR;
goto out;
}
if (!get_client_info_manager().set_batch(m_client_id, m_sensor_id, 0, 0)) {
- ERR("Failed to unset batch for client [%d], for sensor [0x%llx] to client info manager",
+ _E("Failed to unset batch for client [%d], for sensor [0x%llx] to client info manager",
m_client_id, m_sensor_id);
ret_value = OP_ERROR;
goto out;
}
if (!m_module->delete_interval(m_client_id, false)) {
- ERR("Failed to delete interval for client [%d]", m_client_id);
+ _E("Failed to delete interval for client [%d]", m_client_id);
ret_value = OP_ERROR;
goto out;
}
if (!m_module->delete_batch(m_client_id)) {
- ERR("Failed to delete latency for client [%d]", m_client_id);
+ _E("Failed to delete latency for client [%d]", m_client_id);
ret_value = OP_ERROR;
goto out;
}
out:
if (!send_cmd_done(ret_value))
- ERR("Failed to send cmd_done to a client");
+ _E("Failed to send cmd_done to a client");
return true;
}
cmd = (cmd_set_option_t*)payload;
if (!is_permission_allowed()) {
- ERR("Permission denied to set interval for client [%d], for sensor [0x%llx] with option [%d] to client info manager",
+ _E("Permission denied to set interval for client [%d], for sensor [0x%llx] with option [%d] to client info manager",
m_client_id, m_sensor_id, cmd->option);
ret_value = OP_ERROR;
goto out;
}
if (!get_client_info_manager().set_option(m_client_id, m_sensor_id, cmd->option)) {
- ERR("Failed to set option for client [%d], for sensor [0x%llx] with option [%d] to client info manager",
+ _E("Failed to set option for client [%d], for sensor [0x%llx] with option [%d] to client info manager",
m_client_id, m_sensor_id, cmd->option);
ret_value = OP_ERROR;
goto out;
ret_value = OP_SUCCESS;
out:
if (!send_cmd_done(ret_value))
- ERR("Failed to send cmd_done to a client");
+ _E("Failed to send cmd_done to a client");
return true;
}
cmd = (cmd_set_wakeup_t*)payload;
if (!is_permission_allowed()) {
- ERR("Permission denied to set wakeup for client [%d], for sensor [0x%llx] with wakeup [%d] to client info manager",
+ _E("Permission denied to set wakeup for client [%d], for sensor [0x%llx] with wakeup [%d] to client info manager",
m_client_id, m_sensor_id, cmd->wakeup);
ret_value = OP_ERROR;
goto out;
}
if (!get_client_info_manager().set_wakeup(m_client_id, m_sensor_id, cmd->wakeup)) {
- ERR("Failed to set wakeup for client [%d], for sensor [0x%llx] with wakeup [%d] to client info manager",
+ _E("Failed to set wakeup for client [%d], for sensor [0x%llx] with wakeup [%d] to client info manager",
m_client_id, m_sensor_id, cmd->wakeup);
ret_value = OP_ERROR;
goto out;
out:
if (!send_cmd_done(ret_value))
- ERR("Failed to send cmd_done to a client");
+ _E("Failed to send cmd_done to a client");
return true;
}
sensor_data_t *data;
- DBG("CMD_GET_VALUE Handler invoked\n");
+ _D("CMD_GET_VALUE Handler invoked\n");
if (!is_permission_allowed()) {
- ERR("Permission denied to get data for client [%d], for sensor [0x%llx]",
+ _E("Permission denied to get data for client [%d], for sensor [0x%llx]",
m_client_id, m_sensor_id);
state = OP_ERROR;
goto out;
}
while ((state >= 0) && !data->timestamp && (retry++ < RETRY_CNT)) {
- INFO("Wait sensor[0x%llx] data updated for client [%d] #%d", m_sensor_id, m_client_id, retry);
+ _I("Wait sensor[0x%llx] data updated for client [%d] #%d", m_sensor_id, m_client_id, retry);
usleep((retry == 1) ? INIT_WAIT_TIME : WAIT_TIME);
state = m_module->get_data(&data, &length);
}
state = OP_ERROR;
if (state <= 0) {
- ERR("Failed to get data for client [%d], for sensor [0x%llx]",
+ _E("Failed to get data for client [%d], for sensor [0x%llx]",
m_client_id, m_sensor_id);
}
cmd_set_attribute_int_t *cmd;
long ret_value = OP_ERROR;
- DBG("CMD_SET_COMMAND Handler invoked\n");
+ _D("CMD_SET_COMMAND Handler invoked\n");
cmd = (cmd_set_attribute_int_t*)payload;
if (!is_permission_allowed()) {
- ERR("Permission denied to set command for client [%d], for sensor [0x%llx] with attribute [%d]",
+ _E("Permission denied to set command for client [%d], for sensor [0x%llx] with attribute [%d]",
m_client_id, m_sensor_id, cmd->attribute);
ret_value = OP_ERROR;
goto out;
out:
if (!send_cmd_done(ret_value))
- ERR("Failed to send cmd_done to a client");
+ _E("Failed to send cmd_done to a client");
return true;
}
cmd_set_attribute_str_t *cmd;
long ret_value = OP_ERROR;
- DBG("CMD_SEND_SENSORHUB_DATA Handler invoked");
+ _D("CMD_SEND_SENSORHUB_DATA Handler invoked");
cmd = (cmd_set_attribute_str_t*)payload;
if (!is_permission_allowed()) {
- ERR("Permission denied to send sensorhub_data for client [%d], for sensor [0x%llx]",
+ _E("Permission denied to send sensorhub_data for client [%d], for sensor [0x%llx]",
m_client_id, m_sensor_id);
ret_value = OP_ERROR;
goto out;
out:
if (!send_cmd_done(ret_value))
- ERR("Failed to send cmd_done to a client");
+ _E("Failed to send cmd_done to a client");
return true;
}
get_proc_name(info->si_pid, proc_name);
- ERR("Received SIGTERM(%d) from %s(%d)\n", signo, proc_name, info->si_pid);
+ _E("Received SIGTERM(%d) from %s(%d)\n", signo, proc_name, info->si_pid);
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
- INFO("Sensord started");
+ _I("Sensord started");
signal_init();
server::get_instance().stop();
- INFO("Sensord terminated");
+ _I("Sensord terminated");
return 0;
}
if (cynara_creds_socket_get_client(sock_fd, CLIENT_METHOD_DEFAULT, &client) != CYNARA_API_SUCCESS ||
cynara_creds_socket_get_user(sock_fd, USER_METHOD_DEFAULT, &user) != CYNARA_API_SUCCESS ||
(session = cynara_session_from_pid(pid)) == NULL) {
- ERR("Getting client info failed");
+ _E("Getting client info failed");
free(client);
free(user);
free(session);
for (unsigned int i = 0; i < sensors.size(); ++i)
m_permission_set |= sensors[i]->get_permission();
- INFO("Permission Set = %d", m_permission_set);
+ _I("Permission Set = %d", m_permission_set);
if (cynara_initialize(&cynara_env, NULL) != CYNARA_API_SUCCESS) {
cynara_env = NULL;
- ERR("Cynara initialization failed");
+ _E("Cynara initialization failed");
}
}
remains = m_sensor_device->get_data(m_handle.id, data, length);
if (*length < 0) {
- ERR("Failed to get sensor event");
+ _E("Failed to get sensor event");
return -1;
}
if (!m_sensor_device)
return false;
- INFO("Polling interval is set to %dms", interval);
+ _I("Polling interval is set to %dms", interval);
return m_sensor_device->set_interval(m_handle.id, interval);
}
if (!m_sensor_device)
return false;
- INFO("Polling interval is set to %dms", latency);
+ _I("Polling interval is set to %dms", latency);
return m_sensor_device->set_batch_latency(m_handle.id, latency);
}
virtual_sensor_config &config = virtual_sensor_config::get_instance();
if (!config.get(SENSOR_TYPE_AUTO_ROTATION, ELEMENT_VENDOR, m_vendor)) {
- ERR("[VENDOR] is empty\n");
+ _E("[VENDOR] is empty\n");
throw ENXIO;
}
- INFO("m_vendor = %s", m_vendor.c_str());
+ _I("m_vendor = %s", m_vendor.c_str());
if (!config.get(SENSOR_TYPE_AUTO_ROTATION, ELEMENT_RAW_DATA_UNIT, m_raw_data_unit)) {
- ERR("[RAW_DATA_UNIT] is empty\n");
+ _E("[RAW_DATA_UNIT] is empty\n");
throw ENXIO;
}
- INFO("m_raw_data_unit = %s", m_raw_data_unit.c_str());
+ _I("m_raw_data_unit = %s", m_raw_data_unit.c_str());
if (!config.get(SENSOR_TYPE_AUTO_ROTATION, ELEMENT_DEFAULT_SAMPLING_TIME, &m_default_sampling_time)) {
- ERR("[DEFAULT_SAMPLING_TIME] is empty\n");
+ _E("[DEFAULT_SAMPLING_TIME] is empty\n");
throw ENXIO;
}
- INFO("m_default_sampling_time = %d", m_default_sampling_time);
+ _I("m_default_sampling_time = %d", m_default_sampling_time);
m_interval = m_default_sampling_time * MS_TO_US;
}
{
delete m_alg;
- INFO("auto_rotation_sensor is destroyed!\n");
+ _I("auto_rotation_sensor is destroyed!\n");
}
bool auto_rotation_sensor::init(void)
m_accel_sensor = sensor_loader::get_instance().get_sensor(ACCELEROMETER_SENSOR);
if (!m_accel_sensor) {
- ERR("cannot load accel sensor_hal from %s", get_name());
+ _E("cannot load accel sensor_hal from %s", get_name());
return false;
}
m_alg = get_alg();
if (!m_alg) {
- ERR("Not supported AUTO ROTATION sensor");
+ _E("Not supported AUTO ROTATION sensor");
return false;
}
if (!m_alg->open())
return false;
- INFO("%s is created!\n", get_name());
+ _I("%s is created!\n", get_name());
return true;
}
push(rotation_event);
- DBG("Rotation: %d, ACC[0]: %f, ACC[1]: %f, ACC[2]: %f", rotation, event.data.values[0], event.data.values[1], event.data.values[2]);
+ _D("Rotation: %d, ACC[0]: %f, ACC[1]: %f, ACC[2]: %f", rotation, event.data.values[0], event.data.values[1], event.data.values[2]);
return;
}
m_enable_fusion = 0;
if (!config.get(SENSOR_TYPE_FUSION, ELEMENT_VENDOR, m_vendor)) {
- ERR("[VENDOR] is empty\n");
+ _E("[VENDOR] is empty\n");
throw ENXIO;
}
- INFO("m_vendor = %s", m_vendor.c_str());
+ _I("m_vendor = %s", m_vendor.c_str());
if (!config.get(SENSOR_TYPE_FUSION, ELEMENT_RAW_DATA_UNIT, m_raw_data_unit)) {
- ERR("[RAW_DATA_UNIT] is empty\n");
+ _E("[RAW_DATA_UNIT] is empty\n");
throw ENXIO;
}
- INFO("m_raw_data_unit = %s", m_raw_data_unit.c_str());
+ _I("m_raw_data_unit = %s", m_raw_data_unit.c_str());
if (!config.get(SENSOR_TYPE_FUSION, ELEMENT_DEFAULT_SAMPLING_TIME, &m_default_sampling_time)) {
- ERR("[DEFAULT_SAMPLING_TIME] is empty\n");
+ _E("[DEFAULT_SAMPLING_TIME] is empty\n");
throw ENXIO;
}
- INFO("m_default_sampling_time = %d", m_default_sampling_time);
+ _I("m_default_sampling_time = %d", m_default_sampling_time);
if (!config.get(SENSOR_TYPE_FUSION, ELEMENT_ACCEL_STATIC_BIAS, m_accel_static_bias, 3)) {
- ERR("[ACCEL_STATIC_BIAS] is empty\n");
+ _E("[ACCEL_STATIC_BIAS] is empty\n");
throw ENXIO;
}
- INFO("m_accel_static_bias = (%f, %f, %f)", m_accel_static_bias[0], m_accel_static_bias[1], m_accel_static_bias[2]);
+ _I("m_accel_static_bias = (%f, %f, %f)", m_accel_static_bias[0], m_accel_static_bias[1], m_accel_static_bias[2]);
if (!config.get(SENSOR_TYPE_FUSION, ELEMENT_GYRO_STATIC_BIAS, m_gyro_static_bias,3)) {
- ERR("[GYRO_STATIC_BIAS] is empty\n");
+ _E("[GYRO_STATIC_BIAS] is empty\n");
throw ENXIO;
}
- INFO("m_gyro_static_bias = (%f, %f, %f)", m_gyro_static_bias[0], m_gyro_static_bias[1], m_gyro_static_bias[2]);
+ _I("m_gyro_static_bias = (%f, %f, %f)", m_gyro_static_bias[0], m_gyro_static_bias[1], m_gyro_static_bias[2]);
if (!config.get(SENSOR_TYPE_FUSION, ELEMENT_GEOMAGNETIC_STATIC_BIAS, m_geomagnetic_static_bias, 3)) {
- ERR("[GEOMAGNETIC_STATIC_BIAS] is empty\n");
+ _E("[GEOMAGNETIC_STATIC_BIAS] is empty\n");
throw ENXIO;
}
- INFO("m_geomagnetic_static_bias = (%f, %f, %f)", m_geomagnetic_static_bias[0], m_geomagnetic_static_bias[1], m_geomagnetic_static_bias[2]);
+ _I("m_geomagnetic_static_bias = (%f, %f, %f)", m_geomagnetic_static_bias[0], m_geomagnetic_static_bias[1], m_geomagnetic_static_bias[2]);
if (!config.get(SENSOR_TYPE_FUSION, ELEMENT_ACCEL_ROTATION_DIRECTION_COMPENSATION, m_accel_rotation_direction_compensation, 3)) {
- ERR("[ACCEL_ROTATION_DIRECTION_COMPENSATION] is empty\n");
+ _E("[ACCEL_ROTATION_DIRECTION_COMPENSATION] is empty\n");
throw ENXIO;
}
- INFO("m_accel_rotation_direction_compensation = (%d, %d, %d)", m_accel_rotation_direction_compensation[0], m_accel_rotation_direction_compensation[1], m_accel_rotation_direction_compensation[2]);
+ _I("m_accel_rotation_direction_compensation = (%d, %d, %d)", m_accel_rotation_direction_compensation[0], m_accel_rotation_direction_compensation[1], m_accel_rotation_direction_compensation[2]);
if (!config.get(SENSOR_TYPE_FUSION, ELEMENT_GYRO_ROTATION_DIRECTION_COMPENSATION, m_gyro_rotation_direction_compensation, 3)) {
- ERR("[GYRO_ROTATION_DIRECTION_COMPENSATION] is empty\n");
+ _E("[GYRO_ROTATION_DIRECTION_COMPENSATION] is empty\n");
throw ENXIO;
}
- INFO("m_gyro_rotation_direction_compensation = (%d, %d, %d)", m_gyro_rotation_direction_compensation[0], m_gyro_rotation_direction_compensation[1], m_gyro_rotation_direction_compensation[2]);
+ _I("m_gyro_rotation_direction_compensation = (%d, %d, %d)", m_gyro_rotation_direction_compensation[0], m_gyro_rotation_direction_compensation[1], m_gyro_rotation_direction_compensation[2]);
if (!config.get(SENSOR_TYPE_FUSION, ELEMENT_GEOMAGNETIC_ROTATION_DIRECTION_COMPENSATION, m_geomagnetic_rotation_direction_compensation, 3)) {
- ERR("[GEOMAGNETIC_ROTATION_DIRECTION_COMPENSATION] is empty\n");
+ _E("[GEOMAGNETIC_ROTATION_DIRECTION_COMPENSATION] is empty\n");
throw ENXIO;
}
- INFO("m_geomagnetic_rotation_direction_compensation = (%d, %d, %d)", m_geomagnetic_rotation_direction_compensation[0], m_geomagnetic_rotation_direction_compensation[1], m_geomagnetic_rotation_direction_compensation[2]);
+ _I("m_geomagnetic_rotation_direction_compensation = (%d, %d, %d)", m_geomagnetic_rotation_direction_compensation[0], m_geomagnetic_rotation_direction_compensation[1], m_geomagnetic_rotation_direction_compensation[2]);
if (!config.get(SENSOR_TYPE_FUSION, ELEMENT_MAGNETIC_ALIGNMENT_FACTOR, &m_magnetic_alignment_factor)) {
- ERR("[MAGNETIC_ALIGNMENT_FACTOR] is empty\n");
+ _E("[MAGNETIC_ALIGNMENT_FACTOR] is empty\n");
throw ENXIO;
}
- INFO("m_magnetic_alignment_factor = %d", m_magnetic_alignment_factor);
+ _I("m_magnetic_alignment_factor = %d", m_magnetic_alignment_factor);
m_interval = m_default_sampling_time * MS_TO_US;
fusion_sensor::~fusion_sensor()
{
- INFO("fusion_sensor is destroyed!\n");
+ _I("fusion_sensor is destroyed!\n");
}
bool fusion_sensor::init(void)
m_magnetic_sensor = sensor_loader::get_instance().get_sensor(GEOMAGNETIC_SENSOR);
if (!m_accel_sensor) {
- ERR("Failed to load accel sensor: 0x%x", m_accel_sensor);
+ _E("Failed to load accel sensor: 0x%x", m_accel_sensor);
return false;
}
if (!m_gyro_sensor)
- INFO("Failed to load gyro sensor: 0x%x", m_gyro_sensor);
+ _I("Failed to load gyro sensor: 0x%x", m_gyro_sensor);
if (!m_magnetic_sensor)
- INFO("Failed to load geomagnetic sensor: 0x%x", m_magnetic_sensor);
+ _I("Failed to load geomagnetic sensor: 0x%x", m_magnetic_sensor);
- INFO("%s is created!", sensor_base::get_name());
+ _I("%s is created!", sensor_base::get_name());
return true;
}
register_supported_event(GRAVITY_RAW_DATA_EVENT);
if (!config.get(SENSOR_TYPE_GRAVITY, ELEMENT_VENDOR, m_vendor)) {
- ERR("[VENDOR] is empty\n");
+ _E("[VENDOR] is empty\n");
throw ENXIO;
}
- INFO("m_vendor = %s", m_vendor.c_str());
+ _I("m_vendor = %s", m_vendor.c_str());
if (!config.get(SENSOR_TYPE_ORIENTATION, ELEMENT_ORIENTATION_DATA_UNIT, m_orientation_data_unit)) {
- ERR("[ORIENTATION_DATA_UNIT] is empty\n");
+ _E("[ORIENTATION_DATA_UNIT] is empty\n");
throw ENXIO;
}
- INFO("m_orientation_data_unit = %s", m_orientation_data_unit.c_str());
+ _I("m_orientation_data_unit = %s", m_orientation_data_unit.c_str());
if (!config.get(SENSOR_TYPE_GRAVITY, ELEMENT_RAW_DATA_UNIT, m_raw_data_unit)) {
- ERR("[RAW_DATA_UNIT] is empty\n");
+ _E("[RAW_DATA_UNIT] is empty\n");
throw ENXIO;
}
- INFO("m_raw_data_unit = %s", m_raw_data_unit.c_str());
+ _I("m_raw_data_unit = %s", m_raw_data_unit.c_str());
if (!config.get(SENSOR_TYPE_GRAVITY, ELEMENT_DEFAULT_SAMPLING_TIME, &m_default_sampling_time)) {
- ERR("[DEFAULT_SAMPLING_TIME] is empty\n");
+ _E("[DEFAULT_SAMPLING_TIME] is empty\n");
throw ENXIO;
}
- INFO("m_default_sampling_time = %d", m_default_sampling_time);
+ _I("m_default_sampling_time = %d", m_default_sampling_time);
if (!config.get(SENSOR_TYPE_GRAVITY, ELEMENT_GRAVITY_SIGN_COMPENSATION, m_gravity_sign_compensation, 3)) {
- ERR("[GRAVITY_SIGN_COMPENSATION] is empty\n");
+ _E("[GRAVITY_SIGN_COMPENSATION] is empty\n");
throw ENXIO;
}
- INFO("m_gravity_sign_compensation = (%d, %d, %d)", m_gravity_sign_compensation[0], m_gravity_sign_compensation[1], m_gravity_sign_compensation[2]);
+ _I("m_gravity_sign_compensation = (%d, %d, %d)", m_gravity_sign_compensation[0], m_gravity_sign_compensation[1], m_gravity_sign_compensation[2]);
if (!config.get(SENSOR_TYPE_ORIENTATION, ELEMENT_AZIMUTH_ROTATION_COMPENSATION, &m_azimuth_rotation_compensation)) {
- ERR("[AZIMUTH_ROTATION_COMPENSATION] is empty\n");
+ _E("[AZIMUTH_ROTATION_COMPENSATION] is empty\n");
throw ENXIO;
}
- INFO("m_azimuth_rotation_compensation = %d", m_azimuth_rotation_compensation);
+ _I("m_azimuth_rotation_compensation = %d", m_azimuth_rotation_compensation);
if (!config.get(SENSOR_TYPE_ORIENTATION, ELEMENT_PITCH_ROTATION_COMPENSATION, &m_pitch_rotation_compensation)) {
- ERR("[PITCH_ROTATION_COMPENSATION] is empty\n");
+ _E("[PITCH_ROTATION_COMPENSATION] is empty\n");
throw ENXIO;
}
- INFO("m_pitch_rotation_compensation = %d", m_pitch_rotation_compensation);
+ _I("m_pitch_rotation_compensation = %d", m_pitch_rotation_compensation);
if (!config.get(SENSOR_TYPE_ORIENTATION, ELEMENT_ROLL_ROTATION_COMPENSATION, &m_roll_rotation_compensation)) {
- ERR("[ROLL_ROTATION_COMPENSATION] is empty\n");
+ _E("[ROLL_ROTATION_COMPENSATION] is empty\n");
throw ENXIO;
}
- INFO("m_roll_rotation_compensation = %d", m_roll_rotation_compensation);
+ _I("m_roll_rotation_compensation = %d", m_roll_rotation_compensation);
m_interval = m_default_sampling_time * MS_TO_US;
}
gravity_sensor::~gravity_sensor()
{
- INFO("gravity_sensor is destroyed!\n");
+ _I("gravity_sensor is destroyed!\n");
}
bool gravity_sensor::init()
m_fusion_sensor = sensor_loader::get_instance().get_sensor(FUSION_SENSOR);
if (!m_accel_sensor || !m_gyro_sensor || !m_magnetic_sensor || !m_fusion_sensor) {
- ERR("Failed to load sensors, accel: 0x%x, gyro: 0x%x, mag: 0x%x, fusion: 0x%x",
+ _E("Failed to load sensors, accel: 0x%x, gyro: 0x%x, mag: 0x%x, fusion: 0x%x",
m_accel_sensor, m_gyro_sensor, m_magnetic_sensor, m_fusion_sensor);
return false;
}
- INFO("%s is created!", sensor_base::get_name());
+ _I("%s is created!", sensor_base::get_name());
return true;
}
if (!config.get(SENSOR_TYPE_LINEAR_ACCEL, ELEMENT_VENDOR, m_vendor)) {
- ERR("[VENDOR] is empty\n");
+ _E("[VENDOR] is empty\n");
throw ENXIO;
}
- INFO("m_vendor = %s", m_vendor.c_str());
+ _I("m_vendor = %s", m_vendor.c_str());
if (!config.get(SENSOR_TYPE_LINEAR_ACCEL, ELEMENT_RAW_DATA_UNIT, m_raw_data_unit)) {
- ERR("[RAW_DATA_UNIT] is empty\n");
+ _E("[RAW_DATA_UNIT] is empty\n");
throw ENXIO;
}
- INFO("m_raw_data_unit = %s", m_raw_data_unit.c_str());
+ _I("m_raw_data_unit = %s", m_raw_data_unit.c_str());
if (!config.get(SENSOR_TYPE_ORIENTATION, ELEMENT_ORIENTATION_DATA_UNIT, m_orientation_data_unit)) {
- ERR("[ORIENTATION_DATA_UNIT] is empty\n");
+ _E("[ORIENTATION_DATA_UNIT] is empty\n");
throw ENXIO;
}
- INFO("m_orientation_data_unit = %s", m_orientation_data_unit.c_str());
+ _I("m_orientation_data_unit = %s", m_orientation_data_unit.c_str());
if (!config.get(SENSOR_TYPE_LINEAR_ACCEL, ELEMENT_DEFAULT_SAMPLING_TIME, &m_default_sampling_time)) {
- ERR("[DEFAULT_SAMPLING_TIME] is empty\n");
+ _E("[DEFAULT_SAMPLING_TIME] is empty\n");
throw ENXIO;
}
- INFO("m_default_sampling_time = %d", m_default_sampling_time);
+ _I("m_default_sampling_time = %d", m_default_sampling_time);
if (!config.get(SENSOR_TYPE_LINEAR_ACCEL, ELEMENT_ACCEL_STATIC_BIAS, m_accel_static_bias, 3)) {
- ERR("[ACCEL_STATIC_BIAS] is empty\n");
+ _E("[ACCEL_STATIC_BIAS] is empty\n");
throw ENXIO;
}
if (!config.get(SENSOR_TYPE_LINEAR_ACCEL, ELEMENT_ACCEL_ROTATION_DIRECTION_COMPENSATION, m_accel_rotation_direction_compensation, 3)) {
- ERR("[ACCEL_ROTATION_DIRECTION_COMPENSATION] is empty\n");
+ _E("[ACCEL_ROTATION_DIRECTION_COMPENSATION] is empty\n");
throw ENXIO;
}
- INFO("m_accel_rotation_direction_compensation = (%d, %d, %d)", m_accel_rotation_direction_compensation[0], m_accel_rotation_direction_compensation[1], m_accel_rotation_direction_compensation[2]);
+ _I("m_accel_rotation_direction_compensation = (%d, %d, %d)", m_accel_rotation_direction_compensation[0], m_accel_rotation_direction_compensation[1], m_accel_rotation_direction_compensation[2]);
if (!config.get(SENSOR_TYPE_GRAVITY, ELEMENT_GRAVITY_SIGN_COMPENSATION, m_gravity_sign_compensation, 3)) {
- ERR("[GRAVITY_SIGN_COMPENSATION] is empty\n");
+ _E("[GRAVITY_SIGN_COMPENSATION] is empty\n");
throw ENXIO;
}
- INFO("m_gravity_sign_compensation = (%d, %d, %d)", m_gravity_sign_compensation[0], m_gravity_sign_compensation[1], m_gravity_sign_compensation[2]);
+ _I("m_gravity_sign_compensation = (%d, %d, %d)", m_gravity_sign_compensation[0], m_gravity_sign_compensation[1], m_gravity_sign_compensation[2]);
if (!config.get(SENSOR_TYPE_LINEAR_ACCEL, ELEMENT_LINEAR_ACCEL_SIGN_COMPENSATION, m_linear_accel_sign_compensation, 3)) {
- ERR("[LINEAR_ACCEL_SIGN_COMPENSATION] is empty\n");
+ _E("[LINEAR_ACCEL_SIGN_COMPENSATION] is empty\n");
throw ENXIO;
}
- INFO("m_linear_accel_sign_compensation = (%d, %d, %d)", m_linear_accel_sign_compensation[0], m_linear_accel_sign_compensation[1], m_linear_accel_sign_compensation[2]);
+ _I("m_linear_accel_sign_compensation = (%d, %d, %d)", m_linear_accel_sign_compensation[0], m_linear_accel_sign_compensation[1], m_linear_accel_sign_compensation[2]);
if (!config.get(SENSOR_TYPE_ORIENTATION, ELEMENT_AZIMUTH_ROTATION_COMPENSATION, &m_azimuth_rotation_compensation)) {
- ERR("[AZIMUTH_ROTATION_COMPENSATION] is empty\n");
+ _E("[AZIMUTH_ROTATION_COMPENSATION] is empty\n");
throw ENXIO;
}
- INFO("m_azimuth_rotation_compensation = %d", m_azimuth_rotation_compensation);
+ _I("m_azimuth_rotation_compensation = %d", m_azimuth_rotation_compensation);
if (!config.get(SENSOR_TYPE_ORIENTATION, ELEMENT_PITCH_ROTATION_COMPENSATION, &m_pitch_rotation_compensation)) {
- ERR("[PITCH_ROTATION_COMPENSATION] is empty\n");
+ _E("[PITCH_ROTATION_COMPENSATION] is empty\n");
throw ENXIO;
}
- INFO("m_pitch_rotation_compensation = %d", m_pitch_rotation_compensation);
+ _I("m_pitch_rotation_compensation = %d", m_pitch_rotation_compensation);
if (!config.get(SENSOR_TYPE_ORIENTATION, ELEMENT_ROLL_ROTATION_COMPENSATION, &m_roll_rotation_compensation)) {
- ERR("[ROLL_ROTATION_COMPENSATION] is empty\n");
+ _E("[ROLL_ROTATION_COMPENSATION] is empty\n");
throw ENXIO;
}
- INFO("m_roll_rotation_compensation = %d", m_roll_rotation_compensation);
+ _I("m_roll_rotation_compensation = %d", m_roll_rotation_compensation);
m_interval = m_default_sampling_time * MS_TO_US;
linear_accel_sensor::~linear_accel_sensor()
{
- INFO("linear_accel_sensor is destroyed!\n");
+ _I("linear_accel_sensor is destroyed!\n");
}
bool linear_accel_sensor::init()
m_fusion_sensor = sensor_loader::get_instance().get_sensor(FUSION_SENSOR);
if (!m_accel_sensor || !m_gyro_sensor || !m_magnetic_sensor || !m_fusion_sensor) {
- ERR("Failed to load sensors, accel: 0x%x, gyro: 0x%x, mag: 0x%x, fusion: 0x%x",
+ _E("Failed to load sensors, accel: 0x%x, gyro: 0x%x, mag: 0x%x, fusion: 0x%x",
m_accel_sensor, m_gyro_sensor, m_magnetic_sensor, m_fusion_sensor);
return false;
}
- INFO("%s is created!", sensor_base::get_name());
+ _I("%s is created!", sensor_base::get_name());
return true;
}
register_supported_event(ORIENTATION_RAW_DATA_EVENT);
if (!config.get(SENSOR_TYPE_ORIENTATION, ELEMENT_VENDOR, m_vendor)) {
- ERR("[VENDOR] is empty\n");
+ _E("[VENDOR] is empty\n");
throw ENXIO;
}
- INFO("m_vendor = %s", m_vendor.c_str());
+ _I("m_vendor = %s", m_vendor.c_str());
if (!config.get(SENSOR_TYPE_ORIENTATION, ELEMENT_RAW_DATA_UNIT, m_raw_data_unit)) {
- ERR("[RAW_DATA_UNIT] is empty\n");
+ _E("[RAW_DATA_UNIT] is empty\n");
throw ENXIO;
}
- INFO("m_raw_data_unit = %s", m_raw_data_unit.c_str());
+ _I("m_raw_data_unit = %s", m_raw_data_unit.c_str());
if (!config.get(SENSOR_TYPE_ORIENTATION, ELEMENT_DEFAULT_SAMPLING_TIME, &m_default_sampling_time)) {
- ERR("[DEFAULT_SAMPLING_TIME] is empty\n");
+ _E("[DEFAULT_SAMPLING_TIME] is empty\n");
throw ENXIO;
}
- INFO("m_default_sampling_time = %d", m_default_sampling_time);
+ _I("m_default_sampling_time = %d", m_default_sampling_time);
if (!config.get(SENSOR_TYPE_ORIENTATION, ELEMENT_AZIMUTH_ROTATION_COMPENSATION, &m_azimuth_rotation_compensation)) {
- ERR("[AZIMUTH_ROTATION_COMPENSATION] is empty\n");
+ _E("[AZIMUTH_ROTATION_COMPENSATION] is empty\n");
throw ENXIO;
}
- INFO("m_azimuth_rotation_compensation = %d", m_azimuth_rotation_compensation);
+ _I("m_azimuth_rotation_compensation = %d", m_azimuth_rotation_compensation);
if (!config.get(SENSOR_TYPE_ORIENTATION, ELEMENT_PITCH_ROTATION_COMPENSATION, &m_pitch_rotation_compensation)) {
- ERR("[PITCH_ROTATION_COMPENSATION] is empty\n");
+ _E("[PITCH_ROTATION_COMPENSATION] is empty\n");
throw ENXIO;
}
- INFO("m_pitch_rotation_compensation = %d", m_pitch_rotation_compensation);
+ _I("m_pitch_rotation_compensation = %d", m_pitch_rotation_compensation);
if (!config.get(SENSOR_TYPE_ORIENTATION, ELEMENT_ROLL_ROTATION_COMPENSATION, &m_roll_rotation_compensation)) {
- ERR("[ROLL_ROTATION_COMPENSATION] is empty\n");
+ _E("[ROLL_ROTATION_COMPENSATION] is empty\n");
throw ENXIO;
}
- INFO("m_roll_rotation_compensation = %d", m_roll_rotation_compensation);
+ _I("m_roll_rotation_compensation = %d", m_roll_rotation_compensation);
m_interval = m_default_sampling_time * MS_TO_US;
}
orientation_sensor::~orientation_sensor()
{
- INFO("orientation_sensor is destroyed!\n");
+ _I("orientation_sensor is destroyed!\n");
}
bool orientation_sensor::init(void)
m_fusion_sensor = sensor_loader::get_instance().get_sensor(FUSION_SENSOR);
if (!m_accel_sensor || !m_gyro_sensor || !m_magnetic_sensor || !m_fusion_sensor) {
- ERR("Failed to load sensors, accel: 0x%x, gyro: 0x%x, mag: 0x%x, fusion: 0x%x",
+ _E("Failed to load sensors, accel: 0x%x, gyro: 0x%x, mag: 0x%x, fusion: 0x%x",
m_accel_sensor, m_gyro_sensor, m_magnetic_sensor, m_fusion_sensor);
return false;
}
- INFO("%s is created!\n", sensor_base::get_name());
+ _I("%s is created!\n", sensor_base::get_name());
return true;
}
else
m_hardware_fusion = true;
- INFO("m_hardware_fusion = %d", m_hardware_fusion);
+ _I("m_hardware_fusion = %d", m_hardware_fusion);
m_name = string(SENSOR_NAME);
register_supported_event(GAMING_RV_RAW_DATA_EVENT);
m_enable_gaming_rv = 0;
if (!config.get(SENSOR_TYPE_GAMING_RV, ELEMENT_VENDOR, m_vendor)) {
- ERR("[VENDOR] is empty\n");
+ _E("[VENDOR] is empty\n");
throw ENXIO;
}
- INFO("m_vendor = %s", m_vendor.c_str());
+ _I("m_vendor = %s", m_vendor.c_str());
if (!config.get(SENSOR_TYPE_GAMING_RV, ELEMENT_DEFAULT_SAMPLING_TIME, &m_default_sampling_time)) {
- ERR("[DEFAULT_SAMPLING_TIME] is empty\n");
+ _E("[DEFAULT_SAMPLING_TIME] is empty\n");
throw ENXIO;
}
- INFO("m_default_sampling_time = %d", m_default_sampling_time);
+ _I("m_default_sampling_time = %d", m_default_sampling_time);
if (!config.get(SENSOR_TYPE_GAMING_RV, ELEMENT_ACCEL_STATIC_BIAS, m_accel_static_bias, 3)) {
- ERR("[ACCEL_STATIC_BIAS] is empty\n");
+ _E("[ACCEL_STATIC_BIAS] is empty\n");
throw ENXIO;
}
- INFO("m_accel_static_bias = (%f, %f, %f)", m_accel_static_bias[0], m_accel_static_bias[1], m_accel_static_bias[2]);
+ _I("m_accel_static_bias = (%f, %f, %f)", m_accel_static_bias[0], m_accel_static_bias[1], m_accel_static_bias[2]);
if (!config.get(SENSOR_TYPE_GAMING_RV, ELEMENT_GYRO_STATIC_BIAS, m_gyro_static_bias,3)) {
- ERR("[GYRO_STATIC_BIAS] is empty\n");
+ _E("[GYRO_STATIC_BIAS] is empty\n");
throw ENXIO;
}
- INFO("m_gyro_static_bias = (%f, %f, %f)", m_gyro_static_bias[0], m_gyro_static_bias[1], m_gyro_static_bias[2]);
+ _I("m_gyro_static_bias = (%f, %f, %f)", m_gyro_static_bias[0], m_gyro_static_bias[1], m_gyro_static_bias[2]);
if (!config.get(SENSOR_TYPE_GAMING_RV, ELEMENT_ACCEL_ROTATION_DIRECTION_COMPENSATION, m_accel_rotation_direction_compensation, 3)) {
- ERR("[ACCEL_ROTATION_DIRECTION_COMPENSATION] is empty\n");
+ _E("[ACCEL_ROTATION_DIRECTION_COMPENSATION] is empty\n");
throw ENXIO;
}
- INFO("m_accel_rotation_direction_compensation = (%d, %d, %d)", m_accel_rotation_direction_compensation[0], m_accel_rotation_direction_compensation[1], m_accel_rotation_direction_compensation[2]);
+ _I("m_accel_rotation_direction_compensation = (%d, %d, %d)", m_accel_rotation_direction_compensation[0], m_accel_rotation_direction_compensation[1], m_accel_rotation_direction_compensation[2]);
if (!config.get(SENSOR_TYPE_GAMING_RV, ELEMENT_GYRO_ROTATION_DIRECTION_COMPENSATION, m_gyro_rotation_direction_compensation, 3)) {
- ERR("[GYRO_ROTATION_DIRECTION_COMPENSATION] is empty\n");
+ _E("[GYRO_ROTATION_DIRECTION_COMPENSATION] is empty\n");
throw ENXIO;
}
- INFO("m_gyro_rotation_direction_compensation = (%d, %d, %d)", m_gyro_rotation_direction_compensation[0], m_gyro_rotation_direction_compensation[1], m_gyro_rotation_direction_compensation[2]);
+ _I("m_gyro_rotation_direction_compensation = (%d, %d, %d)", m_gyro_rotation_direction_compensation[0], m_gyro_rotation_direction_compensation[1], m_gyro_rotation_direction_compensation[2]);
m_interval = m_default_sampling_time * MS_TO_US;
}
gaming_rv_sensor::~gaming_rv_sensor()
{
- INFO("gaming_rv_sensor is destroyed!\n");
+ _I("gaming_rv_sensor is destroyed!\n");
}
bool gaming_rv_sensor::init()
m_gyro_sensor = sensor_loader::get_instance().get_sensor(GYROSCOPE_SENSOR);
if (!m_accel_sensor || !m_gyro_sensor) {
- ERR("Failed to load sensors, accel: 0x%x, gyro: 0x%x",
+ _E("Failed to load sensors, accel: 0x%x, gyro: 0x%x",
m_accel_sensor, m_gyro_sensor);
return false;
}
- INFO("%s is created!\n", sensor_base::get_name());
+ _I("%s is created!\n", sensor_base::get_name());
return true;
}
register_supported_event(GEOMAGNETIC_RV_RAW_DATA_EVENT);
if (!config.get(SENSOR_TYPE_GEOMAGNETIC_RV, ELEMENT_VENDOR, m_vendor)) {
- ERR("[VENDOR] is empty\n");
+ _E("[VENDOR] is empty\n");
throw ENXIO;
}
- INFO("m_vendor = %s", m_vendor.c_str());
+ _I("m_vendor = %s", m_vendor.c_str());
if (!config.get(SENSOR_TYPE_GEOMAGNETIC_RV, ELEMENT_DEFAULT_SAMPLING_TIME, &m_default_sampling_time)) {
- ERR("[DEFAULT_SAMPLING_TIME] is empty\n");
+ _E("[DEFAULT_SAMPLING_TIME] is empty\n");
throw ENXIO;
}
- INFO("m_default_sampling_time = %d", m_default_sampling_time);
+ _I("m_default_sampling_time = %d", m_default_sampling_time);
m_interval = m_default_sampling_time * MS_TO_US;
}
geomagnetic_rv_sensor::~geomagnetic_rv_sensor()
{
- INFO("geomagnetic_rv_sensor is destroyed!\n");
+ _I("geomagnetic_rv_sensor is destroyed!\n");
}
bool geomagnetic_rv_sensor::init()
m_fusion_sensor = sensor_loader::get_instance().get_sensor(FUSION_SENSOR);
if (!m_accel_sensor || !m_magnetic_sensor || !m_fusion_sensor) {
- ERR("Failed to load sensors, accel: 0x%x, mag: 0x%x, fusion: 0x%x",
+ _E("Failed to load sensors, accel: 0x%x, mag: 0x%x, fusion: 0x%x",
m_accel_sensor, m_magnetic_sensor, m_fusion_sensor);
return false;
}
- INFO("%s is created!\n", sensor_base::get_name());
+ _I("%s is created!\n", sensor_base::get_name());
return true;
}
m_enable_orientation = 0;
if (!config.get(SENSOR_TYPE_RV, ELEMENT_VENDOR, m_vendor)) {
- ERR("[VENDOR] is empty\n");
+ _E("[VENDOR] is empty\n");
throw ENXIO;
}
- INFO("m_vendor = %s", m_vendor.c_str());
+ _I("m_vendor = %s", m_vendor.c_str());
if (!config.get(SENSOR_TYPE_RV, ELEMENT_DEFAULT_SAMPLING_TIME, &m_default_sampling_time)) {
- ERR("[DEFAULT_SAMPLING_TIME] is empty\n");
+ _E("[DEFAULT_SAMPLING_TIME] is empty\n");
throw ENXIO;
}
- INFO("m_default_sampling_time = %d", m_default_sampling_time);
+ _I("m_default_sampling_time = %d", m_default_sampling_time);
m_interval = m_default_sampling_time * MS_TO_US;
}
rv_sensor::~rv_sensor()
{
- INFO("rv_sensor is destroyed!\n");
+ _I("rv_sensor is destroyed!\n");
}
bool rv_sensor::init()
m_fusion_sensor = sensor_loader::get_instance().get_sensor(FUSION_SENSOR);
if (!m_accel_sensor || !m_gyro_sensor || !m_magnetic_sensor || !m_fusion_sensor) {
- ERR("Failed to load sensors, accel: 0x%x, gyro: 0x%x, mag: 0x%x, fusion: 0x%x",
+ _E("Failed to load sensors, accel: 0x%x, gyro: 0x%x, mag: 0x%x, fusion: 0x%x",
m_accel_sensor, m_gyro_sensor, m_magnetic_sensor, m_fusion_sensor);
return false;
}
- INFO("%s is created!\n", sensor_base::get_name());
+ _I("%s is created!\n", sensor_base::get_name());
return true;
}
register_supported_event(TILT_RAW_DATA_EVENT);
if (!config.get(SENSOR_TYPE_TILT, ELEMENT_VENDOR, m_vendor)) {
- ERR("[VENDOR] is empty\n");
+ _E("[VENDOR] is empty\n");
throw ENXIO;
}
- INFO("m_vendor = %s", m_vendor.c_str());
+ _I("m_vendor = %s", m_vendor.c_str());
if (!config.get(SENSOR_TYPE_TILT, ELEMENT_RAW_DATA_UNIT, m_raw_data_unit)) {
- ERR("[RAW_DATA_UNIT] is empty\n");
+ _E("[RAW_DATA_UNIT] is empty\n");
throw ENXIO;
}
- INFO("m_raw_data_unit = %s", m_raw_data_unit.c_str());
+ _I("m_raw_data_unit = %s", m_raw_data_unit.c_str());
if (!config.get(SENSOR_TYPE_TILT, ELEMENT_DEFAULT_SAMPLING_TIME, &m_default_sampling_time)) {
- ERR("[DEFAULT_SAMPLING_TIME] is empty\n");
+ _E("[DEFAULT_SAMPLING_TIME] is empty\n");
throw ENXIO;
}
- INFO("m_default_sampling_time = %d", m_default_sampling_time);
+ _I("m_default_sampling_time = %d", m_default_sampling_time);
if (!config.get(SENSOR_TYPE_TILT, ELEMENT_PITCH_ROTATION_COMPENSATION, &m_pitch_rotation_compensation)) {
- ERR("[PITCH_ROTATION_COMPENSATION] is empty\n");
+ _E("[PITCH_ROTATION_COMPENSATION] is empty\n");
throw ENXIO;
}
- INFO("m_pitch_rotation_compensation = %d", m_pitch_rotation_compensation);
+ _I("m_pitch_rotation_compensation = %d", m_pitch_rotation_compensation);
if (!config.get(SENSOR_TYPE_TILT, ELEMENT_ROLL_ROTATION_COMPENSATION, &m_roll_rotation_compensation)) {
- ERR("[ROLL_ROTATION_COMPENSATION] is empty\n");
+ _E("[ROLL_ROTATION_COMPENSATION] is empty\n");
throw ENXIO;
}
- INFO("m_roll_rotation_compensation = %d", m_roll_rotation_compensation);
+ _I("m_roll_rotation_compensation = %d", m_roll_rotation_compensation);
m_interval = m_default_sampling_time * MS_TO_US;
tilt_sensor::~tilt_sensor()
{
- INFO("tilt_sensor is destroyed!\n");
+ _I("tilt_sensor is destroyed!\n");
}
bool tilt_sensor::init(void)
m_fusion_sensor = sensor_loader::get_instance().get_sensor(FUSION_SENSOR);
if (!m_accel_sensor || !m_fusion_sensor) {
- ERR("Failed to load sensors, accel: 0x%x, fusion: 0x%x",
+ _E("Failed to load sensors, accel: 0x%x, fusion: 0x%x",
m_accel_sensor, m_fusion_sensor);
return false;
}
- INFO("%s is created!\n", sensor_base::get_name());
+ _I("%s is created!\n", sensor_base::get_name());
return true;
}
if (m_client == 1) {
if (!on_start()) {
- ERR("[%s] sensor failed to start", get_name());
+ _E("[%s] sensor failed to start", get_name());
return false;
}
m_started = true;
}
- INFO("[%s] sensor started, #client = %d", get_name(), m_client);
+ _I("[%s] sensor started, #client = %d", get_name(), m_client);
return true;
}
if (m_client == 0) {
if (!on_stop()) {
- ERR("[%s] sensor faild to stop", get_name());
+ _E("[%s] sensor faild to stop", get_name());
return false;
}
m_started = false;
}
- INFO("[%s] sensor stopped, #client = %d", get_name(), m_client);
+ _I("[%s] sensor stopped, #client = %d", get_name(), m_client);
return true;
}
cur_min = m_plugin_info_list.get_min_interval();
if (cur_min != prev_min) {
- INFO("Min interval for sensor[0x%llx] is changed from %dms to %dms"
+ _I("Min interval for sensor[0x%llx] is changed from %dms to %dms"
" by%sclient[%d] adding interval",
get_id(), prev_min, cur_min,
is_processor ? " processor " : " ", client_id);
cur_min = m_plugin_info_list.get_min_interval();
if (!cur_min) {
- INFO("No interval for sensor[0x%llx] by%sclient[%d] deleting interval, "
+ _I("No interval for sensor[0x%llx] by%sclient[%d] deleting interval, "
"so set to default %dms",
get_id(), is_processor ? " processor " : " ",
client_id, POLL_1HZ_MS);
set_interval(POLL_1HZ_MS);
} else if (cur_min != prev_min) {
- INFO("Min interval for sensor[0x%llx] is changed from %dms to %dms"
+ _I("Min interval for sensor[0x%llx] is changed from %dms to %dms"
" by%sclient[%d] deleting interval",
get_id(), prev_min, cur_min,
is_processor ? " processor " : " ", client_id);
cur_max = m_plugin_info_list.get_max_batch();
if (cur_max != prev_max) {
- INFO("Max latency for sensor[0x%llx] is changed from %dms to %dms by client[%d] adding latency",
+ _I("Max latency for sensor[0x%llx] is changed from %dms to %dms by client[%d] adding latency",
get_id(), prev_max, cur_max, client_id);
set_batch_latency(cur_max);
}
cur_max = m_plugin_info_list.get_max_batch();
if (!cur_max) {
- INFO("No latency for sensor[0x%llx] by client[%d] deleting latency, so set to default 0 ms",
+ _I("No latency for sensor[0x%llx] by client[%d] deleting latency, so set to default 0 ms",
get_id(), client_id);
set_batch_latency(0);
} else if (cur_max != prev_max) {
- INFO("Max latency for sensor[0x%llx] is changed from %dms to %dms by client[%d] deleting latency",
+ _I("Max latency for sensor[0x%llx] is changed from %dms to %dms by client[%d] deleting latency",
get_id(), prev_max, cur_max, client_id);
set_batch_latency(cur_max);
cur_wakeup = m_plugin_info_list.is_wakeup_on();
if ((cur_wakeup == SENSOR_WAKEUP_ON) && (prev_wakeup < SENSOR_WAKEUP_ON)) {
- INFO("Wakeup for sensor[0x%llx] is changed from %d to %d by client[%d] adding wakeup",
+ _I("Wakeup for sensor[0x%llx] is changed from %d to %d by client[%d] adding wakeup",
get_id(), prev_wakeup, cur_wakeup, client_id);
set_wakeup(SENSOR_WAKEUP_ON);
}
cur_wakeup = m_plugin_info_list.is_wakeup_on();
if ((cur_wakeup < SENSOR_WAKEUP_ON) && (prev_wakeup == SENSOR_WAKEUP_ON)) {
- INFO("Wakeup for sensor[0x%llx] is changed from %d to %d by client[%d] deleting wakeup",
+ _I("Wakeup for sensor[0x%llx] is changed from %d to %d by client[%d] deleting wakeup",
get_id(), prev_wakeup, cur_wakeup, client_id);
set_wakeup(SENSOR_WAKEUP_OFF);
}
unsigned long long sensor_base::get_timestamp(timeval *t)
{
if (!t) {
- ERR("t is NULL");
+ _E("t is NULL");
return 0;
}
bool sensor_event_dispatcher::run(void)
{
- INFO("Starting Event Dispatcher\n");
+ _I("Starting Event Dispatcher\n");
if (!m_accept_socket.create(SOCK_SEQPACKET)) {
- ERR("Listener Socket Creation failed in Server \n");
+ _E("Listener Socket Creation failed in Server \n");
return false;
}
if(!m_accept_socket.bind(EVENT_CHANNEL_PATH)) {
- ERR("Listener Socket Binding failed in Server \n");
+ _E("Listener Socket Binding failed in Server \n");
m_accept_socket.close();
return false;
}
if(!m_accept_socket.listen(MAX_PENDING_CONNECTION)) {
- ERR("Socket Listen failed in Server \n");
+ _E("Socket Listen failed in Server \n");
return false;
}
client_socket.set_connection_mode();
if (client_socket.recv(&client_id, sizeof(client_id)) <= 0) {
- ERR("Failed to receive client id on socket fd[%d]", client_socket.get_socket_fd());
+ _E("Failed to receive client id on socket fd[%d]", client_socket.get_socket_fd());
return;
}
AUTOLOCK(m_mutex);
if(!get_client_info_manager().set_event_socket(client_id, client_socket)) {
- ERR("Failed to store event socket[%d] for %s", client_socket.get_socket_fd(),
+ _E("Failed to store event socket[%d] for %s", client_socket.get_socket_fd(),
client_info_manager.get_client_info(client_id));
return;
}
event_channel_ready.magic = EVENT_CHANNEL_MAGIC;
event_channel_ready.client_id = client_id;
- INFO("Event channel is accepted for %s on socket[%d]",
+ _I("Event channel is accepted for %s on socket[%d]",
client_info_manager.get_client_info(client_id), client_socket.get_socket_fd());
if (client_socket.send(&event_channel_ready, sizeof(event_channel_ready)) <= 0) {
- ERR("Failed to send event_channel_ready packet to %s on socket fd[%d]",
+ _E("Failed to send event_channel_ready packet to %s on socket fd[%d]",
client_info_manager.get_client_info(client_id), client_socket.get_socket_fd());
return;
}
void sensor_event_dispatcher::accept_connections(void)
{
- INFO("Event channel acceptor is started.\n");
+ _I("Event channel acceptor is started.\n");
while (true) {
csocket client_socket;
if (!m_accept_socket.accept(client_socket)) {
- ERR("Accepting socket failed in Server \n");
+ _E("Accepting socket failed in Server \n");
continue;
}
- INFO("New client connected (socket_fd : %d)\n", client_socket.get_socket_fd());
+ _I("New client connected (socket_fd : %d)\n", client_socket.get_socket_fd());
thread event_channel_creator(&sensor_event_dispatcher::accept_event_channel, this, client_socket);
event_channel_creator.detach();
vector<sensor_event_t> v_sensor_events(MAX_SYNTH_PER_SENSOR);
- INFO("Event Dispatcher started");
+ _I("Event Dispatcher started");
while (true) {
void *seed_event = get_event_queue().pop();
for (int i = 0; i < synthesized_cnt; ++i) {
sensor_event_t *v_event = (sensor_event_t*)malloc(sizeof(sensor_event_t));
if (!v_event) {
- ERR("Failed to allocate memory");
+ _E("Failed to allocate memory");
continue;
}
event = (void *)malloc(length);
if (!event) {
- ERR("Failed to allocate memory");
+ _E("Failed to allocate memory");
return;
}
bool ret = (client_socket.send(event, length) > 0);
if (ret)
- DBG("Event[0x%x] sent to %s on socket[%d]", event_type, client_info_manager.get_client_info(*it_client_id), client_socket.get_socket_fd());
+ _D("Event[0x%x] sent to %s on socket[%d]", event_type, client_info_manager.get_client_info(*it_client_id), client_socket.get_socket_fd());
else
- ERR("Failed to send event[0x%x] to %s on socket[%d]", event_type, client_info_manager.get_client_info(*it_client_id), client_socket.get_socket_fd());
+ _E("Failed to send event[0x%x] to %s on socket[%d]", event_type, client_info_manager.get_client_info(*it_client_id), client_socket.get_socket_fd());
++it_client_id;
}
if (client_info_manager.get_registered_events(client_id, sensor_id, event_vec)) {
if (!client_info_manager.get_event_socket(client_id, client_socket)) {
- ERR("Failed to get event socket from %s",
+ _E("Failed to get event socket from %s",
client_info_manager.get_client_info(client_id));
return;
}
sensor_event_t event;
if (is_record_event(*it_event) && get_last_event(*it_event, event)) {
if (client_socket.send(&event, sizeof(event)) > 0)
- INFO("Send the last event[0x%x] to %s on socket[%d]", event.event_type,
+ _I("Send the last event[0x%x] to %s on socket[%d]", event.event_type,
client_info_manager.get_client_info(client_id), client_socket.get_socket_fd());
else
- ERR("Failed to send event[0x%x] to %s on socket[%d]", event.event_type,
+ _E("Failed to send event[0x%x] to %s on socket[%d]", event.event_type,
client_info_manager.get_client_info(client_id), client_socket.get_socket_fd());
}
++it_event;
AUTOLOCK(m_active_virtual_sensors_mutex);
if (has_active_virtual_sensor(sensor)) {
- ERR("[%s] sensor is already added on active virtual sensors", sensor->get_name());
+ _E("[%s] sensor is already added on active virtual sensors", sensor->get_name());
return false;
}
auto it_v_sensor = find(m_active_virtual_sensors.begin(), m_active_virtual_sensors.end(), sensor);
if (it_v_sensor == m_active_virtual_sensors.end()) {
- ERR("Fail to delete non-existent [%s] sensor on active virtual sensors", sensor->get_name());
+ _E("Fail to delete non-existent [%s] sensor on active virtual sensors", sensor->get_name());
return false;
}
sensor = dynamic_cast<physical_sensor *>(it->second);
if (!sensor) {
- ERR("Failed to get sensor");
+ _E("Failed to get sensor");
return false;
}
bool wake = m_queue.empty();
if (m_queue.size() >= QUEUE_FULL_SIZE) {
- ERR("Queue is full, drop it!");
+ _E("Queue is full, drop it!");
free(event);
} else
m_queue.push(event);
int size;
sensor_device_t *_devices = NULL;
- INFO("load device: [%s]", path.c_str());
+ _I("load device: [%s]", path.c_str());
void *_handle = dlopen(path.c_str(), RTLD_NOW);
if (!_handle) {
- ERR("Failed to dlopen(%s), dlerror : %s", path.c_str(), dlerror());
+ _E("Failed to dlopen(%s), dlerror : %s", path.c_str(), dlerror());
return false;
}
create_t create_devices = (create_t) dlsym(_handle, "create");
if (!create_devices) {
- ERR("Failed to find symbols in %s", path.c_str());
+ _E("Failed to find symbols in %s", path.c_str());
dlclose(_handle);
return false;
}
size = create_devices(&_devices);
if (!_devices) {
- ERR("Failed to create devices, path is %s\n", path.c_str());
+ _E("Failed to create devices, path is %s\n", path.c_str());
dlclose(_handle);
return false;
}
sensor = new(std::nothrow) physical_sensor();
if (!sensor) {
- ERR("Memory allocation failed[%s]", handle.name);
+ _E("Memory allocation failed[%s]", handle.name);
return NULL;
}
std::shared_ptr<sensor_base> sensor_ptr(sensor);
m_sensors.insert(std::make_pair((sensor_type_t)(handles[i].type), sensor_ptr));
- INFO("inserted [%s] sensor", sensor->get_name());
+ _I("inserted [%s] sensor", sensor->get_name());
}
}
try {
instance = new _sensor;
} catch (std::exception &e) {
- ERR("Failed to create %s sensor, exception: %s", name, e.what());
+ _E("Failed to create %s sensor, exception: %s", name, e.what());
return;
} catch (int err) {
- ERR("Failed to create %s sensor err: %d, cause: %s", name, err, strerror(err));
+ _E("Failed to create %s sensor err: %d, cause: %s", name, err, strerror(err));
return;
}
if (!instance->init()) {
- ERR("Failed to init %s", name);
+ _E("Failed to init %s", name);
delete instance;
return;
}
void sensor_loader::show_sensor_info(void)
{
- INFO("========== Loaded sensor information ==========\n");
+ _I("========== Loaded sensor information ==========\n");
int index = 0;
sensor_info info;
sensor->get_sensor_info(info);
- INFO("No:%d [%s]\n", ++index, sensor->get_name());
+ _I("No:%d [%s]\n", ++index, sensor->get_name());
info.show();
it++;
}
- INFO("===============================================\n");
+ _I("===============================================\n");
}
bool sensor_loader::get_paths_from_dir(const string &dir_path, vector<string> &plugin_paths)
dir = opendir(dir_path.c_str());
if (!dir) {
- ERR("Failed to open dir: %s", dir_path.c_str());
+ _E("Failed to open dir: %s", dir_path.c_str());
return false;
}
auto it_event = find(m_reg_events.begin(), m_reg_events.end(), event_type);
if (it_event != m_reg_events.end()) {
- ERR("Event[0x%x] is already registered", event_type);
+ _E("Event[0x%x] is already registered", event_type);
return false;
}
auto it_event = find(m_reg_events.begin(), m_reg_events.end(), event_type);
if (it_event == m_reg_events.end()) {
- ERR("Event[0x%x] is not found",event_type);
+ _E("Event[0x%x] is not found",event_type);
return false;
}
auto it_event = find (m_reg_events.begin(), m_reg_events.end(), event_type);
if (it_event == m_reg_events.end()){
- DBG("Event[0x%x] is not registered",event_type);
+ _D("Event[0x%x] is not registered",event_type);
return false;
}
{
command_worker *cmd_worker;
- INFO("Client acceptor is started");
+ _I("Client acceptor is started");
while (true) {
csocket client_command_socket;
if (!m_client_accep_socket.accept(client_command_socket)) {
- ERR("Failed to accept connection request from a client");
+ _E("Failed to accept connection request from a client");
continue;
}
- DBG("New client (socket_fd : %d) connected", client_command_socket.get_socket_fd());
+ _D("New client (socket_fd : %d) connected", client_command_socket.get_socket_fd());
cmd_worker = new(std::nothrow) command_worker(client_command_socket);
if (!cmd_worker) {
- ERR("Failed to allocate memory");
+ _E("Failed to allocate memory");
continue;
}
void server::poll_event(void)
{
- INFO("Event poller is started");
+ _I("Event poller is started");
sensor_event_poller poller;
if (!poller.poll()) {
- ERR("Failed to poll event");
+ _E("Failed to poll event");
return;
}
}
sock_fd = get_systemd_socket(COMMAND_CHANNEL_PATH);
if (sock_fd >= 0) {
- INFO("Succeeded to get systemd socket(%d)", sock_fd);
+ _I("Succeeded to get systemd socket(%d)", sock_fd);
m_client_accep_socket = csocket(sock_fd);
} else {
- ERR("Failed to get systemd socket, create it by myself!");
+ _E("Failed to get systemd socket, create it by myself!");
if (!m_client_accep_socket.create(SOCK_STREAM)) {
- ERR("Failed to create command channel");
+ _E("Failed to create command channel");
return;
}
if(!m_client_accep_socket.bind(COMMAND_CHANNEL_PATH)) {
- ERR("Failed to bind command channel");
+ _E("Failed to bind command channel");
m_client_accep_socket.close();
return;
}
if(!m_client_accep_socket.listen(MAX_PENDING_CONNECTION)) {
- ERR("Failed to listen command channel");
+ _E("Failed to listen command channel");
return;
}
}
inst.load_config(VIRTUAL_SENSOR_CONFIG_FILE_PATH);
inst.get_device_id();
if (!inst.m_device_id.empty())
- INFO("Device ID = %s", inst.m_device_id.c_str());
+ _I("Device ID = %s", inst.m_device_id.c_str());
else
- ERR("Failed to get Device ID");
+ _E("Failed to get Device ID");
load_done = true;
}
xmlDocPtr doc;
xmlNodePtr cur;
- DBG("virtual_sensor_config::load_config(\"%s\") is called!\n",config_path.c_str());
+ _D("virtual_sensor_config::load_config(\"%s\") is called!\n",config_path.c_str());
doc = xmlParseFile(config_path.c_str());
if (doc == NULL) {
- ERR("There is no %s\n",config_path.c_str());
+ _E("There is no %s\n",config_path.c_str());
return false;
}
cur = xmlDocGetRootElement(doc);
if(cur == NULL) {
- ERR("There is no root element in %s\n",config_path.c_str());
+ _E("There is no root element in %s\n",config_path.c_str());
xmlFreeDoc(doc);
return false;
}
if(xmlStrcmp(cur->name, (const xmlChar *)ROOT_ELEMENT)) {
- ERR("Wrong type document: there is no [%s] root element in %s\n",ROOT_ELEMENT,config_path.c_str());
+ _E("Wrong type document: there is no [%s] root element in %s\n",ROOT_ELEMENT,config_path.c_str());
xmlFreeDoc(doc);
return false;
}
//insert device to device_list
m_virtual_sensor_configs[device_type];
- DBG("<type=\"%s\">\n",device_type.c_str());
+ _D("<type=\"%s\">\n",device_type.c_str());
virtual_sensor_node_ptr = device_node_ptr->xmlChildrenNode;
}
m_virtual_sensor_configs[device_type][(const char*)virtual_sensor_node_ptr->name];
- DBG("<type=\"%s\"><%s>\n",device_type.c_str(),(const char*)virtual_sensor_node_ptr->name);
+ _D("<type=\"%s\"><%s>\n",device_type.c_str(),(const char*)virtual_sensor_node_ptr->name);
element_node_ptr = virtual_sensor_node_ptr->xmlChildrenNode;
while (element_node_ptr != NULL) {
//insert Element to Model
m_virtual_sensor_configs[device_type][(const char*)virtual_sensor_node_ptr->name][(const char*)element_node_ptr->name];
- DBG("<type=\"%s\"><%s><%s>\n",device_type.c_str(),(const char*)virtual_sensor_node_ptr->name,(const char*)element_node_ptr->name);
+ _D("<type=\"%s\"><%s><%s>\n",device_type.c_str(),(const char*)virtual_sensor_node_ptr->name,(const char*)element_node_ptr->name);
attr_ptr = element_node_ptr->properties;
while (attr_ptr != NULL) {
//insert attribute to Element
m_virtual_sensor_configs[device_type][(const char*)virtual_sensor_node_ptr->name][(const char*)element_node_ptr->name][key]=value;
- DBG("<type=\"%s\"><%s><%s \"%s\"=\"%s\">\n",device_type.c_str(),(const char*)virtual_sensor_node_ptr->name,(const char*)element_node_ptr->name,key.c_str(),value.c_str());
+ _D("<type=\"%s\"><%s><%s \"%s\"=\"%s\">\n",device_type.c_str(),(const char*)virtual_sensor_node_ptr->name,(const char*)element_node_ptr->name,key.c_str(),value.c_str());
attr_ptr = attr_ptr->next;
}
element_node_ptr = element_node_ptr->next;
}
- DBG("\n");
+ _D("\n");
virtual_sensor_node_ptr = virtual_sensor_node_ptr->next;
}
auto it_device_list = m_virtual_sensor_configs.find(m_device_id);
if (it_device_list == m_virtual_sensor_configs.end()) {
- ERR("There is no <%s> device\n",m_device_id.c_str());
+ _E("There is no <%s> device\n",m_device_id.c_str());
m_device_id = DEFAULT_DEVICE;
it_device_list = m_virtual_sensor_configs.find(m_device_id);
if (it_device_list == m_virtual_sensor_configs.end()) {
- ERR("There is no Default device\n");
+ _E("There is no Default device\n");
return false;
}
- INFO("m_device_id is set to Default\n");
+ _I("m_device_id is set to Default\n");
}
auto it_virtual_sensor_list = it_device_list->second.find(sensor_type);
if (it_virtual_sensor_list == it_device_list->second.end()) {
- ERR("There is no <%s> sensor\n",sensor_type.c_str());
+ _E("There is no <%s> sensor\n",sensor_type.c_str());
return false;
}
auto it_element = it_virtual_sensor_list->second.find(element);
if (it_element == it_virtual_sensor_list->second.end()) {
- ERR("There is no <%s><%s> element\n",sensor_type.c_str(),element.c_str());
+ _E("There is no <%s><%s> element\n",sensor_type.c_str(),element.c_str());
return false;
}
auto it_attr = it_element->second.find(attr);
if (it_attr == it_element->second.end()) {
- DBG("There is no <%s><%s \"%s\">\n",sensor_type.c_str(),element.c_str(),attr.c_str());
+ _D("There is no <%s><%s \"%s\">\n",sensor_type.c_str(),element.c_str(),attr.c_str());
return false;
}
}
else
{
- DBG("Count value not supported.\n");
+ _D("Count value not supported.\n");
}
return false;
}
else
{
- DBG("Count value not supported.\n");
+ _D("Count value not supported.\n");
}
return false;
{
if (m_trans_func[index] != NULL) {
if(!m_trans_func[index](m_context)) {
- ERR("Transition[%d] function returning false", index);
+ _E("Transition[%d] function returning false", index);
return false;
}
}
lock l(m_mutex);
if (m_state == WORKER_STATE_WORKING) {
- INFO("Worker thread is already working");
+ _I("Worker thread is already working");
return true;
}
return true;
}
- ERR("Failed to start, because current state(%d) is not for START", m_state);
+ _E("Failed to start, because current state(%d) is not for START", m_state);
return false;
}
lock l(m_mutex);
if (m_state == WORKER_STATE_STOPPED) {
- INFO("Worker thread is already stopped");
+ _I("Worker thread is already stopped");
return true;
}
return true;
}
- ERR("Failed to stop, because current state(%d) is not for STOP", m_state);
+ _E("Failed to stop, because current state(%d) is not for STOP", m_state);
return false;
}
lock l(m_mutex);
if (m_state == WORKER_STATE_PAUSED) {
- INFO("Worker thread is already paused");
+ _I("Worker thread is already paused");
return true;
}
return true;
}
- ERR("Failed to pause, because current state(%d) is not for PAUSE", m_state);
+ _E("Failed to pause, because current state(%d) is not for PAUSE", m_state);
return false;
lock l(m_mutex);
if (m_state == WORKER_STATE_WORKING) {
- INFO("Worker thread is already working");
+ _I("Worker thread is already working");
return true;
}
return true;
}
- ERR("Failed to resume, because current state(%d) is not for RESUME", m_state);
+ _E("Failed to resume, because current state(%d) is not for RESUME", m_state);
return false;
}
void worker_thread::main(void)
{
- DBG("Worker thread(0x%x) is created", std::this_thread::get_id());
+ _D("Worker thread(0x%x) is created", std::this_thread::get_id());
transition_function(STARTED);
if (state == WORKER_STATE_WORKING) {
if (!transition_function(WORKING)) {
m_state = WORKER_STATE_STOPPED;
- DBG("Worker thread(0x%x) exits from working state", std::this_thread::get_id());
+ _D("Worker thread(0x%x) exits from working state", std::this_thread::get_id());
m_thread_created = false;
transition_function(STOPPED);
break;
if (m_state == WORKER_STATE_PAUSED) {
transition_function(PAUSED);
- DBG("Worker thread(0x%x) is paused", std::this_thread::get_id());
+ _D("Worker thread(0x%x) is paused", std::this_thread::get_id());
m_cond_working.wait(u);
if (m_state == WORKER_STATE_WORKING) {
transition_function(RESUMED);
- DBG("Worker thread(0x%x) is resumed", std::this_thread::get_id());
+ _D("Worker thread(0x%x) is resumed", std::this_thread::get_id());
} else if (m_state == WORKER_STATE_STOPPED) {
m_thread_created = false;
transition_function(STOPPED);
break;
}
}
- INFO("Worker thread(0x%x)'s main is terminated", std::this_thread::get_id());
+ _I("Worker thread(0x%x)'s main is terminated", std::this_thread::get_id());
}
void worker_thread::set_started(trans_func_t func)
lock_waiting_start_time = MICROSECONDS(sv);
pthread_mutex_lock(&m_history_mutex);
- INFO("%s is waiting for getting %s(0x%x) owned in %s",
+ _I("%s is waiting for getting %s(0x%x) owned in %s",
m_curent_info, expr, this, m_owner_info);
pthread_mutex_unlock(&m_history_mutex);
waiting_time = lock_acquired_time - lock_waiting_start_time;
pthread_mutex_lock(&m_history_mutex);
- INFO("%s acquires lock after waiting %lluus, %s(0x%x) was previously owned in %s",
+ _I("%s acquires lock after waiting %lluus, %s(0x%x) was previously owned in %s",
m_curent_info, waiting_time, expr, this, m_owner_info);
snprintf(m_owner_info, OWNER_INFO_LEN, "%s", m_curent_info);
pthread_mutex_unlock(&m_history_mutex);
m_sock_fd = socket(AF_UNIX, sock_type, 0);
if (!is_valid()) {
- ERR("Failed to create socket for %s, errno : %d , errstr : %s ",
+ _E("Failed to create socket for %s, errno : %d , errstr : %s ",
get_client_name(), errno, strerror(errno));
return false;
}
mode_t socket_mode;
if (!is_valid()) {
- ERR("%s's socket is invalid", get_client_name());
+ _E("%s's socket is invalid", get_client_name());
return false;
}
if((fsetxattr(m_sock_fd, "security.SMACK64IPOUT", "@", 2, 0)) < 0) {
if(errno != EOPNOTSUPP) {
close();
- ERR("security.SMACK64IPOUT error = [%d][%s]\n", errno, strerror(errno) );
+ _E("security.SMACK64IPOUT error = [%d][%s]\n", errno, strerror(errno) );
return false;
}
}
if((fsetxattr(m_sock_fd, "security.SMACK64IPIN", "*", 2, 0)) < 0) {
if(errno != EOPNOTSUPP) {
close();
- ERR("security.SMACK64IPIN error = [%d][%s]\n", errno, strerror(errno) );
+ _E("security.SMACK64IPIN error = [%d][%s]\n", errno, strerror(errno) );
return false;
}
}
length = strlen(m_addr.sun_path) + sizeof(m_addr.sun_family);
if (::bind(m_sock_fd, (struct sockaddr *)&m_addr, length) < 0) {
- ERR("Binding failed for socket(%d), errno : %d , errstr : %s", m_sock_fd, errno, strerror(errno));
+ _E("Binding failed for socket(%d), errno : %d , errstr : %s", m_sock_fd, errno, strerror(errno));
close();
return false;
}
socket_mode = ( S_IRWXU | S_IRWXG | S_IRWXO );
if (chmod(sock_path, socket_mode) < 0) {
- ERR("chmod failed for socket(%d), errno : %d , errstr : %s", m_sock_fd, errno, strerror(errno));
+ _E("chmod failed for socket(%d), errno : %d , errstr : %s", m_sock_fd, errno, strerror(errno));
close();
return false;
}
bool csocket::listen(const int max_connections)
{
if (!is_valid()) {
- ERR("Socket(%d) is invalid", m_sock_fd);
+ _E("Socket(%d) is invalid", m_sock_fd);
return false;
}
if (::listen(m_sock_fd, max_connections) < 0) {
- ERR("Listening failed for socket(%d), errno : %d , errstr : %s", m_sock_fd, errno, strerror(errno));
+ _E("Listening failed for socket(%d), errno : %d , errstr : %s", m_sock_fd, errno, strerror(errno));
close();
return false;
}
} while (err == EINTR);
if (!client_socket.is_valid()) {
- ERR("Accept failed for socket(%d), errno : %d , errstr : %s", m_sock_fd, errno, strerror(errno));
+ _E("Accept failed for socket(%d), errno : %d , errstr : %s", m_sock_fd, errno, strerror(errno));
return false;
}
} while (err == EINTR);
if (err) {
- ERR("send(%d, 0x%x, %d, 0x%x) = %d cause = %s(%d)",
+ _E("send(%d, 0x%x, %d, 0x%x) = %d cause = %s(%d)",
m_sock_fd, buffer, size, m_send_flags, len, strerror(errno), errno);
}
if (len > 0) {
err = 0;
} else if (len == 0) {
- ERR("recv(%d, 0x%p , %d) = %d, because the peer performed shutdown!",
+ _E("recv(%d, 0x%p , %d) = %d, because the peer performed shutdown!",
m_sock_fd, buffer, size, len);
err = 1;
} else {
} while (err == EINTR);
if ((err == EAGAIN) || (err == EWOULDBLOCK)) {
- DBG("recv(%d, 0x%x, %d, 0x%x) = %d cause = %s(%d)",
+ _D("recv(%d, 0x%x, %d, 0x%x) = %d cause = %s(%d)",
m_sock_fd, buffer, size, m_recv_flags, len, strerror(errno), errno);
return 0;
}
if (err) {
- ERR("recv(%d, 0x%x, %d, 0x%x) = %d cause = %s(%d)",
+ _E("recv(%d, 0x%x, %d, 0x%x) = %d cause = %s(%d)",
m_sock_fd, buffer, size, m_recv_flags, len, strerror(errno), errno);
}
total_sent_size += len;
err = 0;
} else {
- ERR("send(%d, 0x%p + %d, %d - %d) = %d, error: %s(%d) for %s",
+ _E("send(%d, 0x%p + %d, %d - %d) = %d, error: %s(%d) for %s",
m_sock_fd, buffer, total_sent_size, size, total_sent_size,
len, strerror(errno), errno, get_client_name());
if (len > 0) {
total_recv_size += len;
} else if (len == 0) {
- ERR("recv(%d, 0x%p + %d, %d - %d) = %d, because the peer of %s performed shutdown!",
+ _E("recv(%d, 0x%p + %d, %d - %d) = %d, because the peer of %s performed shutdown!",
m_sock_fd, buffer, total_recv_size, size, total_recv_size, len, get_client_name());
err = 1;
break;
} else {
- ERR("recv(%d, 0x%p + %d, %d - %d) = %d, error: %s(%d) for %s",
+ _E("recv(%d, 0x%p + %d, %d - %d) = %d, error: %s(%d) for %s",
m_sock_fd, buffer, total_recv_size, size, total_recv_size,
len, strerror(errno), errno, get_client_name());
bool prev_blocking_mode;
if (!is_valid()) {
- ERR("%s's socket is invalid", get_client_name());
+ _E("%s's socket is invalid", get_client_name());
return false;
}
addr_len = strlen(m_addr.sun_path) + sizeof(m_addr.sun_family);
if (::connect(m_sock_fd,(sockaddr *) &m_addr, addr_len) < 0) {
- ERR("connect error: %s sock_fd: %d\n for %s", strerror(errno), m_sock_fd, get_client_name());
+ _E("connect error: %s sock_fd: %d\n for %s", strerror(errno), m_sock_fd, get_client_name());
return false;
}
ret = select(m_sock_fd + 1, NULL, &write_fds, NULL, &tv);
if (ret == -1) {
- ERR("select error: %s sock_fd: %d\n for %s", strerror(errno), m_sock_fd, get_client_name());
+ _E("select error: %s sock_fd: %d\n for %s", strerror(errno), m_sock_fd, get_client_name());
close();
return false;
} else if (!ret) {
- ERR("select timeout: %d seconds elapsed for %s", tv.tv_sec, get_client_name());
+ _E("select timeout: %d seconds elapsed for %s", tv.tv_sec, get_client_name());
close();
return false;
}
if (!FD_ISSET(m_sock_fd, &write_fds)) {
- ERR("select failed for %s, nothing to write, m_sock_fd : %d", get_client_name(), m_sock_fd);
+ _E("select failed for %s, nothing to write, m_sock_fd : %d", get_client_name(), m_sock_fd);
close();
return false;
}
socklen_t len = sizeof(so_error);
if (getsockopt(m_sock_fd, SOL_SOCKET, SO_ERROR, &so_error, &len) == -1) {
- ERR("getsockopt failed for %s, m_sock_fd : %d, errno : %d , errstr : %s",
+ _E("getsockopt failed for %s, m_sock_fd : %d, errno : %d , errstr : %s",
get_client_name(), m_sock_fd, errno, strerror(errno));
close();
return false;
}
if (so_error) {
- ERR("SO_ERROR occurred for %s, m_sock_fd : %d, so_error : %d",
+ _E("SO_ERROR occurred for %s, m_sock_fd : %d, so_error : %d",
get_client_name(), m_sock_fd, so_error);
close();
return false;
flags = fcntl(m_sock_fd, F_GETFL);
if (flags == -1) {
- ERR("fcntl(F_GETFL) failed for %s, m_sock_fd: %d, errno : %d , errstr : %s", get_client_name(), m_sock_fd, errno, strerror(errno));
+ _E("fcntl(F_GETFL) failed for %s, m_sock_fd: %d, errno : %d , errstr : %s", get_client_name(), m_sock_fd, errno, strerror(errno));
return false;
}
flags = fcntl(m_sock_fd, F_SETFL, flags);
if (flags == -1) {
- ERR("fcntl(F_SETFL) failed for %s, m_sock_fd: %d, errno : %d , errstr : %s", get_client_name(), m_sock_fd, errno, strerror(errno));
+ _E("fcntl(F_SETFL) failed for %s, m_sock_fd: %d, errno : %d , errstr : %s", get_client_name(), m_sock_fd, errno, strerror(errno));
return false;
}
opt_len = sizeof(sock_type);
if (getsockopt(m_sock_fd, SOL_SOCKET, SO_TYPE, &sock_type, &opt_len) < 0) {
- ERR("getsockopt(SOL_SOCKET, SO_TYPE) failed for %s, m_sock_fd: %d, errno : %d , errstr : %s", get_client_name(), m_sock_fd, errno, strerror(errno));
+ _E("getsockopt(SOL_SOCKET, SO_TYPE) failed for %s, m_sock_fd: %d, errno : %d , errstr : %s", get_client_name(), m_sock_fd, errno, strerror(errno));
return false;
}
tv.tv_usec = 0;
if(setsockopt(m_sock_fd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)) < 0) {
- ERR("Set SO_RCVTIMEO failed for %s, m_sock_fd : %d, errno : %d , errstr : %s",
+ _E("Set SO_RCVTIMEO failed for %s, m_sock_fd : %d, errno : %d , errstr : %s",
get_client_name(), m_sock_fd, errno, strerror(errno));
close();
return false;
flags = fcntl(m_sock_fd, F_GETFL);
if (flags == -1) {
- ERR("fcntl(F_GETFL) failed for %s, m_sock_fd: %d, errno : %d , errstr : %s", get_client_name(), m_sock_fd, errno, strerror(errno));
+ _E("fcntl(F_GETFL) failed for %s, m_sock_fd: %d, errno : %d , errstr : %s", get_client_name(), m_sock_fd, errno, strerror(errno));
return false;
}
{
if (m_sock_fd >= 0) {
if (::close(m_sock_fd) < 0) {
- ERR("Socket(%d) close failed, errno : %d , errstr : %s", m_sock_fd, errno, strerror(errno));
+ _E("Socket(%d) close failed, errno : %d , errstr : %s", m_sock_fd, errno, strerror(errno));
return false;
}
m_sock_fd = -1;
event.events = EPOLLIN | EPOLLERR | EPOLLHUP;
if (epoll_ctl(m_epfd, EPOLL_CTL_ADD, fd, &event)) {
- ERR("errno : %d , errstr : %s", errno, strerror(errno));
+ _E("errno : %d , errstr : %s", errno, strerror(errno));
return false;
}
if (errno == EINTR)
return true;
- ERR("Epoll failed errrno : %d , errstr : %s", errno, strerror(errno));
+ _E("Epoll failed errrno : %d , errstr : %s", errno, strerror(errno));
return false;
}
if (nr_events == 0) {
- ERR("Epoll timeout!");
+ _E("Epoll timeout!");
return false;
}
m_event_queue.pop();
if (event.events & EPOLLERR) {
- DBG("Poll error!");
+ _D("Poll error!");
return false;
}
if (event.events & EPOLLHUP) {
- INFO("Poll: Connetion is closed from the other side");
+ _I("Poll: Connetion is closed from the other side");
return false;
}
void sensor_info::show(void)
{
- INFO("Type = %d", m_type);
- INFO("ID = 0x%llx", (int64_t)m_id);
- INFO("Privilege = %d", (int)m_privilege);
- INFO("Name = %s", m_name.c_str());
- INFO("Vendor = %s", m_vendor.c_str());
- INFO("Min_range = %f", m_min_range);
- INFO("Max_range = %f", m_max_range);
- INFO("Resolution = %f", m_resolution);
- INFO("Min_interval = %d", m_min_interval);
- INFO("Fifo_count = %d", m_fifo_count);
- INFO("Max_batch_count = %d", m_max_batch_count);
- INFO("supported_event = 0x%x", m_supported_event);
-
- INFO("Wakeup_supported = %d", m_wakeup_supported);
+ _I("Type = %d", m_type);
+ _I("ID = 0x%llx", (int64_t)m_id);
+ _I("Privilege = %d", (int)m_privilege);
+ _I("Name = %s", m_name.c_str());
+ _I("Vendor = %s", m_vendor.c_str());
+ _I("Min_range = %f", m_min_range);
+ _I("Max_range = %f", m_max_range);
+ _I("Resolution = %f", m_resolution);
+ _I("Min_interval = %d", m_min_interval);
+ _I("Fifo_count = %d", m_fifo_count);
+ _I("Max_batch_count = %d", m_max_batch_count);
+ _I("supported_event = 0x%x", m_supported_event);
+
+ _I("Wakeup_supported = %d", m_wakeup_supported);
}
#ifdef _DEBUG
#define DBG SLOGD
#else
-#define DBG(...) do{} while(0)
+#define _D(...) do{} while(0)
#endif
#define ERR SLOGE
#if defined(_DEBUG)
# define warn_if(expr, fmt, arg...) do { \
if(expr) { \
- DBG("(%s) -> " fmt, #expr, ##arg); \
+ _D("(%s) -> " fmt, #expr, ##arg); \
} \
} while (0)
# define ret_if(expr) do { \
if(expr) { \
- DBG("(%s) -> %s() return", #expr, __FUNCTION__); \
+ _D("(%s) -> %s() return", #expr, __FUNCTION__); \
return; \
} \
} while (0)
# define retv_if(expr, val) do { \
if(expr) { \
- DBG("(%s) -> %s() return", #expr, __FUNCTION__); \
+ _D("(%s) -> %s() return", #expr, __FUNCTION__); \
return (val); \
} \
} while (0)
# define retm_if(expr, fmt, arg...) do { \
if(expr) { \
- ERR(fmt, ##arg); \
- DBG("(%s) -> %s() return", #expr, __FUNCTION__); \
+ _E(fmt, ##arg); \
+ _D("(%s) -> %s() return", #expr, __FUNCTION__); \
return; \
} \
} while (0)
# define retvm_if(expr, val, fmt, arg...) do { \
if(expr) { \
- ERR(fmt, ##arg); \
- DBG("(%s) -> %s() return", #expr, __FUNCTION__); \
+ _E(fmt, ##arg); \
+ _D("(%s) -> %s() return", #expr, __FUNCTION__); \
return (val); \
} \
} while (0)
#else
# define warn_if(expr, fmt, arg...) do { \
if(expr) { \
- ERR(fmt, ##arg); \
+ _E(fmt, ##arg); \
} \
} while (0)
# define ret_if(expr) do { \
} while (0)
# define retm_if(expr, fmt, arg...) do { \
if(expr) { \
- ERR(fmt, ##arg); \
+ _E(fmt, ##arg); \
return; \
} \
} while (0)
# define retvm_if(expr, val, fmt, arg...) do { \
if(expr) { \
- ERR(fmt, ##arg); \
+ _E(fmt, ##arg); \
return (val); \
} \
} while (0)
projects / platform / core / system / sensord.git / commitdiff