From 57d79e0450451366d325ebd08638d1cdcb5b6043 Mon Sep 17 00:00:00 2001 From: "kibak.yoon" Date: Tue, 2 Feb 2016 11:58:46 +0900 Subject: [PATCH] sensord: [3/4] add the refactored HAL interface * use the refactored HAL interface Change-Id: Id25bc3b424f2cbf0847408f90c8f4d0b21fdd140 Signed-off-by: kibak.yoon --- src/client/command_channel.cpp | 4 +- src/client/sensor_event_listener.cpp | 15 ++- src/server/command_worker.cpp | 21 ++-- src/server/physical_sensor.cpp | 125 ++++++++++++++--------- src/server/physical_sensor.h | 14 ++- src/server/sensor_base.cpp | 178 +++++++++++++-------------------- src/server/sensor_base.h | 50 ++++----- src/server/sensor_event_dispatcher.cpp | 19 +++- src/server/sensor_event_poller.cpp | 38 ++++--- src/server/sensor_event_poller.h | 4 +- src/server/sensor_event_queue.h | 6 +- src/server/sensor_loader.cpp.in | 2 +- 12 files changed, 235 insertions(+), 241 deletions(-) diff --git a/src/client/command_channel.cpp b/src/client/command_channel.cpp index 92bc9dd..902ec76 100644 --- a/src/client/command_channel.cpp +++ b/src/client/command_channel.cpp @@ -17,6 +17,7 @@ * */ +#include #include #include #include @@ -697,8 +698,7 @@ bool command_channel::cmd_send_sensorhub_data(const char* buffer, int data_len) cmd_send_sensorhub_data = (cmd_send_sensorhub_data_t*)packet->data(); cmd_send_sensorhub_data->data_len = data_len; - memcpy(cmd_send_sensorhub_data->data, buffer, data_len); - + cmd_send_sensorhub_data->data = atoi(buffer); INFO("%s send cmd_send_sensorhub_data(client_id=%d, data_len = %d, buffer = 0x%x)", get_client_name(), m_client_id, data_len, buffer); diff --git a/src/client/sensor_event_listener.cpp b/src/client/sensor_event_listener.cpp index 2c94ca8..52dada1 100644 --- a/src/client/sensor_event_listener.cpp +++ b/src/client/sensor_event_listener.cpp @@ -183,17 +183,18 @@ void sensor_event_listener::handle_events(void* event) } else { sensor_event_t *sensor_event = (sensor_event_t *)event; sensor_id = sensor_event->sensor_id; - sensor_data = &(sensor_event->data); - cur_time = sensor_event->data.timestamp; - accuracy = sensor_event->data.accuracy; + sensor_event->data = (sensor_data_t *)((void *)sensor_event + sizeof(sensor_event_t)); + sensor_data = sensor_event->data; + cur_time = sensor_event->data->timestamp; + accuracy = sensor_event->data->accuracy; if (is_single_state_event(event_type)) { - single_state_event_data = (int) sensor_event->data.values[0]; + single_state_event_data = (int) sensor_event->data->values[0]; event_data.event_data = (void *)&(single_state_event_data); event_data.event_data_size = sizeof(single_state_event_data); } else if (is_panning_event(event_type)) { - panning_data.x = (int)sensor_event->data.values[0]; - panning_data.y = (int)sensor_event->data.values[1]; + panning_data.x = (int)sensor_event->data->values[0]; + panning_data.y = (int)sensor_event->data->values[1]; event_data.event_data = (void *)&panning_data; event_data.event_data_size = sizeof(panning_data); } else { @@ -259,10 +260,8 @@ void sensor_event_listener::handle_events(void* event) post_callback_to_main_loop(*it_calback_info); ++it_calback_info; } - } - client_callback_info* sensor_event_listener::get_callback_info(sensor_id_t sensor_id, const reg_event_info *event_info, void* sensor_data, void *buffer) { client_callback_info* callback_info; diff --git a/src/server/command_worker.cpp b/src/server/command_worker.cpp index c550ce3..e4d8191 100644 --- a/src/server/command_worker.cpp +++ b/src/server/command_worker.cpp @@ -305,7 +305,6 @@ bool command_worker::send_cmd_get_id_done(int client_id) bool command_worker::send_cmd_get_data_done(int state, sensor_data_t *data) { - cpacket* ret_packet; cmd_get_data_done_t *cmd_get_data_done; @@ -745,7 +744,7 @@ bool command_worker::cmd_set_command(void *payload) goto out; } - ret_value = m_module->set_command(cmd->cmd, cmd->value); + ret_value = m_module->set_attribute(cmd->cmd, cmd->value); out: if (!send_cmd_done(ret_value)) @@ -760,7 +759,7 @@ bool command_worker::cmd_get_data(void *payload) int state = OP_ERROR; bool adjusted = false; - sensor_data_t data; + sensor_data_t *data; DBG("CMD_GET_VALUE Handler invoked\n"); @@ -771,7 +770,7 @@ bool command_worker::cmd_get_data(void *payload) goto out; } - state = m_module->get_sensor_data(data); + state = m_module->get_data(&data); // In case of not getting sensor data, wait short time and retry again // 1. changing interval to be less than 10ms @@ -780,7 +779,7 @@ bool command_worker::cmd_get_data(void *payload) // 4. retrying to get data // 5. repeat 2 ~ 4 operations RETRY_CNT times // 6. reverting back to original interval - if (!state && !data.timestamp) { + if ((state > 0) && !data->timestamp) { const int RETRY_CNT = 5; const unsigned long long INIT_WAIT_TIME = 20000; //20ms const unsigned long WAIT_TIME = 100000; //100ms @@ -793,26 +792,26 @@ bool command_worker::cmd_get_data(void *payload) adjusted = true; } - while (!state && !data.timestamp && (retry++ < RETRY_CNT)) { + 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); usleep((retry == 1) ? INIT_WAIT_TIME : WAIT_TIME); - state = m_module->get_sensor_data(data); + state = m_module->get_data(&data); } if (adjusted) m_module->add_interval(m_client_id, interval, false); } - if (!data.timestamp) + if (!data->timestamp) state = OP_ERROR; - if (state) { + if (state <= 0) { ERR("Failed to get data for client [%d], for sensor [0x%llx]", m_client_id, m_sensor_id); } out: - send_cmd_get_data_done(state, &data); + send_cmd_get_data_done(state, data); return true; } @@ -833,7 +832,7 @@ bool command_worker::cmd_send_sensorhub_data(void *payload) goto out; } - ret_value = m_module->send_sensorhub_data(cmd->data, cmd->data_len); + ret_value = m_module->set_attribute(cmd->data, cmd->data_len); out: if (!send_cmd_done(ret_value)) diff --git a/src/server/physical_sensor.cpp b/src/server/physical_sensor.cpp index 3c6f697..7d6de5a 100644 --- a/src/server/physical_sensor.cpp +++ b/src/server/physical_sensor.cpp @@ -27,12 +27,24 @@ cmutex physical_sensor::m_mutex; physical_sensor::physical_sensor() : m_sensor_device(NULL) { - } physical_sensor::~physical_sensor() { +} +void physical_sensor::set_sensor_handle(sensor_handle_t handle) +{ + m_handle.id = handle.id; + m_handle.name = handle.name; + m_handle.type = handle.type; + m_handle.event_type = handle.event_type; + m_handle.info = handle.info; +} + +void physical_sensor::set_sensor_device(sensor_device *device) +{ + m_sensor_device = device; } sensor_type_t physical_sensor::get_type(void) @@ -47,24 +59,10 @@ unsigned int physical_sensor::get_event_type(void) const char* physical_sensor::get_name(void) { - if (m_handle.name.empty()) + if (!m_handle.name) return UNKNOWN_NAME; - return m_handle.name.c_str(); -} - -void physical_sensor::set_sensor_handle(sensor_handle_t handle) -{ - m_handle.id = handle.id; - m_handle.name = handle.name; - m_handle.type = handle.type; - m_handle.event_type = handle.event_type; - m_handle.properties = handle.properties; -} - -void physical_sensor::set_sensor_device(sensor_device *device) -{ - m_sensor_device = device; + return m_handle.name; } int physical_sensor::get_poll_fd() @@ -77,86 +75,119 @@ int physical_sensor::get_poll_fd() return m_sensor_device->get_poll_fd(); } -bool physical_sensor::on_start() +bool physical_sensor::read_fd(std::vector &ids) { AUTOLOCK(m_mutex); - return m_sensor_device->enable(m_handle.id); + if (!m_sensor_device) + return false; + + return m_sensor_device->read_fd(ids); } -bool physical_sensor::on_stop() +int physical_sensor::get_data(sensor_data_t **data) { AUTOLOCK(m_mutex); - return m_sensor_device->disable(m_handle.id); + if (!m_sensor_device) + return false; + + int length = -1; + length = m_sensor_device->get_data(m_handle.id, data); + + if (length < 0) { + ERR("Failed to get sensor event"); + return -1; + } + + return length; } -long physical_sensor::set_command(unsigned int cmd, long value) +bool physical_sensor::flush(void) { AUTOLOCK(m_mutex); - return m_sensor_device->set_command(m_handle.id, std::to_string(cmd), std::to_string(value)); + if (!m_sensor_device) + return false; + + return m_sensor_device->flush(m_handle.id); } bool physical_sensor::set_interval(unsigned long interval) { AUTOLOCK(m_mutex); + if (!m_sensor_device) + return false; + INFO("Polling interval is set to %dms", interval); return m_sensor_device->set_interval(m_handle.id, interval); } -bool physical_sensor::set_batch(unsigned long latency) +bool physical_sensor::set_batch_latency(unsigned long latency) { AUTOLOCK(m_mutex); + if (!m_sensor_device) + return false; + INFO("Polling interval is set to %dms", latency); return m_sensor_device->set_batch_latency(m_handle.id, latency); } -bool physical_sensor::set_wakeup(int wakeup) +int physical_sensor::set_attribute(int32_t attribute, int32_t value) { - return false; + AUTOLOCK(m_mutex); + + if (!m_sensor_device) + return false; + + return m_sensor_device->set_attribute(m_handle.id, attribute, value); } -bool physical_sensor::is_data_ready(void) +bool physical_sensor::set_wakeup(int wakeup) { - AUTOLOCK(m_mutex); - - return m_sensor_device->is_data_ready(); + return false; } -int physical_sensor::get_sensor_data(sensor_data_t &data) +bool physical_sensor::on_start() { AUTOLOCK(m_mutex); - if (!m_sensor_device->get_sensor_data(m_handle.id, data)) { - ERR("Failed to get sensor data"); - return -1; - } + if (!m_sensor_device) + return false; - return 0; + return m_sensor_device->enable(m_handle.id); } -int physical_sensor::get_sensor_event(sensor_event_t **event) +bool physical_sensor::on_stop() { AUTOLOCK(m_mutex); - int event_length = -1; - event_length = m_sensor_device->get_sensor_event(m_handle.id, event); - - if (event_length < 0) { - ERR("Failed to get sensor event"); - return -1; - } + if (!m_sensor_device) + return false; - return event_length; + return m_sensor_device->disable(m_handle.id); } -bool physical_sensor::get_properties(sensor_properties_s &properties) +bool physical_sensor::get_sensor_info(sensor_info &info) { - return m_sensor_device->get_properties(m_handle.id, properties); + info.set_type(get_type()); + info.set_id(get_id()); + info.set_privilege(SENSOR_PRIVILEGE_PUBLIC); // FIXME + info.set_name(m_handle.info.model_name); + info.set_vendor(m_handle.info.vendor); + info.set_min_range(m_handle.info.min_range); + info.set_max_range(m_handle.info.max_range); + info.set_resolution(m_handle.info.resolution); + info.set_min_interval(m_handle.info.min_interval); + info.set_fifo_count(0); // FIXME + info.set_max_batch_count(m_handle.info.max_batch_count); + info.set_supported_event(get_event_type()); + info.set_wakeup_supported(m_handle.info.wakeup_supported); + + return true; } diff --git a/src/server/physical_sensor.h b/src/server/physical_sensor.h index 5abc41b..b7aecd0 100644 --- a/src/server/physical_sensor.h +++ b/src/server/physical_sensor.h @@ -41,11 +41,9 @@ public: int get_poll_fd(); - /* get data */ - bool is_data_ready(void); - virtual int get_sensor_data(sensor_data_t &data); - virtual int get_sensor_event(sensor_event_t **event); - + virtual bool read_fd(std::vector &ids); + virtual int get_data(sensor_data_t **data); + virtual bool flush(void); private: static cmutex m_mutex; @@ -53,12 +51,12 @@ private: sensor_device *m_sensor_device; virtual bool set_interval(unsigned long interval); + virtual bool set_batch_latency(unsigned long latency); + virtual int set_attribute(int32_t attribute, int32_t value); virtual bool set_wakeup(int wakeup); - virtual bool set_batch(unsigned long latency); virtual bool on_start(void); virtual bool on_stop(void); - virtual long set_command(unsigned int cmd, long value); - virtual bool get_properties(sensor_properties_s &properties); + virtual bool get_sensor_info(sensor_info &info); }; #endif /* _PHYSICAL_SENSOR_H_ */ diff --git a/src/server/sensor_base.cpp b/src/server/sensor_base.cpp index 1acd466..5338df2 100644 --- a/src/server/sensor_base.cpp +++ b/src/server/sensor_base.cpp @@ -30,10 +30,9 @@ using std::vector; sensor_base::sensor_base() : m_unique_id(-1) -, m_privilege(SENSOR_PRIVILEGE_PUBLIC) , m_permission(SENSOR_PERMISSION_STANDARD) -, m_client(0) , m_started(false) +, m_client(0) { } @@ -41,11 +40,59 @@ sensor_base::~sensor_base() { } +void sensor_base::set_id(sensor_id_t id) +{ + m_unique_id = id; +} + +sensor_id_t sensor_base::get_id(void) +{ + if (m_unique_id == -1) + return UNKNOWN_SENSOR; + + return m_unique_id; +} + sensor_type_t sensor_base::get_type(void) { return UNKNOWN_SENSOR; } +unsigned int sensor_base::get_event_type(void) +{ + return -1; +} + +const char* sensor_base::get_name() +{ + return NULL; +} + +bool sensor_base::get_sensor_info(sensor_info &info) +{ + return false; +} + +bool sensor_base::is_virtual() +{ + return false; +} + +int sensor_base::get_data(sensor_data_t **data) +{ + return -1; +} + +bool sensor_base::flush(void) +{ + return false; +} + +int sensor_base::set_attribute(int32_t cmd, int32_t value) +{ + return -1; +} + bool sensor_base::start() { AUTOLOCK(m_client_mutex); @@ -86,19 +133,11 @@ bool sensor_base::stop(void) return true; } -bool sensor_base::on_start() -{ - return false; -} - -bool sensor_base::on_stop() +bool sensor_base::is_started(void) { - return false; -} + AUTOLOCK(m_client_mutex); -long sensor_base::set_command(unsigned int cmd, long value) -{ - return -1; + return m_started; } bool sensor_base::add_interval(int client_id, unsigned int interval, bool is_processor) @@ -180,7 +219,7 @@ bool sensor_base::add_batch(int client_id, unsigned int latency) if (cur_max != prev_max) { INFO("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(cur_max); + set_batch_latency(cur_max); } return true; @@ -202,12 +241,12 @@ bool sensor_base::delete_batch(int client_id) INFO("No latency for sensor[0x%llx] by client[%d] deleting latency, so set to default 0 ms", get_id(), client_id); - set_batch(0); + 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", get_id(), prev_max, cur_max, client_id); - set_batch(cur_max); + set_batch_latency(cur_max); } return true; @@ -270,96 +309,38 @@ int sensor_base::get_wakeup(int client_id) return m_plugin_info_list.is_wakeup_on(); } -int sensor_base::get_sensor_data(sensor_data_t &data) -{ - return -1; -} - -int sensor_base::get_sensor_event(sensor_event_t **event) -{ - return -1; -} - -bool sensor_base::get_properties(sensor_properties_s &properties) +bool sensor_base::is_wakeup_supported(void) { return false; } -const char* sensor_base::get_name() -{ - return NULL; -} - -void sensor_base::set_id(sensor_id_t id) -{ - m_unique_id = id; -} - -sensor_id_t sensor_base::get_id(void) -{ - if (m_unique_id == -1) - return UNKNOWN_SENSOR; - - return m_unique_id; -} - -unsigned int sensor_base::get_event_type(void) -{ - return -1; -} - -sensor_privilege_t sensor_base::get_privilege(void) -{ - return m_privilege; -} - int sensor_base::get_permission(void) { return m_permission; } -bool sensor_base::is_started(void) -{ - AUTOLOCK(m_client_mutex); - - return m_started; -} - -bool sensor_base::is_virtual() +void sensor_base::set_permission(int permission) { - return false; + m_permission = permission; } -void sensor_base::get_sensor_info(sensor_info &info) +bool sensor_base::push(sensor_event_t *event, int length) { - sensor_properties_s properties; - properties.wakeup_supported = false; - - get_properties(properties); + AUTOLOCK(m_client_mutex); - info.set_type(get_type()); - info.set_id(get_id()); - info.set_privilege(m_privilege); - info.set_name(properties.name.c_str()); - info.set_vendor(properties.vendor.c_str()); - info.set_min_range(properties.min_range); - info.set_max_range(properties.max_range); - info.set_resolution(properties.resolution); - info.set_min_interval(properties.min_interval); - info.set_fifo_count(properties.fifo_count); - info.set_max_batch_count(properties.max_batch_count); - info.set_supported_event(get_event_type()); - info.set_wakeup_supported(properties.wakeup_supported); + if (m_client <= 0) + return false; - return; + sensor_event_queue::get_instance().push(event, length); + return true; } -bool sensor_base::is_wakeup_supported(void) +bool sensor_base::set_interval(unsigned long interval) { return false; } -bool sensor_base::set_interval(unsigned long interval) +bool sensor_base::set_batch_latency(unsigned long latency) { return false; } @@ -369,35 +350,14 @@ bool sensor_base::set_wakeup(int wakeup) return false; } -bool sensor_base::set_batch(unsigned long latency) +bool sensor_base::on_start() { return false; } -void sensor_base::set_privilege(sensor_privilege_t privilege) -{ - m_privilege = privilege; -} - -void sensor_base::set_permission(int permission) -{ - m_permission = permission; -} - -int sensor_base::send_sensorhub_data(const char* data, int data_len) -{ - return -1; -} - -bool sensor_base::push(sensor_event_t *event, int event_length) +bool sensor_base::on_stop() { - AUTOLOCK(m_client_mutex); - - if (m_client <= 0) - return false; - - sensor_event_queue::get_instance().push(event, event_length); - return true; + return false; } unsigned long long sensor_base::get_timestamp(void) diff --git a/src/server/sensor_base.h b/src/server/sensor_base.h index 0957380..fc69a6e 100644 --- a/src/server/sensor_base.h +++ b/src/server/sensor_base.h @@ -37,14 +37,28 @@ public: sensor_base(); virtual ~sensor_base(); - /* module info */ + /* id */ + void set_id(sensor_id_t id); + sensor_id_t get_id(void); + + /* sensor info */ virtual sensor_type_t get_type(); virtual unsigned int get_event_type(void); virtual const char* get_name(void); + virtual bool get_sensor_info(sensor_info &info); + virtual bool is_virtual(void); + + /* set/get data */ + virtual int get_data(sensor_data_t **data); + + virtual bool flush(void); + virtual int set_attribute(int32_t attribute, int32_t value); + /* start/stop */ bool start(void); bool stop(void); + bool is_started(void); /* interval / batch / wakeup */ bool add_interval(int client_id, unsigned int interval, bool is_processor); @@ -60,55 +74,29 @@ public: int get_wakeup(int client_id); bool is_wakeup_supported(void); - /* get data */ - virtual int get_sensor_data(sensor_data_t &data); - virtual int get_sensor_event(sensor_event_t **event); + bool push(sensor_event_t *event, int length); - /* id */ - void set_id(sensor_id_t id); - sensor_id_t get_id(void); - - /* privilege */ - sensor_privilege_t get_privilege(void); + /* permission(privilege) */ int get_permission(void); - bool is_started(void); - virtual bool is_virtual(void); - - /* sensor info */ - virtual void get_sensor_info(sensor_info &info); - - /* push event to queue */ - bool push(sensor_event_t *event, int event_length); - - /* for sensorhub */ - virtual long set_command(unsigned int cmd, long value); - virtual int send_sensorhub_data(const char* data, int data_len); protected: - void set_privilege(sensor_privilege_t privilege); void set_permission(int permission); private: sensor_id_t m_unique_id; - sensor_privilege_t m_privilege; - int m_permission; plugin_info_list m_plugin_info_list; cmutex m_plugin_info_list_mutex; + bool m_started; unsigned int m_client; cmutex m_client_mutex; - bool m_started; - virtual bool set_interval(unsigned long interval); - virtual bool set_batch(unsigned long latency); + virtual bool set_batch_latency(unsigned long latency); virtual bool set_wakeup(int wakeup); - /* get properties */ - virtual bool get_properties(sensor_properties_s &properties); - virtual bool on_start(void); virtual bool on_stop(void); diff --git a/src/server/sensor_event_dispatcher.cpp b/src/server/sensor_event_dispatcher.cpp index 9b58afc..24d4f26 100644 --- a/src/server/sensor_event_dispatcher.cpp +++ b/src/server/sensor_event_dispatcher.cpp @@ -190,6 +190,7 @@ void sensor_event_dispatcher::dispatch_event(void) void sensor_event_dispatcher::send_sensor_events(vector< pair > &events) { + void *event; sensor_event_t *sensor_events = NULL; client_info_manager& client_info_manager = get_client_info_manager(); @@ -199,11 +200,22 @@ void sensor_event_dispatcher::send_sensor_events(vector< pair > &eve for (unsigned int i = 0; i < events.size(); ++i) { sensor_id_t sensor_id; unsigned int event_type; + int length; + sensor_events = (sensor_event_t*)events[i].first; - int length = events[i].second; + length = sizeof(sensor_event_t) + sensor_events->data_length; sensor_id = sensor_events->sensor_id; event_type = sensor_events->event_type; + event = (void *)malloc(length); + if (!event) { + ERR("Failed to allocate memory"); + return; + } + + memcpy(event, sensor_events, sizeof(sensor_event_t)); + memcpy(event + sizeof(sensor_event_t), sensor_events->data, sensor_events->data_length); + id_vec.clear(); client_info_manager.get_listener_ids(sensor_id, event_type, id_vec); @@ -212,7 +224,7 @@ void sensor_event_dispatcher::send_sensor_events(vector< pair > &eve while (it_client_id != id_vec.end()) { csocket client_socket; client_info_manager.get_event_socket(*it_client_id, client_socket); - bool ret = (client_socket.send(sensor_events, length) > 0); + 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()); @@ -222,6 +234,7 @@ void sensor_event_dispatcher::send_sensor_events(vector< pair > &eve ++it_client_id; } + free(sensor_events->data); free(sensor_events); } } @@ -316,7 +329,7 @@ virtual_sensors sensor_event_dispatcher::get_active_virtual_sensors(void) struct sort_comp { bool operator()(const pair &left, const pair &right) { - return ((sensor_event_t*)(left.first))->data.timestamp < ((sensor_event_t*)(right.first))->data.timestamp; + return ((sensor_event_t*)(left.first))->data->timestamp < ((sensor_event_t*)(right.first))->data->timestamp; } }; diff --git a/src/server/sensor_event_poller.cpp b/src/server/sensor_event_poller.cpp index b02b624..6d0943e 100644 --- a/src/server/sensor_event_poller.cpp +++ b/src/server/sensor_event_poller.cpp @@ -22,6 +22,7 @@ #include #include #include +#include #define EPOLL_MAX_FD 32 @@ -75,6 +76,7 @@ bool sensor_event_poller::add_poll_fd(int fd) bool sensor_event_poller::poll() { + std::vector ids; while (true) { int fd; struct epoll_event poll_event; @@ -83,17 +85,18 @@ bool sensor_event_poller::poll() continue; fd = poll_event.data.fd; + ids.clear(); - if (!is_data_ready(fd)) + if (!read_fd(fd, ids)) continue; - process_event(fd); + process_event(fd, ids); } return true; } -bool sensor_event_poller::is_data_ready(int fd) +bool sensor_event_poller::read_fd(int fd, std::vector &ids) { fd_sensors_t::iterator it; physical_sensor *sensor; @@ -106,13 +109,13 @@ bool sensor_event_poller::is_data_ready(int fd) return false; } - if (!sensor->is_data_ready()) + if (!sensor->read_fd(ids)) return false; return true; } -bool sensor_event_poller::process_event(int fd) +bool sensor_event_poller::process_event(int fd, const std::vector &ids) { physical_sensor *sensor; std::pair ret; @@ -120,23 +123,26 @@ bool sensor_event_poller::process_event(int fd) ret = m_fd_sensors.equal_range(fd); for (auto it_sensor = ret.first; it_sensor != ret.second; ++it_sensor) { - /* - sensor_event_t event; - sensor = it_sensor->second; - - event.sensor_id = sensor->get_id(); - event.event_type = sensor->get_event_type(); - sensor->get_sensor_data(event.data); - */ sensor_event_t *event; - int event_length; + sensor_data_t *data; + int data_length; + sensor = it_sensor->second; - event_length = sensor->get_sensor_event(&event); + auto result = std::find(std::begin(ids), std::end(ids), (sensor->get_id()) & 0xFFFF); + + if (result == std::end(ids)) + continue; + + event = (sensor_event_t *)malloc(sizeof(sensor_event_t)); + + data_length = sensor->get_data(&data); event->sensor_id = sensor->get_id(); event->event_type = sensor->get_event_type(); + event->data_length = data_length; + event->data = data; - sensor->push(event, event_length); + sensor->push(event, sizeof(sensor_event_t)); } return true; diff --git a/src/server/sensor_event_poller.h b/src/server/sensor_event_poller.h index a290b42..5fd6a68 100644 --- a/src/server/sensor_event_poller.h +++ b/src/server/sensor_event_poller.h @@ -39,8 +39,8 @@ private: void init_fd(); void init_sensor_map(); bool add_poll_fd(int fd); - bool is_data_ready(int fd); - bool process_event(int fd); + bool read_fd(int fd, std::vector &ids); + bool process_event(int fd, const std::vector &ids); }; #endif /* _SENSOR_EVENT_POLLER_H_ */ diff --git a/src/server/sensor_event_queue.h b/src/server/sensor_event_queue.h index a57507b..4301915 100644 --- a/src/server/sensor_event_queue.h +++ b/src/server/sensor_event_queue.h @@ -44,7 +44,7 @@ private: bool prioritize_e2 = true; if (priority_list.empty()) - return (e2->data.timestamp < e1->data.timestamp); + return (e2->data->timestamp < e1->data->timestamp); std::set::iterator iter_e1 = priority_list.find(e1->event_type); std::set::iterator iter_e2 = priority_list.find(e2->event_type); @@ -59,7 +59,7 @@ private: if (!prioritize_e1) return true; else { - if (e2->data.timestamp <= e1->data.timestamp) + if (e2->data->timestamp <= e1->data->timestamp) return true; return false; } @@ -67,7 +67,7 @@ private: else { if (prioritize_e1) return false; - else if (e2->data.timestamp <= e1->data.timestamp) + else if (e2->data->timestamp <= e1->data->timestamp) return true; else return false; diff --git a/src/server/sensor_loader.cpp.in b/src/server/sensor_loader.cpp.in index d46ad81..6f046fe 100644 --- a/src/server/sensor_loader.cpp.in +++ b/src/server/sensor_loader.cpp.in @@ -97,7 +97,7 @@ physical_sensor* sensor_loader::create_sensor(sensor_handle_t handle, sensor_dev sensor = new(std::nothrow) physical_sensor(); if (!sensor) { - ERR("Memory allocation failed[%s]", handle.name.c_str()); + ERR("Memory allocation failed[%s]", handle.name); return NULL; } -- 2.7.4