From 40f8b918c1672fd6ba75fdb943cbe996e8c6a4f8 Mon Sep 17 00:00:00 2001 From: "kibak.yoon" Date: Tue, 2 Feb 2016 10:16:58 +0900 Subject: [PATCH 01/16] sensord: move the location of header inclusion Change-Id: Ieb6757572f21fd3f9ff7f0c694365345bb5a3d36 Signed-off-by: kibak.yoon --- src/shared/sensor_internal.h | 15 +++++++-------- src/shared/sensor_internal_deprecated.h | 11 ++++++----- 2 files changed, 13 insertions(+), 13 deletions(-) diff --git a/src/shared/sensor_internal.h b/src/shared/sensor_internal.h index 76ce1d0..62ae845 100644 --- a/src/shared/sensor_internal.h +++ b/src/shared/sensor_internal.h @@ -29,23 +29,22 @@ #endif #include "stdbool.h" - -#ifdef __cplusplus -extern "C" -{ -#endif - #include #include -#include - /*header for common sensor type*/ #include /*header for each sensor type*/ #include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + typedef void (*sensor_cb_t)(sensor_t sensor, unsigned int event_type, sensor_data_t *data, void *user_data); typedef void (*sensorhub_cb_t)(sensor_t sensor, unsigned int event_type, sensorhub_data_t *data, void *user_data); typedef void (*sensor_accuracy_changed_cb_t) (sensor_t sensor, unsigned long long timestamp, int accuracy, void *user_data); diff --git a/src/shared/sensor_internal_deprecated.h b/src/shared/sensor_internal_deprecated.h index cdf3084..4a6948c 100644 --- a/src/shared/sensor_internal_deprecated.h +++ b/src/shared/sensor_internal_deprecated.h @@ -26,11 +26,6 @@ #include "stdbool.h" -#ifdef __cplusplus -extern "C" -{ -#endif - #include /*header for common sensor type*/ @@ -41,6 +36,12 @@ extern "C" #include + +#ifdef __cplusplus +extern "C" +{ +#endif + #define MAX_KEY_LEN 30 typedef struct { -- 2.7.4 From 1eb9c45606154ad2a07c47897067e9fc8b3a180e Mon Sep 17 00:00:00 2001 From: "kibak.yoon" Date: Tue, 2 Feb 2016 11:27:17 +0900 Subject: [PATCH 02/16] sensord: [1/4] add the refactored HAL interface * WARNING: if this patch is applied only, it cannot be built. please apply the series of the patches Change-Id: I3095e9c7b387a0e00cddf5b4086fb18331584231 Signed-off-by: kibak.yoon --- packaging/sensord.spec | 4 +-- src/shared/sensor_common.h | 71 +++++++++------------------------------ src/shared/sensor_hal.h | 83 ++++++++++++++++++++++++++++++++++------------ src/shared/sf_common.h | 62 +++------------------------------- 4 files changed, 84 insertions(+), 136 deletions(-) diff --git a/packaging/sensord.spec b/packaging/sensord.spec index cd22230..ab768f0 100644 --- a/packaging/sensord.spec +++ b/packaging/sensord.spec @@ -21,7 +21,7 @@ BuildRequires: pkgconfig(cynara-client) BuildRequires: pkgconfig(cynara-session) Requires: libsensord = %{version}-%{release} -%define auto_rotation_state ON +%define auto_rotation_state OFF %define orientation_state OFF %define gravity_state OFF %define linear_accel_state OFF @@ -30,7 +30,7 @@ Requires: libsensord = %{version}-%{release} %define gaming_rv_state OFF %define tilt_state OFF %define gyroscope_uncal_state OFF -%define build_test_suite ON +%define build_test_suite OFF %description Sensor daemon diff --git a/src/shared/sensor_common.h b/src/shared/sensor_common.h index 53c7e26..ac3450f 100644 --- a/src/shared/sensor_common.h +++ b/src/shared/sensor_common.h @@ -20,6 +20,10 @@ #ifndef __SENSOR_COMMON_H__ #define __SENSOR_COMMON_H__ +#include +#include +#include + #ifndef DEPRECATED #define DEPRECATED __attribute__((deprecated)) #endif @@ -29,20 +33,17 @@ extern "C" { #endif -/** - * @defgroup SENSOR_FRAMEWORK SensorFW - * To support the unified API for the various sensors - */ - -/** - * @defgroup SENSOR_FRAMEWORK_COMMON Sensor Framework Common API - * @ingroup SENSOR_FRAMEWORK - * - * These APIs are used to control the sensors. - * @{ - */ - -typedef unsigned int sensor_id_t; +/* +typedef union { + struct { + sensor_type_t type; + int16_t sensor_id; + int16_t device_id; + } __attribute__((packed)); + int64_t id; +} sensor_id_t; +*/ +typedef int64_t sensor_id_t; typedef void *sensor_t; @@ -51,39 +52,6 @@ typedef enum { SENSOR_PRIVILEGE_INTERNAL, } sensor_privilege_t; - -#define SENSOR_DATA_VALUE_SIZE 16 - -/* - * When modifying it, check copy_sensor_data() - */ -typedef struct sensor_data_t { -/* - * Use "accuracy" instead of "data_accuracy" - * which is going to be removed soon - */ - union { - int accuracy; - int data_accuracy; //deprecated - }; - - union { - unsigned long long timestamp; - unsigned long long time_stamp; //deprecated - }; - -/* - * Use "value_count" instead of "values_num" - * which is going to be removed soon - */ - union { - int value_count; - int values_num; //deprecated - }; - - float values[SENSOR_DATA_VALUE_SIZE]; -} sensor_data_t; - #define SENSOR_HUB_DATA_SIZE 4096 typedef struct sensorhub_data_t { @@ -96,14 +64,6 @@ typedef struct sensorhub_data_t { float data[16]; } sensorhub_data_t; -enum sensor_accuracy_t { - SENSOR_ACCURACY_UNDEFINED = -1, - SENSOR_ACCURACY_BAD = 0, - SENSOR_ACCURACY_NORMAL =1, - SENSOR_ACCURACY_GOOD = 2, - SENSOR_ACCURACY_VERYGOOD = 3 -}; - /* * To prevent naming confliction as using same enums as sensor CAPI use */ @@ -137,7 +97,6 @@ enum sensor_interval_t { SENSOR_INTERVAL_NORMAL = 200, }; - typedef enum { CONDITION_NO_OP, CONDITION_EQUAL, diff --git a/src/shared/sensor_hal.h b/src/shared/sensor_hal.h index b9f38c6..46fd840 100644 --- a/src/shared/sensor_hal.h +++ b/src/shared/sensor_hal.h @@ -21,14 +21,20 @@ #define _SENSOR_HAL_H_ #include + +#ifdef __cplusplus #include #include -#include -#include +#endif /* __cplusplus */ #define SENSOR_HAL_VERSION(maj,min) \ ((((maj) & 0xffff) << 24) | ((min) & 0xffff)) +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + /* * Sensor Types * These types are used to controll the sensors @@ -98,21 +104,61 @@ typedef enum { SENSOR_DEVICE_ROTATION_VECTOR_RAW, } sensor_device_type; +typedef struct sensor_info_t { + const char *model_name; + const char *vendor; + float min_range; + float max_range; + float resolution; + int min_interval; + int max_batch_count; + bool wakeup_supported; +} sensor_info_t; + /* * A platform sensor handler is generated based on this handle * ID can be assigned from HAL developer. so it has to be unique in HAL. */ typedef struct sensor_handle_t { - uint32_t id; - std::string name; + uint16_t id; + const char *name; sensor_device_type type; unsigned int event_type; // for Internal API - sensor_properties_s properties; + sensor_info_t info; } sensor_handle_t; +enum sensor_accuracy_t { + SENSOR_ACCURACY_UNDEFINED = -1, + SENSOR_ACCURACY_BAD = 0, + SENSOR_ACCURACY_NORMAL =1, + SENSOR_ACCURACY_GOOD = 2, + SENSOR_ACCURACY_VERYGOOD = 3 +}; + +#define SENSOR_DATA_VALUE_SIZE 16 + +/* sensor_data_t */ +typedef struct sensor_data_t { + int accuracy; + unsigned long long timestamp; + int value_count; + float values[SENSOR_DATA_VALUE_SIZE]; +} sensor_data_t; + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#ifdef __cplusplus +typedef struct { + std::vector devices; +} sensor_devices; + +typedef sensor_devices* (*create_t)(void); + /* * Sensor device interface - * 1 HAL must be abstracted from 1 device event node + * 1 device must be abstracted from 1 device event node */ class sensor_device { @@ -127,23 +173,18 @@ public: virtual int get_poll_fd(void) = 0; virtual bool get_sensors(std::vector &sensors) = 0; - /* enable/disable sensor device */ - virtual bool enable(uint32_t id) = 0; - virtual bool disable(uint32_t id) = 0; - - /* set_command or set_option? */ - virtual bool set_command(uint32_t id, std::string command, std::string value) = 0; + virtual bool enable(uint16_t id) = 0; + virtual bool disable(uint16_t id) = 0; - /* the belows can be merged to one */ - virtual bool set_interval(uint32_t id, unsigned long val) = 0; - virtual bool set_batch_latency(uint32_t id, unsigned long val) = 0; + virtual bool set_interval(uint16_t id, unsigned long val) = 0; + virtual bool set_batch_latency(uint16_t id, unsigned long val) = 0; + virtual bool set_attribute(uint16_t id, int32_t attribute, int32_t value) = 0; - /* sensor fw read the data when is_data_ready() is true */ - virtual bool is_data_ready() = 0; - virtual bool get_sensor_data(uint32_t id, sensor_data_t &data) = 0; - virtual int get_sensor_event(uint32_t id, sensor_event_t **event) = 0; + virtual bool read_fd(std::vector &ids) = 0; + virtual int get_data(uint16_t id, sensor_data_t **data) = 0; - /* TODO: use get_sensors() instead of get_properties() */ - virtual bool get_properties(uint32_t id, sensor_properties_s &properties) = 0; + virtual bool flush(uint16_t id) = 0; }; +#endif /* __cplusplus */ + #endif /* _SENSOR_HAL_H_ */ diff --git a/src/shared/sf_common.h b/src/shared/sf_common.h index 2781348..7bcc35f 100644 --- a/src/shared/sf_common.h +++ b/src/shared/sf_common.h @@ -34,8 +34,6 @@ #define CLIENT_ID_INVALID -1 -#define SENSOR_TYPE_MASK 0xFFFF - enum packet_type_t { CMD_NONE = 0, CMD_GET_ID, @@ -84,7 +82,7 @@ typedef struct { typedef struct { int client_id; - int sensor; + sensor_id_t sensor; } cmd_hello_t; typedef struct { @@ -151,7 +149,7 @@ typedef struct { typedef struct { int data_len; - char data[0]; + int data; } cmd_send_sensorhub_data_t; #define EVENT_CHANNEL_MAGIC 0xCAFECAFE @@ -161,74 +159,24 @@ typedef struct { int client_id; } event_channel_ready_t; - -typedef struct { - std::string name; - std::string vendor; - float min_range; - float max_range; - float resolution; - int min_interval; - int fifo_count; - int max_batch_count; - bool wakeup_supported; -} sensor_properties_s; - - -/* - * When modifying it, check copy_sensor*_data() - */ typedef struct sensor_event_t { unsigned int event_type; sensor_id_t sensor_id; - sensor_data_t data; + unsigned int data_length; + sensor_data_t *data; } sensor_event_t; - typedef struct sensorhub_event_t { unsigned int event_type; sensor_id_t sensor_id; + unsigned int data_length; sensorhub_data_t data; } sensorhub_event_t; -typedef struct sensor_devices { - std::vector devices; -} sensor_devices; - -typedef sensor_devices* (*create_t)(void); - typedef void *(*cmd_func_t)(void *data, void *cb_data); typedef std::vector event_type_vector; -enum sensorhub_enable_bit { - SENSORHUB_ACCELEROMETER_ENABLE_BIT = 0, - SENSORHUB_GYROSCOPE_ENABLE_BIT, - SENSORHUB_GEOMAGNETIC_UNCALIB_ENABLE_BIT, - SENSORHUB_GEOMAGNETIC_RAW_ENABLE_BIT, - SENSORHUB_GEOMAGNETIC_ENABLE_BIT, - SENSORHUB_PRESSURE_ENABLE_BIT, - SENSORHUB_GESTURE_ENABLE_BIT, - SENSORHUB_PROXIMITY_ENABLE_BIT, - SENSORHUB_TEMPERATURE_HUMIDITY_ENABLE_BIT, - SENSORHUB_LIGHT_ENABLE_BIT, - SENSORHUB_PROXIMITY_RAW_ENABLE_BIT, - SENSORHUB_ORIENTATION_ENABLE_BIT, - SENSORHUB_STEP_DETECTOR_ENABLE_BIT = 12, - SENSORHUB_SIG_MOTION_ENABLE_BIT, - SENSORHUB_GYRO_UNCALIB_ENABLE_BIT, - SENSORHUB_GAME_ROTATION_VECTOR_ENABLE_BIT = 15, - SENSORHUB_ROTATION_VECTOR_ENABLE_BIT, - SENSORHUB_STEP_COUNTER_ENABLE_BIT, - SENSORHUB_BIO_HRM_RAW_ENABLE_BIT, - SENSORHUB_BIO_HRM_RAW_FAC_ENABLE_BIT, - SENSORHUB_BIO_HRM_LIB_ENABLE_BIT, - SENSORHUB_TILT_MOTION, - SENSORHUB_UV_SENSOR, - SENSORHUB_PIR_ENABLE_BIT, - SENSORHUB_ENABLE_BIT_MAX, -}; - enum sensor_permission_t { SENSOR_PERMISSION_NONE = 0, SENSOR_PERMISSION_STANDARD = (1 << 0), -- 2.7.4 From 87e0a9d16c46947766927f3fb0ca3e0257ad28ee Mon Sep 17 00:00:00 2001 From: "kibak.yoon" Date: Tue, 2 Feb 2016 11:47:00 +0900 Subject: [PATCH 03/16] sensord: [2/4] add the refactored HAL interface * sensor_id_t is changed to int64_t type - 0xFFFFFFFF(32bit) : sensor_type - 0xFFFF(16bit) : sensor_id(index from sensord) - 0xFFFF(16bit) : device_id(index from HAL) * it will be changed to union type Change-Id: I2f75d3ed3405d9cf3e6fc5ffcf51bab425d15a87 Signed-off-by: kibak.yoon --- src/client/client_common.cpp | 4 +-- src/client/sensor_client_info.cpp | 4 +-- src/server/command_worker.cpp | 54 +++++++++++++++++++-------------------- src/server/sensor_base.cpp | 16 ++++++------ src/server/sensor_loader.cpp.in | 20 ++++++++++----- src/shared/sensor_info.cpp | 26 ++++++++++++++++--- src/shared/sensor_info.h | 3 +++ src/shared/sensor_logs.cpp | 2 +- src/shared/sensor_logs.h | 3 ++- 9 files changed, 80 insertions(+), 52 deletions(-) diff --git a/src/client/client_common.cpp b/src/client/client_common.cpp index bc48da0..cc2e919 100644 --- a/src/client/client_common.cpp +++ b/src/client/client_common.cpp @@ -121,7 +121,7 @@ const char* get_log_element_name(log_id id, unsigned int type) const char* get_sensor_name(sensor_id_t sensor_id) { - sensor_type_t sensor_type = (sensor_type_t) (sensor_id & SENSOR_TYPE_MASK); + sensor_type_t sensor_type = (sensor_type_t) (sensor_id >> SENSOR_TYPE_SHIFT); return get_log_element_name(LOG_ID_SENSOR_TYPE, sensor_type); } @@ -185,7 +185,7 @@ unsigned int get_calibration_event_type(unsigned int event_type) { sensor_type_t sensor; - sensor = (sensor_type_t)(event_type >> SENSOR_TYPE_SHIFT); + sensor = (sensor_type_t)(event_type >> EVENT_TYPE_SHIFT); switch (sensor) { default: diff --git a/src/client/sensor_client_info.cpp b/src/client/sensor_client_info.cpp index 0917459..bdae177 100644 --- a/src/client/sensor_client_info.cpp +++ b/src/client/sensor_client_info.cpp @@ -460,7 +460,7 @@ bool sensor_client_info::get_active_batch(sensor_id_t sensor, unsigned int &inte } if (!active_sensor_found) { - DBG("Active sensor[0x%x] is not found for client %s", sensor, get_client_name()); + DBG("Active sensor[0x%llx] is not found for client %s", sensor, get_client_name()); return false; } @@ -492,7 +492,7 @@ unsigned int sensor_client_info::get_active_option(sensor_id_t sensor) } if (!active_sensor_found) - DBG("Active sensor[0x%x] is not found for client %s", sensor, get_client_name()); + DBG("Active sensor[0x%llx] is not found for client %s", sensor, get_client_name()); return active_option; } diff --git a/src/server/command_worker.cpp b/src/server/command_worker.cpp index cd0b628..c550ce3 100644 --- a/src/server/command_worker.cpp +++ b/src/server/command_worker.cpp @@ -229,7 +229,7 @@ bool command_worker::stopped(void *ctx) 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%x] record for client_id[%d]", inst->m_sensor_id, inst->m_client_id); + INFO("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); } } @@ -415,14 +415,14 @@ bool command_worker::cmd_hello(void *payload) } if (!is_permission_allowed()) { - ERR("Permission denied to connect sensor[0x%x] for client [%d]", m_sensor_id, m_client_id); + ERR("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%x], client id [%d]", m_sensor_id, m_client_id); + DBG("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%x], sensor name [%s] on client id [%d]\n", m_sensor_id, m_module->get_name(), m_client_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); ret_value = OP_SUCCESS; out: if (!send_cmd_done(ret_value)) @@ -436,12 +436,12 @@ bool command_worker::cmd_byebye(void *payload) long ret_value = OP_ERROR; if (!is_permission_allowed()) { - ERR("Permission denied to stop sensor[0x%x] for client [%d]", m_sensor_id, m_client_id); + ERR("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%x]", m_client_id, m_sensor_id); + DBG("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); @@ -467,12 +467,12 @@ bool command_worker::cmd_start(void *payload) long ret_value = OP_ERROR; if (!is_permission_allowed()) { - ERR("Permission denied to start sensor[0x%x] for client [%d]", m_sensor_id, m_client_id); + ERR("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%x], called from client [%d]", m_sensor_id, m_client_id); + DBG("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); @@ -484,7 +484,7 @@ bool command_worker::cmd_start(void *payload) get_event_dispathcher().request_last_event(m_client_id, m_sensor_id); ret_value = OP_SUCCESS; } else { - ERR("Failed to start sensor [0x%x] for client [%d]", m_sensor_id, m_client_id); + ERR("Failed to start sensor [0x%llx] for client [%d]", m_sensor_id, m_client_id); ret_value = OP_ERROR; } @@ -500,18 +500,18 @@ bool command_worker::cmd_stop(void *payload) long ret_value = OP_ERROR; if (!is_permission_allowed()) { - ERR("Permission denied to stop sensor[0x%x] for client [%d]", m_sensor_id, m_client_id); + ERR("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%x], called from client [%d]", m_sensor_id, m_client_id); + DBG("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%x] for client [%d]", m_sensor_id, m_client_id); + ERR("Failed to stop sensor [0x%llx] for client [%d]", m_sensor_id, m_client_id); ret_value = OP_ERROR; } @@ -595,28 +595,28 @@ bool command_worker::cmd_set_batch(void *payload) cmd = (cmd_set_batch_t*)payload; if (!is_permission_allowed()) { - ERR("Permission denied to set batch for client [%d], for sensor [0x%x] with batch [%d, %d] to client info manager", + ERR("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%x] with batch [%d, %d] to client info manager", + ERR("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%x] with interval [%d]", + ERR("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%x] with latency [%d]", + ERR("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; @@ -636,14 +636,14 @@ bool command_worker::cmd_unset_batch(void *payload) long ret_value = OP_ERROR; if (!is_permission_allowed()) { - ERR("Permission denied to unset batch for client [%d], for sensor [0x%x] to client info manager", + ERR("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%x] to client info manager", + ERR("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; @@ -678,14 +678,14 @@ bool command_worker::cmd_set_option(void *payload) cmd = (cmd_set_option_t*)payload; if (!is_permission_allowed()) { - ERR("Permission denied to set interval for client [%d], for sensor [0x%x] with option [%d] to client info manager", + ERR("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%x] with option [%d] to client info manager", + ERR("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; @@ -707,14 +707,14 @@ bool command_worker::cmd_set_wakeup(void *payload) cmd = (cmd_set_wakeup_t*)payload; if (!is_permission_allowed()) { - ERR("Permission denied to set wakeup for client [%d], for sensor [0x%x] with wakeup [%d] to client info manager", + ERR("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%x] with wakeup [%d] to client info manager", + ERR("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; @@ -739,7 +739,7 @@ bool command_worker::cmd_set_command(void *payload) cmd = (cmd_set_command_t*)payload; if (!is_permission_allowed()) { - ERR("Permission denied to set command for client [%d], for sensor [0x%x] with cmd [%d]", + ERR("Permission denied to set command for client [%d], for sensor [0x%llx] with cmd [%d]", m_client_id, m_sensor_id, cmd->cmd); ret_value = OP_ERROR; goto out; @@ -765,7 +765,7 @@ bool command_worker::cmd_get_data(void *payload) DBG("CMD_GET_VALUE Handler invoked\n"); if (!is_permission_allowed()) { - ERR("Permission denied to get data for client [%d], for sensor [0x%x]", + ERR("Permission denied to get data for client [%d], for sensor [0x%llx]", m_client_id, m_sensor_id); state = OP_ERROR; goto out; @@ -794,7 +794,7 @@ bool command_worker::cmd_get_data(void *payload) } while (!state && !data.timestamp && (retry++ < RETRY_CNT)) { - INFO("Wait sensor[0x%x] data updated for client [%d] #%d", m_sensor_id, m_client_id, retry); + 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); } @@ -807,7 +807,7 @@ bool command_worker::cmd_get_data(void *payload) state = OP_ERROR; if (state) { - ERR("Failed to get data for client [%d], for sensor [0x%x]", + ERR("Failed to get data for client [%d], for sensor [0x%llx]", m_client_id, m_sensor_id); } @@ -827,7 +827,7 @@ bool command_worker::cmd_send_sensorhub_data(void *payload) cmd = (cmd_send_sensorhub_data_t*)payload; if (!is_permission_allowed()) { - ERR("Permission denied to send sensorhub_data for client [%d], for sensor [0x%x]", + ERR("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; diff --git a/src/server/sensor_base.cpp b/src/server/sensor_base.cpp index 16028f5..1acd466 100644 --- a/src/server/sensor_base.cpp +++ b/src/server/sensor_base.cpp @@ -115,7 +115,7 @@ bool sensor_base::add_interval(int client_id, unsigned int interval, bool is_pro cur_min = m_plugin_info_list.get_min_interval(); if (cur_min != prev_min) { - INFO("Min interval for sensor[0x%x] is changed from %dms to %dms" + INFO("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); @@ -139,14 +139,14 @@ bool sensor_base::delete_interval(int client_id, bool is_processor) cur_min = m_plugin_info_list.get_min_interval(); if (!cur_min) { - INFO("No interval for sensor[0x%x] by%sclient[%d] deleting interval, " + INFO("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%x] is changed from %dms to %dms" + INFO("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); @@ -178,7 +178,7 @@ bool sensor_base::add_batch(int client_id, unsigned int latency) cur_max = m_plugin_info_list.get_max_batch(); if (cur_max != prev_max) { - INFO("Max latency for sensor[0x%x] is changed from %dms to %dms by client[%d] adding latency", + 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); } @@ -199,12 +199,12 @@ bool sensor_base::delete_batch(int client_id) cur_max = m_plugin_info_list.get_max_batch(); if (!cur_max) { - INFO("No latency for sensor[0x%x] by client[%d] deleting latency, so set to default 0 ms", + 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); } else if (cur_max != prev_max) { - INFO("Max latency for sensor[0x%x] is changed from %dms to %dms by client[%d] deleting latency", + 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); @@ -234,7 +234,7 @@ bool sensor_base::add_wakeup(int client_id, int wakeup) 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%x] is changed from %d to %d by client[%d] adding wakeup", + INFO("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); } @@ -255,7 +255,7 @@ bool sensor_base::delete_wakeup(int client_id) 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%x] is changed from %d to %d by client[%d] deleting wakeup", + INFO("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); } diff --git a/src/server/sensor_loader.cpp.in b/src/server/sensor_loader.cpp.in index 25d885b..d46ad81 100644 --- a/src/server/sensor_loader.cpp.in +++ b/src/server/sensor_loader.cpp.in @@ -37,6 +37,7 @@ using std::vector; using std::string; #define DEVICE_PLUGINS_DIR_PATH "/usr/lib/sensor" +#define SENSOR_TYPE_SHIFT 32 #define SENSOR_INDEX_SHIFT 16 sensor_loader::sensor_loader() @@ -89,10 +90,10 @@ bool sensor_loader::load_devices(const string &path, vector &devices, voi physical_sensor* sensor_loader::create_sensor(sensor_handle_t handle, sensor_device *device) { - int index; + int16_t index; physical_sensor *sensor; - index = m_sensors.count((sensor_type_t)handle.type); + index = (int16_t) (m_sensors.count((sensor_type_t)handle.type)); sensor = new(std::nothrow) physical_sensor(); if (!sensor) { @@ -100,7 +101,7 @@ physical_sensor* sensor_loader::create_sensor(sensor_handle_t handle, sensor_dev return NULL; } - sensor->set_id(index << SENSOR_INDEX_SHIFT | handle.type); + sensor->set_id((int64_t)handle.type << SENSOR_TYPE_SHIFT | index << SENSOR_INDEX_SHIFT | handle.id); sensor->set_sensor_handle(handle); sensor->set_sensor_device(device); @@ -172,6 +173,8 @@ bool sensor_loader::load_sensors(void) template void sensor_loader::load_virtual_sensor(const char *name) { + sensor_type_t type; + int16_t index; virtual_sensor *instance = NULL; try { @@ -191,9 +194,12 @@ void sensor_loader::load_virtual_sensor(const char *name) } std::shared_ptr sensor(instance); - sensor_type_t type = sensor->get_type(); - sensor->set_id(type); + type = sensor->get_type(); + index = (int16_t)(m_sensors.count(type)); + + sensor->set_id((int64_t)type << SENSOR_TYPE_SHIFT | index); + m_sensors.insert(std::make_pair(type, sensor)); } @@ -260,8 +266,8 @@ sensor_base* sensor_loader::get_sensor(sensor_id_t id) { vector sensors; - sensor_type_t type = static_cast (id & SENSOR_TYPE_MASK); - unsigned int index = id >> SENSOR_INDEX_SHIFT; + sensor_type_t type = static_cast (id >> SENSOR_TYPE_SHIFT); + unsigned int index = (id >> SENSOR_INDEX_SHIFT) & 0xFFFF; sensors = get_sensors(type); diff --git a/src/shared/sensor_info.cpp b/src/shared/sensor_info.cpp index 030b2dc..79dbfee 100644 --- a/src/shared/sensor_info.cpp +++ b/src/shared/sensor_info.cpp @@ -166,8 +166,8 @@ void sensor_info::set_wakeup_supported(bool supported) void sensor_info::get_raw_data(raw_data_t &data) { - put(data, (int)m_type); - put(data, (int) m_id); + put(data, (int) m_type); + put(data, (int64_t) (m_id)); put(data, (int) m_privilege); put(data, m_name); put(data, m_vendor); @@ -187,7 +187,8 @@ void sensor_info::set_raw_data(const char *data, int data_len) auto it_r_data = raw_data.begin(); - int type, id, privilege; + int type, privilege; + int64_t id; it_r_data = get(it_r_data, type); m_type = (sensor_type_t) type; @@ -210,7 +211,7 @@ void sensor_info::set_raw_data(const char *data, int data_len) void sensor_info::show(void) { INFO("Type = %d", m_type); - INFO("ID = 0x%x", (int)m_id); + INFO("ID = 0x%llx", (uint64_t)m_id); INFO("Privilege = %d", (int)m_privilege); INFO("Name = %s", m_name.c_str()); INFO("Vendor = %s", m_vendor.c_str()); @@ -264,6 +265,16 @@ void sensor_info::put(raw_data_t &data, unsigned int value) copy(&buffer[0], &buffer[sizeof(buffer)], back_inserter(data)); } +void sensor_info::put(raw_data_t &data, int64_t value) +{ + char buffer[sizeof(value)]; + + int64_t *temp = (int64_t *) buffer; + *temp = value; + + copy(&buffer[0], &buffer[sizeof(buffer)], back_inserter(data)); +} + void sensor_info::put(raw_data_t &data, float value) { char buffer[sizeof(value)]; @@ -305,6 +316,13 @@ raw_data_iterator sensor_info::get(raw_data_iterator it, unsigned int &value) return it + sizeof(value); } +raw_data_iterator sensor_info::get(raw_data_iterator it, int64_t &value) +{ + copy(it, it + sizeof(value), (char*) &value); + + return it + sizeof(value); +} + raw_data_iterator sensor_info::get(raw_data_iterator it, float &value) { copy(it, it + sizeof(value), (char*) &value); diff --git a/src/shared/sensor_info.h b/src/shared/sensor_info.h index 732cc62..3b20ff3 100644 --- a/src/shared/sensor_info.h +++ b/src/shared/sensor_info.h @@ -20,6 +20,7 @@ #ifndef _SENSOR_INFO_H_ #define _SENSOR_INFO_H_ +#include #include #include #include @@ -83,12 +84,14 @@ private: void put(raw_data_t &data, int value); void put(raw_data_t &data, unsigned int value); + void put(raw_data_t &data, int64_t value); void put(raw_data_t &data, float value); void put(raw_data_t &data, std::string &value); void put(raw_data_t &data, bool value); raw_data_iterator get(raw_data_iterator it, int &value); raw_data_iterator get(raw_data_iterator it, unsigned int &value); + raw_data_iterator get(raw_data_iterator it, int64_t &value); raw_data_iterator get(raw_data_iterator it, float &value); raw_data_iterator get(raw_data_iterator it, std::string &value); raw_data_iterator get(raw_data_iterator it, bool &value); diff --git a/src/shared/sensor_logs.cpp b/src/shared/sensor_logs.cpp index 6af6cc5..8abd66a 100644 --- a/src/shared/sensor_logs.cpp +++ b/src/shared/sensor_logs.cpp @@ -175,7 +175,7 @@ const char* get_client_name(void) bool is_sensorhub_event(unsigned int event_type) { - if ((event_type >> SENSOR_TYPE_SHIFT) == CONTEXT_SENSOR) + if ((event_type >> EVENT_TYPE_SHIFT) == CONTEXT_SENSOR) return true; return false; diff --git a/src/shared/sensor_logs.h b/src/shared/sensor_logs.h index 4192123..98cdf63 100644 --- a/src/shared/sensor_logs.h +++ b/src/shared/sensor_logs.h @@ -41,7 +41,8 @@ extern "C" #endif -#define SENSOR_TYPE_SHIFT 16 +#define EVENT_TYPE_SHIFT 16 +#define SENSOR_TYPE_SHIFT 32 enum sf_log_type { SF_LOG_PRINT_FILE = 1, -- 2.7.4 From 57d79e0450451366d325ebd08638d1cdcb5b6043 Mon Sep 17 00:00:00 2001 From: "kibak.yoon" Date: Tue, 2 Feb 2016 11:58:46 +0900 Subject: [PATCH 04/16] 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 From 2d75f43127269a220b7d0916dee551725d5fe845 Mon Sep 17 00:00:00 2001 From: "kibak.yoon" Date: Tue, 2 Feb 2016 12:00:59 +0900 Subject: [PATCH 05/16] sensord: [4/4] add the refactored HAL interface * modify virtual sensor interface * support auto_rotation sensor Change-Id: Ie84dd34c3534bcd27edd41ce80ad692e876e157b Signed-off-by: kibak.yoon --- packaging/sensord.spec | 2 +- .../plugins/auto_rotation/auto_rotation_sensor.cpp | 169 ++++++++++++--------- .../plugins/auto_rotation/auto_rotation_sensor.h | 23 ++- src/server/sensor_event_dispatcher.cpp | 2 +- src/server/virtual_sensor.cpp | 1 - src/server/virtual_sensor.h | 21 ++- 6 files changed, 135 insertions(+), 83 deletions(-) diff --git a/packaging/sensord.spec b/packaging/sensord.spec index ab768f0..1e0b4d9 100644 --- a/packaging/sensord.spec +++ b/packaging/sensord.spec @@ -21,7 +21,7 @@ BuildRequires: pkgconfig(cynara-client) BuildRequires: pkgconfig(cynara-session) Requires: libsensord = %{version}-%{release} -%define auto_rotation_state OFF +%define auto_rotation_state ON %define orientation_state OFF %define gravity_state OFF %define linear_accel_state OFF diff --git a/src/server/plugins/auto_rotation/auto_rotation_sensor.cpp b/src/server/plugins/auto_rotation/auto_rotation_sensor.cpp index c50c9fd..087a51e 100644 --- a/src/server/plugins/auto_rotation/auto_rotation_sensor.cpp +++ b/src/server/plugins/auto_rotation/auto_rotation_sensor.cpp @@ -55,9 +55,11 @@ using std::vector; auto_rotation_sensor::auto_rotation_sensor() : m_accel_sensor(NULL) +, m_alg(NULL) , m_rotation(0) +, m_interval(1) , m_rotation_time(1) // rotation state is valid from initial state, so set rotation time to non-zero value -, m_alg(NULL) +, m_default_sampling_time(1) { virtual_sensor_config &config = virtual_sensor_config::get_instance(); @@ -92,6 +94,30 @@ auto_rotation_sensor::~auto_rotation_sensor() INFO("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()); + return false; + } + + m_alg = get_alg(); + + if (!m_alg) { + ERR("Not supported AUTO ROTATION sensor"); + return false; + } + + if (!m_alg->open()) + return false; + + INFO("%s is created!\n", get_name()); + + return true; +} + sensor_type_t auto_rotation_sensor::get_type(void) { return AUTO_ROTATION_SENSOR; @@ -107,43 +133,88 @@ const char* auto_rotation_sensor::get_name(void) return SENSOR_NAME; } -bool auto_rotation_sensor::check_lib(void) +bool auto_rotation_sensor::get_sensor_info(sensor_info &info) { - if (access(AUTO_ROTATION_LIB, F_OK) < 0) - return false; + info.set_type(get_type()); + info.set_id(get_id()); + info.set_privilege(SENSOR_PRIVILEGE_PUBLIC); // FIXME + info.set_name("Auto Rotation Sensor"); + info.set_vendor("Samsung Electronics"); + info.set_min_range(AUTO_ROTATION_DEGREE_UNKNOWN); + info.set_max_range(AUTO_ROTATION_DEGREE_270); + info.set_resolution(1); + info.set_min_interval(1); + info.set_fifo_count(0); + info.set_max_batch_count(0); + info.set_supported_event(get_event_type()); + info.set_wakeup_supported(false); return true; } -auto_rotation_alg *auto_rotation_sensor::get_alg() +void auto_rotation_sensor::synthesize(const sensor_event_t& event) { - return new auto_rotation_alg_emul(); + if (event.event_type != ACCELEROMETER_RAW_DATA_EVENT) + return; + + int rotation; + float acc[3]; + acc[0] = event.data->values[0]; + acc[1] = event.data->values[1]; + acc[2] = event.data->values[2]; + + if (!m_alg->get_rotation(acc, event.data->timestamp, m_rotation, rotation)) + return; + + m_rotation = rotation; + m_rotation_time = event.data->timestamp; + + sensor_event_t *rotation_event; + sensor_data_t *rotation_data; + unsigned int data_length; + + rotation_event = (sensor_event_t *)malloc(sizeof(sensor_event_t)); + data_length = get_data(&rotation_data); + + rotation_event->sensor_id = get_id(); + rotation_event->event_type = AUTO_ROTATION_CHANGE_STATE_EVENT; + rotation_event->data_length = data_length; + rotation_event->data = rotation_data; + + push(rotation_event, sizeof(sensor_event_t)); + + 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]); + return; } -bool auto_rotation_sensor::init(void) +int auto_rotation_sensor::get_data(sensor_data_t **data) { - m_accel_sensor = sensor_loader::get_instance().get_sensor(ACCELEROMETER_SENSOR); + sensor_data_t *sensor_data; + sensor_data = (sensor_data_t *)malloc(sizeof(sensor_data_t)); - if (!m_accel_sensor) { - ERR("cannot load accel sensor_hal from %s", get_name()); - return false; - } + sensor_data->accuracy = SENSOR_ACCURACY_GOOD; + sensor_data->timestamp = m_rotation_time; + sensor_data->values[0] = m_rotation; + sensor_data->value_count = 1; - m_alg = get_alg(); + *data = sensor_data; - if (!m_alg) { - ERR("Not supported AUTO ROTATION sensor"); - return false; - } - - if (!m_alg->open()) - return false; + return sizeof(sensor_data_t); +} - set_privilege(SENSOR_PRIVILEGE_INTERNAL); +bool auto_rotation_sensor::set_interval(unsigned long interval) +{ + return false; +} - INFO("%s is created!\n", get_name()); +bool auto_rotation_sensor::set_batch_latency(unsigned long latency) +{ + return false; +} - return true; +bool auto_rotation_sensor::set_wakeup(int wakeup) +{ + return false; } bool auto_rotation_sensor::on_start(void) @@ -166,56 +237,16 @@ bool auto_rotation_sensor::on_stop(void) return deactivate(); } -void auto_rotation_sensor::synthesize(const sensor_event_t& event, vector &outs) +bool auto_rotation_sensor::check_lib(void) { - if (event.event_type != ACCELEROMETER_RAW_DATA_EVENT) - return; - - int rotation; - float acc[3]; - acc[0] = event.data.values[0]; - acc[1] = event.data.values[1]; - acc[2] = event.data.values[2]; - - if (!m_alg->get_rotation(acc, event.data.timestamp, m_rotation, rotation)) - return; - - sensor_event_t rotation_event; - - INFO("Rotation: %d, ACC[0]: %f, ACC[1]: %f, ACC[2]: %f", rotation, event.data.values[0], event.data.values[1], event.data.values[2]); - rotation_event.sensor_id = get_id(); - rotation_event.data.accuracy = SENSOR_ACCURACY_GOOD; - rotation_event.event_type = AUTO_ROTATION_CHANGE_STATE_EVENT; - rotation_event.data.timestamp = event.data.timestamp; - rotation_event.data.values[0] = rotation; - rotation_event.data.value_count = 1; - outs.push_back(rotation_event); - m_rotation = rotation; - m_rotation_time = event.data.timestamp; + if (access(AUTO_ROTATION_LIB, F_OK) < 0) + return false; - return; + return true; } -int auto_rotation_sensor::get_sensor_data(sensor_data_t &data) +auto_rotation_alg *auto_rotation_sensor::get_alg() { - data.accuracy = SENSOR_ACCURACY_GOOD; - data.timestamp = m_rotation_time; - data.values[0] = m_rotation; - data.value_count = 1; - - return 0; + return new auto_rotation_alg_emul(); } -bool auto_rotation_sensor::get_properties(sensor_properties_s &properties) -{ - properties.name = "Auto Rotation Sensor"; - properties.vendor = "Samsung Electronics"; - properties.min_range = AUTO_ROTATION_DEGREE_UNKNOWN; - properties.max_range = AUTO_ROTATION_DEGREE_270; - properties.min_interval = 1; - properties.resolution = 1; - properties.fifo_count = 0; - properties.max_batch_count = 0; - - return true; -} diff --git a/src/server/plugins/auto_rotation/auto_rotation_sensor.h b/src/server/plugins/auto_rotation/auto_rotation_sensor.h index cc62e57..b2a48b0 100644 --- a/src/server/plugins/auto_rotation/auto_rotation_sensor.h +++ b/src/server/plugins/auto_rotation/auto_rotation_sensor.h @@ -30,34 +30,41 @@ public: virtual ~auto_rotation_sensor(); /* initialize sensor */ - bool init(); + bool init(void); /* sensor info */ - virtual sensor_type_t get_type(); + virtual sensor_type_t get_type(void); virtual unsigned int get_event_type(void); virtual const char* get_name(void); - void synthesize(const sensor_event_t& event, std::vector &outs); + virtual bool get_sensor_info(sensor_info &info); - int get_sensor_data(sensor_data_t &data); - virtual bool get_properties(sensor_properties_s &properties); + /* synthesize event */ + virtual void synthesize(const sensor_event_t& event); + + /* get data */ + virtual int get_data(sensor_data_t **data); private: sensor_base *m_accel_sensor; - cmutex m_value_mutex; + auto_rotation_alg *m_alg; int m_rotation; unsigned int m_interval; unsigned long long m_rotation_time; - auto_rotation_alg *m_alg; std::string m_vendor; std::string m_raw_data_unit; int m_default_sampling_time; - auto_rotation_alg *get_alg(); + virtual bool set_interval(unsigned long interval); + virtual bool set_batch_latency(unsigned long latency); + virtual bool set_wakeup(int wakeup); + virtual bool on_start(void); virtual bool on_stop(void); + bool check_lib(void); + auto_rotation_alg *get_alg(); }; #endif diff --git a/src/server/sensor_event_dispatcher.cpp b/src/server/sensor_event_dispatcher.cpp index 24d4f26..50e40f3 100644 --- a/src/server/sensor_event_dispatcher.cpp +++ b/src/server/sensor_event_dispatcher.cpp @@ -158,7 +158,7 @@ void sensor_event_dispatcher::dispatch_event(void) while (it_v_sensor != v_sensors.end()) { int synthesized_cnt; v_sensor_events.clear(); - (*it_v_sensor)->synthesize(*((sensor_event_t *)seed_event), v_sensor_events); + (*it_v_sensor)->synthesize(*((sensor_event_t *)seed_event)); synthesized_cnt = v_sensor_events.size(); for (int i = 0; i < synthesized_cnt; ++i) { diff --git a/src/server/virtual_sensor.cpp b/src/server/virtual_sensor.cpp index ae3f9be..232d7f1 100644 --- a/src/server/virtual_sensor.cpp +++ b/src/server/virtual_sensor.cpp @@ -42,7 +42,6 @@ bool virtual_sensor::is_virtual(void) return true; } - bool virtual_sensor::activate(void) { return sensor_event_dispatcher::get_instance().add_active_virtual_sensor(this); diff --git a/src/server/virtual_sensor.h b/src/server/virtual_sensor.h index a9c998f..c3176c3 100644 --- a/src/server/virtual_sensor.h +++ b/src/server/virtual_sensor.h @@ -36,14 +36,29 @@ public: virtual unsigned int get_event_type(void) = 0; virtual const char* get_name(void) = 0; - virtual void synthesize(const sensor_event_t& event, std::vector &outs) = 0; - virtual int get_sensor_data(sensor_data_t &data) = 0; - virtual bool is_virtual(void); + virtual bool get_sensor_info(sensor_info &info) = 0; + + /* synthesize event */ + virtual void synthesize(const sensor_event_t& event) = 0; + + /* get data */ + virtual int get_data(sensor_data_t **data) = 0; + + bool is_virtual(void); + protected: bool activate(void); bool deactivate(void); + private: bool m_hardware_fusion; + + virtual bool set_interval(unsigned long interval) = 0; + virtual bool set_batch_latency(unsigned long latency) = 0; + virtual bool set_wakeup(int wakeup) = 0; + + virtual bool on_start(void) = 0; + virtual bool on_stop(void) = 0; }; #endif /* _VIRTUAL_SENSOR_H_ */ -- 2.7.4 From 1c277861c8fdfb367a71485ba1b584cfe581a493 Mon Sep 17 00:00:00 2001 From: "kibak.yoon" Date: Tue, 2 Feb 2016 15:28:03 +0900 Subject: [PATCH 06/16] sensord: remove vector in sensor HAL interface * instead of using std::vector, use point array for interface Change-Id: Ib909856b315da546f66b206bbfedb4b01af4b64d Signed-off-by: kibak.yoon --- src/server/physical_sensor.cpp | 9 ++++++++- src/server/sensor_loader.cpp.in | 26 ++++++++++++++++---------- src/server/sensor_loader.h | 4 ++-- src/shared/sensor_hal.h | 19 +++++++------------ 4 files changed, 33 insertions(+), 25 deletions(-) diff --git a/src/server/physical_sensor.cpp b/src/server/physical_sensor.cpp index 7d6de5a..fc0b3db 100644 --- a/src/server/physical_sensor.cpp +++ b/src/server/physical_sensor.cpp @@ -78,11 +78,18 @@ int physical_sensor::get_poll_fd() bool physical_sensor::read_fd(std::vector &ids) { AUTOLOCK(m_mutex); + int size; + uint16_t *_ids; if (!m_sensor_device) return false; - return m_sensor_device->read_fd(ids); + size = m_sensor_device->read_fd(&_ids); + + for (int i = 0; i < size; ++i) + ids.push_back(_ids[i]); + + return true; } int physical_sensor::get_data(sensor_data_t **data) diff --git a/src/server/sensor_loader.cpp.in b/src/server/sensor_loader.cpp.in index 6f046fe..13731a8 100644 --- a/src/server/sensor_loader.cpp.in +++ b/src/server/sensor_loader.cpp.in @@ -50,8 +50,11 @@ sensor_loader& sensor_loader::get_instance() return inst; } -bool sensor_loader::load_devices(const string &path, vector &devices, void* &handle) +bool sensor_loader::load_devices(const string &path, vector &devices, void* &handle) { + int size; + sensor_device_t *_devices = NULL; + INFO("load device: [%s]", path.c_str()); void *_handle = dlopen(path.c_str(), RTLD_NOW); @@ -71,7 +74,7 @@ bool sensor_loader::load_devices(const string &path, vector &devices, voi return false; } - sensor_devices *_devices = create_devices(); + size = create_devices(&_devices); if (!_devices) { ERR("Failed to create devices, path is %s\n", path.c_str()); @@ -80,11 +83,14 @@ bool sensor_loader::load_devices(const string &path, vector &devices, voi } devices.clear(); - devices.swap(_devices->devices); - delete _devices; + for (int i = 0; i < size; ++i) + devices.push_back(_devices[i]); + handle = _handle; + delete _devices; + return true; } @@ -108,19 +114,19 @@ physical_sensor* sensor_loader::create_sensor(sensor_handle_t handle, sensor_dev return sensor; } -bool sensor_loader::load_physical_sensors(std::vector devices) +bool sensor_loader::load_physical_sensors(std::vector &devices) { + int size; sensor_device *device; - vector handles; + const sensor_handle_t *handles; physical_sensor *sensor; for (void *device_ptr : devices) { device = static_cast(device_ptr); - handles.clear(); - device->get_sensors(handles); + size = device->get_sensors(&handles); - for (unsigned int i = 0; i < handles.size(); ++i) { + for (int i = 0; i < size; ++i) { sensor = create_sensor(handles[i], device); if (!sensor) continue; @@ -157,7 +163,7 @@ bool sensor_loader::load_sensors(void) for_each(unique_device_plugin_paths.begin(), unique_device_plugin_paths.end(), [&](const string &path) { void *handle; - std::vector devices; + std::vector devices; load_devices(path, devices, handle); load_physical_sensors(devices); diff --git a/src/server/sensor_loader.h b/src/server/sensor_loader.h index 41b1dcb..1abe38d 100644 --- a/src/server/sensor_loader.h +++ b/src/server/sensor_loader.h @@ -44,10 +44,10 @@ class sensor_loader private: sensor_loader(); - bool load_devices(const std::string &path, std::vector &devices, void* &handle); + bool load_devices(const std::string &path, std::vector &devices, void* &handle); physical_sensor* create_sensor(sensor_handle_t handle, sensor_device *device); - bool load_physical_sensors(std::vector devices); + bool load_physical_sensors(std::vector &devices); template void load_virtual_sensor(const char *name); void load_virtual_sensors(void); diff --git a/src/shared/sensor_hal.h b/src/shared/sensor_hal.h index 46fd840..19681ed 100644 --- a/src/shared/sensor_hal.h +++ b/src/shared/sensor_hal.h @@ -22,11 +22,6 @@ #include -#ifdef __cplusplus -#include -#include -#endif /* __cplusplus */ - #define SENSOR_HAL_VERSION(maj,min) \ ((((maj) & 0xffff) << 24) | ((min) & 0xffff)) @@ -150,11 +145,11 @@ typedef struct sensor_data_t { #endif /* __cplusplus */ #ifdef __cplusplus -typedef struct { - std::vector devices; -} sensor_devices; - -typedef sensor_devices* (*create_t)(void); +/* + * Create devices + */ +typedef void *sensor_device_t; +typedef int (*create_t)(sensor_device_t **devices); /* * Sensor device interface @@ -171,7 +166,7 @@ public: } virtual int get_poll_fd(void) = 0; - virtual bool get_sensors(std::vector &sensors) = 0; + virtual int get_sensors(const sensor_handle_t **sensors) = 0; virtual bool enable(uint16_t id) = 0; virtual bool disable(uint16_t id) = 0; @@ -180,7 +175,7 @@ public: virtual bool set_batch_latency(uint16_t id, unsigned long val) = 0; virtual bool set_attribute(uint16_t id, int32_t attribute, int32_t value) = 0; - virtual bool read_fd(std::vector &ids) = 0; + virtual int read_fd(uint16_t **ids) = 0; virtual int get_data(uint16_t id, sensor_data_t **data) = 0; virtual bool flush(uint16_t id) = 0; -- 2.7.4 From d75f9027706d445e1c7b5c208afed8dbe48d4d67 Mon Sep 17 00:00:00 2001 From: "kibak.yoon" Date: Tue, 2 Feb 2016 16:14:43 +0900 Subject: [PATCH 07/16] sensord: remove compiler warnings * type has to be signed int * change void * to char * when it uses for arithmetic Change-Id: Ib6be183729a0208efbb3ab8249ad94f277446846 Signed-off-by: kibak.yoon --- src/client/client_common.h | 2 +- src/client/sensor_event_listener.cpp | 2 +- src/server/sensor_event_dispatcher.cpp | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/client/client_common.h b/src/client/client_common.h index 7c6ae30..ef3b645 100644 --- a/src/client/client_common.h +++ b/src/client/client_common.h @@ -47,7 +47,7 @@ struct log_attr { struct log_element { log_id id; - unsigned int type; + int type; struct log_attr log_attr; }; diff --git a/src/client/sensor_event_listener.cpp b/src/client/sensor_event_listener.cpp index 52dada1..f5c2cf4 100644 --- a/src/client/sensor_event_listener.cpp +++ b/src/client/sensor_event_listener.cpp @@ -183,7 +183,7 @@ 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_event->data = (sensor_data_t *)((void *)sensor_event + sizeof(sensor_event_t)); + sensor_event->data = (sensor_data_t *)((char *)sensor_event + sizeof(sensor_event_t)); sensor_data = sensor_event->data; cur_time = sensor_event->data->timestamp; accuracy = sensor_event->data->accuracy; diff --git a/src/server/sensor_event_dispatcher.cpp b/src/server/sensor_event_dispatcher.cpp index 50e40f3..25b1ad2 100644 --- a/src/server/sensor_event_dispatcher.cpp +++ b/src/server/sensor_event_dispatcher.cpp @@ -214,7 +214,7 @@ void sensor_event_dispatcher::send_sensor_events(vector< pair > &eve } memcpy(event, sensor_events, sizeof(sensor_event_t)); - memcpy(event + sizeof(sensor_event_t), sensor_events->data, sensor_events->data_length); + memcpy((char *)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); -- 2.7.4 From 0552befcfe09e54bc1b9b562bb9a14af349436fa Mon Sep 17 00:00:00 2001 From: "kibak.yoon" Date: Tue, 2 Feb 2016 18:06:30 +0900 Subject: [PATCH 08/16] sensord: remove unused parameter * event_length can be known by member variable of sensor_data_t Change-Id: I2c611653332fabe47d1a1ba3235fb2b5eae6b264 Signed-off-by: kibak.yoon --- .../plugins/auto_rotation/auto_rotation_sensor.cpp | 2 +- src/server/sensor_base.cpp | 4 ++-- src/server/sensor_base.h | 2 +- src/server/sensor_event_dispatcher.cpp | 23 +++++++++++----------- src/server/sensor_event_dispatcher.h | 6 +++--- src/server/sensor_event_poller.cpp | 2 +- src/server/sensor_event_queue.cpp | 15 +++++++------- src/server/sensor_event_queue.h | 14 ++++++------- 8 files changed, 33 insertions(+), 35 deletions(-) diff --git a/src/server/plugins/auto_rotation/auto_rotation_sensor.cpp b/src/server/plugins/auto_rotation/auto_rotation_sensor.cpp index 087a51e..1f0b19c 100644 --- a/src/server/plugins/auto_rotation/auto_rotation_sensor.cpp +++ b/src/server/plugins/auto_rotation/auto_rotation_sensor.cpp @@ -181,7 +181,7 @@ void auto_rotation_sensor::synthesize(const sensor_event_t& event) rotation_event->data_length = data_length; rotation_event->data = rotation_data; - push(rotation_event, sizeof(sensor_event_t)); + 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]); return; diff --git a/src/server/sensor_base.cpp b/src/server/sensor_base.cpp index 5338df2..c8711e4 100644 --- a/src/server/sensor_base.cpp +++ b/src/server/sensor_base.cpp @@ -324,14 +324,14 @@ void sensor_base::set_permission(int permission) m_permission = permission; } -bool sensor_base::push(sensor_event_t *event, int length) +bool sensor_base::push(sensor_event_t *event) { AUTOLOCK(m_client_mutex); if (m_client <= 0) return false; - sensor_event_queue::get_instance().push(event, length); + sensor_event_queue::get_instance().push(event); return true; } diff --git a/src/server/sensor_base.h b/src/server/sensor_base.h index fc69a6e..90f644b 100644 --- a/src/server/sensor_base.h +++ b/src/server/sensor_base.h @@ -74,7 +74,7 @@ public: int get_wakeup(int client_id); bool is_wakeup_supported(void); - bool push(sensor_event_t *event, int length); + bool push(sensor_event_t *event); /* permission(privilege) */ int get_permission(void); diff --git a/src/server/sensor_event_dispatcher.cpp b/src/server/sensor_event_dispatcher.cpp index 25b1ad2..9fdc69d 100644 --- a/src/server/sensor_event_dispatcher.cpp +++ b/src/server/sensor_event_dispatcher.cpp @@ -137,8 +137,7 @@ void sensor_event_dispatcher::dispatch_event(void) while (true) { bool is_hub_event = false; - int seed_event_len = 0; - void *seed_event = get_event_queue().pop(&seed_event_len); + void *seed_event = get_event_queue().pop(); unsigned int event_type = *((unsigned int *)(seed_event)); if (is_sensorhub_event(event_type)) @@ -148,8 +147,8 @@ void sensor_event_dispatcher::dispatch_event(void) sensorhub_event_t *sensorhub_event = (sensorhub_event_t *)seed_event; send_sensorhub_events(sensorhub_event); } else { - vector< pair > sensor_events; - sensor_events.push_back(pair(seed_event, seed_event_len)); + vector sensor_events; + sensor_events.push_back(seed_event); virtual_sensors v_sensors = get_active_virtual_sensors(); @@ -169,7 +168,7 @@ void sensor_event_dispatcher::dispatch_event(void) } memcpy(v_event, &v_sensor_events[i], sizeof(sensor_event_t)); - sensor_events.push_back(pair(v_event, sizeof(sensor_event_t))); + sensor_events.push_back(v_event); } ++it_v_sensor; @@ -178,8 +177,8 @@ void sensor_event_dispatcher::dispatch_event(void) sort_sensor_events(sensor_events); for (unsigned int i = 0; i < sensor_events.size(); ++i) { - if (is_record_event(((sensor_event_t*)(sensor_events[i].first))->event_type)) - put_last_event(((sensor_event_t*)(sensor_events[i].first))->event_type, *((sensor_event_t*)(sensor_events[i].first))); + if (is_record_event(((sensor_event_t *)(sensor_events[i]))->event_type)) + put_last_event(((sensor_event_t *)(sensor_events[i]))->event_type, *((sensor_event_t *)(sensor_events[i]))); } send_sensor_events(sensor_events); @@ -188,7 +187,7 @@ void sensor_event_dispatcher::dispatch_event(void) } -void sensor_event_dispatcher::send_sensor_events(vector< pair > &events) +void sensor_event_dispatcher::send_sensor_events(vector &events) { void *event; sensor_event_t *sensor_events = NULL; @@ -202,7 +201,7 @@ void sensor_event_dispatcher::send_sensor_events(vector< pair > &eve unsigned int event_type; int length; - sensor_events = (sensor_event_t*)events[i].first; + sensor_events = (sensor_event_t*)events[i]; length = sizeof(sensor_event_t) + sensor_events->data_length; sensor_id = sensor_events->sensor_id; event_type = sensor_events->event_type; @@ -328,12 +327,12 @@ 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; + bool operator()(const void *left, const void *right) { + return ((sensor_event_t *)left)->data->timestamp < ((sensor_event_t *)right)->data->timestamp; } }; -void sensor_event_dispatcher::sort_sensor_events(vector< pair > &events) +void sensor_event_dispatcher::sort_sensor_events(vector &events) { std::sort(events.begin(), events.end(), sort_comp()); } diff --git a/src/server/sensor_event_dispatcher.h b/src/server/sensor_event_dispatcher.h index 278b498..9ac890b 100644 --- a/src/server/sensor_event_dispatcher.h +++ b/src/server/sensor_event_dispatcher.h @@ -53,8 +53,8 @@ private: void accept_event_channel(csocket client_socket); void dispatch_event(void); - void send_sensor_events(std::vector< std::pair > &events); - void send_sensorhub_events(void* events); + void send_sensor_events(std::vector &events); + void send_sensorhub_events(void *events); static client_info_manager& get_client_info_manager(void); static sensor_event_queue& get_event_queue(void); @@ -65,7 +65,7 @@ private: bool has_active_virtual_sensor(virtual_sensor *sensor); virtual_sensors get_active_virtual_sensors(void); - void sort_sensor_events(std::vector< std::pair > &events); + void sort_sensor_events(std::vector &events); public: static sensor_event_dispatcher& get_instance(); bool run(void); diff --git a/src/server/sensor_event_poller.cpp b/src/server/sensor_event_poller.cpp index 6d0943e..4d2b9e1 100644 --- a/src/server/sensor_event_poller.cpp +++ b/src/server/sensor_event_poller.cpp @@ -142,7 +142,7 @@ bool sensor_event_poller::process_event(int fd, const std::vector &ids event->data_length = data_length; event->data = data; - sensor->push(event, sizeof(sensor_event_t)); + sensor->push(event); } return true; diff --git a/src/server/sensor_event_queue.cpp b/src/server/sensor_event_queue.cpp index 444b053..79b8baf 100644 --- a/src/server/sensor_event_queue.cpp +++ b/src/server/sensor_event_queue.cpp @@ -26,7 +26,7 @@ sensor_event_queue& sensor_event_queue::get_instance() return inst; } -void sensor_event_queue::push_internal(void *event, int length) +void sensor_event_queue::push_internal(void *event) { lock l(m_mutex); bool wake = m_queue.empty(); @@ -35,26 +35,25 @@ void sensor_event_queue::push_internal(void *event, int length) ERR("Queue is full, drop it!"); free(event); } else - m_queue.push(std::pair(event, length)); + m_queue.push(event); if (wake) m_cond_var.notify_one(); } -void* sensor_event_queue::pop(int *length) +void* sensor_event_queue::pop(void) { ulock u(m_mutex); while (m_queue.empty()) m_cond_var.wait(u); - std::pair event = m_queue.top(); + void *event = m_queue.top(); m_queue.pop(); - *length = event.second; - return event.first; + return event; } -void sensor_event_queue::push(sensor_event_t *event, int event_length) +void sensor_event_queue::push(sensor_event_t *event) { - push_internal(event, event_length); + push_internal(event); } diff --git a/src/server/sensor_event_queue.h b/src/server/sensor_event_queue.h index 4301915..b7048b8 100644 --- a/src/server/sensor_event_queue.h +++ b/src/server/sensor_event_queue.h @@ -37,9 +37,9 @@ private: class compare { public: - bool operator() (std::pair v1, std::pair v2) { - sensor_event_t *e1 = (sensor_event_t *)v1.first; - sensor_event_t *e2 = (sensor_event_t *)v2.first; + bool operator() (void *&v1, void *&v2) { + sensor_event_t *e1 = (sensor_event_t *)v1; + sensor_event_t *e2 = (sensor_event_t *)v2; bool prioritize_e1 = true; bool prioritize_e2 = true; @@ -75,7 +75,7 @@ private: } }; - std::priority_queue, std::vector>, compare> m_queue; + std::priority_queue, compare> m_queue; std::mutex m_mutex; std::condition_variable m_cond_var; @@ -87,12 +87,12 @@ private: ~sensor_event_queue() {}; sensor_event_queue(const sensor_event_queue &) {}; sensor_event_queue& operator=(const sensor_event_queue &); - void push_internal(void *event, int length); + void push_internal(void *event); public: static sensor_event_queue& get_instance(); - void push(sensor_event_t *event, int event_length); - void* pop(int *length); + void push(sensor_event_t *event); + void* pop(void); }; #endif /* _SENSOR_EVENT_QUEUE_H_*/ -- 2.7.4 From da5a10d8af597618d002b2e0ae349e99b6d211ab Mon Sep 17 00:00:00 2001 From: "kibak.yoon" Date: Tue, 2 Feb 2016 19:45:42 +0900 Subject: [PATCH 09/16] sensord: modify HAL interface for batching * int get_data(id, data, length) - return value: the remaining count of data Change-Id: I153bc0a218667fd303a033b7550625b9e529723d Signed-off-by: kibak.yoon --- src/server/command_worker.cpp | 9 +++++---- src/server/physical_sensor.cpp | 12 ++++++------ src/server/physical_sensor.h | 2 +- .../plugins/auto_rotation/auto_rotation_sensor.cpp | 16 ++++++++++++---- .../plugins/auto_rotation/auto_rotation_sensor.h | 2 +- src/server/sensor_base.cpp | 2 +- src/server/sensor_base.h | 2 +- src/server/sensor_event_poller.cpp | 18 +++++++++++------- src/server/virtual_sensor.h | 2 +- src/shared/sensor_hal.h | 2 +- 10 files changed, 40 insertions(+), 27 deletions(-) diff --git a/src/server/command_worker.cpp b/src/server/command_worker.cpp index e4d8191..afa3079 100644 --- a/src/server/command_worker.cpp +++ b/src/server/command_worker.cpp @@ -758,6 +758,7 @@ bool command_worker::cmd_get_data(void *payload) const unsigned int GET_DATA_MIN_INTERVAL = 10; int state = OP_ERROR; bool adjusted = false; + int length; sensor_data_t *data; @@ -770,7 +771,7 @@ bool command_worker::cmd_get_data(void *payload) goto out; } - state = m_module->get_data(&data); + state = m_module->get_data(&data, &length); // In case of not getting sensor data, wait short time and retry again // 1. changing interval to be less than 10ms @@ -779,7 +780,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 > 0) && !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 @@ -792,10 +793,10 @@ bool command_worker::cmd_get_data(void *payload) adjusted = true; } - while ((state > 0) && !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_data(&data); + state = m_module->get_data(&data, &length); } if (adjusted) diff --git a/src/server/physical_sensor.cpp b/src/server/physical_sensor.cpp index fc0b3db..59dc653 100644 --- a/src/server/physical_sensor.cpp +++ b/src/server/physical_sensor.cpp @@ -92,22 +92,22 @@ bool physical_sensor::read_fd(std::vector &ids) return true; } -int physical_sensor::get_data(sensor_data_t **data) +int physical_sensor::get_data(sensor_data_t **data, int *length) { AUTOLOCK(m_mutex); if (!m_sensor_device) - return false; + return -1; - int length = -1; - length = m_sensor_device->get_data(m_handle.id, data); + int remains = 0; + remains = m_sensor_device->get_data(m_handle.id, data, length); - if (length < 0) { + if (*length < 0) { ERR("Failed to get sensor event"); return -1; } - return length; + return remains; } bool physical_sensor::flush(void) diff --git a/src/server/physical_sensor.h b/src/server/physical_sensor.h index b7aecd0..9df3a14 100644 --- a/src/server/physical_sensor.h +++ b/src/server/physical_sensor.h @@ -42,7 +42,7 @@ public: int get_poll_fd(); virtual bool read_fd(std::vector &ids); - virtual int get_data(sensor_data_t **data); + virtual int get_data(sensor_data_t **data, int *length); virtual bool flush(void); private: static cmutex m_mutex; diff --git a/src/server/plugins/auto_rotation/auto_rotation_sensor.cpp b/src/server/plugins/auto_rotation/auto_rotation_sensor.cpp index 1f0b19c..5b400b1 100644 --- a/src/server/plugins/auto_rotation/auto_rotation_sensor.cpp +++ b/src/server/plugins/auto_rotation/auto_rotation_sensor.cpp @@ -171,10 +171,14 @@ void auto_rotation_sensor::synthesize(const sensor_event_t& event) sensor_event_t *rotation_event; sensor_data_t *rotation_data; - unsigned int data_length; + int data_length; + int remains; rotation_event = (sensor_event_t *)malloc(sizeof(sensor_event_t)); - data_length = get_data(&rotation_data); + remains = get_data(&rotation_data, &data_length); + + if (remains < 0) + return; rotation_event->sensor_id = get_id(); rotation_event->event_type = AUTO_ROTATION_CHANGE_STATE_EVENT; @@ -187,8 +191,11 @@ void auto_rotation_sensor::synthesize(const sensor_event_t& event) return; } -int auto_rotation_sensor::get_data(sensor_data_t **data) +int auto_rotation_sensor::get_data(sensor_data_t **data, int *length) { + /* if It is batch sensor, remains can be 2+ */ + int remains = 1; + sensor_data_t *sensor_data; sensor_data = (sensor_data_t *)malloc(sizeof(sensor_data_t)); @@ -198,8 +205,9 @@ int auto_rotation_sensor::get_data(sensor_data_t **data) sensor_data->value_count = 1; *data = sensor_data; + *length = sizeof(sensor_data_t); - return sizeof(sensor_data_t); + return --remains; } bool auto_rotation_sensor::set_interval(unsigned long interval) diff --git a/src/server/plugins/auto_rotation/auto_rotation_sensor.h b/src/server/plugins/auto_rotation/auto_rotation_sensor.h index b2a48b0..9b40c7c 100644 --- a/src/server/plugins/auto_rotation/auto_rotation_sensor.h +++ b/src/server/plugins/auto_rotation/auto_rotation_sensor.h @@ -43,7 +43,7 @@ public: virtual void synthesize(const sensor_event_t& event); /* get data */ - virtual int get_data(sensor_data_t **data); + virtual int get_data(sensor_data_t **data, int *length); private: sensor_base *m_accel_sensor; auto_rotation_alg *m_alg; diff --git a/src/server/sensor_base.cpp b/src/server/sensor_base.cpp index c8711e4..9296123 100644 --- a/src/server/sensor_base.cpp +++ b/src/server/sensor_base.cpp @@ -78,7 +78,7 @@ bool sensor_base::is_virtual() return false; } -int sensor_base::get_data(sensor_data_t **data) +int sensor_base::get_data(sensor_data_t **data, int *length) { return -1; } diff --git a/src/server/sensor_base.h b/src/server/sensor_base.h index 90f644b..a955f34 100644 --- a/src/server/sensor_base.h +++ b/src/server/sensor_base.h @@ -50,7 +50,7 @@ public: virtual bool is_virtual(void); /* set/get data */ - virtual int get_data(sensor_data_t **data); + virtual int get_data(sensor_data_t **data, int *length); virtual bool flush(void); virtual int set_attribute(int32_t attribute, int32_t value); diff --git a/src/server/sensor_event_poller.cpp b/src/server/sensor_event_poller.cpp index 4d2b9e1..3dd2efd 100644 --- a/src/server/sensor_event_poller.cpp +++ b/src/server/sensor_event_poller.cpp @@ -126,6 +126,7 @@ bool sensor_event_poller::process_event(int fd, const std::vector &ids sensor_event_t *event; sensor_data_t *data; int data_length; + int remains = 1; sensor = it_sensor->second; @@ -134,15 +135,18 @@ bool sensor_event_poller::process_event(int fd, const std::vector &ids if (result == std::end(ids)) continue; - event = (sensor_event_t *)malloc(sizeof(sensor_event_t)); + while (remains > 0) { + 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; + remains = sensor->get_data(&data, &data_length); - sensor->push(event); + event->sensor_id = sensor->get_id(); + event->event_type = sensor->get_event_type(); + event->data_length = data_length; + event->data = data; + + sensor->push(event); + } } return true; diff --git a/src/server/virtual_sensor.h b/src/server/virtual_sensor.h index c3176c3..993866f 100644 --- a/src/server/virtual_sensor.h +++ b/src/server/virtual_sensor.h @@ -42,7 +42,7 @@ public: virtual void synthesize(const sensor_event_t& event) = 0; /* get data */ - virtual int get_data(sensor_data_t **data) = 0; + virtual int get_data(sensor_data_t **data, int *length) = 0; bool is_virtual(void); diff --git a/src/shared/sensor_hal.h b/src/shared/sensor_hal.h index 19681ed..04e3249 100644 --- a/src/shared/sensor_hal.h +++ b/src/shared/sensor_hal.h @@ -176,7 +176,7 @@ public: virtual bool set_attribute(uint16_t id, int32_t attribute, int32_t value) = 0; virtual int read_fd(uint16_t **ids) = 0; - virtual int get_data(uint16_t id, sensor_data_t **data) = 0; + virtual int get_data(uint16_t id, sensor_data_t **data, int *length) = 0; virtual bool flush(uint16_t id) = 0; }; -- 2.7.4 From ef74baee690954d3c942dd5770a6ecc56feff73c Mon Sep 17 00:00:00 2001 From: "kibak.yoon" Date: Tue, 2 Feb 2016 20:32:17 +0900 Subject: [PATCH 10/16] sensord: enable sensor-test * include stdbool.h in sensor_hal.h Change-Id: I4e41af2676f0f3aae0f8e045c531b2e22e43094f Signed-off-by: kibak.yoon --- packaging/sensord.spec | 2 +- src/shared/sensor_hal.h | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/packaging/sensord.spec b/packaging/sensord.spec index 1e0b4d9..cd22230 100644 --- a/packaging/sensord.spec +++ b/packaging/sensord.spec @@ -30,7 +30,7 @@ Requires: libsensord = %{version}-%{release} %define gaming_rv_state OFF %define tilt_state OFF %define gyroscope_uncal_state OFF -%define build_test_suite OFF +%define build_test_suite ON %description Sensor daemon diff --git a/src/shared/sensor_hal.h b/src/shared/sensor_hal.h index 04e3249..1ed5237 100644 --- a/src/shared/sensor_hal.h +++ b/src/shared/sensor_hal.h @@ -21,6 +21,7 @@ #define _SENSOR_HAL_H_ #include +#include #define SENSOR_HAL_VERSION(maj,min) \ ((((maj) & 0xffff) << 24) | ((min) & 0xffff)) -- 2.7.4 From 5ade766756c4bfbed67387d95210b8d79fbc9c6f Mon Sep 17 00:00:00 2001 From: "kibak.yoon" Date: Tue, 2 Feb 2016 20:53:26 +0900 Subject: [PATCH 11/16] sensord: unify code style for class brackets Change-Id: I3cdd67bb754926cbe0e5d628e62637b12190678a Signed-off-by: kibak.yoon --- src/client/command_channel.h | 3 +-- src/client/sensor_client_info.h | 3 +-- src/server/client_info_manager.h | 1 - src/server/device_config.h | 3 +-- src/server/physical_sensor.h | 3 +-- src/server/plugin_info_list.h | 12 ++++-------- src/server/plugins/auto_rotation/auto_rotation_alg.h | 3 +-- src/server/plugins/auto_rotation/auto_rotation_alg_emul.h | 3 +-- src/server/sensor_base.h | 3 +-- src/server/sensor_event_dispatcher.h | 3 +-- src/server/sensor_event_queue.h | 3 +-- src/server/sensor_loader.h | 3 +-- src/server/server.h | 3 +-- src/server/virtual_sensor.h | 3 +-- src/server/virtual_sensor_config.h | 3 +-- src/server/worker_thread.h | 3 +-- src/shared/cbase_lock.h | 6 ++---- src/shared/cmutex.h | 3 +-- src/shared/cpacket.h | 3 +-- src/shared/sensor_hal.h | 3 +-- src/shared/sensor_info.h | 3 +-- 21 files changed, 24 insertions(+), 49 deletions(-) diff --git a/src/client/command_channel.h b/src/client/command_channel.h index e60434e..cc1225d 100644 --- a/src/client/command_channel.h +++ b/src/client/command_channel.h @@ -25,8 +25,7 @@ #include #include -class command_channel -{ +class command_channel { public: command_channel(); diff --git a/src/client/sensor_client_info.h b/src/client/sensor_client_info.h index a3c9989..9569f61 100644 --- a/src/client/sensor_client_info.h +++ b/src/client/sensor_client_info.h @@ -52,8 +52,7 @@ typedef vector sensor_id_vector; typedef unordered_map sensor_handle_info_map; typedef unordered_map sensor_command_channel_map; -typedef struct sensor_rep -{ +typedef struct sensor_rep { bool active; int option; unsigned int interval; diff --git a/src/server/client_info_manager.h b/src/server/client_info_manager.h index 8947f4b..3eec26e 100644 --- a/src/server/client_info_manager.h +++ b/src/server/client_info_manager.h @@ -29,7 +29,6 @@ typedef std::unordered_map client_id_sensor_record_map; typedef std::vector client_id_vec; - class client_info_manager { public: static client_info_manager& get_instance(); diff --git a/src/server/device_config.h b/src/server/device_config.h index c7a668b..c7f58a2 100644 --- a/src/server/device_config.h +++ b/src/server/device_config.h @@ -24,8 +24,7 @@ #include #include -class device_config -{ +class device_config { protected: virtual bool load_config(const std::string& config_path) = 0; diff --git a/src/server/physical_sensor.h b/src/server/physical_sensor.h index 9df3a14..1b6537c 100644 --- a/src/server/physical_sensor.h +++ b/src/server/physical_sensor.h @@ -24,8 +24,7 @@ #include #include -class physical_sensor : public sensor_base -{ +class physical_sensor : public sensor_base { public: physical_sensor(); virtual ~physical_sensor(); diff --git a/src/server/plugin_info_list.h b/src/server/plugin_info_list.h index d96c556..b8ee5ea 100644 --- a/src/server/plugin_info_list.h +++ b/src/server/plugin_info_list.h @@ -22,8 +22,7 @@ #include -class cinterval_info -{ +class cinterval_info { public: cinterval_info(int client_id, bool is_processor, unsigned int interval); int client_id; @@ -33,8 +32,7 @@ public: typedef std::list::iterator cinterval_info_iterator; -class cbatch_info -{ +class cbatch_info { public: cbatch_info(int client_id, unsigned int latency); int client_id; @@ -43,8 +41,7 @@ public: typedef std::list::iterator cbatch_info_iterator; -class cwakeup_info -{ +class cwakeup_info { public: cwakeup_info(int client_id, int wakeup); int client_id; @@ -53,8 +50,7 @@ public: typedef std::list::iterator cwakeup_info_iterator; -class plugin_info_list -{ +class plugin_info_list { private: static bool comp_interval_info(cinterval_info a, cinterval_info b); cinterval_info_iterator find_if_interval_info(int client_id, bool is_processor); diff --git a/src/server/plugins/auto_rotation/auto_rotation_alg.h b/src/server/plugins/auto_rotation/auto_rotation_alg.h index 3d8dd4c..ab280a2 100644 --- a/src/server/plugins/auto_rotation/auto_rotation_alg.h +++ b/src/server/plugins/auto_rotation/auto_rotation_alg.h @@ -20,8 +20,7 @@ #ifndef _AUTO_ROTATION_ALG_H_ #define _AUTO_ROTATION_ALG_H_ -class auto_rotation_alg -{ +class auto_rotation_alg { public: auto_rotation_alg(); virtual ~auto_rotation_alg(); diff --git a/src/server/plugins/auto_rotation/auto_rotation_alg_emul.h b/src/server/plugins/auto_rotation/auto_rotation_alg_emul.h index ce060de..953d11d 100644 --- a/src/server/plugins/auto_rotation/auto_rotation_alg_emul.h +++ b/src/server/plugins/auto_rotation/auto_rotation_alg_emul.h @@ -22,8 +22,7 @@ #include -class auto_rotation_alg_emul : public auto_rotation_alg -{ +class auto_rotation_alg_emul : public auto_rotation_alg { public: auto_rotation_alg_emul(); virtual ~auto_rotation_alg_emul(); diff --git a/src/server/sensor_base.h b/src/server/sensor_base.h index a955f34..c94ed66 100644 --- a/src/server/sensor_base.h +++ b/src/server/sensor_base.h @@ -31,8 +31,7 @@ #include #include -class sensor_base -{ +class sensor_base { public: sensor_base(); virtual ~sensor_base(); diff --git a/src/server/sensor_event_dispatcher.h b/src/server/sensor_event_dispatcher.h index 9ac890b..4b58b6b 100644 --- a/src/server/sensor_event_dispatcher.h +++ b/src/server/sensor_event_dispatcher.h @@ -33,8 +33,7 @@ typedef std::unordered_map event_type_last_event_map; typedef std::list virtual_sensors; -class sensor_event_dispatcher -{ +class sensor_event_dispatcher { private: bool m_lcd_on; csocket m_accept_socket; diff --git a/src/server/sensor_event_queue.h b/src/server/sensor_event_queue.h index b7048b8..28bf69e 100644 --- a/src/server/sensor_event_queue.h +++ b/src/server/sensor_event_queue.h @@ -30,8 +30,7 @@ extern std::set priority_list; -class sensor_event_queue -{ +class sensor_event_queue { private: static const unsigned int QUEUE_FULL_SIZE = 1000; diff --git a/src/server/sensor_loader.h b/src/server/sensor_loader.h index 1abe38d..9a6a18d 100644 --- a/src/server/sensor_loader.h +++ b/src/server/sensor_loader.h @@ -39,8 +39,7 @@ class sensor_base; typedef std::multimap> sensor_map_t; -class sensor_loader -{ +class sensor_loader { private: sensor_loader(); diff --git a/src/server/server.h b/src/server/server.h index ae52cc5..53549f6 100644 --- a/src/server/server.h +++ b/src/server/server.h @@ -23,8 +23,7 @@ #include #include -class server -{ +class server { private: GMainLoop *m_mainloop; csocket m_client_accep_socket; diff --git a/src/server/virtual_sensor.h b/src/server/virtual_sensor.h index 993866f..5ea14e3 100644 --- a/src/server/virtual_sensor.h +++ b/src/server/virtual_sensor.h @@ -22,8 +22,7 @@ #include -class virtual_sensor : public sensor_base -{ +class virtual_sensor : public sensor_base { public: virtual_sensor(); virtual ~virtual_sensor(); diff --git a/src/server/virtual_sensor_config.h b/src/server/virtual_sensor_config.h index 0c077ff..d9ed919 100644 --- a/src/server/virtual_sensor_config.h +++ b/src/server/virtual_sensor_config.h @@ -57,8 +57,7 @@ typedef std::unordered_map virtual_sensor_de * */ -class virtual_sensor_config : public device_config -{ +class virtual_sensor_config : public device_config { private: virtual_sensor_config(); virtual_sensor_config(virtual_sensor_config const&) {}; diff --git a/src/server/worker_thread.h b/src/server/worker_thread.h index 543d4e8..b12fed5 100644 --- a/src/server/worker_thread.h +++ b/src/server/worker_thread.h @@ -24,8 +24,7 @@ #include #include -class worker_thread -{ +class worker_thread { public: enum worker_state_t { WORKER_STATE_INITIAL, diff --git a/src/shared/cbase_lock.h b/src/shared/cbase_lock.h index 6319488..5b82be2 100644 --- a/src/shared/cbase_lock.h +++ b/src/shared/cbase_lock.h @@ -47,8 +47,7 @@ enum lock_type { #endif -class cbase_lock -{ +class cbase_lock { public: cbase_lock(); virtual ~cbase_lock(); @@ -73,8 +72,7 @@ private: char m_owner_info[OWNER_INFO_LEN]; }; -class Autolock -{ +class Autolock { private: cbase_lock& m_lock; public: diff --git a/src/shared/cmutex.h b/src/shared/cmutex.h index 2d7ec68..7537c7c 100644 --- a/src/shared/cmutex.h +++ b/src/shared/cmutex.h @@ -22,8 +22,7 @@ #include "cbase_lock.h" -class cmutex : public cbase_lock -{ +class cmutex : public cbase_lock { public: cmutex(); virtual ~cmutex(); diff --git a/src/shared/cpacket.h b/src/shared/cpacket.h index 3356ff5..6cc69ec 100644 --- a/src/shared/cpacket.h +++ b/src/shared/cpacket.h @@ -26,8 +26,7 @@ typedef struct packet_header { char data[]; } packet_header; -class cpacket -{ +class cpacket { public: cpacket(); explicit cpacket(size_t size); diff --git a/src/shared/sensor_hal.h b/src/shared/sensor_hal.h index 1ed5237..8b51bad 100644 --- a/src/shared/sensor_hal.h +++ b/src/shared/sensor_hal.h @@ -156,8 +156,7 @@ typedef int (*create_t)(sensor_device_t **devices); * Sensor device interface * 1 device must be abstracted from 1 device event node */ -class sensor_device -{ +class sensor_device { public: virtual ~sensor_device() {} diff --git a/src/shared/sensor_info.h b/src/shared/sensor_info.h index 3b20ff3..61a3cfb 100644 --- a/src/shared/sensor_info.h +++ b/src/shared/sensor_info.h @@ -30,8 +30,7 @@ typedef std::vector raw_data_t; typedef raw_data_t::iterator raw_data_iterator; -class sensor_info -{ +class sensor_info { public: sensor_type_t get_type(void); sensor_id_t get_id(void); -- 2.7.4 From 3ceab6863845942a2a7c3a76244101b267c5b4b9 Mon Sep 17 00:00:00 2001 From: "Hongkuk, Son" Date: Thu, 4 Feb 2016 19:38:38 +0900 Subject: [PATCH 12/16] sensord: fix build error fix CMakeLists.txt to include sensor_hal.h Signed-off-by: Hongkuk, Son Change-Id: Ic7061427c858ce8890a4b032bb61dae0050fe53f --- src/shared/CMakeLists.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/src/shared/CMakeLists.txt b/src/shared/CMakeLists.txt index b648b2b..8cf74f2 100644 --- a/src/shared/CMakeLists.txt +++ b/src/shared/CMakeLists.txt @@ -45,3 +45,4 @@ install(FILES sensor_types.h DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/sensor/) install(FILES sensor_internal_deprecated.h DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/sensor/) install(FILES sensor_internal.h DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/sensor/) install(FILES sensor_common.h DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/sensor/) +install(FILES sensor_hal.h DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/sensor/) -- 2.7.4 From eff36ce2dbdfa61034a693cf40a6d374925ffa67 Mon Sep 17 00:00:00 2001 From: "kibak.yoon" Date: Fri, 5 Feb 2016 21:54:33 +0900 Subject: [PATCH 13/16] sensord: clean up sensor fw code Change-Id: If310720c82c438706c03c44ddd297c7d1dc3e9ae Signed-off-by: kibak.yoon --- src/client/client_common.cpp | 1 + .../plugins/auto_rotation/auto_rotation_sensor.cpp | 5 ++++- src/shared/poller.cpp | 11 ++++++++--- src/shared/poller.h | 1 + src/shared/sensor_common.h | 19 ++++++++++++------- 5 files changed, 26 insertions(+), 11 deletions(-) diff --git a/src/client/client_common.cpp b/src/client/client_common.cpp index cc2e919..73f9b45 100644 --- a/src/client/client_common.cpp +++ b/src/client/client_common.cpp @@ -48,6 +48,7 @@ log_element g_log_elements[] = { FILL_LOG_ELEMENT(LOG_ID_SENSOR_TYPE, GYROSCOPE_UNCAL_SENSOR, 0, 1), FILL_LOG_ELEMENT(LOG_ID_SENSOR_TYPE, ULTRAVIOLET_SENSOR, 0, 1), FILL_LOG_ELEMENT(LOG_ID_SENSOR_TYPE, BIO_LED_RED_SENSOR, 0, 1), + FILL_LOG_ELEMENT(LOG_ID_SENSOR_TYPE, GESTURE_WRIST_UP_SENSOR, 0, 1), FILL_LOG_ELEMENT(LOG_ID_EVENT, PROXIMITY_CHANGE_STATE_EVENT, 0,1), FILL_LOG_ELEMENT(LOG_ID_EVENT, LIGHT_CHANGE_LEVEL_EVENT, 0, 1), diff --git a/src/server/plugins/auto_rotation/auto_rotation_sensor.cpp b/src/server/plugins/auto_rotation/auto_rotation_sensor.cpp index 5b400b1..d8b1700 100644 --- a/src/server/plugins/auto_rotation/auto_rotation_sensor.cpp +++ b/src/server/plugins/auto_rotation/auto_rotation_sensor.cpp @@ -255,6 +255,9 @@ bool auto_rotation_sensor::check_lib(void) auto_rotation_alg *auto_rotation_sensor::get_alg() { - return new auto_rotation_alg_emul(); + auto_rotation_alg *alg = new(std::nothrow) auto_rotation_alg_emul(); + retvm_if(!alg, NULL, "Failed to allocate memory"); + + return alg; } diff --git a/src/shared/poller.cpp b/src/shared/poller.cpp index d2861ad..2fb902b 100644 --- a/src/shared/poller.cpp +++ b/src/shared/poller.cpp @@ -24,12 +24,12 @@ poller::poller() { - m_epfd = epoll_create(EPOLL_MAX); + init_poll_fd(); } poller::poller(int fd) -: poller() { + init_poll_fd(); add_fd(fd); } @@ -39,6 +39,11 @@ poller::~poller() close(m_epfd); } +void poller::init_poll_fd(void) +{ + m_epfd = epoll_create(EPOLL_MAX); +} + bool poller::add_fd(int fd) { struct epoll_event event; @@ -94,7 +99,7 @@ bool poller::poll(struct epoll_event &event) m_event_queue.pop(); if (event.events & EPOLLERR) { - ERR("Poll error!"); + DBG("Poll error!"); return false; } diff --git a/src/shared/poller.h b/src/shared/poller.h index 8e91b0d..5f7e112 100644 --- a/src/shared/poller.h +++ b/src/shared/poller.h @@ -37,6 +37,7 @@ private: int m_epfd; std::queue m_event_queue; + void init_poll_fd(void); bool fill_event_queue(void); }; diff --git a/src/shared/sensor_common.h b/src/shared/sensor_common.h index ac3450f..cae4de6 100644 --- a/src/shared/sensor_common.h +++ b/src/shared/sensor_common.h @@ -55,13 +55,18 @@ typedef enum { #define SENSOR_HUB_DATA_SIZE 4096 typedef struct sensorhub_data_t { - int version; - int sensorhub; - int type; - int hub_data_size; - unsigned long long timestamp; - char hub_data[SENSOR_HUB_DATA_SIZE]; - float data[16]; + int accuracy; + unsigned long long timestamp; + int value_count; + char values[SENSOR_HUB_DATA_SIZE]; + + /* deprecated */ + char hub_data[SENSOR_HUB_DATA_SIZE]; + int version; + int sensorhub; + int type; + int hub_data_size; + float data[16]; } sensorhub_data_t; /* -- 2.7.4 From 45f2e2acfb03341a15a410926da6b3b1d6c63a8b Mon Sep 17 00:00:00 2001 From: "kibak.yoon" Date: Fri, 5 Feb 2016 21:55:39 +0900 Subject: [PATCH 14/16] sensord: change the HAL interface * merge sensor_info_t and sensor_handle_t * add set_attribute_str Change-Id: I765e89dfc11f7580007053121896bd7939ccd10c Signed-off-by: kibak.yoon --- src/client/command_channel.cpp | 2 +- src/server/command_worker.cpp | 2 +- src/server/physical_sensor.cpp | 35 +++++++++++++++++++++++--------- src/server/physical_sensor.h | 1 + src/server/sensor_base.cpp | 5 +++++ src/server/sensor_base.h | 1 + src/shared/sensor_hal.h | 45 ++++++++++++++++++++++++------------------ src/shared/sf_common.h | 2 +- 8 files changed, 62 insertions(+), 31 deletions(-) diff --git a/src/client/command_channel.cpp b/src/client/command_channel.cpp index 902ec76..02303a6 100644 --- a/src/client/command_channel.cpp +++ b/src/client/command_channel.cpp @@ -698,7 +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; - cmd_send_sensorhub_data->data = atoi(buffer); + memcpy(cmd_send_sensorhub_data->data, buffer, data_len); 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/server/command_worker.cpp b/src/server/command_worker.cpp index afa3079..2b8c1db 100644 --- a/src/server/command_worker.cpp +++ b/src/server/command_worker.cpp @@ -833,7 +833,7 @@ bool command_worker::cmd_send_sensorhub_data(void *payload) goto out; } - ret_value = m_module->set_attribute(cmd->data, cmd->data_len); + ret_value = m_module->set_attribute(cmd->data, 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 59dc653..e0baec4 100644 --- a/src/server/physical_sensor.cpp +++ b/src/server/physical_sensor.cpp @@ -39,7 +39,14 @@ void physical_sensor::set_sensor_handle(sensor_handle_t handle) m_handle.name = handle.name; m_handle.type = handle.type; m_handle.event_type = handle.event_type; - m_handle.info = handle.info; + m_handle.model_name = handle.model_name; + m_handle.vendor = handle.vendor; + m_handle.min_range = handle.min_range; + m_handle.max_range = handle.max_range; + m_handle.resolution = handle.resolution; + m_handle.min_interval = handle.min_interval; + m_handle.max_batch_count = handle.max_batch_count; + m_handle.wakeup_supported = handle.wakeup_supported; } void physical_sensor::set_sensor_device(sensor_device *device) @@ -154,6 +161,16 @@ int physical_sensor::set_attribute(int32_t attribute, int32_t value) return m_sensor_device->set_attribute(m_handle.id, attribute, value); } +int physical_sensor::set_attribute(char *attribute, char *value, int value_len) +{ + AUTOLOCK(m_mutex); + + if (!m_sensor_device) + return false; + + return m_sensor_device->set_attribute_str(m_handle.id, attribute, value, value_len); +} + bool physical_sensor::set_wakeup(int wakeup) { return false; @@ -184,16 +201,16 @@ bool physical_sensor::get_sensor_info(sensor_info &info) 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_name(m_handle.model_name); + info.set_vendor(m_handle.vendor); + info.set_min_range(m_handle.min_range); + info.set_max_range(m_handle.max_range); + info.set_resolution(m_handle.resolution); + info.set_min_interval(m_handle.min_interval); info.set_fifo_count(0); // FIXME - info.set_max_batch_count(m_handle.info.max_batch_count); + info.set_max_batch_count(m_handle.max_batch_count); info.set_supported_event(get_event_type()); - info.set_wakeup_supported(m_handle.info.wakeup_supported); + info.set_wakeup_supported(m_handle.wakeup_supported); return true; } diff --git a/src/server/physical_sensor.h b/src/server/physical_sensor.h index 1b6537c..1bb649b 100644 --- a/src/server/physical_sensor.h +++ b/src/server/physical_sensor.h @@ -52,6 +52,7 @@ private: 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 int set_attribute(char *attribute, char *value, int value_len); virtual bool set_wakeup(int wakeup); virtual bool on_start(void); virtual bool on_stop(void); diff --git a/src/server/sensor_base.cpp b/src/server/sensor_base.cpp index 9296123..e097358 100644 --- a/src/server/sensor_base.cpp +++ b/src/server/sensor_base.cpp @@ -93,6 +93,11 @@ int sensor_base::set_attribute(int32_t cmd, int32_t value) return -1; } +int sensor_base::set_attribute(char *attribute, char *value, int value_size) +{ + return -1; +} + bool sensor_base::start() { AUTOLOCK(m_client_mutex); diff --git a/src/server/sensor_base.h b/src/server/sensor_base.h index c94ed66..816dc40 100644 --- a/src/server/sensor_base.h +++ b/src/server/sensor_base.h @@ -53,6 +53,7 @@ public: virtual bool flush(void); virtual int set_attribute(int32_t attribute, int32_t value); + virtual int set_attribute(char *attribute, char *value, int value_size); /* start/stop */ bool start(void); diff --git a/src/shared/sensor_hal.h b/src/shared/sensor_hal.h index 8b51bad..55d84db 100644 --- a/src/shared/sensor_hal.h +++ b/src/shared/sensor_hal.h @@ -1,7 +1,5 @@ /* - * libsensord-share - * - * Copyright (c) 2015 Samsung Electronics Co., Ltd. + * Copyright (c) 2016 Samsung Electronics Co., Ltd. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -100,17 +98,6 @@ typedef enum { SENSOR_DEVICE_ROTATION_VECTOR_RAW, } sensor_device_type; -typedef struct sensor_info_t { - const char *model_name; - const char *vendor; - float min_range; - float max_range; - float resolution; - int min_interval; - int max_batch_count; - bool wakeup_supported; -} sensor_info_t; - /* * A platform sensor handler is generated based on this handle * ID can be assigned from HAL developer. so it has to be unique in HAL. @@ -120,7 +107,14 @@ typedef struct sensor_handle_t { const char *name; sensor_device_type type; unsigned int event_type; // for Internal API - sensor_info_t info; + const char *model_name; + const char *vendor; + float min_range; + float max_range; + float resolution; + int min_interval; + int max_batch_count; + bool wakeup_supported; } sensor_handle_t; enum sensor_accuracy_t { @@ -141,17 +135,29 @@ typedef struct sensor_data_t { float values[SENSOR_DATA_VALUE_SIZE]; } sensor_data_t; -#ifdef __cplusplus -} -#endif /* __cplusplus */ +#define SENSORHUB_DATA_VALUE_SIZE 4096 + +#if 0 +/* sensorhub_data_t */ +typedef struct sensorhub_data_t { + int accuracy; + unsigned long long timestamp; + int value_count; + char values[SENSORHUB_DATA_VALUE_SIZE]; +} sensorhub_data_t; +#endif -#ifdef __cplusplus /* * Create devices */ typedef void *sensor_device_t; typedef int (*create_t)(sensor_device_t **devices); +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#ifdef __cplusplus /* * Sensor device interface * 1 device must be abstracted from 1 device event node @@ -174,6 +180,7 @@ public: virtual bool set_interval(uint16_t id, unsigned long val) = 0; virtual bool set_batch_latency(uint16_t id, unsigned long val) = 0; virtual bool set_attribute(uint16_t id, int32_t attribute, int32_t value) = 0; + virtual bool set_attribute_str(uint16_t id, char *attribute, char *value, int value_len) = 0; virtual int read_fd(uint16_t **ids) = 0; virtual int get_data(uint16_t id, sensor_data_t **data, int *length) = 0; diff --git a/src/shared/sf_common.h b/src/shared/sf_common.h index 7bcc35f..6d2fda5 100644 --- a/src/shared/sf_common.h +++ b/src/shared/sf_common.h @@ -149,7 +149,7 @@ typedef struct { typedef struct { int data_len; - int data; + char data[0]; } cmd_send_sensorhub_data_t; #define EVENT_CHANNEL_MAGIC 0xCAFECAFE -- 2.7.4 From 331725cf84c5731e654f4a840369525d03dcb3c5 Mon Sep 17 00:00:00 2001 From: "kibak.yoon" Date: Fri, 12 Feb 2016 15:06:38 +0900 Subject: [PATCH 15/16] sensord: change the type of hal id to int32_t Change-Id: I5caa05382f7be7c0e146aa7413eee1f321333a3e Signed-off-by: kibak.yoon --- src/server/physical_sensor.cpp | 9 +++++++-- src/server/physical_sensor.h | 4 +++- src/server/sensor_event_poller.cpp | 8 ++++---- src/server/sensor_event_poller.h | 4 ++-- src/server/sensor_loader.cpp.in | 12 ++++++------ src/shared/sensor_common.h | 3 +-- src/shared/sensor_hal.h | 20 ++++++++++---------- 7 files changed, 33 insertions(+), 27 deletions(-) diff --git a/src/server/physical_sensor.cpp b/src/server/physical_sensor.cpp index e0baec4..7de0f64 100644 --- a/src/server/physical_sensor.cpp +++ b/src/server/physical_sensor.cpp @@ -72,6 +72,11 @@ const char* physical_sensor::get_name(void) return m_handle.name; } +uint32_t physical_sensor::get_hal_id(void) +{ + return m_handle.id; +} + int physical_sensor::get_poll_fd() { AUTOLOCK(m_mutex); @@ -82,11 +87,11 @@ int physical_sensor::get_poll_fd() return m_sensor_device->get_poll_fd(); } -bool physical_sensor::read_fd(std::vector &ids) +bool physical_sensor::read_fd(std::vector &ids) { AUTOLOCK(m_mutex); int size; - uint16_t *_ids; + uint32_t *_ids; if (!m_sensor_device) return false; diff --git a/src/server/physical_sensor.h b/src/server/physical_sensor.h index 1bb649b..cc2305f 100644 --- a/src/server/physical_sensor.h +++ b/src/server/physical_sensor.h @@ -37,10 +37,11 @@ public: virtual sensor_type_t get_type(void); virtual unsigned int get_event_type(void); virtual const char* get_name(void); + virtual uint32_t get_hal_id(void); int get_poll_fd(); - virtual bool read_fd(std::vector &ids); + virtual bool read_fd(std::vector &ids); virtual int get_data(sensor_data_t **data, int *length); virtual bool flush(void); private: @@ -48,6 +49,7 @@ private: sensor_handle_t m_handle; sensor_device *m_sensor_device; + uint32_t hal_id; virtual bool set_interval(unsigned long interval); virtual bool set_batch_latency(unsigned long latency); diff --git a/src/server/sensor_event_poller.cpp b/src/server/sensor_event_poller.cpp index 3dd2efd..0070db3 100644 --- a/src/server/sensor_event_poller.cpp +++ b/src/server/sensor_event_poller.cpp @@ -76,7 +76,7 @@ bool sensor_event_poller::add_poll_fd(int fd) bool sensor_event_poller::poll() { - std::vector ids; + std::vector ids; while (true) { int fd; struct epoll_event poll_event; @@ -96,7 +96,7 @@ bool sensor_event_poller::poll() return true; } -bool sensor_event_poller::read_fd(int fd, std::vector &ids) +bool sensor_event_poller::read_fd(int fd, std::vector &ids) { fd_sensors_t::iterator it; physical_sensor *sensor; @@ -115,7 +115,7 @@ bool sensor_event_poller::read_fd(int fd, std::vector &ids) return true; } -bool sensor_event_poller::process_event(int fd, const std::vector &ids) +bool sensor_event_poller::process_event(int fd, const std::vector &ids) { physical_sensor *sensor; std::pair ret; @@ -130,7 +130,7 @@ bool sensor_event_poller::process_event(int fd, const std::vector &ids sensor = it_sensor->second; - auto result = std::find(std::begin(ids), std::end(ids), (sensor->get_id()) & 0xFFFF); + auto result = std::find(std::begin(ids), std::end(ids), sensor->get_hal_id()); if (result == std::end(ids)) continue; diff --git a/src/server/sensor_event_poller.h b/src/server/sensor_event_poller.h index 5fd6a68..4267b1e 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 read_fd(int fd, std::vector &ids); - bool process_event(int fd, const std::vector &ids); + 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_loader.cpp.in b/src/server/sensor_loader.cpp.in index 13731a8..43d0395 100644 --- a/src/server/sensor_loader.cpp.in +++ b/src/server/sensor_loader.cpp.in @@ -38,7 +38,7 @@ using std::string; #define DEVICE_PLUGINS_DIR_PATH "/usr/lib/sensor" #define SENSOR_TYPE_SHIFT 32 -#define SENSOR_INDEX_SHIFT 16 +#define SENSOR_INDEX_MASK 0xFFFFFFFF sensor_loader::sensor_loader() { @@ -96,10 +96,10 @@ bool sensor_loader::load_devices(const string &path, vector &de physical_sensor* sensor_loader::create_sensor(sensor_handle_t handle, sensor_device *device) { - int16_t index; + int32_t index; physical_sensor *sensor; - index = (int16_t) (m_sensors.count((sensor_type_t)handle.type)); + index = (int32_t) (m_sensors.count((sensor_type_t)handle.type)); sensor = new(std::nothrow) physical_sensor(); if (!sensor) { @@ -107,7 +107,7 @@ physical_sensor* sensor_loader::create_sensor(sensor_handle_t handle, sensor_dev return NULL; } - sensor->set_id((int64_t)handle.type << SENSOR_TYPE_SHIFT | index << SENSOR_INDEX_SHIFT | handle.id); + sensor->set_id((int64_t)handle.type << SENSOR_TYPE_SHIFT | index); sensor->set_sensor_handle(handle); sensor->set_sensor_device(device); @@ -273,11 +273,11 @@ sensor_base* sensor_loader::get_sensor(sensor_id_t id) vector sensors; sensor_type_t type = static_cast (id >> SENSOR_TYPE_SHIFT); - unsigned int index = (id >> SENSOR_INDEX_SHIFT) & 0xFFFF; + unsigned int index = (id & SENSOR_INDEX_MASK); sensors = get_sensors(type); - if (sensors.size() <= index) + if (index >= sensors.size()) return NULL; return sensors[index]; diff --git a/src/shared/sensor_common.h b/src/shared/sensor_common.h index cae4de6..a6d551b 100644 --- a/src/shared/sensor_common.h +++ b/src/shared/sensor_common.h @@ -37,8 +37,7 @@ extern "C" typedef union { struct { sensor_type_t type; - int16_t sensor_id; - int16_t device_id; + int32_t id; } __attribute__((packed)); int64_t id; } sensor_id_t; diff --git a/src/shared/sensor_hal.h b/src/shared/sensor_hal.h index 55d84db..0102868 100644 --- a/src/shared/sensor_hal.h +++ b/src/shared/sensor_hal.h @@ -103,7 +103,7 @@ typedef enum { * ID can be assigned from HAL developer. so it has to be unique in HAL. */ typedef struct sensor_handle_t { - uint16_t id; + uint32_t id; const char *name; sensor_device_type type; unsigned int event_type; // for Internal API @@ -174,18 +174,18 @@ public: virtual int get_poll_fd(void) = 0; virtual int get_sensors(const sensor_handle_t **sensors) = 0; - virtual bool enable(uint16_t id) = 0; - virtual bool disable(uint16_t id) = 0; + virtual bool enable(uint32_t id) = 0; + virtual bool disable(uint32_t id) = 0; - virtual bool set_interval(uint16_t id, unsigned long val) = 0; - virtual bool set_batch_latency(uint16_t id, unsigned long val) = 0; - virtual bool set_attribute(uint16_t id, int32_t attribute, int32_t value) = 0; - virtual bool set_attribute_str(uint16_t id, char *attribute, char *value, int value_len) = 0; + virtual bool set_interval(uint32_t id, unsigned long val) = 0; + virtual bool set_batch_latency(uint32_t id, unsigned long val) = 0; + virtual bool set_attribute(uint32_t id, int32_t attribute, int32_t value) = 0; + virtual bool set_attribute_str(uint32_t id, char *attribute, char *value, int value_len) = 0; - virtual int read_fd(uint16_t **ids) = 0; - virtual int get_data(uint16_t id, sensor_data_t **data, int *length) = 0; + virtual int read_fd(uint32_t **ids) = 0; + virtual int get_data(uint32_t id, sensor_data_t **data, int *length) = 0; - virtual bool flush(uint16_t id) = 0; + virtual bool flush(uint32_t id) = 0; }; #endif /* __cplusplus */ -- 2.7.4 From 5c7d2f6e73ce0571baf9a44f73fa463d1f84286f Mon Sep 17 00:00:00 2001 From: "kibak.yoon" Date: Fri, 12 Feb 2016 15:46:04 +0900 Subject: [PATCH 16/16] sensord: change the interface of set_attribute_* Change-Id: I60871bfa07a0acd87f231b425259e7c842958410 Signed-off-by: kibak.yoon --- src/server/command_worker.cpp | 2 +- src/server/physical_sensor.cpp | 4 ++-- src/server/physical_sensor.h | 2 +- src/server/sensor_base.cpp | 2 +- src/server/sensor_base.h | 2 +- src/shared/sensor_hal.h | 4 ++-- 6 files changed, 8 insertions(+), 8 deletions(-) diff --git a/src/server/command_worker.cpp b/src/server/command_worker.cpp index 2b8c1db..3a0faee 100644 --- a/src/server/command_worker.cpp +++ b/src/server/command_worker.cpp @@ -833,7 +833,7 @@ bool command_worker::cmd_send_sensorhub_data(void *payload) goto out; } - ret_value = m_module->set_attribute(cmd->data, cmd->data, cmd->data_len); + ret_value = m_module->set_attribute(0, 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 7de0f64..6410dd2 100644 --- a/src/server/physical_sensor.cpp +++ b/src/server/physical_sensor.cpp @@ -163,10 +163,10 @@ int physical_sensor::set_attribute(int32_t attribute, int32_t value) if (!m_sensor_device) return false; - return m_sensor_device->set_attribute(m_handle.id, attribute, value); + return m_sensor_device->set_attribute_int(m_handle.id, attribute, value); } -int physical_sensor::set_attribute(char *attribute, char *value, int value_len) +int physical_sensor::set_attribute(int32_t attribute, char *value, int value_len) { AUTOLOCK(m_mutex); diff --git a/src/server/physical_sensor.h b/src/server/physical_sensor.h index cc2305f..c59ce89 100644 --- a/src/server/physical_sensor.h +++ b/src/server/physical_sensor.h @@ -54,7 +54,7 @@ private: 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 int set_attribute(char *attribute, char *value, int value_len); + virtual int set_attribute(int32_t attribute, char *value, int value_len); virtual bool set_wakeup(int wakeup); virtual bool on_start(void); virtual bool on_stop(void); diff --git a/src/server/sensor_base.cpp b/src/server/sensor_base.cpp index e097358..cee362f 100644 --- a/src/server/sensor_base.cpp +++ b/src/server/sensor_base.cpp @@ -93,7 +93,7 @@ int sensor_base::set_attribute(int32_t cmd, int32_t value) return -1; } -int sensor_base::set_attribute(char *attribute, char *value, int value_size) +int sensor_base::set_attribute(int32_t attribute, char *value, int value_size) { return -1; } diff --git a/src/server/sensor_base.h b/src/server/sensor_base.h index 816dc40..fcf5751 100644 --- a/src/server/sensor_base.h +++ b/src/server/sensor_base.h @@ -53,7 +53,7 @@ public: virtual bool flush(void); virtual int set_attribute(int32_t attribute, int32_t value); - virtual int set_attribute(char *attribute, char *value, int value_size); + virtual int set_attribute(int32_t attribute, char *value, int value_size); /* start/stop */ bool start(void); diff --git a/src/shared/sensor_hal.h b/src/shared/sensor_hal.h index 0102868..1882d39 100644 --- a/src/shared/sensor_hal.h +++ b/src/shared/sensor_hal.h @@ -179,8 +179,8 @@ public: virtual bool set_interval(uint32_t id, unsigned long val) = 0; virtual bool set_batch_latency(uint32_t id, unsigned long val) = 0; - virtual bool set_attribute(uint32_t id, int32_t attribute, int32_t value) = 0; - virtual bool set_attribute_str(uint32_t id, char *attribute, char *value, int value_len) = 0; + virtual bool set_attribute_int(uint32_t id, int32_t attribute, int32_t value) = 0; + virtual bool set_attribute_str(uint32_t id, int32_t attribute, char *value, int value_len) = 0; virtual int read_fd(uint32_t **ids) = 0; virtual int get_data(uint32_t id, sensor_data_t **data, int *length) = 0; -- 2.7.4