sensord: [3/4] add the refactored HAL interface 70/58570/2
authorkibak.yoon <kibak.yoon@samsung.com>
Tue, 2 Feb 2016 02:58:46 +0000 (11:58 +0900)
committerkibak.yoon <kibak.yoon@samsung.com>
Tue, 2 Feb 2016 03:54:18 +0000 (12:54 +0900)
* use the refactored HAL interface

Change-Id: Id25bc3b424f2cbf0847408f90c8f4d0b21fdd140
Signed-off-by: kibak.yoon <kibak.yoon@samsung.com>
12 files changed:
src/client/command_channel.cpp
src/client/sensor_event_listener.cpp
src/server/command_worker.cpp
src/server/physical_sensor.cpp
src/server/physical_sensor.h
src/server/sensor_base.cpp
src/server/sensor_base.h
src/server/sensor_event_dispatcher.cpp
src/server/sensor_event_poller.cpp
src/server/sensor_event_poller.h
src/server/sensor_event_queue.h
src/server/sensor_loader.cpp.in

index 92bc9dd..902ec76 100644 (file)
@@ -17,6 +17,7 @@
  *
  */
 
+#include <stdlib.h>
 #include <command_channel.h>
 #include <client_common.h>
 #include <sf_common.h>
@@ -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);
index 2c94ca8..52dada1 100644 (file)
@@ -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;
index c550ce3..e4d8191 100644 (file)
@@ -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))
index 3c6f697..7d6de5a 100644 (file)
@@ -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<uint16_t> &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;
 }
 
index 5abc41b..b7aecd0 100644 (file)
@@ -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<uint16_t> &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_ */
index 1acd466..5338df2 100644 (file)
@@ -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)
index 0957380..fc69a6e 100644 (file)
@@ -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);
 
index 9b58afc..24d4f26 100644 (file)
@@ -190,6 +190,7 @@ void sensor_event_dispatcher::dispatch_event(void)
 
 void sensor_event_dispatcher::send_sensor_events(vector< pair<void*, int> > &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<void*, int> > &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<void*, int> > &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<void*, int> > &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<void*, int> &left, const pair<void*, int> &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;
        }
 };
 
index b02b624..6d0943e 100644 (file)
@@ -22,6 +22,7 @@
 #include <physical_sensor.h>
 #include <sensor_event_poller.h>
 #include <sensor_loader.h>
+#include <algorithm>
 
 #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<uint16_t> 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<uint16_t> &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<uint16_t> &ids)
 {
        physical_sensor *sensor;
        std::pair<fd_sensors_t::iterator, fd_sensors_t::iterator> 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;
index a290b42..5fd6a68 100644 (file)
@@ -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<uint16_t> &ids);
+       bool process_event(int fd, const std::vector<uint16_t> &ids);
 };
 
 #endif /* _SENSOR_EVENT_POLLER_H_ */
index a57507b..4301915 100644 (file)
@@ -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<unsigned int>::iterator iter_e1 = priority_list.find(e1->event_type);
                        std::set<unsigned int>::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;
index d46ad81..6f046fe 100644 (file)
@@ -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;
        }