*
*/
+#include <stdlib.h>
#include <command_channel.h>
#include <client_common.h>
#include <sf_common.h>
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);
} 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 {
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;
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;
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))
int state = OP_ERROR;
bool adjusted = false;
- sensor_data_t data;
+ sensor_data_t *data;
DBG("CMD_GET_VALUE Handler invoked\n");
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
// 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
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;
}
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))
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)
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()
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;
}
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;
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_ */
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)
{
}
{
}
+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);
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)
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;
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;
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;
}
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)
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);
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);
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();
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);
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());
++it_client_id;
}
+ free(sensor_events->data);
free(sensor_events);
}
}
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;
}
};
#include <physical_sensor.h>
#include <sensor_event_poller.h>
#include <sensor_loader.h>
+#include <algorithm>
#define EPOLL_MAX_FD 32
bool sensor_event_poller::poll()
{
+ std::vector<uint16_t> ids;
while (true) {
int fd;
struct epoll_event poll_event;
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;
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;
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;
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_ */
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);
if (!prioritize_e1)
return true;
else {
- if (e2->data.timestamp <= e1->data.timestamp)
+ if (e2->data->timestamp <= e1->data->timestamp)
return true;
return false;
}
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;
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;
}
projects / platform / core / system / sensord.git / commitdiff