From 0552befcfe09e54bc1b9b562bb9a14af349436fa Mon Sep 17 00:00:00 2001 From: "kibak.yoon" Date: Tue, 2 Feb 2016 18:06:30 +0900 Subject: [PATCH 01/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 02/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 03/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 04/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 05/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 06/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 07/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 08/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 09/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 From e28d2e43975e755c0e54f133a77fb5a3c26d6e70 Mon Sep 17 00:00:00 2001 From: "kibak.yoon" Date: Fri, 12 Feb 2016 23:48:06 +0900 Subject: [PATCH 10/16] sensord: clean up spec/pc/cmakelists.txt Change-Id: I4e2a505d281e8ba23137e72bdb9ee4ab26ef9fe2 Signed-off-by: kibak.yoon --- CMakeLists.txt | 30 ++++------ packaging/sensord.spec | 8 +-- src/CMakeLists.txt | 9 --- src/client/CMakeLists.txt | 70 ++++++++++------------ src/client/sensor.pc.in | 10 ++-- src/server/CMakeLists.txt | 42 +++++-------- src/server/plugins/CMakeLists.txt | 5 +- .../server/plugins/virtual_sensors.xml | 0 .../{sensor_loader.cpp.in => sensor_loader.cpp} | 0 src/shared/CMakeLists.txt | 48 ++++----------- src/shared/sensor_logs.h | 2 + test/CMakeLists.txt | 4 +- 12 files changed, 86 insertions(+), 142 deletions(-) delete mode 100644 src/CMakeLists.txt rename virtual_sensors.xml => src/server/plugins/virtual_sensors.xml (100%) rename src/server/{sensor_loader.cpp.in => sensor_loader.cpp} (100%) diff --git a/CMakeLists.txt b/CMakeLists.txt index 083e2e2..5c572f1 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,13 +1,6 @@ -cmake_minimum_required(VERSION 2.6) -project(sensord_main CXX) -include(GNUInstallDirs) - -# Setup For pkgconfig File -SET(PREFIX ${CMAKE_INSTALL_PREFIX}) -SET(EXEC_PREFIX "${PREFIX}/bin") -SET(LIBDIR "${PREFIX}/${CMAKE_INSTALL_LIBDIR}") -SET(INCLUDEDIR "${PREFIX}/${CMAKE_INSTALL_INCLUDEDIR}") -SET(VERSION 1.0) +CMAKE_MINIMUM_REQUIRED(VERSION 2.6) +PROJECT(sensord-main CXX) +INCLUDE(GNUInstallDirs) # Common Options SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -O2 -omit-frame-pointer -std=gnu++0x") @@ -16,20 +9,21 @@ SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--gc-section -Wl,--pri MESSAGE("FLAGS: ${CMAKE_CXX_FLAGS}") MESSAGE("FLAGS: ${CMAKE_EXE_LINKER_FLAGS}") -add_definitions(-DUSE_DLOG_LOG) -add_definitions(-DLIBDIR="${CMAKE_INSTALL_LIBDIR}") - # Internal Debugging Options #add_definitions(-Wall -g -D_DEBUG) -# Installing files -INSTALL(FILES virtual_sensors.xml virtual_sensors.xml DESTINATION etc) +INCLUDE_DIRECTORIES( + ${CMAKE_CURRENT_SOURCE_DIR}/src/ + ${CMAKE_CURRENT_SOURCE_DIR}/src/shared +) # Sub-directory -add_subdirectory(systemd) -add_subdirectory(src) +ADD_SUBDIRECTORY(systemd) +ADD_SUBDIRECTORY(src/server) +ADD_SUBDIRECTORY(src/client) +ADD_SUBDIRECTORY(src/shared) IF("${TEST_SUITE}" STREQUAL "ON") -add_subdirectory(test) +ADD_SUBDIRECTORY(test) ENDIF() diff --git a/packaging/sensord.spec b/packaging/sensord.spec index cd22230..f57f7cd 100644 --- a/packaging/sensord.spec +++ b/packaging/sensord.spec @@ -66,13 +66,14 @@ Sensor functional testing cp %{SOURCE1} . cp %{SOURCE2} . -cmake . -DCMAKE_INSTALL_PREFIX=%{_prefix} \ +MAJORVER=`echo %{version} | awk 'BEGIN {FS="."}{print $1}'` + +cmake . -DCMAKE_INSTALL_PREFIX=%{_prefix} -DMAJORVER=${MAJORVER} -DFULLVER=%{version} \ -DORIENTATION=%{orientation_state} -DGRAVITY=%{gravity_state} \ -DLINEAR_ACCEL=%{linear_accel_state} -DRV=%{rv_state} \ -DGEOMAGNETIC_RV=%{geomagnetic_rv_state} -DGAMING_RV=%{gaming_rv_state} \ -DGYROSCOPE_UNCAL=%{gyroscope_uncal_state} -DAUTO_ROTATION=%{auto_rotation_state} \ - -DTILT=%{tilt_state} -DTEST_SUITE=%{build_test_suite} \ - -DLIBDIR=%{_libdir} -DINCLUDEDIR=%{_includedir} + -DTILT=%{tilt_state} -DTEST_SUITE=%{build_test_suite} %build make %{?jobs:-j%jobs} @@ -114,7 +115,6 @@ systemctl daemon-reload %files -n libsensord-devel %defattr(-,root,root,-) %{_includedir}/sensor/*.h -%{_includedir}/sensord-shared/*.h %{_libdir}/libsensor.so %{_libdir}/pkgconfig/sensor.pc %license LICENSE.APLv2 diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt deleted file mode 100644 index e5cd017..0000000 --- a/src/CMakeLists.txt +++ /dev/null @@ -1,9 +0,0 @@ -cmake_minimum_required(VERSION 2.6) -project(sensord_src CXX) - -include_directories(${CMAKE_SOURCE_DIR}/src/shared) -include_directories(${CMAKE_CURRENT_SOURCE_DIR}) - -add_subdirectory(server) -add_subdirectory(client) -add_subdirectory(shared) diff --git a/src/client/CMakeLists.txt b/src/client/CMakeLists.txt index ac7dcc0..80a1ddc 100644 --- a/src/client/CMakeLists.txt +++ b/src/client/CMakeLists.txt @@ -1,51 +1,41 @@ -cmake_minimum_required(VERSION 2.6) -project(sensor CXX) +CMAKE_MINIMUM_REQUIRED(VERSION 2.6) +PROJECT(sensor CXX) -SET(VERSION_MAJOR 1) -SET(VERSION "${VERSION_MAJOR}.1.0") - -SET(PC_NAME "sensor") -SET(PC_DESCRIPTION "Sensord library") -SET(PC_VERSION ${FULLVER}) -SET(PC_LDFLAGS "-lsensor") SET(DEPENDENTS "vconf glib-2.0") -SET(PC_DEPENDENTS "glib-2.0") +SET(VERSION ${FULLVER}) +SET(PREFIX ${CMAKE_INSTALL_PREFIX}) +SET(EXEC_PREFIX "${CMAKE_INSTALL_PREFIX}/bin") -INCLUDE(FindPkgConfig) -PKG_CHECK_MODULES(lib_pkgs REQUIRED ${DEPENDENTS}) +SET(PC_NAME ${PROJECT_NAME}) +SET(PC_DESCRIPTION "Sensor Client library") +SET(PC_INCLUDEDIR "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_INCLUDEDIR}/sensor") +SET(PC_REQUIRES "${DEPENDENTS}") +SET(PC_LIBDIR "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}") +SET(PC_LDFLAGS "-l${PROJECT_NAME}") -FOREACH(flag ${lib_pkgs_LDFLAGS}) - SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${flag}") -ENDFOREACH(flag) +INCLUDE(FindPkgConfig) +PKG_CHECK_MODULES(PKGS REQUIRED ${DEPENDENTS}) -FOREACH(flag ${lib_pkgs_CFLAGS}) +FOREACH(flag ${PKGS_CFLAGS}) SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${flag}") ENDFOREACH(flag) SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fvisibility=hidden -fvisibility-inlines-hidden -g -fPIC") -include_directories(${CMAKE_CURRENT_SOURCE_DIR}) - -add_library(${PROJECT_NAME} SHARED - client.cpp - sensor_client_info.cpp - sensor_event_listener.cpp - sensor_info_manager.cpp - sensor_handle_info.cpp - client_common.cpp - command_channel.cpp -) - -target_link_libraries(${PROJECT_NAME} ${lib_pkgs_LDFLAGS} "sensord-shared") -SET_TARGET_PROPERTIES(${PROJECT_NAME} PROPERTIES SOVERSION ${VERSION_MAJOR}) -SET_TARGET_PROPERTIES(${PROJECT_NAME} PROPERTIES VERSION ${VERSION}) - -configure_file(${PROJECT_NAME}.pc.in ${CMAKE_CURRENT_SOURCE_DIR}/${PROJECT_NAME}.pc @ONLY) -install(TARGETS ${PROJECT_NAME} DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT RuntimeLibraries) -install(FILES reg_event_info.h DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/sensor/) -install(FILES sensor_event_listener.h DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/sensor/) -install(FILES sensor_info_manager.h DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/sensor/) -install(FILES sensor_handle_info.h DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/sensor/) -install(FILES client_common.h DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/sensor/) -install(FILES ${PROJECT_NAME}.pc DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig) +INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}) + +FILE(GLOB_RECURSE SRCS *.cpp) +ADD_LIBRARY(${PROJECT_NAME} SHARED ${SRCS}) + +TARGET_LINK_LIBRARIES(${PROJECT_NAME} ${PKGS_LDFLAGS} "sensord-shared") +SET_TARGET_PROPERTIES(${PROJECT_NAME} PROPERTIES SOVERSION ${MAJORVER}) +SET_TARGET_PROPERTIES(${PROJECT_NAME} PROPERTIES VERSION ${FULLVER}) + +CONFIGURE_FILE(${PROJECT_NAME}.pc.in ${CMAKE_CURRENT_SOURCE_DIR}/${PROJECT_NAME}.pc @ONLY) +INSTALL(TARGETS ${PROJECT_NAME} DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT RuntimeLibraries) +INSTALL( + DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/sensor + FILES_MATCHING PATTERN "*.h" + ) +INSTALL(FILES ${PROJECT_NAME}.pc DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig) diff --git a/src/client/sensor.pc.in b/src/client/sensor.pc.in index 6edf0e7..bdd8271 100644 --- a/src/client/sensor.pc.in +++ b/src/client/sensor.pc.in @@ -2,12 +2,12 @@ prefix=@PREFIX@ exec_prefix=@EXEC_PREFIX@ -libdir=@LIBDIR@ -includedir=@INCLUDEDIR@/sensor +libdir=@PC_LIBDIR@ +includedir=@PC_INCLUDEDIR@ Name: @PC_NAME@ Description: @PC_DESCRIPTION@ -Version: @PC_VERSION@ -Requires: @PC_DEPENDENTS@ +Version: @VERSION@ +Requires: @PC_REQUIRES@ Libs: -L${libdir} @PC_LDFLAGS@ -Cflags: -I${includedir} @PC_CFLAGS@ \ No newline at end of file +Cflags: -I${includedir} @PC_CFLAGS@ diff --git a/src/server/CMakeLists.txt b/src/server/CMakeLists.txt index 7a5a888..7c33264 100644 --- a/src/server/CMakeLists.txt +++ b/src/server/CMakeLists.txt @@ -1,36 +1,26 @@ -cmake_minimum_required(VERSION 2.6) -project(sensord CXX) +CMAKE_MINIMUM_REQUIRED(VERSION 2.6) +PROJECT(sensord CXX) -INCLUDE(FindPkgConfig) -PKG_CHECK_MODULES(server_pkgs REQUIRED glib-2.0 gio-2.0 dlog libsystemd-daemon libxml-2.0 cynara-client cynara-creds-socket cynara-session) - -add_subdirectory(plugins) - -add_definitions(${PLUGIN_DEFS}) +SET(DEPENDENTS "glib-2.0 gio-2.0 dlog libsystemd-daemon libxml-2.0 cynara-client cynara-creds-socket cynara-session") -configure_file(sensor_loader.cpp.in sensor_loader.cpp) - -INCLUDE_DIRECTORIES(include) -FILE(GLOB SERVER_SRCS *.c *.cpp) +INCLUDE(FindPkgConfig) +PKG_CHECK_MODULES(SERVER_PKGS REQUIRED ${DEPENDENTS}) -FOREACH(flag ${server_pkgs_LDFLAGS}) - SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${flag}") -ENDFOREACH(flag) +ADD_SUBDIRECTORY(plugins) +ADD_DEFINITIONS(${PLUGIN_DEFS}) -FOREACH(flag ${server_pkgs_CFLAGS}) +FOREACH(flag ${SERVER_PKGS_CFLAGS}) SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${flag}") ENDFOREACH(flag) - -include_directories(${CMAKE_CURRENT_SOURCE_DIR}) -include_directories(${CMAKE_SOURCE_DIR}/src/client) -include_directories(${CMAKE_SOURCE_DIR}/src/shared) -include_directories(${DIR_INCLUDE}) - -SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -lrt -ldl -pthread -fPIE") +SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ldl -fPIE") SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -pie") -add_executable(${PROJECT_NAME} ${SERVER_SRCS} ${PLUGIN_SRCS}) +INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}) +INCLUDE_DIRECTORIES(${DIR_INCLUDE}) + +FILE(GLOB SERVER_SRCS *.cpp) +ADD_EXECUTABLE(${PROJECT_NAME} ${SERVER_SRCS} ${PLUGIN_SRCS}) -target_link_libraries(${PROJECT_NAME} ${lib_pkgs_LDFLAGS} "sensord-shared") +TARGET_LINK_LIBRARIES(${PROJECT_NAME} ${SERVER_PKGS_LDFLAGS} "sensord-shared") -install(TARGETS ${PROJECT_NAME} DESTINATION bin) +INSTALL(TARGETS ${PROJECT_NAME} DESTINATION bin) diff --git a/src/server/plugins/CMakeLists.txt b/src/server/plugins/CMakeLists.txt index 3dae2cb..db69cf0 100644 --- a/src/server/plugins/CMakeLists.txt +++ b/src/server/plugins/CMakeLists.txt @@ -15,9 +15,6 @@ ENDFOREACH(flag) SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC") include_directories(${CMAKE_CURRENT_SOURCE_DIR}) -include_directories(${CMAKE_SOURCE_DIR}/src/server) -include_directories(${CMAKE_SOURCE_DIR}/src/shared) - IF("${AUTO_ROTATION}" STREQUAL "ON") list (APPEND DIR_INCLUDE "${CMAKE_CURRENT_SOURCE_DIR}/auto_rotation") @@ -122,3 +119,5 @@ set(PLUGIN_SRCS ${PLUGIN_SRCS} PARENT_SCOPE) set(DIR_INCLUDE ${DIR_INCLUDE} PARENT_SCOPE) set(PLUGIN_DEFS ${PLUGIN_DEFS} PARENT_SCOPE) +# Installing files +INSTALL(FILES virtual_sensors.xml virtual_sensors.xml DESTINATION etc) diff --git a/virtual_sensors.xml b/src/server/plugins/virtual_sensors.xml similarity index 100% rename from virtual_sensors.xml rename to src/server/plugins/virtual_sensors.xml diff --git a/src/server/sensor_loader.cpp.in b/src/server/sensor_loader.cpp similarity index 100% rename from src/server/sensor_loader.cpp.in rename to src/server/sensor_loader.cpp diff --git a/src/shared/CMakeLists.txt b/src/shared/CMakeLists.txt index 8cf74f2..a1fb14d 100644 --- a/src/shared/CMakeLists.txt +++ b/src/shared/CMakeLists.txt @@ -1,48 +1,26 @@ cmake_minimum_required(VERSION 2.6) project(sensord-shared CXX) -INCLUDE(FindPkgConfig) -PKG_CHECK_MODULES(shared_pkgs REQUIRED dlog libxml-2.0) +SET(DEPENDENTS "dlog") -FOREACH(flag ${shared_pkgs_LDFLAGS}) - SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${flag}") -ENDFOREACH(flag) +INCLUDE(FindPkgConfig) +PKG_CHECK_MODULES(SHARED_PKGS REQUIRED ${DEPENDENTS}) -FOREACH(flag ${shared_pkgs_CFLAGS}) +FOREACH(flag ${SHARED_PKGS_CFLAGS}) SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${flag}") ENDFOREACH(flag) - SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC") -include_directories(${CMAKE_CURRENT_SOURCE_DIR}) -include_directories(${CMAKE_SOURCE_DIR}/src/client) - -add_library(${PROJECT_NAME} SHARED - cbase_lock.cpp - cmutex.cpp - cpacket.cpp - csocket.cpp - sensor_logs.cpp - sensor_info.cpp - poller.cpp -) +INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}) +INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/src/client) -target_link_libraries(${PROJECT_NAME} ${shared_pkgs_LDFLAGS} "-lrt -ldl -pthread") +FILE(GLOB_RECURSE SRCS *.cpp) +ADD_LIBRARY(${PROJECT_NAME} SHARED ${SRCS}) -install(TARGETS ${PROJECT_NAME} DESTINATION ${CMAKE_INSTALL_LIBDIR}) +TARGET_LINK_LIBRARIES(${PROJECT_NAME} ${SHARED_PKGS_LDFLAGS}) -install(FILES - cpacket.h - csocket.h - cbase_lock.h - sensor_info.h - poller.h - DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/${PROJECT_NAME} +INSTALL(TARGETS ${PROJECT_NAME} DESTINATION ${CMAKE_INSTALL_LIBDIR}) +INSTALL( + DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/sensor + FILES_MATCHING PATTERN "*.h" ) - -install(FILES sensor_deprecated.h DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/sensor/) -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/) diff --git a/src/shared/sensor_logs.h b/src/shared/sensor_logs.h index 98cdf63..a9a3ebf 100644 --- a/src/shared/sensor_logs.h +++ b/src/shared/sensor_logs.h @@ -44,6 +44,8 @@ extern "C" #define EVENT_TYPE_SHIFT 16 #define SENSOR_TYPE_SHIFT 32 +#define USE_DLOG_LOG + enum sf_log_type { SF_LOG_PRINT_FILE = 1, SF_LOG_SYSLOG = 2, diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index 51e778f..a20cc3a 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -37,9 +37,9 @@ SET_TARGET_PROPERTIES(multi-thread-performance-test PROPERTIES LINKER_LANGUAGE C target_link_libraries(api-test glib-2.0 dlog sensor) target_link_libraries(sensor-test glib-2.0 dlog sensor) -target_link_libraries(multi-process-performance-test glib-2.0 dlog sensor) +target_link_libraries(multi-process-performance-test glib-2.0 dlog sensor pthread) target_link_libraries(fusion-data-collection glib-2.0 dlog sensor) -target_link_libraries(multi-thread-performance-test glib-2.0 dlog sensor) +target_link_libraries(multi-thread-performance-test glib-2.0 dlog sensor pthread) INSTALL(TARGETS api-test DESTINATION /usr/bin/) INSTALL(TARGETS sensor-test DESTINATION /usr/bin/) -- 2.7.4 From 78e02a8adef71c5bcc14f6665f7965a739011b6b Mon Sep 17 00:00:00 2001 From: "kibak.yoon" Date: Fri, 12 Feb 2016 23:48:06 +0900 Subject: [PATCH 11/16] sensord: create sensor-hal-devel package - sensor-hal-devel package installs sensor.h only - remove sensorhub-related code Change-Id: Ic1486cf9e3661ff9ef6103678f878e53cc94539a Signed-off-by: kibak.yoon --- CMakeLists.txt | 2 + packaging/sensord.spec | 12 +++++ src/client/sensor_event_listener.cpp | 99 +++++++--------------------------- src/hal/CMakeLists.txt | 4 ++ src/{shared => hal}/sensor_hal.h | 2 - src/server/sensor_event_dispatcher.cpp | 94 +++++++++----------------------- src/server/sensor_event_dispatcher.h | 1 - src/shared/sensor_common.h | 17 ------ src/shared/sensor_logs.cpp | 26 +-------- src/shared/sensor_logs.h | 8 --- src/shared/sf_common.h | 7 --- test/CMakeLists.txt | 1 + 12 files changed, 63 insertions(+), 210 deletions(-) create mode 100644 src/hal/CMakeLists.txt rename src/{shared => hal}/sensor_hal.h (99%) diff --git a/CMakeLists.txt b/CMakeLists.txt index 5c572f1..1994fe5 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -15,6 +15,7 @@ MESSAGE("FLAGS: ${CMAKE_EXE_LINKER_FLAGS}") INCLUDE_DIRECTORIES( ${CMAKE_CURRENT_SOURCE_DIR}/src/ ${CMAKE_CURRENT_SOURCE_DIR}/src/shared + ${CMAKE_CURRENT_SOURCE_DIR}/src/hal ) # Sub-directory @@ -22,6 +23,7 @@ ADD_SUBDIRECTORY(systemd) ADD_SUBDIRECTORY(src/server) ADD_SUBDIRECTORY(src/client) ADD_SUBDIRECTORY(src/shared) +ADD_SUBDIRECTORY(src/hal) IF("${TEST_SUITE}" STREQUAL "ON") ADD_SUBDIRECTORY(test) diff --git a/packaging/sensord.spec b/packaging/sensord.spec index f57f7cd..063d808 100644 --- a/packaging/sensord.spec +++ b/packaging/sensord.spec @@ -51,6 +51,13 @@ Requires: libsensord = %{version}-%{release} %description -n libsensord-devel Sensord shared library +%package -n sensor-hal-devel +Summary: Sensord HAL interface +Group: System/Development + +%description -n sensor-hal-devel +Sensord HAL interface + %if %{build_test_suite} == "ON" %package -n sensor-test Summary: Sensord library @@ -119,6 +126,11 @@ systemctl daemon-reload %{_libdir}/pkgconfig/sensor.pc %license LICENSE.APLv2 +%files -n sensor-hal-devel +%defattr(-,root,root,-) +%{_includedir}/sensor/sensor_hal.h +%license LICENSE.APLv2 + %if %{build_test_suite} == "ON" %files -n sensor-test %defattr(-,root,root,-) diff --git a/src/client/sensor_event_listener.cpp b/src/client/sensor_event_listener.cpp index f5c2cf4..028b8f2 100644 --- a/src/client/sensor_event_listener.cpp +++ b/src/client/sensor_event_listener.cpp @@ -30,7 +30,7 @@ #define MIN_DELIVERY_DIFF_FACTOR 0.75f /* TODO: this macro should be adjusted */ -#define EVENT_BUFFER_SIZE sizeof(sensorhub_event_t) +#define EVENT_BUFFER_SIZE 4224 using std::thread; using std::pair; @@ -167,40 +167,29 @@ void sensor_event_listener::handle_events(void* event) int accuracy = SENSOR_ACCURACY_GOOD; unsigned int event_type = *((unsigned int *)(event)); - bool is_hub_event = is_sensorhub_event(event_type); client_callback_info* callback_info = NULL; vector client_callback_infos; - if (is_hub_event) { - sensorhub_event_t *sensor_hub_event = (sensorhub_event_t *)event; - sensor_id = sensor_hub_event->sensor_id; - sensor_data = &(sensor_hub_event->data); - cur_time = sensor_hub_event->data.timestamp; - - event_data.event_data = &(sensor_hub_event->data); - event_data.event_data_size = sizeof(sensor_hub_event->data); + sensor_event_t *sensor_event = (sensor_event_t *)event; + sensor_id = sensor_event->sensor_id; + 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; + + if (is_single_state_event(event_type)) { + 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]; + event_data.event_data = (void *)&panning_data; + event_data.event_data_size = sizeof(panning_data); } else { - sensor_event_t *sensor_event = (sensor_event_t *)event; - sensor_id = sensor_event->sensor_id; - 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; - - if (is_single_state_event(event_type)) { - 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]; - event_data.event_data = (void *)&panning_data; - event_data.event_data_size = sizeof(panning_data); - } else { - event_data.event_data = &(sensor_event->data); - event_data.event_data_size = sizeof(sensor_event->data); - } + event_data.event_data = &(sensor_event->data); + event_data.event_data_size = sizeof(sensor_event->data); } { /* scope for the lock */ @@ -284,56 +273,6 @@ client_callback_info* sensor_event_listener::get_callback_info(sensor_id_t senso callback_info->sensor_data = sensor_data; callback_info->buffer = buffer; - /* - if (event_info->m_cb_type == SENSOR_EVENT_CB) { - callback_info->sensor_data = new(std::nothrow) char[sizeof(sensor_data_t)]; - - if (!callback_info->sensor_data) { - ERR("Failed to allocate memory"); - delete callback_info; - return NULL; - } - - copy_sensor_data((sensor_data_t*) callback_info->sensor_data, (sensor_data_t*) sensor_data); - } else if (event_info->m_cb_type == SENSORHUB_EVENT_CB) { - callback_info->sensor_data = new(std::nothrow) char[sizeof(sensorhub_data_t)]; - - if (!callback_info->sensor_data) { - ERR("Failed to allocate memory"); - delete callback_info; - return NULL; - } - - copy_sensorhub_data((sensorhub_data_t*) callback_info->sensor_data, (sensorhub_data_t*) sensor_data); - } else if(event_info->m_cb_type == SENSOR_LEGACY_CB) { - sensor_event_data_t *dest_sensor_data; - sensor_event_data_t *src_sensor_data = (sensor_event_data_t *)sensor_data; - callback_info->sensor_data = new(std::nothrow) char[sizeof(sensor_event_data_t)]; - - if (!callback_info->sensor_data) { - ERR("Failed to allocate memory"); - delete callback_info; - return NULL; - } - - dest_sensor_data = (sensor_event_data_t *) callback_info->sensor_data; - dest_sensor_data->event_data_size = src_sensor_data->event_data_size; - dest_sensor_data->event_data = new(std::nothrow) char[src_sensor_data->event_data_size]; - - if (!dest_sensor_data->event_data) { - ERR("Failed to allocate memory"); - delete[] (char *)(callback_info->sensor_data); - delete callback_info; - return NULL; - } - - if (is_sensorhub_event(event_info->type)) - copy_sensorhub_data((sensorhub_data_t*)dest_sensor_data->event_data, (sensorhub_data_t*)src_sensor_data->event_data); - else - memcpy(dest_sensor_data->event_data, src_sensor_data->event_data, src_sensor_data->event_data_size); - } - */ - return callback_info; } diff --git a/src/hal/CMakeLists.txt b/src/hal/CMakeLists.txt new file mode 100644 index 0000000..ee01da1 --- /dev/null +++ b/src/hal/CMakeLists.txt @@ -0,0 +1,4 @@ +CMAKE_MINIMUM_REQUIRED(VERSION 2.6) +PROJECT(sensor-hal CXX) + +INSTALL(FILES sensor_hal.h DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/sensor/) diff --git a/src/shared/sensor_hal.h b/src/hal/sensor_hal.h similarity index 99% rename from src/shared/sensor_hal.h rename to src/hal/sensor_hal.h index 1882d39..ded1a90 100644 --- a/src/shared/sensor_hal.h +++ b/src/hal/sensor_hal.h @@ -137,7 +137,6 @@ typedef struct sensor_data_t { #define SENSORHUB_DATA_VALUE_SIZE 4096 -#if 0 /* sensorhub_data_t */ typedef struct sensorhub_data_t { int accuracy; @@ -145,7 +144,6 @@ typedef struct sensorhub_data_t { int value_count; char values[SENSORHUB_DATA_VALUE_SIZE]; } sensorhub_data_t; -#endif /* * Create devices diff --git a/src/server/sensor_event_dispatcher.cpp b/src/server/sensor_event_dispatcher.cpp index 9fdc69d..1db1c3a 100644 --- a/src/server/sensor_event_dispatcher.cpp +++ b/src/server/sensor_event_dispatcher.cpp @@ -136,53 +136,44 @@ void sensor_event_dispatcher::dispatch_event(void) INFO("Event Dispatcher started"); while (true) { - bool is_hub_event = false; void *seed_event = get_event_queue().pop(); unsigned int event_type = *((unsigned int *)(seed_event)); - if (is_sensorhub_event(event_type)) - is_hub_event = true; + vector sensor_events; + sensor_events.push_back(seed_event); - if (is_hub_event) { - sensorhub_event_t *sensorhub_event = (sensorhub_event_t *)seed_event; - send_sensorhub_events(sensorhub_event); - } else { - vector sensor_events; - sensor_events.push_back(seed_event); + virtual_sensors v_sensors = get_active_virtual_sensors(); - virtual_sensors v_sensors = get_active_virtual_sensors(); + auto it_v_sensor = v_sensors.begin(); - auto it_v_sensor = v_sensors.begin(); + while (it_v_sensor != v_sensors.end()) { + int synthesized_cnt; + v_sensor_events.clear(); + (*it_v_sensor)->synthesize(*((sensor_event_t *)seed_event)); + synthesized_cnt = v_sensor_events.size(); - while (it_v_sensor != v_sensors.end()) { - int synthesized_cnt; - v_sensor_events.clear(); - (*it_v_sensor)->synthesize(*((sensor_event_t *)seed_event)); - synthesized_cnt = v_sensor_events.size(); - - for (int i = 0; i < synthesized_cnt; ++i) { - sensor_event_t *v_event = (sensor_event_t*)malloc(sizeof(sensor_event_t)); - if (!v_event) { - ERR("Failed to allocate memory"); - continue; - } - - memcpy(v_event, &v_sensor_events[i], sizeof(sensor_event_t)); - sensor_events.push_back(v_event); + for (int i = 0; i < synthesized_cnt; ++i) { + sensor_event_t *v_event = (sensor_event_t*)malloc(sizeof(sensor_event_t)); + if (!v_event) { + ERR("Failed to allocate memory"); + continue; } - ++it_v_sensor; + memcpy(v_event, &v_sensor_events[i], sizeof(sensor_event_t)); + sensor_events.push_back(v_event); } - sort_sensor_events(sensor_events); + ++it_v_sensor; + } - for (unsigned int i = 0; i < sensor_events.size(); ++i) { - 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]))); - } + sort_sensor_events(sensor_events); - send_sensor_events(sensor_events); + for (unsigned int i = 0; i < sensor_events.size(); ++i) { + 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); } } @@ -238,43 +229,6 @@ void sensor_event_dispatcher::send_sensor_events(vector &events) } } -void sensor_event_dispatcher::send_sensorhub_events(void* events) -{ - sensorhub_event_t *sensor_hub_events; - client_info_manager& client_info_manager = get_client_info_manager(); - - const int RESERVED_CLIENT_CNT = 20; - static client_id_vec id_vec(RESERVED_CLIENT_CNT); - - sensor_hub_events = (sensorhub_event_t *)events; - - sensor_id_t sensor_id; - unsigned int event_type; - - sensor_id = sensor_hub_events->sensor_id; - event_type = sensor_hub_events->event_type; - - id_vec.clear(); - client_info_manager.get_listener_ids(sensor_id, event_type, id_vec); - - auto it_client_id = id_vec.begin(); - - 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_hub_events, sizeof(sensorhub_event_t)) > 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()); - else - ERR("Failed to send event[0x%x] to %s on socket[%d]", event_type, client_info_manager.get_client_info(*it_client_id), client_socket.get_socket_fd()); - - ++it_client_id; - } - - free(sensor_hub_events); -} - client_info_manager& sensor_event_dispatcher::get_client_info_manager(void) { return client_info_manager::get_instance(); diff --git a/src/server/sensor_event_dispatcher.h b/src/server/sensor_event_dispatcher.h index 4b58b6b..cd38f97 100644 --- a/src/server/sensor_event_dispatcher.h +++ b/src/server/sensor_event_dispatcher.h @@ -53,7 +53,6 @@ private: void dispatch_event(void); 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); diff --git a/src/shared/sensor_common.h b/src/shared/sensor_common.h index a6d551b..2edc306 100644 --- a/src/shared/sensor_common.h +++ b/src/shared/sensor_common.h @@ -51,23 +51,6 @@ typedef enum { SENSOR_PRIVILEGE_INTERNAL, } sensor_privilege_t; -#define SENSOR_HUB_DATA_SIZE 4096 - -typedef struct sensorhub_data_t { - 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; - /* * To prevent naming confliction as using same enums as sensor CAPI use */ diff --git a/src/shared/sensor_logs.cpp b/src/shared/sensor_logs.cpp index 8abd66a..5426c0f 100644 --- a/src/shared/sensor_logs.cpp +++ b/src/shared/sensor_logs.cpp @@ -24,12 +24,10 @@ #include #include #include -#include "sensor_logs.h" #include #include #include -#include -#include +#include "sensor_logs.h" #ifndef EXTAPI #define EXTAPI __attribute__((visibility("default"))) @@ -171,25 +169,3 @@ const char* get_client_name(void) return client_name; } - - -bool is_sensorhub_event(unsigned int event_type) -{ - if ((event_type >> EVENT_TYPE_SHIFT) == CONTEXT_SENSOR) - return true; - - return false; -} - -void copy_sensor_data(sensor_data_t *dest, sensor_data_t *src) -{ - memcpy(dest, src, offsetof(sensor_data_t, values)); - memcpy(dest->values, src->values, src->value_count * sizeof(src->values[0])); -} - -void copy_sensorhub_data(sensorhub_data_t *dest, sensorhub_data_t *src) -{ - memcpy(dest, src, offsetof(sensorhub_data_t, hub_data)); - memcpy(dest->hub_data, src->hub_data, src->hub_data_size); - memcpy(dest->data, src->data, sizeof(src->data)); -} diff --git a/src/shared/sensor_logs.h b/src/shared/sensor_logs.h index a9a3ebf..70b10fa 100644 --- a/src/shared/sensor_logs.h +++ b/src/shared/sensor_logs.h @@ -216,16 +216,8 @@ void sf_log(int type , int priority , const char *tag , const char *fmt , ...); #endif -struct sensor_data_t; -struct sensorhub_data_t; -typedef struct sensor_data_t sensor_data_t; -typedef struct sensorhub_data_t sensorhub_data_t; - const char* get_client_name(void); bool get_proc_name(pid_t pid, char *process_name); -bool is_sensorhub_event(unsigned int event_type); -void copy_sensor_data(sensor_data_t *dest, sensor_data_t *src); -void copy_sensorhub_data(sensorhub_data_t *dest, sensorhub_data_t *src); #ifdef __cplusplus } diff --git a/src/shared/sf_common.h b/src/shared/sf_common.h index 6d2fda5..e504eee 100644 --- a/src/shared/sf_common.h +++ b/src/shared/sf_common.h @@ -166,13 +166,6 @@ typedef struct sensor_event_t { 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 void *(*cmd_func_t)(void *data, void *cb_data); typedef std::vector event_type_vector; diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index a20cc3a..d9e3ec9 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -14,6 +14,7 @@ add_definitions(-DPREFIX="${CMAKE_INSTALL_PREFIX}") include_directories(${CMAKE_CURRENT_SOURCE_DIR}) include_directories(${CMAKE_SOURCE_DIR}/src/client) include_directories(${CMAKE_SOURCE_DIR}/src/shared) +include_directories(${CMAKE_SOURCE_DIR}/src/hal) FOREACH(flag ${pkgs_CFLAGS}) SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}") -- 2.7.4 From 08d395575e7ffe26cc114c0cd5134d96c7199ca6 Mon Sep 17 00:00:00 2001 From: "kibak.yoon" Date: Sat, 13 Feb 2016 11:31:04 +0900 Subject: [PATCH 12/16] sensord: remove useless the type-casting Change-Id: I174a36bc3e773a5920c6ea6354dfb34add7054d4 Signed-off-by: kibak.yoon --- src/shared/sensor_info.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/shared/sensor_info.cpp b/src/shared/sensor_info.cpp index 79dbfee..dfa0fe5 100644 --- a/src/shared/sensor_info.cpp +++ b/src/shared/sensor_info.cpp @@ -167,7 +167,7 @@ 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, (int64_t) (m_id)); + put(data, m_id); put(data, (int) m_privilege); put(data, m_name); put(data, m_vendor); @@ -211,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%llx", (uint64_t)m_id); + INFO("ID = 0x%llx", (int64_t)m_id); INFO("Privilege = %d", (int)m_privilege); INFO("Name = %s", m_name.c_str()); INFO("Vendor = %s", m_vendor.c_str()); -- 2.7.4 From ddd5845ad5adbaeb87fd6d896d87cb0ee88e9b27 Mon Sep 17 00:00:00 2001 From: "kibak.yoon" Date: Sat, 13 Feb 2016 13:14:10 +0900 Subject: [PATCH 13/16] sensord: add set_attribute_* API for internal Change-Id: I4e9c058f80e37b7067823fc1ff3b543010365852 Signed-off-by: kibak.yoon --- src/client/client.cpp | 241 +++++++++++++++++++++++------------------ src/client/command_channel.cpp | 100 ++++++++--------- src/client/command_channel.h | 4 +- src/server/command_worker.cpp | 62 +++++------ src/server/command_worker.h | 4 +- src/shared/sensor_internal.h | 21 ++++ src/shared/sf_common.h | 17 +-- 7 files changed, 253 insertions(+), 196 deletions(-) diff --git a/src/client/client.cpp b/src/client/client.cpp index 05e3897..e64482f 100644 --- a/src/client/client.cpp +++ b/src/client/client.cpp @@ -312,96 +312,6 @@ static bool change_sensor_rep(sensor_id_t sensor_id, sensor_rep &prev_rep, senso return true; } -API int sf_connect(sensor_type_t sensor_type) -{ - sensor_t sensor; - - sensor = sensord_get_sensor(sensor_type); - - return sensord_connect(sensor); -} - -API int sf_disconnect(int handle) -{ - return sensord_disconnect(handle) ? OP_SUCCESS : OP_ERROR; -} - -API int sf_start(int handle, int option) -{ - return sensord_start(handle, option) ? OP_SUCCESS : OP_ERROR; -} - -API int sf_stop(int handle) -{ - return sensord_stop(handle) ? OP_SUCCESS : OP_ERROR; -} - -API int sf_register_event(int handle, unsigned int event_type, event_condition_t *event_condition, sensor_callback_func_t cb, void *user_data) -{ - unsigned int interval = BASE_GATHERING_INTERVAL; - - if (event_condition != NULL) { - if ((event_condition->cond_op == CONDITION_EQUAL) && (event_condition->cond_value1 > 0)) - interval = event_condition->cond_value1; - } - - return register_event(handle, event_type, interval, 0, SENSOR_LEGACY_CB, (void*) cb, user_data) ? OP_SUCCESS : OP_ERROR; -} - -API int sf_unregister_event(int handle, unsigned int event_type) -{ - return sensord_unregister_event(handle, event_type) ? OP_SUCCESS : OP_ERROR; -} - -API int sf_change_event_condition(int handle, unsigned int event_type, event_condition_t *event_condition) -{ - unsigned int interval = BASE_GATHERING_INTERVAL; - - if (event_condition != NULL) { - if ((event_condition->cond_op == CONDITION_EQUAL) && (event_condition->cond_value1 > 0)) - interval = event_condition->cond_value1; - } - - return sensord_change_event_interval(handle, event_type, interval) ? OP_SUCCESS : OP_ERROR; -} - -API int sf_change_sensor_option(int handle, int option) -{ - return sensord_set_option(handle, option) ? OP_SUCCESS : OP_ERROR; -} - - -API int sf_send_sensorhub_data(int handle, const char* data, int data_len) -{ - return sensord_send_sensorhub_data(handle, data, data_len) ? OP_SUCCESS : OP_ERROR; -} - -API int sf_get_data(int handle, unsigned int data_id, sensor_data_t* sensor_data) -{ - return sensord_get_data(handle, data_id, sensor_data) ? OP_SUCCESS : OP_ERROR; -} - -API int sf_check_rotation(unsigned long *rotation) -{ - rotation = 0; - return 0; -} - -int sf_is_sensor_event_available(sensor_type_t sensor_type, unsigned int event_type) -{ - return 0; -} - -int sf_get_data_properties(unsigned int data_id, sensor_data_properties_t *return_data_properties) -{ - return 0; -} - -int sf_get_properties(sensor_type_t sensor_type, sensor_properties_t *return_properties) -{ - return 0; -} - static bool get_sensor_list(void) { static cmutex l; @@ -1118,7 +1028,7 @@ API bool sensord_set_wakeup(int handle, int wakeup) return true; } -API bool sensord_send_sensorhub_data(int handle, const char *data, int data_len) +API bool sensord_set_attribute_int(int handle, int attribute, int value) { sensor_id_t sensor_id; command_channel *cmd_channel; @@ -1131,31 +1041,65 @@ API bool sensord_send_sensorhub_data(int handle, const char *data, int data_len) return false; } - retvm_if (sensor_id != CONTEXT_SENSOR, false, "%s use this API wrongly, only for CONTEXT_SENSOR not for %s", - get_client_name(), get_sensor_name(sensor_id)); - if (!client_info.get_command_channel(sensor_id, &cmd_channel)) { ERR("client %s failed to get command channel for %s", get_client_name(), get_sensor_name(sensor_id)); return false; } - retvm_if((data_len < 0) || (data == NULL), false, "Invalid data_len: %d, data: 0x%x, handle: %d, %s, %s", - data_len, data, handle, get_sensor_name(sensor_id), get_client_name()); - client_id = client_info.get_client_id(); - retvm_if ((client_id < 0), false, "Invalid client id : %d, handle: %d, %s, %s", client_id, handle, get_sensor_name(sensor_id), get_client_name()); + retvm_if ((client_id < 0), false, + "Invalid client id : %d, handle: %d, %s, %s", + client_id, handle, get_sensor_name(sensor_id), get_client_name()); - retvm_if (!client_info.is_sensor_active(sensor_id), false, "%s with client_id:%d is not active state for %s with handle: %d", - get_sensor_name(sensor_id), client_id, get_client_name(), handle); + if (!cmd_channel->cmd_set_attribute_int(attribute, value)) { + ERR("Sending cmd_set_attribute_int(%d, %d) failed for %s", + client_id, value, get_client_name); + return false; + } + + return true; +} + +API bool sensord_set_attribute_str(int handle, int attribute, const char *value, int value_len) +{ + sensor_id_t sensor_id; + command_channel *cmd_channel; + int client_id; + + AUTOLOCK(lock); - if (!cmd_channel->cmd_send_sensorhub_data(data, data_len)) { - ERR("Sending cmd_send_sensorhub_data(%d, %d, 0x%x) failed for %s", - client_id, data_len, data, get_client_name); + if (!client_info.get_sensor_id(handle, sensor_id)) { + ERR("client %s failed to get handle information", get_client_name()); + return false; + } + + if (!client_info.get_command_channel(sensor_id, &cmd_channel)) { + ERR("client %s failed to get command channel for %s", + get_client_name(), get_sensor_name(sensor_id)); + return false; + } + + retvm_if((value_len < 0) || (value == NULL), false, + "Invalid value_len: %d, value: 0x%x, handle: %d, %s, %s", + value_len, value, handle, get_sensor_name(sensor_id), get_client_name()); + + client_id = client_info.get_client_id(); + retvm_if ((client_id < 0), false, + "Invalid client id : %d, handle: %d, %s, %s", + client_id, handle, get_sensor_name(sensor_id), get_client_name()); + + if (!cmd_channel->cmd_set_attribute_str(attribute, value, value_len)) { + ERR("Sending cmd_set_attribute_str(%d, %d, 0x%x) failed for %s", + client_id, value_len, value, get_client_name); return false; } return true; +} +API bool sensord_send_sensorhub_data(int handle, const char *data, int data_len) +{ + return sensord_set_attribute_str(handle, 0, data, data_len); } API bool sensord_get_data(int handle, unsigned int data_id, sensor_data_t* sensor_data) @@ -1196,3 +1140,94 @@ API bool sensord_get_data(int handle, unsigned int data_id, sensor_data_t* senso return true; } + +/* deprecated APIs */ +API int sf_connect(sensor_type_t sensor_type) +{ + sensor_t sensor; + + sensor = sensord_get_sensor(sensor_type); + + return sensord_connect(sensor); +} + +API int sf_disconnect(int handle) +{ + return sensord_disconnect(handle) ? OP_SUCCESS : OP_ERROR; +} + +API int sf_start(int handle, int option) +{ + return sensord_start(handle, option) ? OP_SUCCESS : OP_ERROR; +} + +API int sf_stop(int handle) +{ + return sensord_stop(handle) ? OP_SUCCESS : OP_ERROR; +} + +API int sf_register_event(int handle, unsigned int event_type, event_condition_t *event_condition, sensor_callback_func_t cb, void *user_data) +{ + unsigned int interval = BASE_GATHERING_INTERVAL; + + if (event_condition != NULL) { + if ((event_condition->cond_op == CONDITION_EQUAL) && (event_condition->cond_value1 > 0)) + interval = event_condition->cond_value1; + } + + return register_event(handle, event_type, interval, 0, SENSOR_LEGACY_CB, (void*) cb, user_data) ? OP_SUCCESS : OP_ERROR; +} + +API int sf_unregister_event(int handle, unsigned int event_type) +{ + return sensord_unregister_event(handle, event_type) ? OP_SUCCESS : OP_ERROR; +} + +API int sf_change_event_condition(int handle, unsigned int event_type, event_condition_t *event_condition) +{ + unsigned int interval = BASE_GATHERING_INTERVAL; + + if (event_condition != NULL) { + if ((event_condition->cond_op == CONDITION_EQUAL) && (event_condition->cond_value1 > 0)) + interval = event_condition->cond_value1; + } + + return sensord_change_event_interval(handle, event_type, interval) ? OP_SUCCESS : OP_ERROR; +} + +API int sf_change_sensor_option(int handle, int option) +{ + return sensord_set_option(handle, option) ? OP_SUCCESS : OP_ERROR; +} + +API int sf_send_sensorhub_data(int handle, const char* data, int data_len) +{ + return sensord_send_sensorhub_data(handle, data, data_len) ? OP_SUCCESS : OP_ERROR; +} + +API int sf_get_data(int handle, unsigned int data_id, sensor_data_t* sensor_data) +{ + return sensord_get_data(handle, data_id, sensor_data) ? OP_SUCCESS : OP_ERROR; +} + +API int sf_check_rotation(unsigned long *rotation) +{ + rotation = 0; + return 0; +} + +API int sf_is_sensor_event_available(sensor_type_t sensor_type, unsigned int event_type) +{ + return 0; +} + +API int sf_get_data_properties(unsigned int data_id, sensor_data_properties_t *return_data_properties) +{ + return 0; +} + +API int sf_get_properties(sensor_type_t sensor_type, sensor_properties_t *return_properties) +{ + return 0; +} + diff --git a/src/client/command_channel.cpp b/src/client/command_channel.cpp index 02303a6..888503d 100644 --- a/src/client/command_channel.cpp +++ b/src/client/command_channel.cpp @@ -596,47 +596,6 @@ bool command_channel::cmd_unset_batch(void) return true; } -bool command_channel::cmd_set_command(unsigned int cmd, long value) -{ - cpacket *packet; - cmd_set_command_t *cmd_set_command; - cmd_done_t *cmd_done; - - packet = new(std::nothrow) cpacket(sizeof(cmd_set_command_t)); - retvm_if(!packet, false, "Failed to allocate memory"); - - packet->set_cmd(CMD_SET_COMMAND); - - cmd_set_command = (cmd_set_command_t*)packet->data(); - cmd_set_command->cmd = cmd; - cmd_set_command->value = value; - - - INFO("%s send cmd_set_command(client_id=%d, %s, 0x%x, %ld)", - get_client_name(), m_client_id, get_sensor_name(m_sensor_id), cmd, value); - - if (!command_handler(packet, (void **)&cmd_done)) { - ERR("Client %s failed to send/receive command for sensor[%s] with client_id [%d], property[0x%x], value[%d]", - get_client_name(), get_sensor_name(m_sensor_id), m_client_id, cmd, value); - delete packet; - return false; - } - - if (cmd_done->value < 0) { - ERR("Client %s got error[%d] from server for sensor[%s] with property[0x%x], value[%d]", - get_client_name(), cmd_done->value, get_sensor_name(m_sensor_id), cmd, value); - - delete[] (char *)cmd_done; - delete packet; - return false; - } - - delete[] (char *)cmd_done; - delete packet; - - return true; -} - bool command_channel::cmd_get_data(unsigned int type, sensor_data_t* sensor_data) { cpacket *packet; @@ -685,23 +644,64 @@ bool command_channel::cmd_get_data(unsigned int type, sensor_data_t* sensor_data return true; } -bool command_channel::cmd_send_sensorhub_data(const char* buffer, int data_len) +bool command_channel::cmd_set_attribute_int(int attribute, int value) +{ + cpacket *packet; + cmd_set_attribute_int_t *cmd_set_attribute_int; + cmd_done_t *cmd_done; + + packet = new(std::nothrow) cpacket(sizeof(cmd_set_attribute_int_t)); + retvm_if(!packet, false, "Failed to allocate memory"); + + packet->set_cmd(CMD_SET_ATTRIBUTE_INT); + + cmd_set_attribute_int = (cmd_set_attribute_int_t*)packet->data(); + cmd_set_attribute_int->attribute = attribute; + cmd_set_attribute_int->value = value; + + INFO("%s send cmd_set_attribute_int(client_id=%d, %s, 0x%x, %d)", + get_client_name(), m_client_id, get_sensor_name(m_sensor_id), attribute, value); + + if (!command_handler(packet, (void **)&cmd_done)) { + ERR("Client %s failed to send/receive command for sensor[%s] with client_id [%d], property[0x%x], value[%d]", + get_client_name(), get_sensor_name(m_sensor_id), m_client_id, attribute, value); + delete packet; + return false; + } + + if (cmd_done->value < 0) { + ERR("Client %s got error[%d] from server for sensor[%s] with property[0x%x], value[%d]", + get_client_name(), cmd_done->value, get_sensor_name(m_sensor_id), attribute, value); + + delete[] (char *)cmd_done; + delete packet; + return false; + } + + delete[] (char *)cmd_done; + delete packet; + + return true; +} + +bool command_channel::cmd_set_attribute_str(int attribute, const char* value, int value_len) { cpacket *packet; - cmd_send_sensorhub_data_t *cmd_send_sensorhub_data; + cmd_set_attribute_str_t *cmd_set_attribute_str; cmd_done_t *cmd_done; - packet = new(std::nothrow) cpacket(sizeof(cmd_send_sensorhub_data_t) + data_len); + packet = new(std::nothrow) cpacket(sizeof(cmd_set_attribute_str_t) + value_len); retvm_if(!packet, false, "Failed to allocate memory"); - packet->set_cmd(CMD_SEND_SENSORHUB_DATA); + packet->set_cmd(CMD_SET_ATTRIBUTE_STR); - 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_set_attribute_str = (cmd_set_attribute_str_t*)packet->data(); + cmd_set_attribute_str->attribute = attribute; + cmd_set_attribute_str->value_len = value_len; + memcpy(cmd_set_attribute_str->value, value, value_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); + INFO("%s send cmd_set_attribute_str(client_id=%d, value_len = %d, buffer = 0x%x)", + get_client_name(), m_client_id, value_len, value); if (!command_handler(packet, (void **)&cmd_done)) { ERR("%s failed to send/receive command with client_id [%d]", diff --git a/src/client/command_channel.h b/src/client/command_channel.h index cc1225d..439ace6 100644 --- a/src/client/command_channel.h +++ b/src/client/command_channel.h @@ -48,9 +48,9 @@ public: bool cmd_unregister_events(event_type_vector &event_vec); bool cmd_set_batch(unsigned int interval, unsigned int latency); bool cmd_unset_batch(void); - bool cmd_set_command(unsigned int cmd, long value); bool cmd_get_data(unsigned int type, sensor_data_t* values); - bool cmd_send_sensorhub_data(const char* buffer, int data_len); + bool cmd_set_attribute_int(int attribute, int value); + bool cmd_set_attribute_str(int attribute, const char* buffer, int data_len); private: csocket m_command_socket; int m_client_id; diff --git a/src/server/command_worker.cpp b/src/server/command_worker.cpp index 3a0faee..7407310 100644 --- a/src/server/command_worker.cpp +++ b/src/server/command_worker.cpp @@ -84,9 +84,9 @@ void command_worker::init_cmd_handlers(void) m_cmd_handlers[CMD_SET_WAKEUP] = &command_worker::cmd_set_wakeup; m_cmd_handlers[CMD_SET_BATCH] = &command_worker::cmd_set_batch; m_cmd_handlers[CMD_UNSET_BATCH] = &command_worker::cmd_unset_batch; - m_cmd_handlers[CMD_SET_COMMAND] = &command_worker::cmd_set_command; m_cmd_handlers[CMD_GET_DATA] = &command_worker::cmd_get_data; - m_cmd_handlers[CMD_SEND_SENSORHUB_DATA] = &command_worker::cmd_send_sensorhub_data; + m_cmd_handlers[CMD_SET_ATTRIBUTE_INT] = &command_worker::cmd_set_attribute_int; + m_cmd_handlers[CMD_SET_ATTRIBUTE_STR] = &command_worker::cmd_set_attribute_str; } void command_worker::get_sensor_list(int permissions, cpacket &sensor_list) @@ -728,31 +728,6 @@ out: return true; } -bool command_worker::cmd_set_command(void *payload) -{ - cmd_set_command_t *cmd; - long ret_value = OP_ERROR; - - DBG("CMD_SET_COMMAND Handler invoked\n"); - - cmd = (cmd_set_command_t*)payload; - - if (!is_permission_allowed()) { - 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; - } - - ret_value = m_module->set_attribute(cmd->cmd, cmd->value); - -out: - if (!send_cmd_done(ret_value)) - ERR("Failed to send cmd_done to a client"); - - return true; -} - bool command_worker::cmd_get_data(void *payload) { const unsigned int GET_DATA_MIN_INTERVAL = 10; @@ -817,14 +792,39 @@ out: return true; } -bool command_worker::cmd_send_sensorhub_data(void *payload) +bool command_worker::cmd_set_attribute_int(void *payload) +{ + cmd_set_attribute_int_t *cmd; + long ret_value = OP_ERROR; + + DBG("CMD_SET_COMMAND Handler invoked\n"); + + cmd = (cmd_set_attribute_int_t*)payload; + + if (!is_permission_allowed()) { + ERR("Permission denied to set command for client [%d], for sensor [0x%llx] with attribute [%d]", + m_client_id, m_sensor_id, cmd->attribute); + ret_value = OP_ERROR; + goto out; + } + + ret_value = m_module->set_attribute(cmd->attribute, cmd->value); + +out: + if (!send_cmd_done(ret_value)) + ERR("Failed to send cmd_done to a client"); + + return true; +} + +bool command_worker::cmd_set_attribute_str(void *payload) { - cmd_send_sensorhub_data_t *cmd; + cmd_set_attribute_str_t *cmd; long ret_value = OP_ERROR; DBG("CMD_SEND_SENSORHUB_DATA Handler invoked"); - cmd = (cmd_send_sensorhub_data_t*)payload; + cmd = (cmd_set_attribute_str_t*)payload; if (!is_permission_allowed()) { ERR("Permission denied to send sensorhub_data for client [%d], for sensor [0x%llx]", @@ -833,7 +833,7 @@ bool command_worker::cmd_send_sensorhub_data(void *payload) goto out; } - ret_value = m_module->set_attribute(0, cmd->data, cmd->data_len); + ret_value = m_module->set_attribute(cmd->attribute, cmd->value, cmd->value_len); out: if (!send_cmd_done(ret_value)) diff --git a/src/server/command_worker.h b/src/server/command_worker.h index 217f4aa..8323571 100644 --- a/src/server/command_worker.h +++ b/src/server/command_worker.h @@ -74,9 +74,9 @@ private: bool cmd_unset_batch(void *payload); bool cmd_set_option(void *payload); bool cmd_set_wakeup(void *payload); - bool cmd_set_command(void *payload); bool cmd_get_data(void *payload); - bool cmd_send_sensorhub_data(void *payload); + bool cmd_set_attribute_int(void *payload); + bool cmd_set_attribute_str(void *payload); void get_info(std::string &info); diff --git a/src/shared/sensor_internal.h b/src/shared/sensor_internal.h index 62ae845..0a3d85a 100644 --- a/src/shared/sensor_internal.h +++ b/src/shared/sensor_internal.h @@ -330,6 +330,27 @@ bool sensord_set_option(int handle, int option); bool sensord_set_wakeup(int handle, int wakeup); /** + * @brief Set the attribute to a connected sensor + * + * @param[in] handle a handle represensting a connected sensor. + * @param[in] attribute an attribute to change + * @param[in] value an attribute value + * @return true on success, otherwise false. + */ +bool sensord_set_attribute_int(int handle, int attribute, int value); + +/** + * @brief Set the attribute to a connected sensor + * + * @param[in] handle a handle represensting a connected sensor. + * @param[in] attribute an attribute to change + * @param[in] value an attribute value + * @param[in] value_len the length of value + * @return true on success, otherwise false. + */ +bool sensord_set_attribute_str(int handle, int attribute, const char *value, int value_len); + +/** * @brief Send data to sensorhub * * @param[in] handle a handle represensting a connected context sensor. diff --git a/src/shared/sf_common.h b/src/shared/sf_common.h index e504eee..4df48eb 100644 --- a/src/shared/sf_common.h +++ b/src/shared/sf_common.h @@ -49,9 +49,9 @@ enum packet_type_t { CMD_SET_WAKEUP, CMD_SET_BATCH, CMD_UNSET_BATCH, - CMD_SET_COMMAND, CMD_GET_DATA, - CMD_SEND_SENSORHUB_DATA, + CMD_SET_ATTRIBUTE_INT, + CMD_SET_ATTRIBUTE_STR, CMD_CNT, }; @@ -143,14 +143,15 @@ typedef struct { } cmd_set_wakeup_t; typedef struct { - unsigned int cmd; - long value; -} cmd_set_command_t; + int attribute; + int value; +} cmd_set_attribute_int_t; typedef struct { - int data_len; - char data[0]; -} cmd_send_sensorhub_data_t; + int attribute; + int value_len; + char value[0]; +} cmd_set_attribute_str_t; #define EVENT_CHANNEL_MAGIC 0xCAFECAFE -- 2.7.4 From 1be04943bec1a325085fb5ebb5838a5a2b38f789 Mon Sep 17 00:00:00 2001 From: "kibak.yoon" Date: Sat, 13 Feb 2016 14:42:13 +0900 Subject: [PATCH 14/16] sensord: clean up sf_common.h/sensor_common.h/sensor_logs.h - add command_common.h for command macro/struct/enum - clean up sensor_logs.h also Change-Id: I4241a7cf7955df79bfb54ea5fb3777da50e76adb Signed-off-by: kibak.yoon --- src/client/CMakeLists.txt | 2 +- src/client/client.cpp | 33 +++--- src/client/command_channel.cpp | 2 +- src/client/command_channel.h | 2 +- src/client/reg_event_info.h | 4 +- src/client/sensor_client_info.cpp | 1 - src/client/sensor_client_info.h | 1 - src/client/sensor_event_listener.cpp | 7 +- src/client/sensor_event_listener.h | 1 - src/client/sensor_handle_info.h | 1 + src/server/client_info_manager.cpp | 1 + src/server/client_sensor_record.h | 1 - src/server/command_worker.cpp | 5 +- src/server/command_worker.h | 1 + src/server/permission_checker.cpp | 1 - src/server/physical_sensor.h | 1 - .../plugins/auto_rotation/auto_rotation_sensor.cpp | 1 - src/server/plugins/fusion/fusion_sensor.cpp | 1 - src/server/plugins/gravity/gravity_sensor.cpp | 1 - .../plugins/linear_accel/linear_accel_sensor.cpp | 1 - .../plugins/orientation/orientation_sensor.cpp | 1 - .../rotation_vector/gaming_rv/gaming_rv_sensor.cpp | 1 - .../geomagnetic_rv/geomagnetic_rv_sensor.cpp | 1 - .../plugins/rotation_vector/rv/rv_sensor.cpp | 1 - src/server/plugins/sensor_module_create.cpp.in | 2 - src/server/plugins/tilt/tilt_sensor.cpp | 1 - src/server/sensor_event_dispatcher.cpp | 3 +- src/server/sensor_event_dispatcher.h | 1 - src/server/sensor_event_queue.h | 2 +- src/server/sensor_usage.h | 1 - src/server/server.cpp | 1 + src/server/worker_thread.cpp | 28 ++--- src/shared/{sf_common.h => command_common.h} | 48 +------- src/shared/cpacket.cpp | 2 +- src/shared/poller.cpp | 3 +- src/shared/sensor_common.h | 61 +++++++--- src/shared/sensor_info.h | 1 - src/shared/sensor_internal.h | 4 - src/shared/sensor_internal_deprecated.h | 28 ++--- src/shared/sensor_logs.cpp | 87 +------------- src/shared/sensor_logs.h | 130 +++------------------ 41 files changed, 130 insertions(+), 345 deletions(-) rename src/shared/{sf_common.h => command_common.h} (71%) diff --git a/src/client/CMakeLists.txt b/src/client/CMakeLists.txt index 80a1ddc..f002263 100644 --- a/src/client/CMakeLists.txt +++ b/src/client/CMakeLists.txt @@ -1,7 +1,7 @@ CMAKE_MINIMUM_REQUIRED(VERSION 2.6) PROJECT(sensor CXX) -SET(DEPENDENTS "vconf glib-2.0") +SET(DEPENDENTS "vconf glib-2.0 dlog") SET(VERSION ${FULLVER}) SET(PREFIX ${CMAKE_INSTALL_PREFIX}) SET(EXEC_PREFIX "${CMAKE_INSTALL_PREFIX}/bin") diff --git a/src/client/client.cpp b/src/client/client.cpp index e64482f..3dcf35a 100644 --- a/src/client/client.cpp +++ b/src/client/client.cpp @@ -17,7 +17,6 @@ * */ -#include #include #include #include @@ -63,7 +62,7 @@ void init_client(void) static void good_bye(void) { - _D("Good bye! %s\n", get_client_name()); + DBG("Good bye! %s\n", get_client_name()); clean_up(); } @@ -72,14 +71,14 @@ static int g_power_save_state_cb_cnt = 0; static void set_power_save_state_cb(void) { if (g_power_save_state_cb_cnt < 0) - _E("g_power_save_state_cb_cnt(%d) is wrong", g_power_save_state_cb_cnt); + ERR("g_power_save_state_cb_cnt(%d) is wrong", g_power_save_state_cb_cnt); ++g_power_save_state_cb_cnt; if (g_power_save_state_cb_cnt == 1) { - _D("Power save callback is registered"); + DBG("Power save callback is registered"); g_power_save_state = get_power_save_state(); - _D("power_save_state = [%d]", g_power_save_state); + DBG("power_save_state = [%d]", g_power_save_state); vconf_notify_key_changed(VCONFKEY_PM_STATE, power_save_state_cb, NULL); } } @@ -89,10 +88,10 @@ static void unset_power_save_state_cb(void) --g_power_save_state_cb_cnt; if (g_power_save_state_cb_cnt < 0) - _E("g_power_save_state_cb_cnt(%d) is wrong", g_power_save_state_cb_cnt); + ERR("g_power_save_state_cb_cnt(%d) is wrong", g_power_save_state_cb_cnt); if (g_power_save_state_cb_cnt == 0) { - _D("Power save callback is unregistered"); + DBG("Power save callback is unregistered"); vconf_ignore_key_changed(VCONFKEY_PM_STATE, power_save_state_cb); } } @@ -106,7 +105,7 @@ static void clean_up(void) auto it_handle = handles.begin(); while (it_handle != handles.end()) { - sf_disconnect(*it_handle); + sensord_disconnect(*it_handle); ++it_handle; } } @@ -136,12 +135,12 @@ static void power_save_state_cb(keynode_t *node, void *data) cur_power_save_state = get_power_save_state(); if (cur_power_save_state == g_power_save_state) { - _T("g_power_save_state NOT changed : [%d]", cur_power_save_state); + DBG("g_power_save_state NOT changed : [%d]", cur_power_save_state); return; } g_power_save_state = cur_power_save_state; - _D("power_save_state: %d noti to %s", g_power_save_state, get_client_name()); + DBG("power_save_state: %d noti to %s", g_power_save_state, get_client_name()); client_info.get_listening_sensors(sensors); @@ -162,7 +161,7 @@ static void restore_session(void) { AUTOLOCK(lock); - _I("Trying to restore session for %s", get_client_name()); + INFO("Trying to restore session for %s", get_client_name()); command_channel *cmd_channel; int client_id; @@ -183,7 +182,7 @@ static void restore_session(void) retm_if (!cmd_channel, "Failed to allocate memory"); if (!cmd_channel->create_channel()) { - _E("%s failed to create command channel for %s", get_client_name(), get_sensor_name(*it_sensor)); + ERR("%s failed to create command channel for %s", get_client_name(), get_sensor_name(*it_sensor)); delete cmd_channel; goto FAILED; } @@ -193,7 +192,7 @@ static void restore_session(void) if (first_connection) { first_connection = false; if (!cmd_channel->cmd_get_id(client_id)) { - _E("Failed to get client id"); + ERR("Failed to get client id"); goto FAILED; } @@ -204,7 +203,7 @@ static void restore_session(void) cmd_channel->set_client_id(client_id); if (!cmd_channel->cmd_hello(*it_sensor)) { - _E("Sending cmd_hello(%s, %d) failed for %s", get_sensor_name(*it_sensor), client_id, get_client_name()); + ERR("Sending cmd_hello(%s, %d) failed for %s", get_sensor_name(*it_sensor), client_id, get_client_name()); goto FAILED; } @@ -215,20 +214,20 @@ static void restore_session(void) client_info.get_sensor_rep(*it_sensor, cur_rep); if (!change_sensor_rep(*it_sensor, prev_rep, cur_rep)) { - _E("Failed to change rep(%s) for %s", get_sensor_name(*it_sensor), get_client_name()); + ERR("Failed to change rep(%s) for %s", get_sensor_name(*it_sensor), get_client_name()); goto FAILED; } ++it_sensor; } - _I("Succeeded to restore session for %s", get_client_name()); + INFO("Succeeded to restore session for %s", get_client_name()); return; FAILED: event_listener.clear(); - _E("Failed to restore session for %s", get_client_name()); + ERR("Failed to restore session for %s", get_client_name()); } static bool get_events_diff(event_type_vector &a_vec, event_type_vector &b_vec, event_type_vector &add_vec, event_type_vector &del_vec) diff --git a/src/client/command_channel.cpp b/src/client/command_channel.cpp index 888503d..06cb549 100644 --- a/src/client/command_channel.cpp +++ b/src/client/command_channel.cpp @@ -20,7 +20,7 @@ #include #include #include -#include +#include #include #include diff --git a/src/client/command_channel.h b/src/client/command_channel.h index 439ace6..f205106 100644 --- a/src/client/command_channel.h +++ b/src/client/command_channel.h @@ -20,7 +20,7 @@ #ifndef _COMMAND_CHANNEL_H_ #define _COMMAND_CHANNEL_H_ -#include +#include #include #include #include diff --git a/src/client/reg_event_info.h b/src/client/reg_event_info.h index 44d8937..18e1335 100644 --- a/src/client/reg_event_info.h +++ b/src/client/reg_event_info.h @@ -20,8 +20,8 @@ #ifndef _REG_EVENT_INFO_H_ #define _REG_EVENT_INFO_H_ -#include -#include +#include +#include typedef enum { SENSOR_EVENT_CB, diff --git a/src/client/sensor_client_info.cpp b/src/client/sensor_client_info.cpp index bdae177..1e2c12c 100644 --- a/src/client/sensor_client_info.cpp +++ b/src/client/sensor_client_info.cpp @@ -19,7 +19,6 @@ #include #include -#include #include #include diff --git a/src/client/sensor_client_info.h b/src/client/sensor_client_info.h index 9569f61..b408356 100644 --- a/src/client/sensor_client_info.h +++ b/src/client/sensor_client_info.h @@ -25,7 +25,6 @@ #include #include #include -#include #include #include #include diff --git a/src/client/sensor_event_listener.cpp b/src/client/sensor_event_listener.cpp index 028b8f2..6d62eb5 100644 --- a/src/client/sensor_event_listener.cpp +++ b/src/client/sensor_event_listener.cpp @@ -19,7 +19,6 @@ #include #include -#include #include #include @@ -472,12 +471,12 @@ void sensor_event_listener::stop_event_listener(void) if (m_thread_state != THREAD_STATE_TERMINATE) { m_thread_state = THREAD_STATE_STOP; - _D("%s is waiting listener thread[state: %d] to be terminated", get_client_name(), m_thread_state); + DBG("%s is waiting listener thread[state: %d] to be terminated", get_client_name(), m_thread_state); if (m_thread_cond.wait_for(u, std::chrono::seconds(THREAD_TERMINATING_TIMEOUT)) == std::cv_status::timeout) - _E("Fail to stop listener thread after waiting %d seconds", THREAD_TERMINATING_TIMEOUT); + ERR("Fail to stop listener thread after waiting %d seconds", THREAD_TERMINATING_TIMEOUT); else - _D("Listener thread for %s is terminated", get_client_name()); + DBG("Listener thread for %s is terminated", get_client_name()); } } diff --git a/src/client/sensor_event_listener.h b/src/client/sensor_event_listener.h index 317f527..d9fc2f8 100644 --- a/src/client/sensor_event_listener.h +++ b/src/client/sensor_event_listener.h @@ -37,7 +37,6 @@ #include #include -#include #include #include #include diff --git a/src/client/sensor_handle_info.h b/src/client/sensor_handle_info.h index 2af4d95..e70c386 100644 --- a/src/client/sensor_handle_info.h +++ b/src/client/sensor_handle_info.h @@ -25,6 +25,7 @@ #include #include #include +#include typedef std::unordered_map event_info_map; diff --git a/src/server/client_info_manager.cpp b/src/server/client_info_manager.cpp index 52308ff..037e9a1 100644 --- a/src/server/client_info_manager.cpp +++ b/src/server/client_info_manager.cpp @@ -17,6 +17,7 @@ * */ +#include #include #include #include diff --git a/src/server/client_sensor_record.h b/src/server/client_sensor_record.h index d6968e9..cad13f4 100644 --- a/src/server/client_sensor_record.h +++ b/src/server/client_sensor_record.h @@ -21,7 +21,6 @@ #define _CLIENT_SENSOR_RECORD_H_ #include -#include #include #include #include diff --git a/src/server/command_worker.cpp b/src/server/command_worker.cpp index 7407310..b6491ab 100644 --- a/src/server/command_worker.cpp +++ b/src/server/command_worker.cpp @@ -17,7 +17,7 @@ * */ -#include +#include #include #include #include @@ -25,8 +25,9 @@ #include #include #include -#include #include +#include +#include using std::string; using std::vector; diff --git a/src/server/command_worker.h b/src/server/command_worker.h index 8323571..f455cb6 100644 --- a/src/server/command_worker.h +++ b/src/server/command_worker.h @@ -20,6 +20,7 @@ #ifndef _COMMAND_WORKER_H_ #define _COMMAND_WORKER_H_ +#include #include #include #include diff --git a/src/server/permission_checker.cpp b/src/server/permission_checker.cpp index aa700b8..5a06dd9 100644 --- a/src/server/permission_checker.cpp +++ b/src/server/permission_checker.cpp @@ -21,7 +21,6 @@ #include #include #include -#include #include #include #include diff --git a/src/server/physical_sensor.h b/src/server/physical_sensor.h index c59ce89..32cfa38 100644 --- a/src/server/physical_sensor.h +++ b/src/server/physical_sensor.h @@ -21,7 +21,6 @@ #define _PHYSICAL_SENSOR_H_ #include -#include #include class physical_sensor : public sensor_base { diff --git a/src/server/plugins/auto_rotation/auto_rotation_sensor.cpp b/src/server/plugins/auto_rotation/auto_rotation_sensor.cpp index d8b1700..fbff5d5 100644 --- a/src/server/plugins/auto_rotation/auto_rotation_sensor.cpp +++ b/src/server/plugins/auto_rotation/auto_rotation_sensor.cpp @@ -27,7 +27,6 @@ #include #include -#include #include #include diff --git a/src/server/plugins/fusion/fusion_sensor.cpp b/src/server/plugins/fusion/fusion_sensor.cpp index 49d3f9e..98db53c 100644 --- a/src/server/plugins/fusion/fusion_sensor.cpp +++ b/src/server/plugins/fusion/fusion_sensor.cpp @@ -26,7 +26,6 @@ #include #include #include -#include #include #include #include diff --git a/src/server/plugins/gravity/gravity_sensor.cpp b/src/server/plugins/gravity/gravity_sensor.cpp index b39218f..390169f 100644 --- a/src/server/plugins/gravity/gravity_sensor.cpp +++ b/src/server/plugins/gravity/gravity_sensor.cpp @@ -26,7 +26,6 @@ #include #include #include -#include #include #include #include diff --git a/src/server/plugins/linear_accel/linear_accel_sensor.cpp b/src/server/plugins/linear_accel/linear_accel_sensor.cpp index 3c194f3..93f4086 100644 --- a/src/server/plugins/linear_accel/linear_accel_sensor.cpp +++ b/src/server/plugins/linear_accel/linear_accel_sensor.cpp @@ -26,7 +26,6 @@ #include #include #include -#include #include #include #include diff --git a/src/server/plugins/orientation/orientation_sensor.cpp b/src/server/plugins/orientation/orientation_sensor.cpp index 2775c4c..911b7f3 100644 --- a/src/server/plugins/orientation/orientation_sensor.cpp +++ b/src/server/plugins/orientation/orientation_sensor.cpp @@ -26,7 +26,6 @@ #include #include #include -#include #include #include #include diff --git a/src/server/plugins/rotation_vector/gaming_rv/gaming_rv_sensor.cpp b/src/server/plugins/rotation_vector/gaming_rv/gaming_rv_sensor.cpp index ac19b63..4d022c7 100644 --- a/src/server/plugins/rotation_vector/gaming_rv/gaming_rv_sensor.cpp +++ b/src/server/plugins/rotation_vector/gaming_rv/gaming_rv_sensor.cpp @@ -26,7 +26,6 @@ #include #include #include -#include #include #include #include diff --git a/src/server/plugins/rotation_vector/geomagnetic_rv/geomagnetic_rv_sensor.cpp b/src/server/plugins/rotation_vector/geomagnetic_rv/geomagnetic_rv_sensor.cpp index 43abcf2..6f1e606 100644 --- a/src/server/plugins/rotation_vector/geomagnetic_rv/geomagnetic_rv_sensor.cpp +++ b/src/server/plugins/rotation_vector/geomagnetic_rv/geomagnetic_rv_sensor.cpp @@ -26,7 +26,6 @@ #include #include #include -#include #include #include #include diff --git a/src/server/plugins/rotation_vector/rv/rv_sensor.cpp b/src/server/plugins/rotation_vector/rv/rv_sensor.cpp index 3a98182..f00ffef 100644 --- a/src/server/plugins/rotation_vector/rv/rv_sensor.cpp +++ b/src/server/plugins/rotation_vector/rv/rv_sensor.cpp @@ -26,7 +26,6 @@ #include #include #include -#include #include #include #include diff --git a/src/server/plugins/sensor_module_create.cpp.in b/src/server/plugins/sensor_module_create.cpp.in index 780461b..576fdf6 100644 --- a/src/server/plugins/sensor_module_create.cpp.in +++ b/src/server/plugins/sensor_module_create.cpp.in @@ -59,8 +59,6 @@ #include #endif -#include - extern "C" sensor_module* create(void) { sensor_module *module = new(std::nothrow) sensor_module; diff --git a/src/server/plugins/tilt/tilt_sensor.cpp b/src/server/plugins/tilt/tilt_sensor.cpp index ef1a088..cab3520 100644 --- a/src/server/plugins/tilt/tilt_sensor.cpp +++ b/src/server/plugins/tilt/tilt_sensor.cpp @@ -26,7 +26,6 @@ #include #include #include -#include #include #include #include diff --git a/src/server/sensor_event_dispatcher.cpp b/src/server/sensor_event_dispatcher.cpp index 1db1c3a..f29a668 100644 --- a/src/server/sensor_event_dispatcher.cpp +++ b/src/server/sensor_event_dispatcher.cpp @@ -17,9 +17,9 @@ * */ +#include #include #include -#include #include using std::thread; @@ -137,7 +137,6 @@ void sensor_event_dispatcher::dispatch_event(void) while (true) { void *seed_event = get_event_queue().pop(); - unsigned int event_type = *((unsigned int *)(seed_event)); vector sensor_events; sensor_events.push_back(seed_event); diff --git a/src/server/sensor_event_dispatcher.h b/src/server/sensor_event_dispatcher.h index cd38f97..befa90e 100644 --- a/src/server/sensor_event_dispatcher.h +++ b/src/server/sensor_event_dispatcher.h @@ -20,7 +20,6 @@ #ifndef _SENSOR_EVENT_DISPATCHER_H_ #define _SENSOR_EVENT_DISPATCHER_H_ -#include #include #include #include diff --git a/src/server/sensor_event_queue.h b/src/server/sensor_event_queue.h index 28bf69e..ba9decb 100644 --- a/src/server/sensor_event_queue.h +++ b/src/server/sensor_event_queue.h @@ -20,13 +20,13 @@ #ifndef _SENSOR_EVENT_QUEUE_H_ #define _SENSOR_EVENT_QUEUE_H_ -#include #include #include #include #include #include #include +#include extern std::set priority_list; diff --git a/src/server/sensor_usage.h b/src/server/sensor_usage.h index 7e6d3ac..59165e4 100644 --- a/src/server/sensor_usage.h +++ b/src/server/sensor_usage.h @@ -20,7 +20,6 @@ #ifndef _SENSOR_USAGE_H_ #define _SENSOR_USAGE_H_ -#include #include #include diff --git a/src/server/server.cpp b/src/server/server.cpp index 8f572bc..ad28539 100644 --- a/src/server/server.cpp +++ b/src/server/server.cpp @@ -20,6 +20,7 @@ #include #include #include +#include #include #include #include diff --git a/src/server/worker_thread.cpp b/src/server/worker_thread.cpp index 2726706..e6e7d4a 100644 --- a/src/server/worker_thread.cpp +++ b/src/server/worker_thread.cpp @@ -41,7 +41,7 @@ bool worker_thread::transition_function(trans_func_index index) { if (m_trans_func[index] != NULL) { if(!m_trans_func[index](m_context)) { - _T("Transition[%d] function returning false", index); + ERR("Transition[%d] function returning false", index); return false; } } @@ -61,7 +61,7 @@ bool worker_thread::start(void) lock l(m_mutex); if (m_state == WORKER_STATE_WORKING) { - _T("Worker thread is already working"); + INFO("Worker thread is already working"); return true; } @@ -79,7 +79,7 @@ bool worker_thread::start(void) return true; } - _T("Failed to start, because current state(%d) is not for START", m_state); + ERR("Failed to start, because current state(%d) is not for START", m_state); return false; } @@ -89,7 +89,7 @@ bool worker_thread::stop(void) lock l(m_mutex); if (m_state == WORKER_STATE_STOPPED) { - _T("Worker thread is already stopped"); + INFO("Worker thread is already stopped"); return true; } @@ -102,7 +102,7 @@ bool worker_thread::stop(void) return true; } - _T("Failed to stop, because current state(%d) is not for STOP", m_state); + ERR("Failed to stop, because current state(%d) is not for STOP", m_state); return false; } @@ -111,7 +111,7 @@ bool worker_thread::pause(void) lock l(m_mutex); if (m_state == WORKER_STATE_PAUSED) { - _T("Worker thread is already paused"); + INFO("Worker thread is already paused"); return true; } @@ -120,7 +120,7 @@ bool worker_thread::pause(void) return true; } - _T("Failed to pause, because current state(%d) is not for PAUSE", m_state); + ERR("Failed to pause, because current state(%d) is not for PAUSE", m_state); return false; @@ -131,7 +131,7 @@ bool worker_thread::resume(void) lock l(m_mutex); if (m_state == WORKER_STATE_WORKING) { - _T("Worker thread is already working"); + INFO("Worker thread is already working"); return true; } @@ -141,7 +141,7 @@ bool worker_thread::resume(void) return true; } - _T("Failed to resume, because current state(%d) is not for RESUME", m_state); + ERR("Failed to resume, because current state(%d) is not for RESUME", m_state); return false; } @@ -153,7 +153,7 @@ bool worker_thread::resume(void) void worker_thread::main(void) { - _T("Worker thread(0x%x) is created", std::this_thread::get_id()); + DBG("Worker thread(0x%x) is created", std::this_thread::get_id()); transition_function(STARTED); @@ -164,7 +164,7 @@ void worker_thread::main(void) if (state == WORKER_STATE_WORKING) { if (!transition_function(WORKING)) { m_state = WORKER_STATE_STOPPED; - _T("Worker thread(0x%x) exits from working state", std::this_thread::get_id()); + DBG("Worker thread(0x%x) exits from working state", std::this_thread::get_id()); m_thread_created = false; transition_function(STOPPED); break; @@ -177,12 +177,12 @@ void worker_thread::main(void) if (m_state == WORKER_STATE_PAUSED) { transition_function(PAUSED); - _T("Worker thread(0x%x) is paused", std::this_thread::get_id()); + DBG("Worker thread(0x%x) is paused", std::this_thread::get_id()); m_cond_working.wait(u); if (m_state == WORKER_STATE_WORKING) { transition_function(RESUMED); - _T("Worker thread(0x%x) is resumed", std::this_thread::get_id()); + DBG("Worker thread(0x%x) is resumed", std::this_thread::get_id()); } else if (m_state == WORKER_STATE_STOPPED) { m_thread_created = false; transition_function(STOPPED); @@ -194,7 +194,7 @@ void worker_thread::main(void) break; } } - _T("Worker thread(0x%x)'s main is terminated", std::this_thread::get_id()); + INFO("Worker thread(0x%x)'s main is terminated", std::this_thread::get_id()); } void worker_thread::set_started(trans_func_t func) diff --git a/src/shared/sf_common.h b/src/shared/command_common.h similarity index 71% rename from src/shared/sf_common.h rename to src/shared/command_common.h index 4df48eb..6fa17b4 100644 --- a/src/shared/sf_common.h +++ b/src/shared/command_common.h @@ -17,14 +17,10 @@ * */ -#ifndef _SF_COMMON_H_ -#define _SF_COMMON_H_ +#ifndef _COMMAND_COMMON_H_ +#define _COMMAND_COMMON_H_ -#include #include -#include -#include -#include #define COMMAND_CHANNEL_PATH "/tmp/sensord_command_socket" #define EVENT_CHANNEL_PATH "/tmp/sensord_event_socket" @@ -32,8 +28,6 @@ #define MAX_HANDLE 256 #define MAX_HANDLE_REACHED -2 -#define CLIENT_ID_INVALID -1 - enum packet_type_t { CMD_NONE = 0, CMD_GET_ID, @@ -55,24 +49,6 @@ enum packet_type_t { CMD_CNT, }; -enum sensor_state_t { - SENSOR_STATE_UNKNOWN = -1, - SENSOR_STATE_STOPPED = 0, - SENSOR_STATE_STARTED = 1, - SENSOR_STATE_PAUSED = 2 -}; - -enum poll_interval_t { - POLL_100HZ_MS = 10, - POLL_50HZ_MS = 20, - POLL_25HZ_MS = 40, - POLL_20HZ_MS = 50, - POLL_10HZ_MS = 100, - POLL_5HZ_MS = 200, - POLL_1HZ_MS = 1000, - POLL_MAX_HZ_MS = POLL_1HZ_MS, -}; - typedef struct { char name[NAME_MAX]; } cmd_get_id_t; @@ -160,24 +136,6 @@ typedef struct { int client_id; } event_channel_ready_t; -typedef struct sensor_event_t { - unsigned int event_type; - sensor_id_t sensor_id; - unsigned int data_length; - sensor_data_t *data; -} sensor_event_t; - typedef void *(*cmd_func_t)(void *data, void *cb_data); -typedef std::vector event_type_vector; - -enum sensor_permission_t { - SENSOR_PERMISSION_NONE = 0, - SENSOR_PERMISSION_STANDARD = (1 << 0), - SENSOR_PERMISSION_BIO = (1 << 1), -}; - -#define BIO_SENSOR_PRIVELEGE_NAME "sensord::bio" -#define BIO_SENSOR_ACCESS_RIGHT "rw" - -#endif /* _SF_COMMON_H_ */ +#endif /* _COMMAND_COMMON_H_ */ diff --git a/src/shared/cpacket.cpp b/src/shared/cpacket.cpp index 8e680b0..6cb6e8c 100644 --- a/src/shared/cpacket.cpp +++ b/src/shared/cpacket.cpp @@ -23,7 +23,7 @@ #include #include #include -#include +#include cpacket::cpacket() { diff --git a/src/shared/poller.cpp b/src/shared/poller.cpp index 2fb902b..aaa43fe 100644 --- a/src/shared/poller.cpp +++ b/src/shared/poller.cpp @@ -16,9 +16,10 @@ * limitations under the License. * */ +#include +#include #include #include -#include #define EPOLL_MAX 32 diff --git a/src/shared/sensor_common.h b/src/shared/sensor_common.h index 2edc306..abbb21c 100644 --- a/src/shared/sensor_common.h +++ b/src/shared/sensor_common.h @@ -24,8 +24,10 @@ #include #include -#ifndef DEPRECATED -#define DEPRECATED __attribute__((deprecated)) +#define CLIENT_ID_INVALID -1 + +#ifndef NAME_MAX +#define NAME_MAX 256 #endif #ifdef __cplusplus @@ -46,11 +48,6 @@ typedef int64_t sensor_id_t; typedef void *sensor_t; -typedef enum { - SENSOR_PRIVILEGE_PUBLIC, - SENSOR_PRIVILEGE_INTERNAL, -} sensor_privilege_t; - /* * To prevent naming confliction as using same enums as sensor CAPI use */ @@ -66,22 +63,26 @@ enum sensor_option_t { typedef enum sensor_option_t sensor_option_e; #endif -/* - * To prevent naming confliction as using same enums as sensor CAPI use - */ -#ifndef __SENSOR_H__ enum sensor_wakeup_t { SENSOR_WAKEUP_UNKNOWN = -1, SENSOR_WAKEUP_OFF = 0, SENSOR_WAKEUP_ON = 1, }; -typedef enum sensor_wakeup_t sensor_wakeup_e; -#endif +enum poll_interval_t { + POLL_100HZ_MS = 10, + POLL_50HZ_MS = 20, + POLL_25HZ_MS = 40, + POLL_20HZ_MS = 50, + POLL_10HZ_MS = 100, + POLL_5HZ_MS = 200, + POLL_1HZ_MS = 1000, + POLL_MAX_HZ_MS = POLL_1HZ_MS, +}; enum sensor_interval_t { - SENSOR_INTERVAL_FASTEST = 0, - SENSOR_INTERVAL_NORMAL = 200, + SENSOR_INTERVAL_FASTEST = POLL_100HZ_MS, + SENSOR_INTERVAL_NORMAL = POLL_5HZ_MS, }; typedef enum { @@ -91,9 +92,39 @@ typedef enum { CONDITION_LESS_THAN, } condition_op_t; +enum sensor_state_t { + SENSOR_STATE_UNKNOWN = -1, + SENSOR_STATE_STOPPED = 0, + SENSOR_STATE_STARTED = 1, + SENSOR_STATE_PAUSED = 2 +}; + +typedef enum { + SENSOR_PRIVILEGE_PUBLIC, + SENSOR_PRIVILEGE_INTERNAL, +} sensor_privilege_t; + +enum sensor_permission_t { + SENSOR_PERMISSION_NONE = 0, + SENSOR_PERMISSION_STANDARD = (1 << 0), + SENSOR_PERMISSION_BIO = (1 << 1) +}; + +typedef struct sensor_event_t { + unsigned int event_type; + sensor_id_t sensor_id; + unsigned int data_length; + sensor_data_t *data; +} sensor_event_t; + #ifdef __cplusplus } #endif +#ifdef __cplusplus +#include + +typedef std::vector event_type_vector; +#endif #endif /* __SENSOR_COMMON_H__ */ diff --git a/src/shared/sensor_info.h b/src/shared/sensor_info.h index 61a3cfb..536c6f9 100644 --- a/src/shared/sensor_info.h +++ b/src/shared/sensor_info.h @@ -21,7 +21,6 @@ #define _SENSOR_INFO_H_ #include -#include #include #include #include diff --git a/src/shared/sensor_internal.h b/src/shared/sensor_internal.h index 0a3d85a..d5b495f 100644 --- a/src/shared/sensor_internal.h +++ b/src/shared/sensor_internal.h @@ -20,10 +20,6 @@ #ifndef __SENSOR_INTERNAL_H__ #define __SENSOR_INTERNAL_H__ -#ifndef DEPRECATED -#define DEPRECATED __attribute__((deprecated)) -#endif - #ifndef API #define API __attribute__((visibility("default"))) #endif diff --git a/src/shared/sensor_internal_deprecated.h b/src/shared/sensor_internal_deprecated.h index 4a6948c..a2c05bd 100644 --- a/src/shared/sensor_internal_deprecated.h +++ b/src/shared/sensor_internal_deprecated.h @@ -79,13 +79,13 @@ typedef struct { float sensor_resolution; } sensor_data_properties_t; -int sf_is_sensor_event_available(sensor_type_t sensor_type , unsigned int event_type); +DEPRECATED int sf_is_sensor_event_available(sensor_type_t sensor_type , unsigned int event_type); -int sf_get_data_properties(unsigned int data_id, sensor_data_properties_t *return_data_properties); +DEPRECATED int sf_get_data_properties(unsigned int data_id, sensor_data_properties_t *return_data_properties); -int sf_get_properties(sensor_type_t sensor_type, sensor_properties_t *return_properties); +DEPRECATED int sf_get_properties(sensor_type_t sensor_type, sensor_properties_t *return_properties); -int sf_check_rotation(unsigned long *rotation); +DEPRECATED int sf_check_rotation(unsigned long *rotation); /** * @fn int sf_connect(sensor_type_t sensor) @@ -93,7 +93,7 @@ int sf_check_rotation(unsigned long *rotation); * @param[in] sensor_type your desired sensor type * @return if it succeed, it return handle value( >=0 ) , otherwise negative value return */ -int sf_connect(sensor_type_t sensor_type); +DEPRECATED int sf_connect(sensor_type_t sensor_type); /** * @fn int sf_disconnect(int handle) @@ -101,7 +101,7 @@ int sf_connect(sensor_type_t sensor_type); * @param[in] handle received handle value by sf_connect() * @return if it succeed, it return zero value , otherwise negative value return */ -int sf_disconnect(int handle); +DEPRECATED int sf_disconnect(int handle); /** * @fn int sf_start(int handle , int option) @@ -110,7 +110,7 @@ int sf_disconnect(int handle); * @param[in] option With SENSOR_OPTION_DEFAULT, it stops to sense when LCD is off, and with SENSOR_OPTION_ALWAYS_ON, it continues to sense even when LCD is off * @return if it succeed, it return zero value , otherwise negative value return */ -int sf_start(int handle , int option); +DEPRECATED int sf_start(int handle , int option); /** * @fn int sf_stop(int handle) @@ -118,7 +118,7 @@ int sf_start(int handle , int option); * @param[in] handle received handle value by sf_connect() * @return if it succeed, it return zero value , otherwise negative value return */ -int sf_stop(int handle); +DEPRECATED int sf_stop(int handle); /** * @fn int sf_register_event(int handle , unsigned int event_type , event_conditon_t *event_condition , sensor_callback_func_t cb , void *user_data ) @@ -130,7 +130,7 @@ int sf_stop(int handle); * @param[in] user_data your option data that will be send when your define callback function called. if you don't have any option data, just use a NULL value * @return if it succeed, it return zero value , otherwise negative value return */ -int sf_register_event(int handle , unsigned int event_type , event_condition_t *event_condition , sensor_callback_func_t cb , void *user_data ); +DEPRECATED int sf_register_event(int handle , unsigned int event_type , event_condition_t *event_condition , sensor_callback_func_t cb , void *user_data ); /** * @fn int sf_unregister_event(int handle, unsigned int event_type) @@ -139,7 +139,7 @@ int sf_register_event(int handle , unsigned int event_type , event_condition_t * * @param[in] event_type your desired event_type that you want to unregister event * @return if it succeed, it return zero value , otherwise negative value return */ -int sf_unregister_event(int handle, unsigned int event_type); +DEPRECATED int sf_unregister_event(int handle, unsigned int event_type); /** * @fn int sf_get_data(int handle , unsigned int data_id , sensor_data_t* values) @@ -149,7 +149,7 @@ int sf_unregister_event(int handle, unsigned int event_type); * @param[out] values return values * @return if it succeed, it return zero value , otherwise negative value return */ -int sf_get_data(int handle , unsigned int data_id , sensor_data_t* values); +DEPRECATED int sf_get_data(int handle , unsigned int data_id , sensor_data_t* values); /** * @fn int sf_change_event_condition(int handle, unsigned int event_type, event_condition_t *event_condition) @@ -159,7 +159,7 @@ int sf_get_data(int handle , unsigned int data_id , sensor_data_t* values); * @param[in] event_condition your desired event condition that you want to change event * @return if it succeed, it return zero value , otherwise negative value return */ -int sf_change_event_condition(int handle, unsigned int event_type, event_condition_t *event_condition); +DEPRECATED int sf_change_event_condition(int handle, unsigned int event_type, event_condition_t *event_condition); /** * @fn int sf_change_sensor_option(int handle, int option) @@ -169,7 +169,7 @@ int sf_change_event_condition(int handle, unsigned int event_type, event_conditi * @return if it succeed, it return zero value , otherwise negative value return */ -int sf_change_sensor_option(int handle, int option); +DEPRECATED int sf_change_sensor_option(int handle, int option); /** * @fn int sf_send_sensorhub_data(int handle, const char* buffer, int data_len) @@ -179,7 +179,7 @@ int sf_change_sensor_option(int handle, int option); * @param[in] data_len the length of data * @return if it succeed, it returns zero, otherwise negative value */ -int sf_send_sensorhub_data(int handle, const char* data, int data_len); +DEPRECATED int sf_send_sensorhub_data(int handle, const char* data, int data_len); #ifdef __cplusplus diff --git a/src/shared/sensor_logs.cpp b/src/shared/sensor_logs.cpp index 5426c0f..e98e41b 100644 --- a/src/shared/sensor_logs.cpp +++ b/src/shared/sensor_logs.cpp @@ -17,7 +17,6 @@ * */ -#include #include #include #include @@ -25,92 +24,10 @@ #include #include #include -#include -#include +#include #include "sensor_logs.h" -#ifndef EXTAPI -#define EXTAPI __attribute__((visibility("default"))) -#endif - -#define SF_SERVER_MSG_LOG_FILE "/var/log/messages" -#define FILE_LENGTH 255 - -static int sf_debug_file_fd; -static char sf_debug_file_buf[FILE_LENGTH]; - -EXTAPI void sf_log(int type , int priority , const char *tag , const char *fmt , ...) -{ - va_list ap; - va_start(ap, fmt); - - switch (type) { - case SF_LOG_PRINT_FILE: - sf_debug_file_fd = open(SF_SERVER_MSG_LOG_FILE, O_WRONLY|O_CREAT|O_APPEND, 0644); - if (sf_debug_file_fd != -1) { - vsnprintf(sf_debug_file_buf,255, fmt , ap ); - int total_bytes_written = 0; - while (total_bytes_written < (int) strlen(sf_debug_file_buf)){ - int bytes_written = write(sf_debug_file_fd, (sf_debug_file_buf + total_bytes_written), strlen(sf_debug_file_buf) - total_bytes_written); - if (bytes_written == -1) - break; - total_bytes_written = total_bytes_written + bytes_written; - } - close(sf_debug_file_fd); - } - break; - - case SF_LOG_SYSLOG: - int syslog_prio; - switch (priority) { - case SF_LOG_ERR: - syslog_prio = LOG_ERR|LOG_DAEMON; - break; - case SF_LOG_WARN: - syslog_prio = LOG_WARNING|LOG_DAEMON; - break; - - case SF_LOG_DBG: - syslog_prio = LOG_DEBUG|LOG_DAEMON; - break; - - case SF_LOG_INFO: - syslog_prio = LOG_INFO|LOG_DAEMON; - break; - - default: - syslog_prio = priority; - break; - } - - vsyslog(syslog_prio, fmt, ap); - break; - - case SF_LOG_DLOG: - if (tag) { - switch (priority) { - case SF_LOG_ERR: - SLOG_VA(LOG_ERROR, tag ? tag : "NULL" , fmt ? fmt : "NULL" , ap); - break; - - case SF_LOG_WARN: - SLOG_VA(LOG_WARN, tag ? tag : "NULL" , fmt ? fmt : "NULL" , ap); - break; - - case SF_LOG_DBG: - SLOG_VA(LOG_DEBUG, tag ? tag : "NULL", fmt ? fmt : "NULL" , ap); - break; - - case SF_LOG_INFO: - SLOG_VA(LOG_INFO, tag ? tag : "NULL" , fmt ? fmt : "NULL" , ap); - break; - } - } - break; - } - - va_end(ap); -} +#define PATH_MAX 256 #if defined(_DEBUG) bool get_proc_name(pid_t pid, char *process_name) diff --git a/src/shared/sensor_logs.h b/src/shared/sensor_logs.h index 70b10fa..aa01eb7 100644 --- a/src/shared/sensor_logs.h +++ b/src/shared/sensor_logs.h @@ -20,137 +20,32 @@ #ifndef _SENSOR_LOGS_H_ #define _SENSOR_LOGS_H_ -#ifndef __cplusplus -#include -#endif /* !__cplusplus */ - -#ifdef __cplusplus -extern "C" -{ -#endif - +#include #include -#include - -#if !defined(PATH_MAX) -#define PATH_MAX 256 -#endif - -#if !defined(NAME_MAX) -#define NAME_MAX 256 -#endif - #define EVENT_TYPE_SHIFT 16 #define SENSOR_TYPE_SHIFT 32 -#define USE_DLOG_LOG - -enum sf_log_type { - SF_LOG_PRINT_FILE = 1, - SF_LOG_SYSLOG = 2, - SF_LOG_DLOG = 3, -}; - -enum sf_priority_type { - SF_LOG_ERR = 1, - SF_LOG_DBG = 2, - SF_LOG_INFO = 3, - SF_LOG_WARN = 4, -}; - -void sf_log(int type , int priority , const char *tag , const char *fmt , ...); - #define MICROSECONDS(tv) ((tv.tv_sec * 1000000ll) + tv.tv_usec) -#ifndef __MODULE__ -#include -#define __MODULE__ (strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILE__) -#endif - -//for new log system - dlog #ifdef LOG_TAG #undef LOG_TAG #endif #define LOG_TAG "SENSOR" -#if defined(_DEBUG) || defined(USE_FILE_DEBUG) - -#define DbgPrint(fmt, arg...) do { sf_log(SF_LOG_PRINT_FILE, 0, LOG_TAG , " [SF_MSG_PRT][%s:%d] " fmt"\n",__MODULE__, __LINE__, ##arg); } while(0) - -#endif - -#if defined(USE_SYSLOG_DEBUG) - -#define ERR(fmt, arg...) do { sf_log(SF_LOG_SYSLOG, SF_LOG_ERR, LOG_TAG, "%s:%s(%d)> " fmt, __MODULE__, __func__, __LINE__, ##arg); } while(0) -#define WARN(fmt, arg...) do { sf_log(SF_LOG_SYSLOG, SF_LOG_WARN, LOG_TAG, "%s:%s(%d)> " fmt, __MODULE__, __func__, __LINE__, ##arg); } while(0) -#define INFO(fmt, arg...) do { sf_log(SF_LOG_SYSLOG, SF_LOG_INFO, LOG_TAG, "%s:%s(%d)> " fmt, __MODULE__, __func__, __LINE__, ##arg); } while(0) -#define DBG(fmt, arg...) do { sf_log(SF_LOG_SYSLOG, SF_LOG_DBG, LOG_TAG, "%s:%s(%d)> " fmt, __MODULE__, __func__, __LINE__, ##arg); } while(0) - -#define _E(fmt, arg...) do { sf_log(SF_LOG_SYSLOG, SF_LOG_ERR, LOG_TAG, "%s:%s(%d)> " fmt, __MODULE__, __func__, __LINE__, ##arg); } while(0) -#define _W(fmt, arg...) do { sf_log(SF_LOG_SYSLOG, SF_LOG_WARN, LOG_TAG, "%s:%s(%d)> " fmt, __MODULE__, __func__, __LINE__, ##arg); } while(0) -#define _I(fmt, arg...) do { sf_log(SF_LOG_SYSLOG, SF_LOG_INFO, LOG_TAG, "%s:%s(%d)> " fmt, __MODULE__, __func__, __LINE__, ##arg); } while(0) -#define _D(fmt, arg...) do { sf_log(SF_LOG_SYSLOG, SF_LOG_DBG, LOG_TAG, "%s:%s(%d)> " fmt, __MODULE__, __func__, __LINE__, ##arg); } while(0) -#define _T(fmt, arg...) do { sf_log(SF_LOG_SYSLOG, SF_LOG_DBG, LOG_TAG, "%s:%s(%d)> " fmt, __MODULE__, __func__, __LINE__, ##arg); } while(0) - - -#elif defined(_DEBUG) || defined(USE_DLOG_DEBUG) - -#define ERR(fmt, arg...) do { sf_log(SF_LOG_DLOG, SF_LOG_ERR, LOG_TAG, "%s:%s(%d)> " fmt, __MODULE__, __func__, __LINE__, ##arg); } while(0) -#define WARN(fmt, arg...) do { sf_log(SF_LOG_DLOG, SF_LOG_WARN, LOG_TAG, "%s:%s(%d)> " fmt, __MODULE__, __func__, __LINE__, ##arg); } while(0) -#define INFO(fmt, arg...) do { sf_log(SF_LOG_DLOG, SF_LOG_INFO, LOG_TAG, "%s:%s(%d)> " fmt, __MODULE__, __func__, __LINE__, ##arg); } while(0) -#define DBG(fmt, arg...) do { sf_log(SF_LOG_DLOG, SF_LOG_DBG, LOG_TAG, "%s:%s(%d)> " fmt, __MODULE__, __func__, __LINE__, ##arg); } while(0) - -#define _E(fmt, arg...) do { sf_log(SF_LOG_SYSLOG, SF_LOG_ERR, LOG_TAG, "%s:%s(%d)> " fmt, __MODULE__, __func__, __LINE__, ##arg); } while(0) -#define _W(fmt, arg...) do { sf_log(SF_LOG_SYSLOG, SF_LOG_WARN, LOG_TAG, "%s:%s(%d)> " fmt, __MODULE__, __func__, __LINE__, ##arg); } while(0) -#define _I(fmt, arg...) do { sf_log(SF_LOG_SYSLOG, SF_LOG_INFO, LOG_TAG, "%s:%s(%d)> " fmt, __MODULE__, __func__, __LINE__, ##arg); } while(0) -#define _D(fmt, arg...) do { sf_log(SF_LOG_SYSLOG, SF_LOG_DBG, LOG_TAG, "%s:%s(%d)> " fmt, __MODULE__, __func__, __LINE__, ##arg); } while(0) -#define _T(fmt, arg...) do { sf_log(SF_LOG_SYSLOG, SF_LOG_DBG, LOG_TAG, "%s:%s(%d)> " fmt, __MODULE__, __func__, __LINE__, ##arg); } while(0) - -#elif defined(USE_FILE_DEBUG) - -#define ERR(fmt, arg...) do { sf_log(SF_LOG_PRINT_FILE, 0, LOG_TAG, "[SF_MSG_ERR][%s:%d] " fmt"\n",__MODULE__, __LINE__, ##arg); } while(0) -#define WARN(fmt, arg...) do { sf_log(SF_LOG_PRINT_FILE, 0, LOG_TAG, "[SF_MSG_WARN][%s:%d] " fmt"\n",__MODULE__, __LINE__, ##arg); } while(0) -#define DBG(fmt, arg...) do { sf_log(SF_LOG_PRINT_FILE, 0, LOG_TAG, "[SF_MSG_DBG][%s:%d] " fmt"\n",__MODULE__, __LINE__, ##arg); } while(0) -#define INFO(fmt, arg...) do { sf_log(SF_LOG_PRINT_FILE, 0, LOG_TAG, "[SF_MSG_INFO][%s:%d] " fmt"\n",__MODULE__, __LINE__, ##arg); } while(0) - -#define _E(fmt, arg...) do { sf_log(SF_LOG_PRINT_FILE, 0, LOG_TAG ,"[SF_MSG_ERR][%s:%d] " fmt"\n",__MODULE__, __LINE__, ##arg); } while(0) -#define _W(fmt, arg...) do { sf_log(SF_LOG_PRINT_FILE, 0, LOG_TAG ,"[SF_MSG_WARN][%s:%d] " fmt"\n",__MODULE__, __LINE__, ##arg); } while(0) -#define _I(fmt, arg...) do { sf_log(SF_LOG_PRINT_FILE, 0, LOG_TAG ,"[SF_MSG_INFO][%s:%d] " fmt"\n",__MODULE__, __LINE__, ##arg); } while(0) -#define _D(fmt, arg...) do { sf_log(SF_LOG_PRINT_FILE, 0, LOG_TAG ,"[SF_MSG_DBG][%s:%d] " fmt"\n",__MODULE__, __LINE__, ##arg); } while(0) -#define _T(fmt, arg...) do { sf_log(SF_LOG_PRINT_FILE, 0, LOG_TAG ,"[SF_MSG_TEMP][%s:%d] " fmt"\n",__MODULE__, __LINE__, ##arg); } while(0) - -#elif defined(USE_DLOG_LOG) - -#define ERR(fmt, arg...) do { sf_log(SF_LOG_DLOG, SF_LOG_ERR, LOG_TAG, "%s:%s(%d)> " fmt, __MODULE__, __func__, __LINE__, ##arg); } while(0) -#define WARN(fmt, arg...) do { sf_log(SF_LOG_DLOG, SF_LOG_WARN, LOG_TAG, "%s:%s(%d)> " fmt, __MODULE__, __func__, __LINE__, ##arg); } while(0) -#define INFO(fmt, arg...) do { sf_log(SF_LOG_DLOG, SF_LOG_INFO, LOG_TAG, "%s:%s(%d)> " fmt, __MODULE__, __func__, __LINE__, ##arg); } while(0) - -#define DBG(...) do{} while(0) -#define DbgPrint(...) do{} while(0) - - -#define _E(fmt, arg...) do { sf_log(SF_LOG_DLOG, SF_LOG_ERR, LOG_TAG, "%s:%s(%d)> " fmt, __MODULE__, __func__, __LINE__, ##arg); } while(0) -#define _W(fmt, arg...) do { sf_log(SF_LOG_DLOG, SF_LOG_WARN, LOG_TAG, "%s:%s(%d)> " fmt, __MODULE__, __func__, __LINE__, ##arg); } while(0) -#define _I(fmt, arg...) do { sf_log(SF_LOG_DLOG, SF_LOG_INFO, LOG_TAG, "%s:%s(%d)> " fmt, __MODULE__, __func__, __LINE__, ##arg); } while(0) -#define _D(fmt, arg...) do { sf_log(SF_LOG_DLOG, SF_LOG_DBG, LOG_TAG, "%s:%s(%d)> " fmt, __MODULE__, __func__, __LINE__, ##arg); } while(0) -#define _T(...) - +#ifdef _DEBUG +#define DBG SLOGD #else -#define ERR(fmt, arg...) do { sf_log(SF_LOG_DLOG, SF_LOG_ERR, LOG_TAG, "%s:%s(%d)> " fmt, __MODULE__, __func__, __LINE__, ##arg); } while(0) -#define WARN(...) do{} while(0) -#define DbgPrint(...) do{} while(0) #define DBG(...) do{} while(0) -#define INFO(...) do{} while(0) - -#define _E(fmt, arg...) do { sf_log(SF_LOG_DLOG, SF_LOG_ERR, LOG_TAG, "%s:%s(%d)> " fmt, __MODULE__, __func__, __LINE__, ##arg); } while(0) -#define _W(...) do{} while(0) -#define _I(...) do{} while(0) -#define _D(...) do{} while(0) -#define _T(...) do{} while(0) - #endif +#define ERR SLOGE +#define WARN SLOGW +#define INFO SLOGI +#define _E ERR +#define _W WARN +#define _I INFO +#define _D DBG #if defined(_DEBUG) # define warn_if(expr, fmt, arg...) do { \ @@ -216,6 +111,11 @@ void sf_log(int type , int priority , const char *tag , const char *fmt , ...); #endif +#ifdef __cplusplus +extern "C" +{ +#endif + const char* get_client_name(void); bool get_proc_name(pid_t pid, char *process_name); -- 2.7.4 From d4b91cf9b0b73c0579485841b179396fe3693bc8 Mon Sep 17 00:00:00 2001 From: "kibak.yoon" Date: Sat, 13 Feb 2016 14:48:24 +0900 Subject: [PATCH 15/16] sensord: change macros for log - use _E/_I/_D/_W Change-Id: Ibd73416a4e00a8c739d4793f5ecded6c2f4e7fc3 Signed-off-by: kibak.yoon --- src/client/client.cpp | 144 ++++++++++----------- src/client/client_common.cpp | 6 +- src/client/command_channel.cpp | 100 +++++++------- src/client/sensor_client_info.cpp | 48 +++---- src/client/sensor_event_listener.cpp | 40 +++--- src/client/sensor_handle_info.cpp | 12 +- src/server/client_info_manager.cpp | 44 +++---- src/server/client_sensor_record.cpp | 16 +-- src/server/command_worker.cpp | 138 ++++++++++---------- src/server/main.cpp | 6 +- src/server/permission_checker.cpp | 6 +- src/server/physical_sensor.cpp | 6 +- .../plugins/auto_rotation/auto_rotation_sensor.cpp | 22 ++-- src/server/plugins/fusion/fusion_sensor.cpp | 50 +++---- src/server/plugins/gravity/gravity_sensor.cpp | 38 +++--- .../plugins/linear_accel/linear_accel_sensor.cpp | 48 +++---- .../plugins/orientation/orientation_sensor.cpp | 30 ++--- .../rotation_vector/gaming_rv/gaming_rv_sensor.cpp | 32 ++--- .../geomagnetic_rv/geomagnetic_rv_sensor.cpp | 14 +- .../plugins/rotation_vector/rv/rv_sensor.cpp | 14 +- src/server/plugins/tilt/tilt_sensor.cpp | 26 ++-- src/server/sensor_base.cpp | 26 ++-- src/server/sensor_event_dispatcher.cpp | 42 +++--- src/server/sensor_event_poller.cpp | 2 +- src/server/sensor_event_queue.cpp | 2 +- src/server/sensor_loader.cpp | 26 ++-- src/server/sensor_usage.cpp | 6 +- src/server/server.cpp | 22 ++-- src/server/virtual_sensor_config.cpp | 38 +++--- src/server/worker_thread.cpp | 28 ++-- src/shared/cbase_lock.cpp | 4 +- src/shared/csocket.cpp | 58 ++++----- src/shared/poller.cpp | 10 +- src/shared/sensor_info.cpp | 28 ++-- src/shared/sensor_logs.h | 22 ++-- 35 files changed, 577 insertions(+), 577 deletions(-) diff --git a/src/client/client.cpp b/src/client/client.cpp index 3dcf35a..abd7d9f 100644 --- a/src/client/client.cpp +++ b/src/client/client.cpp @@ -62,7 +62,7 @@ void init_client(void) static void good_bye(void) { - DBG("Good bye! %s\n", get_client_name()); + _D("Good bye! %s\n", get_client_name()); clean_up(); } @@ -71,14 +71,14 @@ static int g_power_save_state_cb_cnt = 0; static void set_power_save_state_cb(void) { if (g_power_save_state_cb_cnt < 0) - ERR("g_power_save_state_cb_cnt(%d) is wrong", g_power_save_state_cb_cnt); + _E("g_power_save_state_cb_cnt(%d) is wrong", g_power_save_state_cb_cnt); ++g_power_save_state_cb_cnt; if (g_power_save_state_cb_cnt == 1) { - DBG("Power save callback is registered"); + _D("Power save callback is registered"); g_power_save_state = get_power_save_state(); - DBG("power_save_state = [%d]", g_power_save_state); + _D("power_save_state = [%d]", g_power_save_state); vconf_notify_key_changed(VCONFKEY_PM_STATE, power_save_state_cb, NULL); } } @@ -88,10 +88,10 @@ static void unset_power_save_state_cb(void) --g_power_save_state_cb_cnt; if (g_power_save_state_cb_cnt < 0) - ERR("g_power_save_state_cb_cnt(%d) is wrong", g_power_save_state_cb_cnt); + _E("g_power_save_state_cb_cnt(%d) is wrong", g_power_save_state_cb_cnt); if (g_power_save_state_cb_cnt == 0) { - DBG("Power save callback is unregistered"); + _D("Power save callback is unregistered"); vconf_ignore_key_changed(VCONFKEY_PM_STATE, power_save_state_cb); } } @@ -135,12 +135,12 @@ static void power_save_state_cb(keynode_t *node, void *data) cur_power_save_state = get_power_save_state(); if (cur_power_save_state == g_power_save_state) { - DBG("g_power_save_state NOT changed : [%d]", cur_power_save_state); + _D("g_power_save_state NOT changed : [%d]", cur_power_save_state); return; } g_power_save_state = cur_power_save_state; - DBG("power_save_state: %d noti to %s", g_power_save_state, get_client_name()); + _D("power_save_state: %d noti to %s", g_power_save_state, get_client_name()); client_info.get_listening_sensors(sensors); @@ -161,7 +161,7 @@ static void restore_session(void) { AUTOLOCK(lock); - INFO("Trying to restore session for %s", get_client_name()); + _I("Trying to restore session for %s", get_client_name()); command_channel *cmd_channel; int client_id; @@ -182,7 +182,7 @@ static void restore_session(void) retm_if (!cmd_channel, "Failed to allocate memory"); if (!cmd_channel->create_channel()) { - ERR("%s failed to create command channel for %s", get_client_name(), get_sensor_name(*it_sensor)); + _E("%s failed to create command channel for %s", get_client_name(), get_sensor_name(*it_sensor)); delete cmd_channel; goto FAILED; } @@ -192,7 +192,7 @@ static void restore_session(void) if (first_connection) { first_connection = false; if (!cmd_channel->cmd_get_id(client_id)) { - ERR("Failed to get client id"); + _E("Failed to get client id"); goto FAILED; } @@ -203,7 +203,7 @@ static void restore_session(void) cmd_channel->set_client_id(client_id); if (!cmd_channel->cmd_hello(*it_sensor)) { - ERR("Sending cmd_hello(%s, %d) failed for %s", get_sensor_name(*it_sensor), client_id, get_client_name()); + _E("Sending cmd_hello(%s, %d) failed for %s", get_sensor_name(*it_sensor), client_id, get_client_name()); goto FAILED; } @@ -214,20 +214,20 @@ static void restore_session(void) client_info.get_sensor_rep(*it_sensor, cur_rep); if (!change_sensor_rep(*it_sensor, prev_rep, cur_rep)) { - ERR("Failed to change rep(%s) for %s", get_sensor_name(*it_sensor), get_client_name()); + _E("Failed to change rep(%s) for %s", get_sensor_name(*it_sensor), get_client_name()); goto FAILED; } ++it_sensor; } - INFO("Succeeded to restore session for %s", get_client_name()); + _I("Succeeded to restore session for %s", get_client_name()); return; FAILED: event_listener.clear(); - ERR("Failed to restore session for %s", get_client_name()); + _E("Failed to restore session for %s", get_client_name()); } static bool get_events_diff(event_type_vector &a_vec, event_type_vector &b_vec, event_type_vector &add_vec, event_type_vector &del_vec) @@ -249,7 +249,7 @@ static bool change_sensor_rep(sensor_id_t sensor_id, sensor_rep &prev_rep, senso event_type_vector add_event_types, del_event_types; if (!client_info.get_command_channel(sensor_id, &cmd_channel)) { - ERR("client %s failed to get command channel for %s", get_client_name(), get_sensor_name(sensor_id)); + _E("client %s failed to get command channel for %s", get_client_name(), get_sensor_name(sensor_id)); return false; } @@ -261,21 +261,21 @@ static bool change_sensor_rep(sensor_id_t sensor_id, sensor_rep &prev_rep, senso if (cur_rep.active) { if (prev_rep.option != cur_rep.option) { if (!cmd_channel->cmd_set_option(cur_rep.option)) { - ERR("Sending cmd_set_option(%d, %s, %d) failed for %s", client_id, get_sensor_name(sensor_id), cur_rep.option, get_client_name()); + _E("Sending cmd_set_option(%d, %s, %d) failed for %s", client_id, get_sensor_name(sensor_id), cur_rep.option, get_client_name()); return false; } } if ( (prev_rep.interval != cur_rep.interval) || (prev_rep.latency != cur_rep.latency)) { if (!cmd_channel->cmd_set_batch(cur_rep.interval, cur_rep.latency)) { - ERR("Sending cmd_set_batch(%d, %s, %d, %d) failed for %s", client_id, get_sensor_name(sensor_id), cur_rep.interval, cur_rep.latency, get_client_name()); + _E("Sending cmd_set_batch(%d, %s, %d, %d) failed for %s", client_id, get_sensor_name(sensor_id), cur_rep.interval, cur_rep.latency, get_client_name()); return false; } } if (!add_event_types.empty()) { if (!cmd_channel->cmd_register_events(add_event_types)) { - ERR("Sending cmd_register_events(%d, add_event_types) failed for %s", client_id, get_client_name()); + _E("Sending cmd_register_events(%d, add_event_types) failed for %s", client_id, get_client_name()); return false; } } @@ -284,7 +284,7 @@ static bool change_sensor_rep(sensor_id_t sensor_id, sensor_rep &prev_rep, senso if (prev_rep.active && !del_event_types.empty()) { if (!cmd_channel->cmd_unregister_events(del_event_types)) { - ERR("Sending cmd_unregister_events(%d, del_event_types) failed for %s", client_id, get_client_name()); + _E("Sending cmd_unregister_events(%d, del_event_types) failed for %s", client_id, get_client_name()); return false; } } @@ -292,17 +292,17 @@ static bool change_sensor_rep(sensor_id_t sensor_id, sensor_rep &prev_rep, senso if (prev_rep.active != cur_rep.active) { if (cur_rep.active) { if (!cmd_channel->cmd_start()) { - ERR("Sending cmd_start(%d, %s) failed for %s", client_id, get_sensor_name(sensor_id), get_client_name()); + _E("Sending cmd_start(%d, %s) failed for %s", client_id, get_sensor_name(sensor_id), get_client_name()); return false; } } else { if (!cmd_channel->cmd_unset_batch()) { - ERR("Sending cmd_unset_interval(%d, %s) failed for %s", client_id, get_sensor_name(sensor_id), get_client_name()); + _E("Sending cmd_unset_interval(%d, %s) failed for %s", client_id, get_sensor_name(sensor_id), get_client_name()); return false; } if (!cmd_channel->cmd_stop()) { - ERR("Sending cmd_stop(%d, %s) failed for %s", client_id, get_sensor_name(sensor_id), get_client_name()); + _E("Sending cmd_stop(%d, %s) failed for %s", client_id, get_sensor_name(sensor_id), get_client_name()); return false; } } @@ -322,7 +322,7 @@ static bool get_sensor_list(void) command_channel cmd_channel; if (!cmd_channel.create_channel()) { - ERR("%s failed to create command channel", get_client_name()); + _E("%s failed to create command channel", get_client_name()); return false; } @@ -542,7 +542,7 @@ API int sensord_connect(sensor_t sensor) handle = client_info.create_handle(sensor_id); if (handle == MAX_HANDLE_REACHED) { - ERR("Maximum number of handles reached, sensor: %s in client %s", get_sensor_name(sensor_id), get_client_name()); + _E("Maximum number of handles reached, sensor: %s in client %s", get_sensor_name(sensor_id), get_client_name()); return OP_ERROR; } @@ -551,7 +551,7 @@ API int sensord_connect(sensor_t sensor) retvm_if (!cmd_channel, OP_ERROR, "Failed to allocate memory"); if (!cmd_channel->create_channel()) { - ERR("%s failed to create command channel for %s", get_client_name(), get_sensor_name(sensor_id)); + _E("%s failed to create command channel for %s", get_client_name(), get_sensor_name(sensor_id)); client_info.delete_handle(handle); delete cmd_channel; return OP_ERROR; @@ -561,7 +561,7 @@ API int sensord_connect(sensor_t sensor) } if (!client_info.get_command_channel(sensor_id, &cmd_channel)) { - ERR("%s failed to get command channel for %s", get_client_name(), get_sensor_name(sensor_id)); + _E("%s failed to get command channel for %s", get_client_name(), get_sensor_name(sensor_id)); client_info.delete_handle(handle); return OP_ERROR; } @@ -569,28 +569,28 @@ API int sensord_connect(sensor_t sensor) if (!client_info.has_client_id()) { first_connection = true; if(!cmd_channel->cmd_get_id(client_id)) { - ERR("Sending cmd_get_id() failed for %s", get_sensor_name(sensor_id)); + _E("Sending cmd_get_id() failed for %s", get_sensor_name(sensor_id)); client_info.close_command_channel(sensor_id); client_info.delete_handle(handle); return OP_ERROR; } client_info.set_client_id(client_id); - INFO("%s gets client_id [%d]", get_client_name(), client_id); + _I("%s gets client_id [%d]", get_client_name(), client_id); event_listener.start_event_listener(); - INFO("%s starts listening events with client_id [%d]", get_client_name(), client_id); + _I("%s starts listening events with client_id [%d]", get_client_name(), client_id); } client_id = client_info.get_client_id(); cmd_channel->set_client_id(client_id); - INFO("%s[%d] connects with %s[%d]", get_client_name(), client_id, get_sensor_name(sensor_id), handle); + _I("%s[%d] connects with %s[%d]", get_client_name(), client_id, get_sensor_name(sensor_id), handle); client_info.set_sensor_params(handle, SENSOR_STATE_STOPPED, SENSOR_OPTION_DEFAULT); if (!sensor_registered) { if(!cmd_channel->cmd_hello(sensor_id)) { - ERR("Sending cmd_hello(%s, %d) failed for %s", get_sensor_name(sensor_id), client_id, get_client_name()); + _E("Sending cmd_hello(%s, %d) failed for %s", get_sensor_name(sensor_id), client_id, get_client_name()); client_info.close_command_channel(sensor_id); client_info.delete_handle(handle); if (first_connection) { @@ -616,22 +616,22 @@ API bool sensord_disconnect(int handle) if (!client_info.get_sensor_state(handle, sensor_state)|| !client_info.get_sensor_id(handle, sensor_id)) { - ERR("client %s failed to get handle information", get_client_name()); + _E("client %s failed to get handle information", get_client_name()); return false; } if (!client_info.get_command_channel(sensor_id, &cmd_channel)) { - ERR("client %s failed to get command channel for %s", get_client_name(), get_sensor_name(sensor_id)); + _E("client %s failed to get command channel for %s", get_client_name(), get_sensor_name(sensor_id)); return false; } client_id = client_info.get_client_id(); retvm_if ((client_id < 0), false, "Invalid client id : %d, handle: %d, %s, %s", client_id, handle, get_sensor_name(sensor_id), get_client_name()); - INFO("%s disconnects with %s[%d]", get_client_name(), get_sensor_name(sensor_id), handle); + _I("%s disconnects with %s[%d]", get_client_name(), get_sensor_name(sensor_id), handle); if (sensor_state != SENSOR_STATE_STOPPED) { - WARN("%s[%d] for %s is not stopped before disconnecting.", + _W("%s[%d] for %s is not stopped before disconnecting.", get_sensor_name(sensor_id), handle, get_client_name()); sensord_stop(handle); } @@ -644,14 +644,14 @@ API bool sensord_disconnect(int handle) if (!client_info.is_sensor_registered(sensor_id)) { if(!cmd_channel->cmd_byebye()) { - ERR("Sending cmd_byebye(%d, %s) failed for %s", client_id, get_sensor_name(sensor_id), get_client_name()); + _E("Sending cmd_byebye(%d, %s) failed for %s", client_id, get_sensor_name(sensor_id), get_client_name()); return false; } client_info.close_command_channel(sensor_id); } if (!client_info.is_active()) { - INFO("Stop listening events for client %s with client id [%d]", get_client_name(), client_info.get_client_id()); + _I("Stop listening events for client %s with client id [%d]", get_client_name(), client_info.get_client_id()); event_listener.stop_event_listener(); } @@ -672,14 +672,14 @@ static bool register_event(int handle, unsigned int event_type, unsigned int int AUTOLOCK(lock); if (!client_info.get_sensor_id(handle, sensor_id)) { - ERR("client %s failed to get handle information", get_client_name()); + _E("client %s failed to get handle information", get_client_name()); return false; } if (interval == 0) interval = DEFAULT_INTERVAL; - INFO("%s registers event %s[0x%x] for sensor %s[%d] with interval: %d, latency: %d, cb: 0x%x, user_data: 0x%x", + _I("%s registers event %s[0x%x] for sensor %s[%d] with interval: %d, latency: %d, cb: 0x%x, user_data: 0x%x", get_client_name(), get_event_name(event_type), event_type, get_sensor_name(sensor_id), handle, interval, max_batch_latency, cb, user_data); @@ -718,18 +718,18 @@ API bool sensord_unregister_event(int handle, unsigned int event_type) AUTOLOCK(lock); if (!client_info.get_sensor_id(handle, sensor_id)) { - ERR("client %s failed to get handle information", get_client_name()); + _E("client %s failed to get handle information", get_client_name()); return false; } - INFO("%s unregisters event %s[0x%x] for sensor %s[%d]", get_client_name(), get_event_name(event_type), + _I("%s unregisters event %s[0x%x] for sensor %s[%d]", get_client_name(), get_event_name(event_type), event_type, get_sensor_name(sensor_id), handle); client_info.get_sensor_rep(sensor_id, prev_rep); client_info.get_event_info(handle, event_type, prev_interval, prev_latency, prev_cb_type, prev_cb, prev_user_data); if (!client_info.unregister_event(handle, event_type)) { - ERR("%s try to unregister non registered event %s[0x%x] for sensor %s[%d]", + _E("%s try to unregister non registered event %s[0x%x] for sensor %s[%d]", get_client_name(),get_event_name(event_type), event_type, get_sensor_name(sensor_id), handle); return false; } @@ -754,12 +754,12 @@ API bool sensord_register_accuracy_cb(int handle, sensor_accuracy_changed_cb_t c AUTOLOCK(lock); if (!client_info.get_sensor_id(handle, sensor_id)) { - ERR("client %s failed to get handle information", get_client_name()); + _E("client %s failed to get handle information", get_client_name()); return false; } - INFO("%s registers accuracy_changed_cb for sensor %s[%d] with cb: 0x%x, user_data: 0x%x", + _I("%s registers accuracy_changed_cb for sensor %s[%d] with cb: 0x%x, user_data: 0x%x", get_client_name(), get_sensor_name(sensor_id), handle, cb, user_data); client_info.register_accuracy_cb(handle, cb , user_data); @@ -775,12 +775,12 @@ API bool sensord_unregister_accuracy_cb(int handle) AUTOLOCK(lock); if (!client_info.get_sensor_id(handle, sensor_id)) { - ERR("client %s failed to get handle information", get_client_name()); + _E("client %s failed to get handle information", get_client_name()); return false; } - INFO("%s unregisters accuracy_changed_cb for sensor %s[%d]", + _I("%s unregisters accuracy_changed_cb for sensor %s[%d]", get_client_name(), get_sensor_name(sensor_id), handle); client_info.unregister_accuracy_cb(handle); @@ -799,14 +799,14 @@ API bool sensord_start(int handle, int option) AUTOLOCK(lock); if (!client_info.get_sensor_id(handle, sensor_id)) { - ERR("client %s failed to get handle information", get_client_name()); + _E("client %s failed to get handle information", get_client_name()); return false; } retvm_if ((option < 0) || (option >= SENSOR_OPTION_END), false, "Invalid option value : %d, handle: %d, %s, %s", option, handle, get_sensor_name(sensor_id), get_client_name()); - INFO("%s starts %s[%d], with option: %d, power save state: %d", get_client_name(), get_sensor_name(sensor_id), + _I("%s starts %s[%d], with option: %d, power save state: %d", get_client_name(), get_sensor_name(sensor_id), handle, option, g_power_save_state); if (g_power_save_state && !(g_power_save_state & option)) { @@ -840,7 +840,7 @@ API bool sensord_stop(int handle) if (!client_info.get_sensor_state(handle, sensor_state)|| !client_info.get_sensor_id(handle, sensor_id)) { - ERR("client %s failed to get handle information", get_client_name()); + _E("client %s failed to get handle information", get_client_name()); return false; } @@ -848,7 +848,7 @@ API bool sensord_stop(int handle) get_client_name(), get_sensor_name(sensor_id), handle); - INFO("%s stops sensor %s[%d]", get_client_name(), get_sensor_name(sensor_id), handle); + _I("%s stops sensor %s[%d]", get_client_name(), get_sensor_name(sensor_id), handle); client_info.get_sensor_rep(sensor_id, prev_rep); client_info.get_sensor_params(handle, prev_state, prev_option); @@ -877,11 +877,11 @@ static bool change_event_batch(int handle, unsigned int event_type, unsigned int AUTOLOCK(lock); if (!client_info.get_sensor_id(handle, sensor_id)) { - ERR("client %s failed to get handle information", get_client_name()); + _E("client %s failed to get handle information", get_client_name()); return false; } - INFO("%s changes batch of event %s[0x%x] for %s[%d] to (%d, %d)", get_client_name(), get_event_name(event_type), + _I("%s changes batch of event %s[0x%x] for %s[%d] to (%d, %d)", get_client_name(), get_event_name(event_type), event_type, get_sensor_name(sensor_id), handle, interval, latency); client_info.get_sensor_rep(sensor_id, prev_rep); @@ -914,11 +914,11 @@ API bool sensord_change_event_interval(int handle, unsigned int event_type, unsi AUTOLOCK(lock); if (!client_info.get_event_info(handle, event_type, prev_interval, prev_latency, prev_cb_type, prev_cb, prev_user_data)) { - ERR("Failed to get event info with handle = %d, event_type = 0x%x", handle, event_type); + _E("Failed to get event info with handle = %d, event_type = 0x%x", handle, event_type); return false; } - INFO("handle = %d, event_type = 0x%x, interval = %d, prev_latency = %d", handle, event_type, interval, prev_latency); + _I("handle = %d, event_type = 0x%x, interval = %d, prev_latency = %d", handle, event_type, interval, prev_latency); return change_event_batch(handle, event_type, interval, prev_latency); } @@ -932,7 +932,7 @@ API bool sensord_change_event_max_batch_latency(int handle, unsigned int event_t AUTOLOCK(lock); if (!client_info.get_event_info(handle, event_type, prev_interval, prev_latency, prev_cb_type, prev_cb, prev_user_data)) { - ERR("Failed to get event info with handle = %d, event_type = 0x%x", handle, event_type); + _E("Failed to get event info with handle = %d, event_type = 0x%x", handle, event_type); return false; } @@ -944,11 +944,11 @@ API bool sensord_change_event_maincontext(int handle, unsigned int event_type, G AUTOLOCK(lock); if (!client_info.set_event_maincontext(handle, event_type, maincontext)) { - ERR("Failed to get event info with handle = %d, event_type = 0x%x, maincontext = 0x%x", handle, event_type, maincontext); + _E("Failed to get event info with handle = %d, event_type = 0x%x, maincontext = 0x%x", handle, event_type, maincontext); return false; } - INFO("handle = %d, event_type = 0x%x, maincontext = 0x%x", handle, event_type, maincontext); + _I("handle = %d, event_type = 0x%x, maincontext = 0x%x", handle, event_type, maincontext); return true; } @@ -964,7 +964,7 @@ API bool sensord_set_option(int handle, int option) if (!client_info.get_sensor_state(handle, sensor_state)|| !client_info.get_sensor_id(handle, sensor_id)) { - ERR("client %s failed to get handle information", get_client_name()); + _E("client %s failed to get handle information", get_client_name()); return false; } @@ -1002,7 +1002,7 @@ API bool sensord_set_wakeup(int handle, int wakeup) AUTOLOCK(lock); if (!client_info.get_sensor_id(handle, sensor_id)) { - ERR("client %s failed to get handle information", get_client_name()); + _E("client %s failed to get handle information", get_client_name()); return false; } @@ -1012,7 +1012,7 @@ API bool sensord_set_wakeup(int handle, int wakeup) client_info.set_sensor_wakeup(handle, wakeup); if (!client_info.get_command_channel(sensor_id, &cmd_channel)) { - ERR("client %s failed to get command channel for %s", get_client_name(), get_sensor_name(sensor_id)); + _E("client %s failed to get command channel for %s", get_client_name(), get_sensor_name(sensor_id)); return false; } @@ -1020,7 +1020,7 @@ API bool sensord_set_wakeup(int handle, int wakeup) retvm_if ((client_id < 0), false, "Invalid client id : %d, handle: %d, %s, %s", client_id, handle, get_sensor_name(sensor_id), get_client_name()); if (!cmd_channel->cmd_set_wakeup(wakeup)) { - ERR("Sending cmd_set_wakeup(%d, %s, %d) failed for %s", client_id, get_sensor_name(sensor_id), wakeup, get_client_name()); + _E("Sending cmd_set_wakeup(%d, %s, %d) failed for %s", client_id, get_sensor_name(sensor_id), wakeup, get_client_name()); return false; } @@ -1036,12 +1036,12 @@ API bool sensord_set_attribute_int(int handle, int attribute, int value) AUTOLOCK(lock); if (!client_info.get_sensor_id(handle, sensor_id)) { - ERR("client %s failed to get handle information", get_client_name()); + _E("client %s failed to get handle information", get_client_name()); return false; } if (!client_info.get_command_channel(sensor_id, &cmd_channel)) { - ERR("client %s failed to get command channel for %s", get_client_name(), get_sensor_name(sensor_id)); + _E("client %s failed to get command channel for %s", get_client_name(), get_sensor_name(sensor_id)); return false; } @@ -1051,7 +1051,7 @@ API bool sensord_set_attribute_int(int handle, int attribute, int value) client_id, handle, get_sensor_name(sensor_id), get_client_name()); if (!cmd_channel->cmd_set_attribute_int(attribute, value)) { - ERR("Sending cmd_set_attribute_int(%d, %d) failed for %s", + _E("Sending cmd_set_attribute_int(%d, %d) failed for %s", client_id, value, get_client_name); return false; } @@ -1068,12 +1068,12 @@ API bool sensord_set_attribute_str(int handle, int attribute, const char *value, AUTOLOCK(lock); if (!client_info.get_sensor_id(handle, sensor_id)) { - ERR("client %s failed to get handle information", get_client_name()); + _E("client %s failed to get handle information", get_client_name()); return false; } if (!client_info.get_command_channel(sensor_id, &cmd_channel)) { - ERR("client %s failed to get command channel for %s", + _E("client %s failed to get command channel for %s", get_client_name(), get_sensor_name(sensor_id)); return false; } @@ -1088,7 +1088,7 @@ API bool sensord_set_attribute_str(int handle, int attribute, const char *value, client_id, handle, get_sensor_name(sensor_id), get_client_name()); if (!cmd_channel->cmd_set_attribute_str(attribute, value, value_len)) { - ERR("Sending cmd_set_attribute_str(%d, %d, 0x%x) failed for %s", + _E("Sending cmd_set_attribute_str(%d, %d, 0x%x) failed for %s", client_id, value_len, value, get_client_name); return false; } @@ -1114,12 +1114,12 @@ API bool sensord_get_data(int handle, unsigned int data_id, sensor_data_t* senso if (!client_info.get_sensor_state(handle, sensor_state)|| !client_info.get_sensor_id(handle, sensor_id)) { - ERR("client %s failed to get handle information", get_client_name()); + _E("client %s failed to get handle information", get_client_name()); return false; } if (!client_info.get_command_channel(sensor_id, &cmd_channel)) { - ERR("client %s failed to get command channel for %s", get_client_name(), get_sensor_name(sensor_id)); + _E("client %s failed to get command channel for %s", get_client_name(), get_sensor_name(sensor_id)); return false; } @@ -1127,12 +1127,12 @@ API bool sensord_get_data(int handle, unsigned int data_id, sensor_data_t* senso retvm_if ((client_id < 0), false, "Invalid client id : %d, handle: %d, %s, %s", client_id, handle, get_sensor_name(sensor_id), get_client_name()); if (sensor_state != SENSOR_STATE_STARTED) { - ERR("Sensor %s is not started for client %s with handle: %d, sensor_state: %d", get_sensor_name(sensor_id), get_client_name(), handle, sensor_state); + _E("Sensor %s is not started for client %s with handle: %d, sensor_state: %d", get_sensor_name(sensor_id), get_client_name(), handle, sensor_state); return false; } if(!cmd_channel->cmd_get_data(data_id, sensor_data)) { - ERR("cmd_get_data(%d, %d, 0x%x) failed for %s", client_id, data_id, sensor_data, get_client_name()); + _E("cmd_get_data(%d, %d, 0x%x) failed for %s", client_id, data_id, sensor_data, get_client_name()); return false; } diff --git a/src/client/client_common.cpp b/src/client/client_common.cpp index 73f9b45..3fc8ff5 100644 --- a/src/client/client_common.cpp +++ b/src/client/client_common.cpp @@ -113,7 +113,7 @@ const char* get_log_element_name(log_id id, unsigned int type) auto iter = g_log_maps[id].find(type); if (iter == g_log_maps[id].end()) { - INFO("Unknown type value: 0x%x", type); + _I("Unknown type value: 0x%x", type); return p_unknown; } @@ -218,11 +218,11 @@ void print_event_occurrence_log(sensor_handle_info &sensor_handle_info, const re return; } - INFO("%s receives %s with %s[%d][state: %d, option: %d count: %d]", get_client_name(), log_attr->name, + _I("%s receives %s with %s[%d][state: %d, option: %d count: %d]", get_client_name(), log_attr->name, get_sensor_name(sensor_handle_info.m_sensor_id), sensor_handle_info.m_handle, sensor_handle_info.m_sensor_state, sensor_handle_info.m_sensor_option, log_attr->cnt); - INFO("0x%x(cb_event_type = %s, &user_data, client_data = 0x%x)\n", event_info->m_cb, + _I("0x%x(cb_event_type = %s, &user_data, client_data = 0x%x)\n", event_info->m_cb, log_attr->name, event_info->m_user_data); } diff --git a/src/client/command_channel.cpp b/src/client/command_channel.cpp index 06cb549..cdb8fe9 100644 --- a/src/client/command_channel.cpp +++ b/src/client/command_channel.cpp @@ -39,18 +39,18 @@ command_channel::~command_channel() bool command_channel::command_handler(cpacket *packet, void **return_payload) { if (!m_command_socket.is_valid()) { - ERR("Command socket(%d) is not valid for client %s", m_command_socket.get_socket_fd(), get_client_name()); + _E("Command socket(%d) is not valid for client %s", m_command_socket.get_socket_fd(), get_client_name()); return false; } if (packet->size() == 0) { - ERR("Packet is not valid for client %s", get_client_name()); + _E("Packet is not valid for client %s", get_client_name()); return false; } if (m_command_socket.send(packet->packet(), packet->size()) <= 0) { m_command_socket.close(); - ERR("Failed to send command in client %s", get_client_name()); + _E("Failed to send command in client %s", get_client_name()); return false; } @@ -58,7 +58,7 @@ bool command_channel::command_handler(cpacket *packet, void **return_payload) if (m_command_socket.recv(&header, sizeof(header)) <= 0) { m_command_socket.close(); - ERR("Failed to receive header for reply packet in client %s", get_client_name()); + _E("Failed to receive header for reply packet in client %s", get_client_name()); return false; } @@ -67,7 +67,7 @@ bool command_channel::command_handler(cpacket *packet, void **return_payload) if (m_command_socket.recv(buffer, header.size) <= 0) { m_command_socket.close(); - ERR("Failed to receive reply packet in client %s", get_client_name()); + _E("Failed to receive reply packet in client %s", get_client_name()); delete[] buffer; return false; } @@ -83,7 +83,7 @@ bool command_channel::create_channel(void) return false; if (!m_command_socket.connect(COMMAND_CHANNEL_PATH)) { - ERR("Failed to connect command channel for client %s, command socket fd[%d]", get_client_name(), m_command_socket.get_socket_fd()); + _E("Failed to connect command channel for client %s, command socket fd[%d]", get_client_name(), m_command_socket.get_socket_fd()); return false; } @@ -112,16 +112,16 @@ bool command_channel::cmd_get_id(int &client_id) get_proc_name(getpid(), cmd_get_id->name); - INFO("%s send cmd_get_id()", get_client_name()); + _I("%s send cmd_get_id()", get_client_name()); if (!command_handler(packet, (void **)&cmd_get_id_done)) { - ERR("Client %s failed to send/receive command", get_client_name()); + _E("Client %s failed to send/receive command", get_client_name()); delete packet; return false; } if (cmd_get_id_done->client_id < 0) { - ERR("Client %s failed to get client_id[%d] from server", + _E("Client %s failed to get client_id[%d] from server", get_client_name(), cmd_get_id_done->client_id); delete[] (char *)cmd_get_id_done; delete packet; @@ -144,10 +144,10 @@ bool command_channel::cmd_get_sensor_list(void) packet.set_payload_size(sizeof(cmd_get_sensor_list_t)); packet.set_cmd(CMD_GET_SENSOR_LIST); - INFO("%s send cmd_get_sensor_list", get_client_name()); + _I("%s send cmd_get_sensor_list", get_client_name()); if (!command_handler(&packet, (void **)&cmd_get_sensor_list_done)) { - ERR("Client %s failed to send/receive command", get_client_name()); + _E("Client %s failed to send/receive command", get_client_name()); return false; } @@ -166,7 +166,7 @@ bool command_channel::cmd_get_sensor_list(void) info = new(std::nothrow) sensor_info; if (!info) { - ERR("Failed to allocate memory"); + _E("Failed to allocate memory"); delete[] (char *)cmd_get_sensor_list_done; return false; } @@ -196,18 +196,18 @@ bool command_channel::cmd_hello(sensor_id_t sensor) cmd_hello->client_id = m_client_id; cmd_hello->sensor = sensor; - INFO("%s send cmd_hello(client_id=%d, %s)", + _I("%s send cmd_hello(client_id=%d, %s)", get_client_name(), m_client_id, get_sensor_name(sensor)); if (!command_handler(packet, (void **)&cmd_done)) { - ERR("Client %s failed to send/receive command for sensor[%s]", + _E("Client %s failed to send/receive command for sensor[%s]", get_client_name(), get_sensor_name(sensor)); delete packet; return false; } if (cmd_done->value < 0) { - ERR("client %s got error[%d] from server with sensor [%s]", + _E("client %s got error[%d] from server with sensor [%s]", get_client_name(), cmd_done->value, get_sensor_name(sensor)); delete[] (char *)cmd_done; @@ -233,18 +233,18 @@ bool command_channel::cmd_byebye(void) packet->set_cmd(CMD_BYEBYE); - INFO("%s send cmd_byebye(client_id=%d, %s)", + _I("%s send cmd_byebye(client_id=%d, %s)", get_client_name(), m_client_id, get_sensor_name(m_sensor_id)); if (!command_handler(packet, (void **)&cmd_done)) { - ERR("Client %s failed to send/receive command for sensor[%s] with client_id [%d]", + _E("Client %s failed to send/receive command for sensor[%s] with client_id [%d]", get_client_name(), get_sensor_name(m_sensor_id), m_client_id); delete packet; return false; } if (cmd_done->value < 0) { - ERR("Client %s got error[%d] from server for sensor[%s] with client_id [%d]", + _E("Client %s got error[%d] from server for sensor[%s] with client_id [%d]", get_client_name(), cmd_done->value, get_sensor_name(m_sensor_id), m_client_id); delete[] (char *)cmd_done; @@ -275,18 +275,18 @@ bool command_channel::cmd_start(void) packet->set_cmd(CMD_START); - INFO("%s send cmd_start(client_id=%d, %s)", + _I("%s send cmd_start(client_id=%d, %s)", get_client_name(), m_client_id, get_sensor_name(m_sensor_id)); if (!command_handler(packet, (void **)&cmd_done)) { - ERR("Client %s failed to send/receive command for sensor[%s] with client_id [%d]", + _E("Client %s failed to send/receive command for sensor[%s] with client_id [%d]", get_client_name(), get_sensor_name(m_sensor_id), m_client_id); delete packet; return false; } if (cmd_done->value < 0) { - ERR("Client %s got error[%d] from server for sensor[%s] with client_id [%d]", + _E("Client %s got error[%d] from server for sensor[%s] with client_id [%d]", get_client_name(), cmd_done->value, get_sensor_name(m_sensor_id), m_client_id); delete[] (char *)cmd_done; @@ -310,18 +310,18 @@ bool command_channel::cmd_stop(void) packet->set_cmd(CMD_STOP); - INFO("%s send cmd_stop(client_id=%d, %s)", + _I("%s send cmd_stop(client_id=%d, %s)", get_client_name(), m_client_id, get_sensor_name(m_sensor_id)); if (!command_handler(packet, (void **)&cmd_done)) { - ERR("Client %s failed to send/receive command for sensor[%s] with client_id [%d]", + _E("Client %s failed to send/receive command for sensor[%s] with client_id [%d]", get_client_name(), get_sensor_name(m_sensor_id), m_client_id); delete packet; return false; } if (cmd_done->value < 0) { - ERR("Client %s got error[%d] from server for sensor[%s] with client_id [%d]", + _E("Client %s got error[%d] from server for sensor[%s] with client_id [%d]", get_client_name(), cmd_done->value, get_sensor_name(m_sensor_id), m_client_id); delete[] (char *)cmd_done; @@ -349,18 +349,18 @@ bool command_channel::cmd_set_option(int option) cmd_set_option = (cmd_set_option_t*)packet->data(); cmd_set_option->option = option; - INFO("%s send cmd_set_option(client_id=%d, %s, option=%d)", + _I("%s send cmd_set_option(client_id=%d, %s, option=%d)", get_client_name(), m_client_id, get_sensor_name(m_sensor_id), option); if (!command_handler(packet, (void **)&cmd_done)) { - ERR("Client %s failed to send/receive command for sensor[%s] with client_id [%d], option[%d]", + _E("Client %s failed to send/receive command for sensor[%s] with client_id [%d], option[%d]", get_client_name(), get_sensor_name(m_sensor_id), m_client_id, option); delete packet; return false; } if (cmd_done->value < 0) { - ERR("Client %s got error[%d] from server for sensor[%s] with client_id [%d], option[%d]", + _E("Client %s got error[%d] from server for sensor[%s] with client_id [%d], option[%d]", get_client_name(), cmd_done->value, get_sensor_name(m_sensor_id), m_client_id, option); delete[] (char *)cmd_done; @@ -388,18 +388,18 @@ bool command_channel::cmd_set_wakeup(int wakeup) cmd_set_wakeup = (cmd_set_wakeup_t*)packet->data(); cmd_set_wakeup->wakeup = wakeup; - INFO("%s send cmd_set_wakeup(client_id=%d, %s, wakeup=%d)", + _I("%s send cmd_set_wakeup(client_id=%d, %s, wakeup=%d)", get_client_name(), m_client_id, get_sensor_name(m_sensor_id), wakeup); if (!command_handler(packet, (void **)&cmd_done)) { - ERR("Client %s failed to send/receive command for sensor[%s] with client_id [%d], wakeup[%d]", + _E("Client %s failed to send/receive command for sensor[%s] with client_id [%d], wakeup[%d]", get_client_name(), get_sensor_name(m_sensor_id), m_client_id, wakeup); delete packet; return false; } if (cmd_done->value < 0) { - ERR("Client %s got error[%d] from server for sensor[%s] with client_id [%d], wakeup[%d]", + _E("Client %s got error[%d] from server for sensor[%s] with client_id [%d], wakeup[%d]", get_client_name(), cmd_done->value, get_sensor_name(m_sensor_id), m_client_id, wakeup); delete[] (char *)cmd_done; @@ -427,18 +427,18 @@ bool command_channel::cmd_register_event(unsigned int event_type) cmd_reg = (cmd_reg_t*)packet->data(); cmd_reg->event_type = event_type; - INFO("%s send cmd_register_event(client_id=%d, %s)", + _I("%s send cmd_register_event(client_id=%d, %s)", get_client_name(), m_client_id, get_event_name(event_type)); if (!command_handler(packet, (void **)&cmd_done)) { - ERR("Client %s failed to send/receive command with client_id [%d], event_type[%s]", + _E("Client %s failed to send/receive command with client_id [%d], event_type[%s]", get_client_name(), m_client_id, get_event_name(event_type)); delete packet; return false; } if (cmd_done->value < 0) { - ERR("Client %s got error[%d] from server with client_id [%d], event_type[%s]", + _E("Client %s got error[%d] from server with client_id [%d], event_type[%s]", get_client_name(), cmd_done->value, m_client_id, get_event_name(event_type)); delete[] (char *)cmd_done; @@ -481,18 +481,18 @@ bool command_channel::cmd_unregister_event(unsigned int event_type) cmd_unreg = (cmd_unreg_t*)packet->data(); cmd_unreg->event_type = event_type; - INFO("%s send cmd_unregister_event(client_id=%d, %s)", + _I("%s send cmd_unregister_event(client_id=%d, %s)", get_client_name(), m_client_id, get_event_name(event_type)); if (!command_handler(packet, (void **)&cmd_done)) { - ERR("Client %s failed to send/receive command with client_id [%d], event_type[%s]", + _E("Client %s failed to send/receive command with client_id [%d], event_type[%s]", get_client_name(), m_client_id, get_event_name(event_type)); delete packet; return false; } if (cmd_done->value < 0) { - ERR("Client %s got error[%d] from server with client_id [%d], event_type[%s]", + _E("Client %s got error[%d] from server with client_id [%d], event_type[%s]", get_client_name(), cmd_done->value, m_client_id, get_event_name(event_type)); delete[] (char *)cmd_done; @@ -536,18 +536,18 @@ bool command_channel::cmd_set_batch(unsigned int interval, unsigned int latency) cmd_set_batch->interval = interval; cmd_set_batch->latency = latency; - INFO("%s send cmd_set_batch(client_id=%d, %s, interval=%d, latency = %d)", + _I("%s send cmd_set_batch(client_id=%d, %s, interval=%d, latency = %d)", get_client_name(), m_client_id, get_sensor_name(m_sensor_id), interval, latency); if (!command_handler(packet, (void **)&cmd_done)) { - ERR("%s failed to send/receive command for sensor[%s] with client_id [%d], interval[%d], latency[%d]", + _E("%s failed to send/receive command for sensor[%s] with client_id [%d], interval[%d], latency[%d]", get_client_name(), get_sensor_name(m_sensor_id), m_client_id, interval, latency); delete packet; return false; } if (cmd_done->value < 0) { - ERR("%s got error[%d] from server for sensor[%s] with client_id [%d], interval[%d], latency[%d]", + _E("%s got error[%d] from server for sensor[%s] with client_id [%d], interval[%d], latency[%d]", get_client_name(), cmd_done->value, get_sensor_name(m_sensor_id), m_client_id, interval, latency); delete[] (char *)cmd_done; @@ -571,18 +571,18 @@ bool command_channel::cmd_unset_batch(void) packet->set_cmd(CMD_UNSET_BATCH); - INFO("%s send cmd_unset_batch(client_id=%d, %s)", + _I("%s send cmd_unset_batch(client_id=%d, %s)", get_client_name(), m_client_id, get_sensor_name(m_sensor_id)); if (!command_handler(packet, (void **)&cmd_done)) { - ERR("Client %s failed to send/receive command for sensor[%s] with client_id [%d]", + _E("Client %s failed to send/receive command for sensor[%s] with client_id [%d]", get_client_name(), get_sensor_name(m_sensor_id), m_client_id); delete packet; return false; } if (cmd_done->value < 0) { - ERR("Client %s got error[%d] from server for sensor[%s] with client_id [%d]", + _E("Client %s got error[%d] from server for sensor[%s] with client_id [%d]", get_client_name(), cmd_done->value, get_sensor_name(m_sensor_id), m_client_id); delete[] (char *)cmd_done; @@ -611,14 +611,14 @@ bool command_channel::cmd_get_data(unsigned int type, sensor_data_t* sensor_data cmd_get_data->type = type; if (!command_handler(packet, (void **)&cmd_get_data_done)) { - ERR("Client %s failed to send/receive command with client_id [%d], data_id[%s]", + _E("Client %s failed to send/receive command with client_id [%d], data_id[%s]", get_client_name(), m_client_id, get_data_name(type)); delete packet; return false; } if (cmd_get_data_done->state < 0 ) { - ERR("Client %s got error[%d] from server with client_id [%d], data_id[%s]", + _E("Client %s got error[%d] from server with client_id [%d], data_id[%s]", get_client_name(), cmd_get_data_done->state, m_client_id, get_data_name(type)); sensor_data->accuracy = SENSOR_ACCURACY_UNDEFINED; sensor_data->timestamp = 0; @@ -659,18 +659,18 @@ bool command_channel::cmd_set_attribute_int(int attribute, int value) cmd_set_attribute_int->attribute = attribute; cmd_set_attribute_int->value = value; - INFO("%s send cmd_set_attribute_int(client_id=%d, %s, 0x%x, %d)", + _I("%s send cmd_set_attribute_int(client_id=%d, %s, 0x%x, %d)", get_client_name(), m_client_id, get_sensor_name(m_sensor_id), attribute, value); if (!command_handler(packet, (void **)&cmd_done)) { - ERR("Client %s failed to send/receive command for sensor[%s] with client_id [%d], property[0x%x], value[%d]", + _E("Client %s failed to send/receive command for sensor[%s] with client_id [%d], property[0x%x], value[%d]", get_client_name(), get_sensor_name(m_sensor_id), m_client_id, attribute, value); delete packet; return false; } if (cmd_done->value < 0) { - ERR("Client %s got error[%d] from server for sensor[%s] with property[0x%x], value[%d]", + _E("Client %s got error[%d] from server for sensor[%s] with property[0x%x], value[%d]", get_client_name(), cmd_done->value, get_sensor_name(m_sensor_id), attribute, value); delete[] (char *)cmd_done; @@ -700,18 +700,18 @@ bool command_channel::cmd_set_attribute_str(int attribute, const char* value, in cmd_set_attribute_str->value_len = value_len; memcpy(cmd_set_attribute_str->value, value, value_len); - INFO("%s send cmd_set_attribute_str(client_id=%d, value_len = %d, buffer = 0x%x)", + _I("%s send cmd_set_attribute_str(client_id=%d, value_len = %d, buffer = 0x%x)", get_client_name(), m_client_id, value_len, value); if (!command_handler(packet, (void **)&cmd_done)) { - ERR("%s failed to send/receive command with client_id [%d]", + _E("%s failed to send/receive command with client_id [%d]", get_client_name(), m_client_id); delete packet; return false; } if (cmd_done->value < 0) { - ERR("%s got error[%d] from server with client_id [%d]", + _E("%s got error[%d] from server with client_id [%d]", get_client_name(), cmd_done->value, m_client_id); delete[] (char *)cmd_done; diff --git a/src/client/sensor_client_info.cpp b/src/client/sensor_client_info.cpp index 1e2c12c..30dfab2 100644 --- a/src/client/sensor_client_info.cpp +++ b/src/client/sensor_client_info.cpp @@ -58,7 +58,7 @@ int sensor_client_info::create_handle(sensor_id_t sensor) handle++; if (handle == MAX_HANDLE) { - ERR("Handles of client %s are full", get_client_name()); + _E("Handles of client %s are full", get_client_name()); return MAX_HANDLE_REACHED; } @@ -82,7 +82,7 @@ bool sensor_client_info::delete_handle(int handle) auto it_handle = m_sensor_handle_infos.find(handle); if (it_handle == m_sensor_handle_infos.end()) { - ERR("Handle[%d] is not found for client %s", handle, get_client_name()); + _E("Handle[%d] is not found for client %s", handle, get_client_name()); return false; } @@ -106,7 +106,7 @@ bool sensor_client_info::register_event(int handle, unsigned int event_type, auto it_handle = m_sensor_handle_infos.find(handle); if (it_handle == m_sensor_handle_infos.end()) { - ERR("Handle[%d] is not found for client %s", handle, get_client_name()); + _E("Handle[%d] is not found for client %s", handle, get_client_name()); return false; } @@ -123,7 +123,7 @@ bool sensor_client_info::unregister_event(int handle, unsigned int event_type) auto it_handle = m_sensor_handle_infos.find(handle); if (it_handle == m_sensor_handle_infos.end()) { - ERR("Handle[%d] is not found for client %s", handle, get_client_name()); + _E("Handle[%d] is not found for client %s", handle, get_client_name()); return false; } @@ -140,7 +140,7 @@ bool sensor_client_info::register_accuracy_cb(int handle, sensor_accuracy_change auto it_handle = m_sensor_handle_infos.find(handle); if (it_handle == m_sensor_handle_infos.end()) { - ERR("Handle[%d] is not found for client %s", handle, get_client_name()); + _E("Handle[%d] is not found for client %s", handle, get_client_name()); return false; } @@ -158,7 +158,7 @@ bool sensor_client_info::unregister_accuracy_cb(int handle) auto it_handle = m_sensor_handle_infos.find(handle); if (it_handle == m_sensor_handle_infos.end()) { - ERR("Handle[%d] is not found for client %s", handle, get_client_name()); + _E("Handle[%d] is not found for client %s", handle, get_client_name()); return false; } @@ -176,7 +176,7 @@ bool sensor_client_info::set_sensor_params(int handle, int sensor_state, int sen auto it_handle = m_sensor_handle_infos.find(handle); if (it_handle == m_sensor_handle_infos.end()) { - ERR("Handle[%d] is not found for client %s", handle, get_client_name()); + _E("Handle[%d] is not found for client %s", handle, get_client_name()); return false; } @@ -193,7 +193,7 @@ bool sensor_client_info::get_sensor_params(int handle, int &sensor_state, int &s auto it_handle = m_sensor_handle_infos.find(handle); if (it_handle == m_sensor_handle_infos.end()) { - ERR("Handle[%d] is not found for client %s", handle, get_client_name()); + _E("Handle[%d] is not found for client %s", handle, get_client_name()); return false; } @@ -210,7 +210,7 @@ bool sensor_client_info::set_sensor_state(int handle, int sensor_state) auto it_handle = m_sensor_handle_infos.find(handle); if (it_handle == m_sensor_handle_infos.end()) { - ERR("Handle[%d] is not found for client %s", handle, get_client_name()); + _E("Handle[%d] is not found for client %s", handle, get_client_name()); return false; } @@ -226,7 +226,7 @@ bool sensor_client_info::set_sensor_option(int handle, int sensor_option) auto it_handle = m_sensor_handle_infos.find(handle); if (it_handle == m_sensor_handle_infos.end()) { - ERR("Handle[%d] is not found for client %s", handle, get_client_name()); + _E("Handle[%d] is not found for client %s", handle, get_client_name()); return false; } @@ -242,7 +242,7 @@ bool sensor_client_info::set_event_batch(int handle, unsigned int event_type, un auto it_handle = m_sensor_handle_infos.find(handle); if (it_handle == m_sensor_handle_infos.end()) { - ERR("Handle[%d] is not found for client %s", handle, get_client_name()); + _E("Handle[%d] is not found for client %s", handle, get_client_name()); return false; } @@ -259,7 +259,7 @@ bool sensor_client_info::set_event_maincontext(int handle, unsigned int event_ty auto it_handle = m_sensor_handle_infos.find(handle); if (it_handle == m_sensor_handle_infos.end()) { - ERR("Handle[%d] is not found for client %s", handle, get_client_name()); + _E("Handle[%d] is not found for client %s", handle, get_client_name()); return false; } @@ -276,7 +276,7 @@ bool sensor_client_info::set_accuracy(int handle, int accuracy) auto it_handle = m_sensor_handle_infos.find(handle); if (it_handle == m_sensor_handle_infos.end()) { - ERR("Handle[%d] is not found for client %s", handle, get_client_name()); + _E("Handle[%d] is not found for client %s", handle, get_client_name()); return false; } @@ -292,7 +292,7 @@ bool sensor_client_info::set_bad_accuracy(int handle, int bad_accuracy) auto it_handle = m_sensor_handle_infos.find(handle); if (it_handle == m_sensor_handle_infos.end()) { - ERR("Handle[%d] is not found for client %s", handle, get_client_name()); + _E("Handle[%d] is not found for client %s", handle, get_client_name()); return false; } @@ -308,7 +308,7 @@ bool sensor_client_info::get_event_info(int handle, unsigned int event_type, uns auto it_handle = m_sensor_handle_infos.find(handle); if (it_handle == m_sensor_handle_infos.end()) { - ERR("Handle[%d] is not found for client %s", handle, get_client_name()); + _E("Handle[%d] is not found for client %s", handle, get_client_name()); return false; } @@ -363,7 +363,7 @@ bool sensor_client_info::add_command_channel(sensor_id_t sensor, command_channel auto it_channel = m_command_channels.find(sensor); if (it_channel != m_command_channels.end()) { - ERR("%s alreay has command_channel for %s", get_client_name(), get_sensor_name(sensor)); + _E("%s alreay has command_channel for %s", get_client_name(), get_sensor_name(sensor)); return false; } @@ -377,7 +377,7 @@ bool sensor_client_info::get_command_channel(sensor_id_t sensor, command_channel auto it_channel = m_command_channels.find(sensor); if (it_channel == m_command_channels.end()) { - ERR("%s doesn't have command_channel for %s", get_client_name(), get_sensor_name(sensor)); + _E("%s doesn't have command_channel for %s", get_client_name(), get_sensor_name(sensor)); return false; } @@ -406,7 +406,7 @@ bool sensor_client_info::close_command_channel(sensor_id_t sensor_id) auto it_channel = m_command_channels.find(sensor_id); if (it_channel == m_command_channels.end()) { - ERR("%s doesn't have command_channel for %s", get_client_name(), get_sensor_name(sensor_id)); + _E("%s doesn't have command_channel for %s", get_client_name(), get_sensor_name(sensor_id)); return false; } @@ -459,7 +459,7 @@ bool sensor_client_info::get_active_batch(sensor_id_t sensor, unsigned int &inte } if (!active_sensor_found) { - DBG("Active sensor[0x%llx] is not found for client %s", sensor, get_client_name()); + _D("Active sensor[0x%llx] is not found for client %s", sensor, get_client_name()); return false; } @@ -491,7 +491,7 @@ unsigned int sensor_client_info::get_active_option(sensor_id_t sensor) } if (!active_sensor_found) - DBG("Active sensor[0x%llx] is not found for client %s", sensor, get_client_name()); + _D("Active sensor[0x%llx] is not found for client %s", sensor, get_client_name()); return active_option; } @@ -503,7 +503,7 @@ bool sensor_client_info::get_sensor_id(int handle, sensor_id_t &sensor) auto it_handle = m_sensor_handle_infos.find(handle); if (it_handle == m_sensor_handle_infos.end()) { - ERR("Handle[%d] is not found for client %s", handle, get_client_name()); + _E("Handle[%d] is not found for client %s", handle, get_client_name()); return false; } @@ -519,7 +519,7 @@ bool sensor_client_info::get_sensor_state(int handle, int &sensor_state) auto it_handle = m_sensor_handle_infos.find(handle); if (it_handle == m_sensor_handle_infos.end()) { - ERR("Handle[%d] is not found for client %s", handle, get_client_name()); + _E("Handle[%d] is not found for client %s", handle, get_client_name()); return false; } @@ -535,7 +535,7 @@ bool sensor_client_info::get_sensor_wakeup(int handle, int &sensor_wakeup) auto it_handle = m_sensor_handle_infos.find(handle); if (it_handle == m_sensor_handle_infos.end()) { - ERR("Handle[%d] is not found for client %s", handle, get_client_name()); + _E("Handle[%d] is not found for client %s", handle, get_client_name()); return false; } @@ -551,7 +551,7 @@ bool sensor_client_info::set_sensor_wakeup(int handle, int sensor_wakeup) auto it_handle = m_sensor_handle_infos.find(handle); if (it_handle == m_sensor_handle_infos.end()) { - ERR("Handle[%d] is not found for client %s", handle, get_client_name()); + _E("Handle[%d] is not found for client %s", handle, get_client_name()); return false; } diff --git a/src/client/sensor_event_listener.cpp b/src/client/sensor_event_listener.cpp index 6d62eb5..4550da6 100644 --- a/src/client/sensor_event_listener.cpp +++ b/src/client/sensor_event_listener.cpp @@ -87,13 +87,13 @@ void sensor_event_listener::operate_sensor(sensor_id_t sensor, int power_save_st !(it_handle->second.m_sensor_option & power_save_state)) { m_client_info.set_sensor_state(it_handle->first, SENSOR_STATE_PAUSED); - INFO("%s's %s[%d] is paused", get_client_name(), get_sensor_name(sensor), it_handle->first); + _I("%s's %s[%d] is paused", get_client_name(), get_sensor_name(sensor), it_handle->first); } else if ((it_handle->second.m_sensor_state == SENSOR_STATE_PAUSED) && (!power_save_state || (it_handle->second.m_sensor_option & power_save_state))) { m_client_info.set_sensor_state(it_handle->first, SENSOR_STATE_STARTED); - INFO("%s's %s[%d] is resumed", get_client_name(), get_sensor_name(sensor), it_handle->first); + _I("%s's %s[%d] is resumed", get_client_name(), get_sensor_name(sensor), it_handle->first); } } @@ -220,7 +220,7 @@ void sensor_event_listener::handle_events(void* event) callback_info = get_callback_info(sensor_id, event_info, sensor_data, event); if (!callback_info) { - ERR("Failed to get callback_info"); + _E("Failed to get callback_info"); continue; } @@ -307,7 +307,7 @@ gboolean sensor_event_listener::callback_dispatcher(gpointer data) else if (cb_info->cb_type == SENSOR_LEGACY_CB) ((sensor_legacy_cb_t) cb_info->cb)(cb_info->event_type, (sensor_event_data_t *) cb_info->sensor_data, cb_info->user_data); } else { - WARN("Discard invalid callback cb(0x%x)(%s, 0x%x, 0x%x) with id: %llu", + _W("Discard invalid callback cb(0x%x)(%s, 0x%x, 0x%x) with id: %llu", cb_info->cb, get_event_name(cb_info->event_type), cb_info->sensor_data, cb_info->user_data, cb_info->event_id); } @@ -340,13 +340,13 @@ ssize_t sensor_event_listener::sensor_event_poll(void* buffer, int buffer_len, s len = m_event_socket.recv(buffer, buffer_len); if (!len) { - INFO("%s failed to read after poll!", get_client_name()); + _I("%s failed to read after poll!", get_client_name()); return -1; } } if (len < 0) { - INFO("%s failed to recv event from event socket", get_client_name()); + _I("%s failed to recv event from event socket", get_client_name()); return -1; } @@ -366,20 +366,20 @@ void sensor_event_listener::listen_events(void) void *buffer = malloc(EVENT_BUFFER_SIZE); if (!buffer) { - ERR("Failed to allocate memory"); + _E("Failed to allocate memory"); break; } len = sensor_event_poll(buffer, EVENT_BUFFER_SIZE, event); if (len <= 0) { - INFO("sensor_event_poll failed"); + _I("sensor_event_poll failed"); free(buffer); break; } void *buffer_shrinked = realloc(buffer, len); if (!buffer_shrinked) { - ERR("Failed to allocate memory"); + _E("Failed to allocate memory"); free(buffer); break; } @@ -403,7 +403,7 @@ void sensor_event_listener::listen_events(void) m_thread_cond.notify_one(); } - INFO("Event listener thread is terminated."); + _I("Event listener thread is terminated."); if (m_client_info.has_client_id() && (event.events & EPOLLHUP)) { if (m_hup_observer) @@ -421,35 +421,35 @@ bool sensor_event_listener::create_event_channel(void) return false; if (!m_event_socket.connect(EVENT_CHANNEL_PATH)) { - ERR("Failed to connect event channel for client %s, event socket fd[%d]", get_client_name(), m_event_socket.get_socket_fd()); + _E("Failed to connect event channel for client %s, event socket fd[%d]", get_client_name(), m_event_socket.get_socket_fd()); return false; } if (!m_event_socket.set_connection_mode()) { - ERR("Failed to set connection mode for client %s", get_client_name()); + _E("Failed to set connection mode for client %s", get_client_name()); return false; } client_id = m_client_info.get_client_id(); if (m_event_socket.send(&client_id, sizeof(client_id)) <= 0) { - ERR("Failed to send client id for client %s on event socket[%d]", get_client_name(), m_event_socket.get_socket_fd()); + _E("Failed to send client id for client %s on event socket[%d]", get_client_name(), m_event_socket.get_socket_fd()); return false; } if (m_event_socket.recv(&event_channel_ready, sizeof(event_channel_ready)) <= 0) { - ERR("%s failed to recv event_channel_ready packet on event socket[%d] with client id [%d]", + _E("%s failed to recv event_channel_ready packet on event socket[%d] with client id [%d]", get_client_name(), m_event_socket.get_socket_fd(), client_id); return false; } if ((event_channel_ready.magic != EVENT_CHANNEL_MAGIC) || (event_channel_ready.client_id != client_id)) { - ERR("Event_channel_ready packet is wrong, magic = 0x%x, client id = %d", + _E("Event_channel_ready packet is wrong, magic = 0x%x, client id = %d", event_channel_ready.magic, event_channel_ready.client_id); return false; } - INFO("Event channel is established for client %s on socket[%d] with client id : %d", + _I("Event channel is established for client %s on socket[%d] with client id : %d", get_client_name(), m_event_socket.get_socket_fd(), client_id); return true; @@ -471,12 +471,12 @@ void sensor_event_listener::stop_event_listener(void) if (m_thread_state != THREAD_STATE_TERMINATE) { m_thread_state = THREAD_STATE_STOP; - DBG("%s is waiting listener thread[state: %d] to be terminated", get_client_name(), m_thread_state); + _D("%s is waiting listener thread[state: %d] to be terminated", get_client_name(), m_thread_state); if (m_thread_cond.wait_for(u, std::chrono::seconds(THREAD_TERMINATING_TIMEOUT)) == std::cv_status::timeout) - ERR("Fail to stop listener thread after waiting %d seconds", THREAD_TERMINATING_TIMEOUT); + _E("Fail to stop listener thread after waiting %d seconds", THREAD_TERMINATING_TIMEOUT); else - DBG("Listener thread for %s is terminated", get_client_name()); + _D("Listener thread for %s is terminated", get_client_name()); } } @@ -504,7 +504,7 @@ void sensor_event_listener::set_hup_observer(hup_observer_t observer) bool sensor_event_listener::start_event_listener(void) { if (!create_event_channel()) { - ERR("Event channel is not established for %s", get_client_name()); + _E("Event channel is not established for %s", get_client_name()); return false; } diff --git a/src/client/sensor_handle_info.cpp b/src/client/sensor_handle_info.cpp index 1439d43..1be96c0 100644 --- a/src/client/sensor_handle_info.cpp +++ b/src/client/sensor_handle_info.cpp @@ -49,7 +49,7 @@ reg_event_info* sensor_handle_info::get_reg_event_info(unsigned int event_type) auto it_event = m_reg_event_infos.find(event_type); if (it_event == m_reg_event_infos.end()) { - DBG("Event %s[0x%x] is not registered for client %s", get_event_name(event_type), event_type, get_client_name()); + _D("Event %s[0x%x] is not registered for client %s", get_event_name(event_type), event_type, get_client_name()); return NULL; } @@ -73,7 +73,7 @@ bool sensor_handle_info::add_reg_event_info(unsigned int event_type, unsigned in auto it_event = m_reg_event_infos.find(event_type); if (it_event != m_reg_event_infos.end()) { - ERR("Event %s[0x%x] is already registered for client %s", get_event_name(event_type), event_type, get_client_name()); + _E("Event %s[0x%x] is already registered for client %s", get_event_name(event_type), event_type, get_client_name()); return false; } @@ -96,7 +96,7 @@ bool sensor_handle_info::delete_reg_event_info(unsigned int event_type) auto it_event = m_reg_event_infos.find(event_type); if (it_event == m_reg_event_infos.end()) { - ERR("Event %s[0x%x] is not registered for client %s", get_event_name(event_type), event_type, get_client_name()); + _E("Event %s[0x%x] is not registered for client %s", get_event_name(event_type), event_type, get_client_name()); return false; } @@ -121,7 +121,7 @@ bool sensor_handle_info::change_reg_event_batch(unsigned int event_type, unsigne auto it_event = m_reg_event_infos.find(event_type); if (it_event == m_reg_event_infos.end()) { - ERR("Event %s[0x%x] is not registered for client %s", get_event_name(event_type), event_type, get_client_name()); + _E("Event %s[0x%x] is not registered for client %s", get_event_name(event_type), event_type, get_client_name()); return false; } @@ -137,7 +137,7 @@ bool sensor_handle_info::change_reg_event_maincontext(unsigned int event_type, G auto it_event = m_reg_event_infos.find(event_type); if (it_event == m_reg_event_infos.end()) { - ERR("Event %s[0x%x] is not registered for client %s", get_event_name(event_type), event_type, get_client_name()); + _E("Event %s[0x%x] is not registered for client %s", get_event_name(event_type), event_type, get_client_name()); return false; } @@ -149,7 +149,7 @@ bool sensor_handle_info::change_reg_event_maincontext(unsigned int event_type, G void sensor_handle_info::get_batch(unsigned int &interval, unsigned int &latency) { if (m_reg_event_infos.empty()) { - DBG("No events are registered for client %s", get_client_name()); + _D("No events are registered for client %s", get_client_name()); interval = POLL_MAX_HZ_MS; latency = 0; return; diff --git a/src/server/client_info_manager.cpp b/src/server/client_info_manager.cpp index 037e9a1..c7f1c25 100644 --- a/src/server/client_info_manager.cpp +++ b/src/server/client_info_manager.cpp @@ -46,7 +46,7 @@ bool client_info_manager::get_registered_events(int client_id, sensor_id_t senso auto it_record = m_clients.find(client_id); if (it_record == m_clients.end()) { - ERR("Client[%d] is not found", client_id); + _E("Client[%d] is not found", client_id); return false; } @@ -64,7 +64,7 @@ bool client_info_manager::register_event(int client_id, sensor_id_t sensor_id, u auto it_record = m_clients.find(client_id); if (it_record == m_clients.end()) { - ERR("Client[%d] is not found", client_id); + _E("Client[%d] is not found", client_id); return false; } @@ -81,7 +81,7 @@ bool client_info_manager::unregister_event(int client_id, sensor_id_t sensor_id, auto it_record = m_clients.find(client_id); if (it_record == m_clients.end()) { - ERR("Client[%d] is not found", client_id); + _E("Client[%d] is not found", client_id); return false; } @@ -98,7 +98,7 @@ bool client_info_manager::set_batch(int client_id, sensor_id_t sensor_id, unsign auto it_record = m_clients.find(client_id); if (it_record == m_clients.end()) { - ERR("Client[%d] is not found", client_id); + _E("Client[%d] is not found", client_id); return false; } @@ -112,7 +112,7 @@ bool client_info_manager::get_batch(int client_id, sensor_id_t sensor_id, unsign auto it_record = m_clients.find(client_id); if (it_record == m_clients.end()) { - ERR("Client[%d] is not found", client_id); + _E("Client[%d] is not found", client_id); return false; } @@ -126,7 +126,7 @@ bool client_info_manager::set_option(int client_id, sensor_id_t sensor_id, int o auto it_record = m_clients.find(client_id); if (it_record == m_clients.end()) { - ERR("Client[%d] is not found", client_id); + _E("Client[%d] is not found", client_id); return false; } @@ -143,7 +143,7 @@ bool client_info_manager::set_wakeup(int client_id, sensor_id_t sensor_id, int w auto it_record = m_clients.find(client_id); if (it_record == m_clients.end()) { - ERR("Client[%d] is not found", client_id); + _E("Client[%d] is not found", client_id); return false; } @@ -160,7 +160,7 @@ bool client_info_manager::set_start(int client_id, sensor_id_t sensor_id, bool s auto it_record = m_clients.find(client_id); if (it_record == m_clients.end()) { - ERR("Client[%d] is not found", client_id); + _E("Client[%d] is not found", client_id); return false; } @@ -178,7 +178,7 @@ bool client_info_manager::is_started(int client_id, sensor_id_t sensor_id) auto it_record = m_clients.find(client_id); if (it_record == m_clients.end()) { - ERR("Client[%d] is not found", client_id); + _E("Client[%d] is not found", client_id); return false; } @@ -197,7 +197,7 @@ int client_info_manager::create_client_record(void) client_id++; if (client_id == MAX_HANDLE) { - ERR("Sensor records of clients are full"); + _E("Sensor records of clients are full"); return MAX_HANDLE_REACHED; } @@ -216,13 +216,13 @@ bool client_info_manager::remove_client_record(int client_id) auto it_record = m_clients.find(client_id); if (it_record == m_clients.end()) { - ERR("Client[%d] is not found", client_id); + _E("Client[%d] is not found", client_id); return false; } m_clients.erase(it_record); - INFO("Client record for client[%d] is removed from client info manager", client_id); + _I("Client record for client[%d] is removed from client info manager", client_id); return true; } @@ -245,7 +245,7 @@ void client_info_manager::set_client_info(int client_id, pid_t pid, const string auto it_record = m_clients.find(client_id); if (it_record == m_clients.end()) { - ERR("Client[%d] is not found", client_id); + _E("Client[%d] is not found", client_id); return; } @@ -261,7 +261,7 @@ const char* client_info_manager::get_client_info(int client_id) auto it_record = m_clients.find(client_id); if (it_record == m_clients.end()) { - DBG("Client[%d] is not found", client_id); + _D("Client[%d] is not found", client_id); return NULL; } @@ -275,7 +275,7 @@ bool client_info_manager::set_permission(int client_id, int permission) auto it_record = m_clients.find(client_id); if (it_record == m_clients.end()) { - DBG("Client[%d] is not found", client_id); + _D("Client[%d] is not found", client_id); return false; } @@ -290,7 +290,7 @@ bool client_info_manager::get_permission(int client_id, int &permission) auto it_record = m_clients.find(client_id); if (it_record == m_clients.end()) { - DBG("Client[%d] is not found", client_id); + _D("Client[%d] is not found", client_id); return false; } @@ -305,7 +305,7 @@ bool client_info_manager::create_sensor_record(int client_id, sensor_id_t sensor auto it_record = m_clients.find(client_id); if (it_record == m_clients.end()) { - ERR("Client record[%d] is not registered", client_id); + _E("Client record[%d] is not registered", client_id); return false; } @@ -321,7 +321,7 @@ bool client_info_manager::remove_sensor_record(int client_id, sensor_id_t sensor auto it_record = m_clients.find(client_id); if (it_record == m_clients.end()) { - ERR("Client[%d] is not found", client_id); + _E("Client[%d] is not found", client_id); return false; } @@ -342,7 +342,7 @@ bool client_info_manager::has_sensor_record(int client_id, sensor_id_t sensor_id auto it_record = m_clients.find(client_id); if (it_record == m_clients.end()) { - DBG("Client[%d] is not found", client_id); + _D("Client[%d] is not found", client_id); return false; } @@ -359,7 +359,7 @@ bool client_info_manager::has_sensor_record(int client_id) auto it_record = m_clients.find(client_id); if (it_record == m_clients.end()) { - DBG("Client[%d] is not found", client_id); + _D("Client[%d] is not found", client_id); return false; } @@ -392,7 +392,7 @@ bool client_info_manager::get_event_socket(int client_id, csocket &socket) auto it_record = m_clients.find(client_id); if (it_record == m_clients.end()) { - ERR("Client[%d] is not found", client_id); + _E("Client[%d] is not found", client_id); return false; } @@ -409,7 +409,7 @@ bool client_info_manager::set_event_socket(int client_id, const csocket &socket) auto it_record = m_clients.find(client_id); if (it_record == m_clients.end()) { - ERR("Client[%d] is not found", client_id); + _E("Client[%d] is not found", client_id); return false; } diff --git a/src/server/client_sensor_record.cpp b/src/server/client_sensor_record.cpp index da52cf4..cdca1e1 100644 --- a/src/server/client_sensor_record.cpp +++ b/src/server/client_sensor_record.cpp @@ -49,7 +49,7 @@ bool client_sensor_record::register_event(sensor_id_t sensor_id, unsigned int ev } if (!it_usage->second.register_event(event_type)) { - ERR("Event[0x%x] is already registered", event_type); + _E("Event[0x%x] is already registered", event_type); return false; } @@ -61,12 +61,12 @@ bool client_sensor_record::unregister_event(sensor_id_t sensor_id, unsigned int auto it_usage = m_sensor_usages.find(sensor_id); if (it_usage == m_sensor_usages.end()) { - ERR("Sensor[0x%x] is not registered", sensor_id); + _E("Sensor[0x%x] is not registered", sensor_id); return false; } if (!it_usage->second.unregister_event(event_type)) { - ERR("Event[0x%x] is already registered", event_type); + _E("Event[0x%x] is already registered", event_type); return false; } @@ -150,7 +150,7 @@ bool client_sensor_record::get_batch(sensor_id_t sensor_id, unsigned int &interv auto it_usage = m_sensor_usages.find(sensor_id); if (it_usage == m_sensor_usages.end()) { - ERR("Sensor[0x%x] is not found", sensor_id); + _E("Sensor[0x%x] is not found", sensor_id); return false; } @@ -178,7 +178,7 @@ bool client_sensor_record::add_sensor_usage(sensor_id_t sensor_id) auto it_usage = m_sensor_usages.find(sensor_id); if (it_usage != m_sensor_usages.end()) { - ERR("Sensor[0x%x] is already registered", sensor_id); + _E("Sensor[0x%x] is already registered", sensor_id); return false; } @@ -192,7 +192,7 @@ bool client_sensor_record::remove_sensor_usage(sensor_id_t sensor_id) auto it_usage = m_sensor_usages.find(sensor_id); if (it_usage == m_sensor_usages.end()) { - ERR("Sensor[0x%x] is not found", sensor_id); + _E("Sensor[0x%x] is not found", sensor_id); return false; } m_sensor_usages.erase(it_usage); @@ -213,7 +213,7 @@ bool client_sensor_record::has_sensor_usage(sensor_id_t sensor_id) auto it_usage = m_sensor_usages.find(sensor_id); if (it_usage == m_sensor_usages.end()) { - DBG("Sensor[0x%x] is not found", sensor_id); + _D("Sensor[0x%x] is not found", sensor_id); return false; } @@ -226,7 +226,7 @@ bool client_sensor_record::get_registered_events(sensor_id_t sensor_id, event_ty auto it_usage = m_sensor_usages.find(sensor_id); if (it_usage == m_sensor_usages.end()) { - DBG("Sensor[0x%x] is not found", sensor_id); + _D("Sensor[0x%x] is not found", sensor_id); return false; } diff --git a/src/server/command_worker.cpp b/src/server/command_worker.cpp index b6491ab..1df1fda 100644 --- a/src/server/command_worker.cpp +++ b/src/server/command_worker.cpp @@ -183,7 +183,7 @@ bool command_worker::working(void *ctx) if (inst->m_socket.recv(&header, sizeof(header)) <= 0) { string info; inst->get_info(info); - DBG("%s failed to receive header", info.c_str()); + _D("%s failed to receive header", info.c_str()); return false; } @@ -195,7 +195,7 @@ bool command_worker::working(void *ctx) if (inst->m_socket.recv(payload, header.size) <= 0) { string info; inst->get_info(info); - DBG("%s failed to receive data of packet", info.c_str()); + _D("%s failed to receive data of packet", info.c_str()); delete[] payload; return false; } @@ -218,19 +218,19 @@ bool command_worker::stopped(void *ctx) command_worker *inst = (command_worker *)ctx; inst->get_info(info); - INFO("%s is stopped", info.c_str()); + _I("%s is stopped", info.c_str()); if ((inst->m_module) && (inst->m_client_id != CLIENT_ID_INVALID)) { if (get_client_info_manager().is_started(inst->m_client_id, inst->m_sensor_id)) { - WARN("Does not receive cmd_stop before connection broken for [%s]!!", inst->m_module->get_name()); + _W("Does not receive cmd_stop before connection broken for [%s]!!", inst->m_module->get_name()); inst->m_module->delete_interval(inst->m_client_id, false); inst->m_module->stop(); } if (inst->m_sensor_id) { if (get_client_info_manager().has_sensor_record(inst->m_client_id, inst->m_sensor_id)) { - INFO("Removing sensor[0x%llx] record for client_id[%d]", inst->m_sensor_id, inst->m_client_id); + _I("Removing sensor[0x%llx] record for client_id[%d]", inst->m_sensor_id, inst->m_client_id); get_client_info_manager().remove_sensor_record(inst->m_client_id, inst->m_sensor_id); } } @@ -245,7 +245,7 @@ bool command_worker::dispatch_command(int cmd, void* payload) int ret = false; if (!(cmd > 0 && cmd < CMD_CNT)) { - ERR("Unknown command: %d", cmd); + _E("Unknown command: %d", cmd); } else { cmd_handler_t cmd_handler; cmd_handler = command_worker::m_cmd_handlers[cmd]; @@ -270,7 +270,7 @@ bool command_worker::send_cmd_done(long value) cmd_done->value = value; if (m_socket.send(ret_packet->packet(), ret_packet->size()) <= 0) { - ERR("Failed to send a cmd_done to client_id [%d] with value [%ld]", m_client_id, value); + _E("Failed to send a cmd_done to client_id [%d] with value [%ld]", m_client_id, value); delete ret_packet; return false; } @@ -295,7 +295,7 @@ bool command_worker::send_cmd_get_id_done(int client_id) cmd_get_id_done->client_id = client_id; if (m_socket.send(ret_packet->packet(), ret_packet->size()) <= 0) { - ERR("Failed to send a cmd_get_id_done with client_id [%d]", client_id); + _E("Failed to send a cmd_get_id_done with client_id [%d]", client_id); delete ret_packet; return false; } @@ -320,7 +320,7 @@ bool command_worker::send_cmd_get_data_done(int state, sensor_data_t *data) memcpy(&cmd_get_data_done->base_data , data, sizeof(sensor_data_t)); if (m_socket.send(ret_packet->packet(), ret_packet->size()) <= 0) { - ERR("Failed to send a cmd_get_data_done"); + _E("Failed to send a cmd_get_data_done"); delete ret_packet; return false; } @@ -336,12 +336,12 @@ bool command_worker::send_cmd_get_sensor_list_done(void) int permission = get_permission(); - INFO("permission = 0x%x", permission); + _I("permission = 0x%x", permission); get_sensor_list(permission, sensor_list); if (m_socket.send(sensor_list.packet(), sensor_list.size()) <= 0) { - ERR("Failed to send a cmd_get_sensor_list_done"); + _E("Failed to send a cmd_get_sensor_list_done"); return false; } @@ -355,11 +355,11 @@ bool command_worker::cmd_get_id(void *payload) struct ucred cr; socklen_t opt_len = sizeof(cr); - DBG("CMD_GET_ID Handler invoked\n"); + _D("CMD_GET_ID Handler invoked\n"); cmd = (cmd_get_id_t*)payload; if (getsockopt(m_socket.get_socket_fd(), SOL_SOCKET, SO_PEERCRED, &cr, &opt_len)) { - ERR("Failed to get socket option with SO_PEERCRED"); + _E("Failed to get socket option with SO_PEERCRED"); return false; } @@ -370,10 +370,10 @@ bool command_worker::cmd_get_id(void *payload) m_permission = get_permission(); get_client_info_manager().set_permission(client_id, m_permission); - INFO("New client id [%d] created", client_id); + _I("New client id [%d] created", client_id); if (!send_cmd_get_id_done(client_id)) - ERR("Failed to send cmd_done to a client"); + _E("Failed to send cmd_done to a client"); return true; } @@ -381,10 +381,10 @@ bool command_worker::cmd_get_id(void *payload) bool command_worker::cmd_get_sensor_list(void *payload) { - DBG("CMD_GET_SENSOR_LIST Handler invoked\n"); + _D("CMD_GET_SENSOR_LIST Handler invoked\n"); if (!send_cmd_get_sensor_list_done()) - ERR("Failed to send cmd_get_sensor_list_done to a client"); + _E("Failed to send cmd_get_sensor_list_done to a client"); return true; } @@ -394,7 +394,7 @@ bool command_worker::cmd_hello(void *payload) cmd_hello_t *cmd; long ret_value = OP_ERROR; - DBG("CMD_HELLO Handler invoked\n"); + _D("CMD_HELLO Handler invoked\n"); cmd = (cmd_hello_t*)payload; m_sensor_id = cmd->sensor; @@ -406,7 +406,7 @@ bool command_worker::cmd_hello(void *payload) m_module = (sensor_base *)sensor_loader::get_instance().get_sensor(cmd->sensor); if (!m_module) { - ERR("Sensor type[%d] is not supported", cmd->sensor); + _E("Sensor type[%d] is not supported", cmd->sensor); if (!get_client_info_manager().has_sensor_record(m_client_id)) get_client_info_manager().remove_client_record(m_client_id); @@ -415,18 +415,18 @@ bool command_worker::cmd_hello(void *payload) } if (!is_permission_allowed()) { - ERR("Permission denied to connect sensor[0x%llx] for client [%d]", m_sensor_id, m_client_id); + _E("Permission denied to connect sensor[0x%llx] for client [%d]", m_sensor_id, m_client_id); ret_value = OP_ERROR; goto out; } - DBG("Hello sensor [0x%llx], client id [%d]", m_sensor_id, m_client_id); + _D("Hello sensor [0x%llx], client id [%d]", m_sensor_id, m_client_id); get_client_info_manager().create_sensor_record(m_client_id, m_sensor_id); - INFO("New sensor record created for sensor [0x%llx], sensor name [%s] on client id [%d]\n", m_sensor_id, m_module->get_name(), m_client_id); + _I("New sensor record created for sensor [0x%llx], sensor name [%s] on client id [%d]\n", m_sensor_id, m_module->get_name(), m_client_id); ret_value = OP_SUCCESS; out: if (!send_cmd_done(ret_value)) - ERR("Failed to send cmd_done to a client"); + _E("Failed to send cmd_done to a client"); return true; } @@ -436,15 +436,15 @@ bool command_worker::cmd_byebye(void *payload) long ret_value = OP_ERROR; if (!is_permission_allowed()) { - ERR("Permission denied to stop sensor[0x%llx] for client [%d]", m_sensor_id, m_client_id); + _E("Permission denied to stop sensor[0x%llx] for client [%d]", m_sensor_id, m_client_id); ret_value = OP_ERROR; goto out; } - DBG("CMD_BYEBYE for client [%d], sensor [0x%llx]", m_client_id, m_sensor_id); + _D("CMD_BYEBYE for client [%d], sensor [0x%llx]", m_client_id, m_sensor_id); if (!get_client_info_manager().remove_sensor_record(m_client_id, m_sensor_id)) { - ERR("Error removing sensor_record for client [%d]", m_client_id); + _E("Error removing sensor_record for client [%d]", m_client_id); ret_value = OP_ERROR; goto out; } @@ -454,7 +454,7 @@ bool command_worker::cmd_byebye(void *payload) out: if (!send_cmd_done(ret_value)) - ERR("Failed to send cmd_done to a client"); + _E("Failed to send cmd_done to a client"); if (ret_value == OP_SUCCESS) return false; @@ -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%llx] for client [%d]", m_sensor_id, m_client_id); + _E("Permission denied to start sensor[0x%llx] for client [%d]", m_sensor_id, m_client_id); ret_value = OP_ERROR; goto out; } - DBG("START Sensor [0x%llx], called from client [%d]", m_sensor_id, m_client_id); + _D("START Sensor [0x%llx], called from client [%d]", m_sensor_id, m_client_id); if (m_module->start()) { get_client_info_manager().set_start(m_client_id, m_sensor_id, true); @@ -484,13 +484,13 @@ 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%llx] for client [%d]", m_sensor_id, m_client_id); + _E("Failed to start sensor [0x%llx] for client [%d]", m_sensor_id, m_client_id); ret_value = OP_ERROR; } out: if (!send_cmd_done(ret_value)) - ERR("Failed to send cmd_done to a client"); + _E("Failed to send cmd_done to a client"); return true; } @@ -500,24 +500,24 @@ bool command_worker::cmd_stop(void *payload) long ret_value = OP_ERROR; if (!is_permission_allowed()) { - ERR("Permission denied to stop sensor[0x%llx] for client [%d]", m_sensor_id, m_client_id); + _E("Permission denied to stop sensor[0x%llx] for client [%d]", m_sensor_id, m_client_id); ret_value = OP_ERROR; goto out; } - DBG("STOP Sensor [0x%llx], called from client [%d]", m_sensor_id, m_client_id); + _D("STOP Sensor [0x%llx], called from client [%d]", m_sensor_id, m_client_id); if (m_module->stop()) { get_client_info_manager().set_start(m_client_id, m_sensor_id, false); ret_value = OP_SUCCESS; } else { - ERR("Failed to stop sensor [0x%llx] for client [%d]", m_sensor_id, m_client_id); + _E("Failed to stop sensor [0x%llx] for client [%d]", m_sensor_id, m_client_id); ret_value = OP_ERROR; } out: if (!send_cmd_done(ret_value)) - ERR("Failed to send cmd_done to a client"); + _E("Failed to send cmd_done to a client"); return true; } @@ -530,14 +530,14 @@ bool command_worker::cmd_register_event(void *payload) cmd = (cmd_reg_t*)payload; if (!is_permission_allowed()) { - ERR("Permission denied to register event [0x%x] for client [%d] to client info manager", + _E("Permission denied to register event [0x%x] for client [%d] to client info manager", cmd->event_type, m_client_id); ret_value = OP_ERROR; goto out; } if (!get_client_info_manager().register_event(m_client_id, m_sensor_id, cmd->event_type)) { - INFO("Failed to register event [0x%x] for client [%d] to client info manager", + _I("Failed to register event [0x%x] for client [%d] to client info manager", cmd->event_type, m_client_id); ret_value = OP_ERROR; goto out; @@ -546,11 +546,11 @@ bool command_worker::cmd_register_event(void *payload) insert_priority_list(cmd->event_type); ret_value = OP_SUCCESS; - DBG("Registering Event [0x%x] is done for client [%d]", cmd->event_type, m_client_id); + _D("Registering Event [0x%x] is done for client [%d]", cmd->event_type, m_client_id); out: if (!send_cmd_done(ret_value)) - ERR("Failed to send cmd_done to a client"); + _E("Failed to send cmd_done to a client"); return true; } @@ -563,26 +563,26 @@ bool command_worker::cmd_unregister_event(void *payload) cmd = (cmd_unreg_t*)payload; if (!is_permission_allowed()) { - ERR("Permission denied to unregister event [0x%x] for client [%d] to client info manager", + _E("Permission denied to unregister event [0x%x] for client [%d] to client info manager", cmd->event_type, m_client_id); ret_value = OP_ERROR; goto out; } if (!get_client_info_manager().unregister_event(m_client_id, m_sensor_id, cmd->event_type)) { - ERR("Failed to unregister event [0x%x] for client [%d] from client info manager", + _E("Failed to unregister event [0x%x] for client [%d] from client info manager", cmd->event_type, m_client_id); ret_value = OP_ERROR; goto out; } ret_value = OP_SUCCESS; - DBG("Unregistering Event [0x%x] is done for client [%d]", + _D("Unregistering Event [0x%x] is done for client [%d]", cmd->event_type, m_client_id); out: if (!send_cmd_done(ret_value)) - ERR("Failed to send cmd_done to a client"); + _E("Failed to send cmd_done to a client"); return true; } @@ -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%llx] with batch [%d, %d] to client info manager", + _E("Permission denied to set batch for client [%d], for sensor [0x%llx] with batch [%d, %d] to client info manager", m_client_id, m_sensor_id, cmd->interval, cmd->latency); ret_value = OP_ERROR; goto out; } if (!get_client_info_manager().set_batch(m_client_id, m_sensor_id, cmd->interval, cmd->latency)) { - ERR("Failed to set batch for client [%d], for sensor [0x%llx] with batch [%d, %d] to client info manager", + _E("Failed to set batch for client [%d], for sensor [0x%llx] with batch [%d, %d] to client info manager", m_client_id, m_sensor_id, cmd->interval, cmd->latency); ret_value = OP_ERROR; goto out; } if (!m_module->add_interval(m_client_id, cmd->interval, false)) { - ERR("Failed to set interval for client [%d], for sensor [0x%llx] with interval [%d]", + _E("Failed to set interval for client [%d], for sensor [0x%llx] with interval [%d]", m_client_id, m_sensor_id, cmd->interval); ret_value = OP_ERROR; goto out; } if (!m_module->add_batch(m_client_id, cmd->latency)) { - ERR("Failed to set latency for client [%d], for sensor [0x%llx] with latency [%d]", + _E("Failed to set latency for client [%d], for sensor [0x%llx] with latency [%d]", m_client_id, m_sensor_id, cmd->latency); ret_value = OP_ERROR; goto out; @@ -626,7 +626,7 @@ bool command_worker::cmd_set_batch(void *payload) out: if (!send_cmd_done(ret_value)) - ERR("Failed to send cmd_done to a client"); + _E("Failed to send cmd_done to a client"); return true; } @@ -636,27 +636,27 @@ 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%llx] to client info manager", + _E("Permission denied to unset batch for client [%d], for sensor [0x%llx] to client info manager", m_client_id, m_sensor_id); ret_value = OP_ERROR; goto out; } if (!get_client_info_manager().set_batch(m_client_id, m_sensor_id, 0, 0)) { - ERR("Failed to unset batch for client [%d], for sensor [0x%llx] to client info manager", + _E("Failed to unset batch for client [%d], for sensor [0x%llx] to client info manager", m_client_id, m_sensor_id); ret_value = OP_ERROR; goto out; } if (!m_module->delete_interval(m_client_id, false)) { - ERR("Failed to delete interval for client [%d]", m_client_id); + _E("Failed to delete interval for client [%d]", m_client_id); ret_value = OP_ERROR; goto out; } if (!m_module->delete_batch(m_client_id)) { - ERR("Failed to delete latency for client [%d]", m_client_id); + _E("Failed to delete latency for client [%d]", m_client_id); ret_value = OP_ERROR; goto out; } @@ -665,7 +665,7 @@ bool command_worker::cmd_unset_batch(void *payload) out: if (!send_cmd_done(ret_value)) - ERR("Failed to send cmd_done to a client"); + _E("Failed to send cmd_done to a client"); return true; } @@ -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%llx] with option [%d] to client info manager", + _E("Permission denied to set interval for client [%d], for sensor [0x%llx] with option [%d] to client info manager", m_client_id, m_sensor_id, cmd->option); ret_value = OP_ERROR; goto out; } if (!get_client_info_manager().set_option(m_client_id, m_sensor_id, cmd->option)) { - ERR("Failed to set option for client [%d], for sensor [0x%llx] with option [%d] to client info manager", + _E("Failed to set option for client [%d], for sensor [0x%llx] with option [%d] to client info manager", m_client_id, m_sensor_id, cmd->option); ret_value = OP_ERROR; goto out; @@ -694,7 +694,7 @@ bool command_worker::cmd_set_option(void *payload) ret_value = OP_SUCCESS; out: if (!send_cmd_done(ret_value)) - ERR("Failed to send cmd_done to a client"); + _E("Failed to send cmd_done to a client"); return true; } @@ -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%llx] with wakeup [%d] to client info manager", + _E("Permission denied to set wakeup for client [%d], for sensor [0x%llx] with wakeup [%d] to client info manager", m_client_id, m_sensor_id, cmd->wakeup); ret_value = OP_ERROR; goto out; } if (!get_client_info_manager().set_wakeup(m_client_id, m_sensor_id, cmd->wakeup)) { - ERR("Failed to set wakeup for client [%d], for sensor [0x%llx] with wakeup [%d] to client info manager", + _E("Failed to set wakeup for client [%d], for sensor [0x%llx] with wakeup [%d] to client info manager", m_client_id, m_sensor_id, cmd->wakeup); ret_value = OP_ERROR; goto out; @@ -724,7 +724,7 @@ bool command_worker::cmd_set_wakeup(void *payload) out: if (!send_cmd_done(ret_value)) - ERR("Failed to send cmd_done to a client"); + _E("Failed to send cmd_done to a client"); return true; } @@ -738,10 +738,10 @@ bool command_worker::cmd_get_data(void *payload) sensor_data_t *data; - DBG("CMD_GET_VALUE Handler invoked\n"); + _D("CMD_GET_VALUE Handler invoked\n"); if (!is_permission_allowed()) { - ERR("Permission denied to get data for client [%d], for sensor [0x%llx]", + _E("Permission denied to get data for client [%d], for sensor [0x%llx]", m_client_id, m_sensor_id); state = OP_ERROR; goto out; @@ -770,7 +770,7 @@ bool command_worker::cmd_get_data(void *payload) } while ((state >= 0) && !data->timestamp && (retry++ < RETRY_CNT)) { - INFO("Wait sensor[0x%llx] data updated for client [%d] #%d", m_sensor_id, m_client_id, retry); + _I("Wait sensor[0x%llx] data updated for client [%d] #%d", m_sensor_id, m_client_id, retry); usleep((retry == 1) ? INIT_WAIT_TIME : WAIT_TIME); state = m_module->get_data(&data, &length); } @@ -783,7 +783,7 @@ bool command_worker::cmd_get_data(void *payload) state = OP_ERROR; if (state <= 0) { - ERR("Failed to get data for client [%d], for sensor [0x%llx]", + _E("Failed to get data for client [%d], for sensor [0x%llx]", m_client_id, m_sensor_id); } @@ -798,12 +798,12 @@ bool command_worker::cmd_set_attribute_int(void *payload) cmd_set_attribute_int_t *cmd; long ret_value = OP_ERROR; - DBG("CMD_SET_COMMAND Handler invoked\n"); + _D("CMD_SET_COMMAND Handler invoked\n"); cmd = (cmd_set_attribute_int_t*)payload; if (!is_permission_allowed()) { - ERR("Permission denied to set command for client [%d], for sensor [0x%llx] with attribute [%d]", + _E("Permission denied to set command for client [%d], for sensor [0x%llx] with attribute [%d]", m_client_id, m_sensor_id, cmd->attribute); ret_value = OP_ERROR; goto out; @@ -813,7 +813,7 @@ bool command_worker::cmd_set_attribute_int(void *payload) out: if (!send_cmd_done(ret_value)) - ERR("Failed to send cmd_done to a client"); + _E("Failed to send cmd_done to a client"); return true; } @@ -823,12 +823,12 @@ bool command_worker::cmd_set_attribute_str(void *payload) cmd_set_attribute_str_t *cmd; long ret_value = OP_ERROR; - DBG("CMD_SEND_SENSORHUB_DATA Handler invoked"); + _D("CMD_SEND_SENSORHUB_DATA Handler invoked"); cmd = (cmd_set_attribute_str_t*)payload; if (!is_permission_allowed()) { - ERR("Permission denied to send sensorhub_data for client [%d], for sensor [0x%llx]", + _E("Permission denied to send sensorhub_data for client [%d], for sensor [0x%llx]", m_client_id, m_sensor_id); ret_value = OP_ERROR; goto out; @@ -838,7 +838,7 @@ bool command_worker::cmd_set_attribute_str(void *payload) out: if (!send_cmd_done(ret_value)) - ERR("Failed to send cmd_done to a client"); + _E("Failed to send cmd_done to a client"); return true; } diff --git a/src/server/main.cpp b/src/server/main.cpp index 767f55a..bcf0bb2 100644 --- a/src/server/main.cpp +++ b/src/server/main.cpp @@ -31,7 +31,7 @@ static void sig_term_handler(int signo, siginfo_t *info, void *data) get_proc_name(info->si_pid, proc_name); - ERR("Received SIGTERM(%d) from %s(%d)\n", signo, proc_name, info->si_pid); + _E("Received SIGTERM(%d) from %s(%d)\n", signo, proc_name, info->si_pid); exit(EXIT_SUCCESS); } @@ -52,7 +52,7 @@ static void signal_init(void) int main(int argc, char *argv[]) { - INFO("Sensord started"); + _I("Sensord started"); signal_init(); @@ -62,6 +62,6 @@ int main(int argc, char *argv[]) server::get_instance().stop(); - INFO("Sensord terminated"); + _I("Sensord terminated"); return 0; } diff --git a/src/server/permission_checker.cpp b/src/server/permission_checker.cpp index 5a06dd9..9eb9e63 100644 --- a/src/server/permission_checker.cpp +++ b/src/server/permission_checker.cpp @@ -42,7 +42,7 @@ static bool check_privilege_by_sockfd(int sock_fd, const char *priv) if (cynara_creds_socket_get_client(sock_fd, CLIENT_METHOD_DEFAULT, &client) != CYNARA_API_SUCCESS || cynara_creds_socket_get_user(sock_fd, USER_METHOD_DEFAULT, &user) != CYNARA_API_SUCCESS || (session = cynara_session_from_pid(pid)) == NULL) { - ERR("Getting client info failed"); + _E("Getting client info failed"); free(client); free(user); free(session); @@ -86,11 +86,11 @@ void permission_checker::init() for (unsigned int i = 0; i < sensors.size(); ++i) m_permission_set |= sensors[i]->get_permission(); - INFO("Permission Set = %d", m_permission_set); + _I("Permission Set = %d", m_permission_set); if (cynara_initialize(&cynara_env, NULL) != CYNARA_API_SUCCESS) { cynara_env = NULL; - ERR("Cynara initialization failed"); + _E("Cynara initialization failed"); } } diff --git a/src/server/physical_sensor.cpp b/src/server/physical_sensor.cpp index 6410dd2..7d17901 100644 --- a/src/server/physical_sensor.cpp +++ b/src/server/physical_sensor.cpp @@ -115,7 +115,7 @@ int physical_sensor::get_data(sensor_data_t **data, int *length) remains = m_sensor_device->get_data(m_handle.id, data, length); if (*length < 0) { - ERR("Failed to get sensor event"); + _E("Failed to get sensor event"); return -1; } @@ -139,7 +139,7 @@ bool physical_sensor::set_interval(unsigned long interval) if (!m_sensor_device) return false; - INFO("Polling interval is set to %dms", interval); + _I("Polling interval is set to %dms", interval); return m_sensor_device->set_interval(m_handle.id, interval); } @@ -151,7 +151,7 @@ bool physical_sensor::set_batch_latency(unsigned long latency) if (!m_sensor_device) return false; - INFO("Polling interval is set to %dms", latency); + _I("Polling interval is set to %dms", latency); return m_sensor_device->set_batch_latency(m_handle.id, latency); } diff --git a/src/server/plugins/auto_rotation/auto_rotation_sensor.cpp b/src/server/plugins/auto_rotation/auto_rotation_sensor.cpp index fbff5d5..e819c2b 100644 --- a/src/server/plugins/auto_rotation/auto_rotation_sensor.cpp +++ b/src/server/plugins/auto_rotation/auto_rotation_sensor.cpp @@ -63,25 +63,25 @@ auto_rotation_sensor::auto_rotation_sensor() virtual_sensor_config &config = virtual_sensor_config::get_instance(); if (!config.get(SENSOR_TYPE_AUTO_ROTATION, ELEMENT_VENDOR, m_vendor)) { - ERR("[VENDOR] is empty\n"); + _E("[VENDOR] is empty\n"); throw ENXIO; } - INFO("m_vendor = %s", m_vendor.c_str()); + _I("m_vendor = %s", m_vendor.c_str()); if (!config.get(SENSOR_TYPE_AUTO_ROTATION, ELEMENT_RAW_DATA_UNIT, m_raw_data_unit)) { - ERR("[RAW_DATA_UNIT] is empty\n"); + _E("[RAW_DATA_UNIT] is empty\n"); throw ENXIO; } - INFO("m_raw_data_unit = %s", m_raw_data_unit.c_str()); + _I("m_raw_data_unit = %s", m_raw_data_unit.c_str()); if (!config.get(SENSOR_TYPE_AUTO_ROTATION, ELEMENT_DEFAULT_SAMPLING_TIME, &m_default_sampling_time)) { - ERR("[DEFAULT_SAMPLING_TIME] is empty\n"); + _E("[DEFAULT_SAMPLING_TIME] is empty\n"); throw ENXIO; } - INFO("m_default_sampling_time = %d", m_default_sampling_time); + _I("m_default_sampling_time = %d", m_default_sampling_time); m_interval = m_default_sampling_time * MS_TO_US; } @@ -90,7 +90,7 @@ auto_rotation_sensor::~auto_rotation_sensor() { delete m_alg; - INFO("auto_rotation_sensor is destroyed!\n"); + _I("auto_rotation_sensor is destroyed!\n"); } bool auto_rotation_sensor::init(void) @@ -98,21 +98,21 @@ bool auto_rotation_sensor::init(void) m_accel_sensor = sensor_loader::get_instance().get_sensor(ACCELEROMETER_SENSOR); if (!m_accel_sensor) { - ERR("cannot load accel sensor_hal from %s", get_name()); + _E("cannot load accel sensor_hal from %s", get_name()); return false; } m_alg = get_alg(); if (!m_alg) { - ERR("Not supported AUTO ROTATION sensor"); + _E("Not supported AUTO ROTATION sensor"); return false; } if (!m_alg->open()) return false; - INFO("%s is created!\n", get_name()); + _I("%s is created!\n", get_name()); return true; } @@ -186,7 +186,7 @@ void auto_rotation_sensor::synthesize(const sensor_event_t& event) push(rotation_event); - DBG("Rotation: %d, ACC[0]: %f, ACC[1]: %f, ACC[2]: %f", rotation, event.data.values[0], event.data.values[1], event.data.values[2]); + _D("Rotation: %d, ACC[0]: %f, ACC[1]: %f, ACC[2]: %f", rotation, event.data.values[0], event.data.values[1], event.data.values[2]); return; } diff --git a/src/server/plugins/fusion/fusion_sensor.cpp b/src/server/plugins/fusion/fusion_sensor.cpp index 98db53c..412f8b0 100644 --- a/src/server/plugins/fusion/fusion_sensor.cpp +++ b/src/server/plugins/fusion/fusion_sensor.cpp @@ -83,74 +83,74 @@ fusion_sensor::fusion_sensor() m_enable_fusion = 0; if (!config.get(SENSOR_TYPE_FUSION, ELEMENT_VENDOR, m_vendor)) { - ERR("[VENDOR] is empty\n"); + _E("[VENDOR] is empty\n"); throw ENXIO; } - INFO("m_vendor = %s", m_vendor.c_str()); + _I("m_vendor = %s", m_vendor.c_str()); if (!config.get(SENSOR_TYPE_FUSION, ELEMENT_RAW_DATA_UNIT, m_raw_data_unit)) { - ERR("[RAW_DATA_UNIT] is empty\n"); + _E("[RAW_DATA_UNIT] is empty\n"); throw ENXIO; } - INFO("m_raw_data_unit = %s", m_raw_data_unit.c_str()); + _I("m_raw_data_unit = %s", m_raw_data_unit.c_str()); if (!config.get(SENSOR_TYPE_FUSION, ELEMENT_DEFAULT_SAMPLING_TIME, &m_default_sampling_time)) { - ERR("[DEFAULT_SAMPLING_TIME] is empty\n"); + _E("[DEFAULT_SAMPLING_TIME] is empty\n"); throw ENXIO; } - INFO("m_default_sampling_time = %d", m_default_sampling_time); + _I("m_default_sampling_time = %d", m_default_sampling_time); if (!config.get(SENSOR_TYPE_FUSION, ELEMENT_ACCEL_STATIC_BIAS, m_accel_static_bias, 3)) { - ERR("[ACCEL_STATIC_BIAS] is empty\n"); + _E("[ACCEL_STATIC_BIAS] is empty\n"); throw ENXIO; } - INFO("m_accel_static_bias = (%f, %f, %f)", m_accel_static_bias[0], m_accel_static_bias[1], m_accel_static_bias[2]); + _I("m_accel_static_bias = (%f, %f, %f)", m_accel_static_bias[0], m_accel_static_bias[1], m_accel_static_bias[2]); if (!config.get(SENSOR_TYPE_FUSION, ELEMENT_GYRO_STATIC_BIAS, m_gyro_static_bias,3)) { - ERR("[GYRO_STATIC_BIAS] is empty\n"); + _E("[GYRO_STATIC_BIAS] is empty\n"); throw ENXIO; } - INFO("m_gyro_static_bias = (%f, %f, %f)", m_gyro_static_bias[0], m_gyro_static_bias[1], m_gyro_static_bias[2]); + _I("m_gyro_static_bias = (%f, %f, %f)", m_gyro_static_bias[0], m_gyro_static_bias[1], m_gyro_static_bias[2]); if (!config.get(SENSOR_TYPE_FUSION, ELEMENT_GEOMAGNETIC_STATIC_BIAS, m_geomagnetic_static_bias, 3)) { - ERR("[GEOMAGNETIC_STATIC_BIAS] is empty\n"); + _E("[GEOMAGNETIC_STATIC_BIAS] is empty\n"); throw ENXIO; } - INFO("m_geomagnetic_static_bias = (%f, %f, %f)", m_geomagnetic_static_bias[0], m_geomagnetic_static_bias[1], m_geomagnetic_static_bias[2]); + _I("m_geomagnetic_static_bias = (%f, %f, %f)", m_geomagnetic_static_bias[0], m_geomagnetic_static_bias[1], m_geomagnetic_static_bias[2]); if (!config.get(SENSOR_TYPE_FUSION, ELEMENT_ACCEL_ROTATION_DIRECTION_COMPENSATION, m_accel_rotation_direction_compensation, 3)) { - ERR("[ACCEL_ROTATION_DIRECTION_COMPENSATION] is empty\n"); + _E("[ACCEL_ROTATION_DIRECTION_COMPENSATION] is empty\n"); throw ENXIO; } - INFO("m_accel_rotation_direction_compensation = (%d, %d, %d)", m_accel_rotation_direction_compensation[0], m_accel_rotation_direction_compensation[1], m_accel_rotation_direction_compensation[2]); + _I("m_accel_rotation_direction_compensation = (%d, %d, %d)", m_accel_rotation_direction_compensation[0], m_accel_rotation_direction_compensation[1], m_accel_rotation_direction_compensation[2]); if (!config.get(SENSOR_TYPE_FUSION, ELEMENT_GYRO_ROTATION_DIRECTION_COMPENSATION, m_gyro_rotation_direction_compensation, 3)) { - ERR("[GYRO_ROTATION_DIRECTION_COMPENSATION] is empty\n"); + _E("[GYRO_ROTATION_DIRECTION_COMPENSATION] is empty\n"); throw ENXIO; } - INFO("m_gyro_rotation_direction_compensation = (%d, %d, %d)", m_gyro_rotation_direction_compensation[0], m_gyro_rotation_direction_compensation[1], m_gyro_rotation_direction_compensation[2]); + _I("m_gyro_rotation_direction_compensation = (%d, %d, %d)", m_gyro_rotation_direction_compensation[0], m_gyro_rotation_direction_compensation[1], m_gyro_rotation_direction_compensation[2]); if (!config.get(SENSOR_TYPE_FUSION, ELEMENT_GEOMAGNETIC_ROTATION_DIRECTION_COMPENSATION, m_geomagnetic_rotation_direction_compensation, 3)) { - ERR("[GEOMAGNETIC_ROTATION_DIRECTION_COMPENSATION] is empty\n"); + _E("[GEOMAGNETIC_ROTATION_DIRECTION_COMPENSATION] is empty\n"); throw ENXIO; } - INFO("m_geomagnetic_rotation_direction_compensation = (%d, %d, %d)", m_geomagnetic_rotation_direction_compensation[0], m_geomagnetic_rotation_direction_compensation[1], m_geomagnetic_rotation_direction_compensation[2]); + _I("m_geomagnetic_rotation_direction_compensation = (%d, %d, %d)", m_geomagnetic_rotation_direction_compensation[0], m_geomagnetic_rotation_direction_compensation[1], m_geomagnetic_rotation_direction_compensation[2]); if (!config.get(SENSOR_TYPE_FUSION, ELEMENT_MAGNETIC_ALIGNMENT_FACTOR, &m_magnetic_alignment_factor)) { - ERR("[MAGNETIC_ALIGNMENT_FACTOR] is empty\n"); + _E("[MAGNETIC_ALIGNMENT_FACTOR] is empty\n"); throw ENXIO; } - INFO("m_magnetic_alignment_factor = %d", m_magnetic_alignment_factor); + _I("m_magnetic_alignment_factor = %d", m_magnetic_alignment_factor); m_interval = m_default_sampling_time * MS_TO_US; @@ -159,7 +159,7 @@ fusion_sensor::fusion_sensor() fusion_sensor::~fusion_sensor() { - INFO("fusion_sensor is destroyed!\n"); + _I("fusion_sensor is destroyed!\n"); } bool fusion_sensor::init(void) @@ -169,17 +169,17 @@ bool fusion_sensor::init(void) m_magnetic_sensor = sensor_loader::get_instance().get_sensor(GEOMAGNETIC_SENSOR); if (!m_accel_sensor) { - ERR("Failed to load accel sensor: 0x%x", m_accel_sensor); + _E("Failed to load accel sensor: 0x%x", m_accel_sensor); return false; } if (!m_gyro_sensor) - INFO("Failed to load gyro sensor: 0x%x", m_gyro_sensor); + _I("Failed to load gyro sensor: 0x%x", m_gyro_sensor); if (!m_magnetic_sensor) - INFO("Failed to load geomagnetic sensor: 0x%x", m_magnetic_sensor); + _I("Failed to load geomagnetic sensor: 0x%x", m_magnetic_sensor); - INFO("%s is created!", sensor_base::get_name()); + _I("%s is created!", sensor_base::get_name()); return true; } diff --git a/src/server/plugins/gravity/gravity_sensor.cpp b/src/server/plugins/gravity/gravity_sensor.cpp index 390169f..4cfc528 100644 --- a/src/server/plugins/gravity/gravity_sensor.cpp +++ b/src/server/plugins/gravity/gravity_sensor.cpp @@ -78,67 +78,67 @@ gravity_sensor::gravity_sensor() register_supported_event(GRAVITY_RAW_DATA_EVENT); if (!config.get(SENSOR_TYPE_GRAVITY, ELEMENT_VENDOR, m_vendor)) { - ERR("[VENDOR] is empty\n"); + _E("[VENDOR] is empty\n"); throw ENXIO; } - INFO("m_vendor = %s", m_vendor.c_str()); + _I("m_vendor = %s", m_vendor.c_str()); if (!config.get(SENSOR_TYPE_ORIENTATION, ELEMENT_ORIENTATION_DATA_UNIT, m_orientation_data_unit)) { - ERR("[ORIENTATION_DATA_UNIT] is empty\n"); + _E("[ORIENTATION_DATA_UNIT] is empty\n"); throw ENXIO; } - INFO("m_orientation_data_unit = %s", m_orientation_data_unit.c_str()); + _I("m_orientation_data_unit = %s", m_orientation_data_unit.c_str()); if (!config.get(SENSOR_TYPE_GRAVITY, ELEMENT_RAW_DATA_UNIT, m_raw_data_unit)) { - ERR("[RAW_DATA_UNIT] is empty\n"); + _E("[RAW_DATA_UNIT] is empty\n"); throw ENXIO; } - INFO("m_raw_data_unit = %s", m_raw_data_unit.c_str()); + _I("m_raw_data_unit = %s", m_raw_data_unit.c_str()); if (!config.get(SENSOR_TYPE_GRAVITY, ELEMENT_DEFAULT_SAMPLING_TIME, &m_default_sampling_time)) { - ERR("[DEFAULT_SAMPLING_TIME] is empty\n"); + _E("[DEFAULT_SAMPLING_TIME] is empty\n"); throw ENXIO; } - INFO("m_default_sampling_time = %d", m_default_sampling_time); + _I("m_default_sampling_time = %d", m_default_sampling_time); if (!config.get(SENSOR_TYPE_GRAVITY, ELEMENT_GRAVITY_SIGN_COMPENSATION, m_gravity_sign_compensation, 3)) { - ERR("[GRAVITY_SIGN_COMPENSATION] is empty\n"); + _E("[GRAVITY_SIGN_COMPENSATION] is empty\n"); throw ENXIO; } - INFO("m_gravity_sign_compensation = (%d, %d, %d)", m_gravity_sign_compensation[0], m_gravity_sign_compensation[1], m_gravity_sign_compensation[2]); + _I("m_gravity_sign_compensation = (%d, %d, %d)", m_gravity_sign_compensation[0], m_gravity_sign_compensation[1], m_gravity_sign_compensation[2]); if (!config.get(SENSOR_TYPE_ORIENTATION, ELEMENT_AZIMUTH_ROTATION_COMPENSATION, &m_azimuth_rotation_compensation)) { - ERR("[AZIMUTH_ROTATION_COMPENSATION] is empty\n"); + _E("[AZIMUTH_ROTATION_COMPENSATION] is empty\n"); throw ENXIO; } - INFO("m_azimuth_rotation_compensation = %d", m_azimuth_rotation_compensation); + _I("m_azimuth_rotation_compensation = %d", m_azimuth_rotation_compensation); if (!config.get(SENSOR_TYPE_ORIENTATION, ELEMENT_PITCH_ROTATION_COMPENSATION, &m_pitch_rotation_compensation)) { - ERR("[PITCH_ROTATION_COMPENSATION] is empty\n"); + _E("[PITCH_ROTATION_COMPENSATION] is empty\n"); throw ENXIO; } - INFO("m_pitch_rotation_compensation = %d", m_pitch_rotation_compensation); + _I("m_pitch_rotation_compensation = %d", m_pitch_rotation_compensation); if (!config.get(SENSOR_TYPE_ORIENTATION, ELEMENT_ROLL_ROTATION_COMPENSATION, &m_roll_rotation_compensation)) { - ERR("[ROLL_ROTATION_COMPENSATION] is empty\n"); + _E("[ROLL_ROTATION_COMPENSATION] is empty\n"); throw ENXIO; } - INFO("m_roll_rotation_compensation = %d", m_roll_rotation_compensation); + _I("m_roll_rotation_compensation = %d", m_roll_rotation_compensation); m_interval = m_default_sampling_time * MS_TO_US; } gravity_sensor::~gravity_sensor() { - INFO("gravity_sensor is destroyed!\n"); + _I("gravity_sensor is destroyed!\n"); } bool gravity_sensor::init() @@ -150,12 +150,12 @@ bool gravity_sensor::init() m_fusion_sensor = sensor_loader::get_instance().get_sensor(FUSION_SENSOR); if (!m_accel_sensor || !m_gyro_sensor || !m_magnetic_sensor || !m_fusion_sensor) { - ERR("Failed to load sensors, accel: 0x%x, gyro: 0x%x, mag: 0x%x, fusion: 0x%x", + _E("Failed to load sensors, accel: 0x%x, gyro: 0x%x, mag: 0x%x, fusion: 0x%x", m_accel_sensor, m_gyro_sensor, m_magnetic_sensor, m_fusion_sensor); return false; } - INFO("%s is created!", sensor_base::get_name()); + _I("%s is created!", sensor_base::get_name()); return true; } diff --git a/src/server/plugins/linear_accel/linear_accel_sensor.cpp b/src/server/plugins/linear_accel/linear_accel_sensor.cpp index 93f4086..6a43e75 100644 --- a/src/server/plugins/linear_accel/linear_accel_sensor.cpp +++ b/src/server/plugins/linear_accel/linear_accel_sensor.cpp @@ -88,79 +88,79 @@ linear_accel_sensor::linear_accel_sensor() if (!config.get(SENSOR_TYPE_LINEAR_ACCEL, ELEMENT_VENDOR, m_vendor)) { - ERR("[VENDOR] is empty\n"); + _E("[VENDOR] is empty\n"); throw ENXIO; } - INFO("m_vendor = %s", m_vendor.c_str()); + _I("m_vendor = %s", m_vendor.c_str()); if (!config.get(SENSOR_TYPE_LINEAR_ACCEL, ELEMENT_RAW_DATA_UNIT, m_raw_data_unit)) { - ERR("[RAW_DATA_UNIT] is empty\n"); + _E("[RAW_DATA_UNIT] is empty\n"); throw ENXIO; } - INFO("m_raw_data_unit = %s", m_raw_data_unit.c_str()); + _I("m_raw_data_unit = %s", m_raw_data_unit.c_str()); if (!config.get(SENSOR_TYPE_ORIENTATION, ELEMENT_ORIENTATION_DATA_UNIT, m_orientation_data_unit)) { - ERR("[ORIENTATION_DATA_UNIT] is empty\n"); + _E("[ORIENTATION_DATA_UNIT] is empty\n"); throw ENXIO; } - INFO("m_orientation_data_unit = %s", m_orientation_data_unit.c_str()); + _I("m_orientation_data_unit = %s", m_orientation_data_unit.c_str()); if (!config.get(SENSOR_TYPE_LINEAR_ACCEL, ELEMENT_DEFAULT_SAMPLING_TIME, &m_default_sampling_time)) { - ERR("[DEFAULT_SAMPLING_TIME] is empty\n"); + _E("[DEFAULT_SAMPLING_TIME] is empty\n"); throw ENXIO; } - INFO("m_default_sampling_time = %d", m_default_sampling_time); + _I("m_default_sampling_time = %d", m_default_sampling_time); if (!config.get(SENSOR_TYPE_LINEAR_ACCEL, ELEMENT_ACCEL_STATIC_BIAS, m_accel_static_bias, 3)) { - ERR("[ACCEL_STATIC_BIAS] is empty\n"); + _E("[ACCEL_STATIC_BIAS] is empty\n"); throw ENXIO; } if (!config.get(SENSOR_TYPE_LINEAR_ACCEL, ELEMENT_ACCEL_ROTATION_DIRECTION_COMPENSATION, m_accel_rotation_direction_compensation, 3)) { - ERR("[ACCEL_ROTATION_DIRECTION_COMPENSATION] is empty\n"); + _E("[ACCEL_ROTATION_DIRECTION_COMPENSATION] is empty\n"); throw ENXIO; } - INFO("m_accel_rotation_direction_compensation = (%d, %d, %d)", m_accel_rotation_direction_compensation[0], m_accel_rotation_direction_compensation[1], m_accel_rotation_direction_compensation[2]); + _I("m_accel_rotation_direction_compensation = (%d, %d, %d)", m_accel_rotation_direction_compensation[0], m_accel_rotation_direction_compensation[1], m_accel_rotation_direction_compensation[2]); if (!config.get(SENSOR_TYPE_GRAVITY, ELEMENT_GRAVITY_SIGN_COMPENSATION, m_gravity_sign_compensation, 3)) { - ERR("[GRAVITY_SIGN_COMPENSATION] is empty\n"); + _E("[GRAVITY_SIGN_COMPENSATION] is empty\n"); throw ENXIO; } - INFO("m_gravity_sign_compensation = (%d, %d, %d)", m_gravity_sign_compensation[0], m_gravity_sign_compensation[1], m_gravity_sign_compensation[2]); + _I("m_gravity_sign_compensation = (%d, %d, %d)", m_gravity_sign_compensation[0], m_gravity_sign_compensation[1], m_gravity_sign_compensation[2]); if (!config.get(SENSOR_TYPE_LINEAR_ACCEL, ELEMENT_LINEAR_ACCEL_SIGN_COMPENSATION, m_linear_accel_sign_compensation, 3)) { - ERR("[LINEAR_ACCEL_SIGN_COMPENSATION] is empty\n"); + _E("[LINEAR_ACCEL_SIGN_COMPENSATION] is empty\n"); throw ENXIO; } - INFO("m_linear_accel_sign_compensation = (%d, %d, %d)", m_linear_accel_sign_compensation[0], m_linear_accel_sign_compensation[1], m_linear_accel_sign_compensation[2]); + _I("m_linear_accel_sign_compensation = (%d, %d, %d)", m_linear_accel_sign_compensation[0], m_linear_accel_sign_compensation[1], m_linear_accel_sign_compensation[2]); if (!config.get(SENSOR_TYPE_ORIENTATION, ELEMENT_AZIMUTH_ROTATION_COMPENSATION, &m_azimuth_rotation_compensation)) { - ERR("[AZIMUTH_ROTATION_COMPENSATION] is empty\n"); + _E("[AZIMUTH_ROTATION_COMPENSATION] is empty\n"); throw ENXIO; } - INFO("m_azimuth_rotation_compensation = %d", m_azimuth_rotation_compensation); + _I("m_azimuth_rotation_compensation = %d", m_azimuth_rotation_compensation); if (!config.get(SENSOR_TYPE_ORIENTATION, ELEMENT_PITCH_ROTATION_COMPENSATION, &m_pitch_rotation_compensation)) { - ERR("[PITCH_ROTATION_COMPENSATION] is empty\n"); + _E("[PITCH_ROTATION_COMPENSATION] is empty\n"); throw ENXIO; } - INFO("m_pitch_rotation_compensation = %d", m_pitch_rotation_compensation); + _I("m_pitch_rotation_compensation = %d", m_pitch_rotation_compensation); if (!config.get(SENSOR_TYPE_ORIENTATION, ELEMENT_ROLL_ROTATION_COMPENSATION, &m_roll_rotation_compensation)) { - ERR("[ROLL_ROTATION_COMPENSATION] is empty\n"); + _E("[ROLL_ROTATION_COMPENSATION] is empty\n"); throw ENXIO; } - INFO("m_roll_rotation_compensation = %d", m_roll_rotation_compensation); + _I("m_roll_rotation_compensation = %d", m_roll_rotation_compensation); m_interval = m_default_sampling_time * MS_TO_US; @@ -168,7 +168,7 @@ linear_accel_sensor::linear_accel_sensor() linear_accel_sensor::~linear_accel_sensor() { - INFO("linear_accel_sensor is destroyed!\n"); + _I("linear_accel_sensor is destroyed!\n"); } bool linear_accel_sensor::init() @@ -180,12 +180,12 @@ bool linear_accel_sensor::init() m_fusion_sensor = sensor_loader::get_instance().get_sensor(FUSION_SENSOR); if (!m_accel_sensor || !m_gyro_sensor || !m_magnetic_sensor || !m_fusion_sensor) { - ERR("Failed to load sensors, accel: 0x%x, gyro: 0x%x, mag: 0x%x, fusion: 0x%x", + _E("Failed to load sensors, accel: 0x%x, gyro: 0x%x, mag: 0x%x, fusion: 0x%x", m_accel_sensor, m_gyro_sensor, m_magnetic_sensor, m_fusion_sensor); return false; } - INFO("%s is created!", sensor_base::get_name()); + _I("%s is created!", sensor_base::get_name()); return true; } diff --git a/src/server/plugins/orientation/orientation_sensor.cpp b/src/server/plugins/orientation/orientation_sensor.cpp index 911b7f3..3bd6047 100644 --- a/src/server/plugins/orientation/orientation_sensor.cpp +++ b/src/server/plugins/orientation/orientation_sensor.cpp @@ -73,53 +73,53 @@ orientation_sensor::orientation_sensor() register_supported_event(ORIENTATION_RAW_DATA_EVENT); if (!config.get(SENSOR_TYPE_ORIENTATION, ELEMENT_VENDOR, m_vendor)) { - ERR("[VENDOR] is empty\n"); + _E("[VENDOR] is empty\n"); throw ENXIO; } - INFO("m_vendor = %s", m_vendor.c_str()); + _I("m_vendor = %s", m_vendor.c_str()); if (!config.get(SENSOR_TYPE_ORIENTATION, ELEMENT_RAW_DATA_UNIT, m_raw_data_unit)) { - ERR("[RAW_DATA_UNIT] is empty\n"); + _E("[RAW_DATA_UNIT] is empty\n"); throw ENXIO; } - INFO("m_raw_data_unit = %s", m_raw_data_unit.c_str()); + _I("m_raw_data_unit = %s", m_raw_data_unit.c_str()); if (!config.get(SENSOR_TYPE_ORIENTATION, ELEMENT_DEFAULT_SAMPLING_TIME, &m_default_sampling_time)) { - ERR("[DEFAULT_SAMPLING_TIME] is empty\n"); + _E("[DEFAULT_SAMPLING_TIME] is empty\n"); throw ENXIO; } - INFO("m_default_sampling_time = %d", m_default_sampling_time); + _I("m_default_sampling_time = %d", m_default_sampling_time); if (!config.get(SENSOR_TYPE_ORIENTATION, ELEMENT_AZIMUTH_ROTATION_COMPENSATION, &m_azimuth_rotation_compensation)) { - ERR("[AZIMUTH_ROTATION_COMPENSATION] is empty\n"); + _E("[AZIMUTH_ROTATION_COMPENSATION] is empty\n"); throw ENXIO; } - INFO("m_azimuth_rotation_compensation = %d", m_azimuth_rotation_compensation); + _I("m_azimuth_rotation_compensation = %d", m_azimuth_rotation_compensation); if (!config.get(SENSOR_TYPE_ORIENTATION, ELEMENT_PITCH_ROTATION_COMPENSATION, &m_pitch_rotation_compensation)) { - ERR("[PITCH_ROTATION_COMPENSATION] is empty\n"); + _E("[PITCH_ROTATION_COMPENSATION] is empty\n"); throw ENXIO; } - INFO("m_pitch_rotation_compensation = %d", m_pitch_rotation_compensation); + _I("m_pitch_rotation_compensation = %d", m_pitch_rotation_compensation); if (!config.get(SENSOR_TYPE_ORIENTATION, ELEMENT_ROLL_ROTATION_COMPENSATION, &m_roll_rotation_compensation)) { - ERR("[ROLL_ROTATION_COMPENSATION] is empty\n"); + _E("[ROLL_ROTATION_COMPENSATION] is empty\n"); throw ENXIO; } - INFO("m_roll_rotation_compensation = %d", m_roll_rotation_compensation); + _I("m_roll_rotation_compensation = %d", m_roll_rotation_compensation); m_interval = m_default_sampling_time * MS_TO_US; } orientation_sensor::~orientation_sensor() { - INFO("orientation_sensor is destroyed!\n"); + _I("orientation_sensor is destroyed!\n"); } bool orientation_sensor::init(void) @@ -131,12 +131,12 @@ bool orientation_sensor::init(void) m_fusion_sensor = sensor_loader::get_instance().get_sensor(FUSION_SENSOR); if (!m_accel_sensor || !m_gyro_sensor || !m_magnetic_sensor || !m_fusion_sensor) { - ERR("Failed to load sensors, accel: 0x%x, gyro: 0x%x, mag: 0x%x, fusion: 0x%x", + _E("Failed to load sensors, accel: 0x%x, gyro: 0x%x, mag: 0x%x, fusion: 0x%x", m_accel_sensor, m_gyro_sensor, m_magnetic_sensor, m_fusion_sensor); return false; } - INFO("%s is created!\n", sensor_base::get_name()); + _I("%s is created!\n", sensor_base::get_name()); return true; } diff --git a/src/server/plugins/rotation_vector/gaming_rv/gaming_rv_sensor.cpp b/src/server/plugins/rotation_vector/gaming_rv/gaming_rv_sensor.cpp index 4d022c7..0296707 100644 --- a/src/server/plugins/rotation_vector/gaming_rv/gaming_rv_sensor.cpp +++ b/src/server/plugins/rotation_vector/gaming_rv/gaming_rv_sensor.cpp @@ -70,60 +70,60 @@ gaming_rv_sensor::gaming_rv_sensor() else m_hardware_fusion = true; - INFO("m_hardware_fusion = %d", m_hardware_fusion); + _I("m_hardware_fusion = %d", m_hardware_fusion); m_name = string(SENSOR_NAME); register_supported_event(GAMING_RV_RAW_DATA_EVENT); m_enable_gaming_rv = 0; if (!config.get(SENSOR_TYPE_GAMING_RV, ELEMENT_VENDOR, m_vendor)) { - ERR("[VENDOR] is empty\n"); + _E("[VENDOR] is empty\n"); throw ENXIO; } - INFO("m_vendor = %s", m_vendor.c_str()); + _I("m_vendor = %s", m_vendor.c_str()); if (!config.get(SENSOR_TYPE_GAMING_RV, ELEMENT_DEFAULT_SAMPLING_TIME, &m_default_sampling_time)) { - ERR("[DEFAULT_SAMPLING_TIME] is empty\n"); + _E("[DEFAULT_SAMPLING_TIME] is empty\n"); throw ENXIO; } - INFO("m_default_sampling_time = %d", m_default_sampling_time); + _I("m_default_sampling_time = %d", m_default_sampling_time); if (!config.get(SENSOR_TYPE_GAMING_RV, ELEMENT_ACCEL_STATIC_BIAS, m_accel_static_bias, 3)) { - ERR("[ACCEL_STATIC_BIAS] is empty\n"); + _E("[ACCEL_STATIC_BIAS] is empty\n"); throw ENXIO; } - INFO("m_accel_static_bias = (%f, %f, %f)", m_accel_static_bias[0], m_accel_static_bias[1], m_accel_static_bias[2]); + _I("m_accel_static_bias = (%f, %f, %f)", m_accel_static_bias[0], m_accel_static_bias[1], m_accel_static_bias[2]); if (!config.get(SENSOR_TYPE_GAMING_RV, ELEMENT_GYRO_STATIC_BIAS, m_gyro_static_bias,3)) { - ERR("[GYRO_STATIC_BIAS] is empty\n"); + _E("[GYRO_STATIC_BIAS] is empty\n"); throw ENXIO; } - INFO("m_gyro_static_bias = (%f, %f, %f)", m_gyro_static_bias[0], m_gyro_static_bias[1], m_gyro_static_bias[2]); + _I("m_gyro_static_bias = (%f, %f, %f)", m_gyro_static_bias[0], m_gyro_static_bias[1], m_gyro_static_bias[2]); if (!config.get(SENSOR_TYPE_GAMING_RV, ELEMENT_ACCEL_ROTATION_DIRECTION_COMPENSATION, m_accel_rotation_direction_compensation, 3)) { - ERR("[ACCEL_ROTATION_DIRECTION_COMPENSATION] is empty\n"); + _E("[ACCEL_ROTATION_DIRECTION_COMPENSATION] is empty\n"); throw ENXIO; } - INFO("m_accel_rotation_direction_compensation = (%d, %d, %d)", m_accel_rotation_direction_compensation[0], m_accel_rotation_direction_compensation[1], m_accel_rotation_direction_compensation[2]); + _I("m_accel_rotation_direction_compensation = (%d, %d, %d)", m_accel_rotation_direction_compensation[0], m_accel_rotation_direction_compensation[1], m_accel_rotation_direction_compensation[2]); if (!config.get(SENSOR_TYPE_GAMING_RV, ELEMENT_GYRO_ROTATION_DIRECTION_COMPENSATION, m_gyro_rotation_direction_compensation, 3)) { - ERR("[GYRO_ROTATION_DIRECTION_COMPENSATION] is empty\n"); + _E("[GYRO_ROTATION_DIRECTION_COMPENSATION] is empty\n"); throw ENXIO; } - INFO("m_gyro_rotation_direction_compensation = (%d, %d, %d)", m_gyro_rotation_direction_compensation[0], m_gyro_rotation_direction_compensation[1], m_gyro_rotation_direction_compensation[2]); + _I("m_gyro_rotation_direction_compensation = (%d, %d, %d)", m_gyro_rotation_direction_compensation[0], m_gyro_rotation_direction_compensation[1], m_gyro_rotation_direction_compensation[2]); m_interval = m_default_sampling_time * MS_TO_US; } gaming_rv_sensor::~gaming_rv_sensor() { - INFO("gaming_rv_sensor is destroyed!\n"); + _I("gaming_rv_sensor is destroyed!\n"); } bool gaming_rv_sensor::init() @@ -132,12 +132,12 @@ bool gaming_rv_sensor::init() m_gyro_sensor = sensor_loader::get_instance().get_sensor(GYROSCOPE_SENSOR); if (!m_accel_sensor || !m_gyro_sensor) { - ERR("Failed to load sensors, accel: 0x%x, gyro: 0x%x", + _E("Failed to load sensors, accel: 0x%x, gyro: 0x%x", m_accel_sensor, m_gyro_sensor); return false; } - INFO("%s is created!\n", sensor_base::get_name()); + _I("%s is created!\n", sensor_base::get_name()); return true; } diff --git a/src/server/plugins/rotation_vector/geomagnetic_rv/geomagnetic_rv_sensor.cpp b/src/server/plugins/rotation_vector/geomagnetic_rv/geomagnetic_rv_sensor.cpp index 6f1e606..6ca994c 100644 --- a/src/server/plugins/rotation_vector/geomagnetic_rv/geomagnetic_rv_sensor.cpp +++ b/src/server/plugins/rotation_vector/geomagnetic_rv/geomagnetic_rv_sensor.cpp @@ -62,25 +62,25 @@ geomagnetic_rv_sensor::geomagnetic_rv_sensor() register_supported_event(GEOMAGNETIC_RV_RAW_DATA_EVENT); if (!config.get(SENSOR_TYPE_GEOMAGNETIC_RV, ELEMENT_VENDOR, m_vendor)) { - ERR("[VENDOR] is empty\n"); + _E("[VENDOR] is empty\n"); throw ENXIO; } - INFO("m_vendor = %s", m_vendor.c_str()); + _I("m_vendor = %s", m_vendor.c_str()); if (!config.get(SENSOR_TYPE_GEOMAGNETIC_RV, ELEMENT_DEFAULT_SAMPLING_TIME, &m_default_sampling_time)) { - ERR("[DEFAULT_SAMPLING_TIME] is empty\n"); + _E("[DEFAULT_SAMPLING_TIME] is empty\n"); throw ENXIO; } - INFO("m_default_sampling_time = %d", m_default_sampling_time); + _I("m_default_sampling_time = %d", m_default_sampling_time); m_interval = m_default_sampling_time * MS_TO_US; } geomagnetic_rv_sensor::~geomagnetic_rv_sensor() { - INFO("geomagnetic_rv_sensor is destroyed!\n"); + _I("geomagnetic_rv_sensor is destroyed!\n"); } bool geomagnetic_rv_sensor::init() @@ -91,12 +91,12 @@ bool geomagnetic_rv_sensor::init() m_fusion_sensor = sensor_loader::get_instance().get_sensor(FUSION_SENSOR); if (!m_accel_sensor || !m_magnetic_sensor || !m_fusion_sensor) { - ERR("Failed to load sensors, accel: 0x%x, mag: 0x%x, fusion: 0x%x", + _E("Failed to load sensors, accel: 0x%x, mag: 0x%x, fusion: 0x%x", m_accel_sensor, m_magnetic_sensor, m_fusion_sensor); return false; } - INFO("%s is created!\n", sensor_base::get_name()); + _I("%s is created!\n", sensor_base::get_name()); return true; } diff --git a/src/server/plugins/rotation_vector/rv/rv_sensor.cpp b/src/server/plugins/rotation_vector/rv/rv_sensor.cpp index f00ffef..1fc7db0 100644 --- a/src/server/plugins/rotation_vector/rv/rv_sensor.cpp +++ b/src/server/plugins/rotation_vector/rv/rv_sensor.cpp @@ -69,25 +69,25 @@ rv_sensor::rv_sensor() m_enable_orientation = 0; if (!config.get(SENSOR_TYPE_RV, ELEMENT_VENDOR, m_vendor)) { - ERR("[VENDOR] is empty\n"); + _E("[VENDOR] is empty\n"); throw ENXIO; } - INFO("m_vendor = %s", m_vendor.c_str()); + _I("m_vendor = %s", m_vendor.c_str()); if (!config.get(SENSOR_TYPE_RV, ELEMENT_DEFAULT_SAMPLING_TIME, &m_default_sampling_time)) { - ERR("[DEFAULT_SAMPLING_TIME] is empty\n"); + _E("[DEFAULT_SAMPLING_TIME] is empty\n"); throw ENXIO; } - INFO("m_default_sampling_time = %d", m_default_sampling_time); + _I("m_default_sampling_time = %d", m_default_sampling_time); m_interval = m_default_sampling_time * MS_TO_US; } rv_sensor::~rv_sensor() { - INFO("rv_sensor is destroyed!\n"); + _I("rv_sensor is destroyed!\n"); } bool rv_sensor::init() @@ -99,12 +99,12 @@ bool rv_sensor::init() m_fusion_sensor = sensor_loader::get_instance().get_sensor(FUSION_SENSOR); if (!m_accel_sensor || !m_gyro_sensor || !m_magnetic_sensor || !m_fusion_sensor) { - ERR("Failed to load sensors, accel: 0x%x, gyro: 0x%x, mag: 0x%x, fusion: 0x%x", + _E("Failed to load sensors, accel: 0x%x, gyro: 0x%x, mag: 0x%x, fusion: 0x%x", m_accel_sensor, m_gyro_sensor, m_magnetic_sensor, m_fusion_sensor); return false; } - INFO("%s is created!\n", sensor_base::get_name()); + _I("%s is created!\n", sensor_base::get_name()); return true; } diff --git a/src/server/plugins/tilt/tilt_sensor.cpp b/src/server/plugins/tilt/tilt_sensor.cpp index cab3520..8b1af3c 100644 --- a/src/server/plugins/tilt/tilt_sensor.cpp +++ b/src/server/plugins/tilt/tilt_sensor.cpp @@ -63,39 +63,39 @@ tilt_sensor::tilt_sensor() register_supported_event(TILT_RAW_DATA_EVENT); if (!config.get(SENSOR_TYPE_TILT, ELEMENT_VENDOR, m_vendor)) { - ERR("[VENDOR] is empty\n"); + _E("[VENDOR] is empty\n"); throw ENXIO; } - INFO("m_vendor = %s", m_vendor.c_str()); + _I("m_vendor = %s", m_vendor.c_str()); if (!config.get(SENSOR_TYPE_TILT, ELEMENT_RAW_DATA_UNIT, m_raw_data_unit)) { - ERR("[RAW_DATA_UNIT] is empty\n"); + _E("[RAW_DATA_UNIT] is empty\n"); throw ENXIO; } - INFO("m_raw_data_unit = %s", m_raw_data_unit.c_str()); + _I("m_raw_data_unit = %s", m_raw_data_unit.c_str()); if (!config.get(SENSOR_TYPE_TILT, ELEMENT_DEFAULT_SAMPLING_TIME, &m_default_sampling_time)) { - ERR("[DEFAULT_SAMPLING_TIME] is empty\n"); + _E("[DEFAULT_SAMPLING_TIME] is empty\n"); throw ENXIO; } - INFO("m_default_sampling_time = %d", m_default_sampling_time); + _I("m_default_sampling_time = %d", m_default_sampling_time); if (!config.get(SENSOR_TYPE_TILT, ELEMENT_PITCH_ROTATION_COMPENSATION, &m_pitch_rotation_compensation)) { - ERR("[PITCH_ROTATION_COMPENSATION] is empty\n"); + _E("[PITCH_ROTATION_COMPENSATION] is empty\n"); throw ENXIO; } - INFO("m_pitch_rotation_compensation = %d", m_pitch_rotation_compensation); + _I("m_pitch_rotation_compensation = %d", m_pitch_rotation_compensation); if (!config.get(SENSOR_TYPE_TILT, ELEMENT_ROLL_ROTATION_COMPENSATION, &m_roll_rotation_compensation)) { - ERR("[ROLL_ROTATION_COMPENSATION] is empty\n"); + _E("[ROLL_ROTATION_COMPENSATION] is empty\n"); throw ENXIO; } - INFO("m_roll_rotation_compensation = %d", m_roll_rotation_compensation); + _I("m_roll_rotation_compensation = %d", m_roll_rotation_compensation); m_interval = m_default_sampling_time * MS_TO_US; @@ -103,7 +103,7 @@ tilt_sensor::tilt_sensor() tilt_sensor::~tilt_sensor() { - INFO("tilt_sensor is destroyed!\n"); + _I("tilt_sensor is destroyed!\n"); } bool tilt_sensor::init(void) @@ -112,12 +112,12 @@ bool tilt_sensor::init(void) m_fusion_sensor = sensor_loader::get_instance().get_sensor(FUSION_SENSOR); if (!m_accel_sensor || !m_fusion_sensor) { - ERR("Failed to load sensors, accel: 0x%x, fusion: 0x%x", + _E("Failed to load sensors, accel: 0x%x, fusion: 0x%x", m_accel_sensor, m_fusion_sensor); return false; } - INFO("%s is created!\n", sensor_base::get_name()); + _I("%s is created!\n", sensor_base::get_name()); return true; } diff --git a/src/server/sensor_base.cpp b/src/server/sensor_base.cpp index cee362f..654ac97 100644 --- a/src/server/sensor_base.cpp +++ b/src/server/sensor_base.cpp @@ -106,14 +106,14 @@ bool sensor_base::start() if (m_client == 1) { if (!on_start()) { - ERR("[%s] sensor failed to start", get_name()); + _E("[%s] sensor failed to start", get_name()); return false; } m_started = true; } - INFO("[%s] sensor started, #client = %d", get_name(), m_client); + _I("[%s] sensor started, #client = %d", get_name(), m_client); return true; } @@ -126,14 +126,14 @@ bool sensor_base::stop(void) if (m_client == 0) { if (!on_stop()) { - ERR("[%s] sensor faild to stop", get_name()); + _E("[%s] sensor faild to stop", get_name()); return false; } m_started = false; } - INFO("[%s] sensor stopped, #client = %d", get_name(), m_client); + _I("[%s] sensor stopped, #client = %d", get_name(), m_client); return true; } @@ -159,7 +159,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%llx] is changed from %dms to %dms" + _I("Min interval for sensor[0x%llx] is changed from %dms to %dms" " by%sclient[%d] adding interval", get_id(), prev_min, cur_min, is_processor ? " processor " : " ", client_id); @@ -183,14 +183,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%llx] by%sclient[%d] deleting interval, " + _I("No interval for sensor[0x%llx] by%sclient[%d] deleting interval, " "so set to default %dms", get_id(), is_processor ? " processor " : " ", client_id, POLL_1HZ_MS); set_interval(POLL_1HZ_MS); } else if (cur_min != prev_min) { - INFO("Min interval for sensor[0x%llx] is changed from %dms to %dms" + _I("Min interval for sensor[0x%llx] is changed from %dms to %dms" " by%sclient[%d] deleting interval", get_id(), prev_min, cur_min, is_processor ? " processor " : " ", client_id); @@ -222,7 +222,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%llx] is changed from %dms to %dms by client[%d] adding latency", + _I("Max latency for sensor[0x%llx] is changed from %dms to %dms by client[%d] adding latency", get_id(), prev_max, cur_max, client_id); set_batch_latency(cur_max); } @@ -243,12 +243,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%llx] by client[%d] deleting latency, so set to default 0 ms", + _I("No latency for sensor[0x%llx] by client[%d] deleting latency, so set to default 0 ms", get_id(), client_id); set_batch_latency(0); } else if (cur_max != prev_max) { - INFO("Max latency for sensor[0x%llx] is changed from %dms to %dms by client[%d] deleting latency", + _I("Max latency for sensor[0x%llx] is changed from %dms to %dms by client[%d] deleting latency", get_id(), prev_max, cur_max, client_id); set_batch_latency(cur_max); @@ -278,7 +278,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%llx] is changed from %d to %d by client[%d] adding wakeup", + _I("Wakeup for sensor[0x%llx] is changed from %d to %d by client[%d] adding wakeup", get_id(), prev_wakeup, cur_wakeup, client_id); set_wakeup(SENSOR_WAKEUP_ON); } @@ -299,7 +299,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%llx] is changed from %d to %d by client[%d] deleting wakeup", + _I("Wakeup for sensor[0x%llx] is changed from %d to %d by client[%d] deleting wakeup", get_id(), prev_wakeup, cur_wakeup, client_id); set_wakeup(SENSOR_WAKEUP_OFF); } @@ -375,7 +375,7 @@ unsigned long long sensor_base::get_timestamp(void) unsigned long long sensor_base::get_timestamp(timeval *t) { if (!t) { - ERR("t is NULL"); + _E("t is NULL"); return 0; } diff --git a/src/server/sensor_event_dispatcher.cpp b/src/server/sensor_event_dispatcher.cpp index f29a668..598f172 100644 --- a/src/server/sensor_event_dispatcher.cpp +++ b/src/server/sensor_event_dispatcher.cpp @@ -45,21 +45,21 @@ sensor_event_dispatcher& sensor_event_dispatcher::get_instance() bool sensor_event_dispatcher::run(void) { - INFO("Starting Event Dispatcher\n"); + _I("Starting Event Dispatcher\n"); if (!m_accept_socket.create(SOCK_SEQPACKET)) { - ERR("Listener Socket Creation failed in Server \n"); + _E("Listener Socket Creation failed in Server \n"); return false; } if(!m_accept_socket.bind(EVENT_CHANNEL_PATH)) { - ERR("Listener Socket Binding failed in Server \n"); + _E("Listener Socket Binding failed in Server \n"); m_accept_socket.close(); return false; } if(!m_accept_socket.listen(MAX_PENDING_CONNECTION)) { - ERR("Socket Listen failed in Server \n"); + _E("Socket Listen failed in Server \n"); return false; } @@ -81,7 +81,7 @@ void sensor_event_dispatcher::accept_event_channel(csocket client_socket) client_socket.set_connection_mode(); if (client_socket.recv(&client_id, sizeof(client_id)) <= 0) { - ERR("Failed to receive client id on socket fd[%d]", client_socket.get_socket_fd()); + _E("Failed to receive client id on socket fd[%d]", client_socket.get_socket_fd()); return; } @@ -90,7 +90,7 @@ void sensor_event_dispatcher::accept_event_channel(csocket client_socket) AUTOLOCK(m_mutex); if(!get_client_info_manager().set_event_socket(client_id, client_socket)) { - ERR("Failed to store event socket[%d] for %s", client_socket.get_socket_fd(), + _E("Failed to store event socket[%d] for %s", client_socket.get_socket_fd(), client_info_manager.get_client_info(client_id)); return; } @@ -98,11 +98,11 @@ void sensor_event_dispatcher::accept_event_channel(csocket client_socket) event_channel_ready.magic = EVENT_CHANNEL_MAGIC; event_channel_ready.client_id = client_id; - INFO("Event channel is accepted for %s on socket[%d]", + _I("Event channel is accepted for %s on socket[%d]", client_info_manager.get_client_info(client_id), client_socket.get_socket_fd()); if (client_socket.send(&event_channel_ready, sizeof(event_channel_ready)) <= 0) { - ERR("Failed to send event_channel_ready packet to %s on socket fd[%d]", + _E("Failed to send event_channel_ready packet to %s on socket fd[%d]", client_info_manager.get_client_info(client_id), client_socket.get_socket_fd()); return; } @@ -110,17 +110,17 @@ void sensor_event_dispatcher::accept_event_channel(csocket client_socket) void sensor_event_dispatcher::accept_connections(void) { - INFO("Event channel acceptor is started.\n"); + _I("Event channel acceptor is started.\n"); while (true) { csocket client_socket; if (!m_accept_socket.accept(client_socket)) { - ERR("Accepting socket failed in Server \n"); + _E("Accepting socket failed in Server \n"); continue; } - INFO("New client connected (socket_fd : %d)\n", client_socket.get_socket_fd()); + _I("New client connected (socket_fd : %d)\n", client_socket.get_socket_fd()); thread event_channel_creator(&sensor_event_dispatcher::accept_event_channel, this, client_socket); event_channel_creator.detach(); @@ -133,7 +133,7 @@ void sensor_event_dispatcher::dispatch_event(void) vector v_sensor_events(MAX_SYNTH_PER_SENSOR); - INFO("Event Dispatcher started"); + _I("Event Dispatcher started"); while (true) { void *seed_event = get_event_queue().pop(); @@ -154,7 +154,7 @@ void sensor_event_dispatcher::dispatch_event(void) for (int i = 0; i < synthesized_cnt; ++i) { sensor_event_t *v_event = (sensor_event_t*)malloc(sizeof(sensor_event_t)); if (!v_event) { - ERR("Failed to allocate memory"); + _E("Failed to allocate memory"); continue; } @@ -198,7 +198,7 @@ void sensor_event_dispatcher::send_sensor_events(vector &events) event = (void *)malloc(length); if (!event) { - ERR("Failed to allocate memory"); + _E("Failed to allocate memory"); return; } @@ -216,9 +216,9 @@ void sensor_event_dispatcher::send_sensor_events(vector &events) bool ret = (client_socket.send(event, length) > 0); if (ret) - DBG("Event[0x%x] sent to %s on socket[%d]", event_type, client_info_manager.get_client_info(*it_client_id), client_socket.get_socket_fd()); + _D("Event[0x%x] sent to %s on socket[%d]", event_type, client_info_manager.get_client_info(*it_client_id), client_socket.get_socket_fd()); else - ERR("Failed to send event[0x%x] to %s on socket[%d]", event_type, client_info_manager.get_client_info(*it_client_id), client_socket.get_socket_fd()); + _E("Failed to send event[0x%x] to %s on socket[%d]", event_type, client_info_manager.get_client_info(*it_client_id), client_socket.get_socket_fd()); ++it_client_id; } @@ -298,7 +298,7 @@ void sensor_event_dispatcher::request_last_event(int client_id, sensor_id_t sens if (client_info_manager.get_registered_events(client_id, sensor_id, event_vec)) { if (!client_info_manager.get_event_socket(client_id, client_socket)) { - ERR("Failed to get event socket from %s", + _E("Failed to get event socket from %s", client_info_manager.get_client_info(client_id)); return; } @@ -308,10 +308,10 @@ void sensor_event_dispatcher::request_last_event(int client_id, sensor_id_t sens sensor_event_t event; if (is_record_event(*it_event) && get_last_event(*it_event, event)) { if (client_socket.send(&event, sizeof(event)) > 0) - INFO("Send the last event[0x%x] to %s on socket[%d]", event.event_type, + _I("Send the last event[0x%x] to %s on socket[%d]", event.event_type, client_info_manager.get_client_info(client_id), client_socket.get_socket_fd()); else - ERR("Failed to send event[0x%x] to %s on socket[%d]", event.event_type, + _E("Failed to send event[0x%x] to %s on socket[%d]", event.event_type, client_info_manager.get_client_info(client_id), client_socket.get_socket_fd()); } ++it_event; @@ -325,7 +325,7 @@ bool sensor_event_dispatcher::add_active_virtual_sensor(virtual_sensor * sensor) AUTOLOCK(m_active_virtual_sensors_mutex); if (has_active_virtual_sensor(sensor)) { - ERR("[%s] sensor is already added on active virtual sensors", sensor->get_name()); + _E("[%s] sensor is already added on active virtual sensors", sensor->get_name()); return false; } @@ -341,7 +341,7 @@ bool sensor_event_dispatcher::delete_active_virtual_sensor(virtual_sensor * sens auto it_v_sensor = find(m_active_virtual_sensors.begin(), m_active_virtual_sensors.end(), sensor); if (it_v_sensor == m_active_virtual_sensors.end()) { - ERR("Fail to delete non-existent [%s] sensor on active virtual sensors", sensor->get_name()); + _E("Fail to delete non-existent [%s] sensor on active virtual sensors", sensor->get_name()); return false; } diff --git a/src/server/sensor_event_poller.cpp b/src/server/sensor_event_poller.cpp index 0070db3..62b26b9 100644 --- a/src/server/sensor_event_poller.cpp +++ b/src/server/sensor_event_poller.cpp @@ -105,7 +105,7 @@ bool sensor_event_poller::read_fd(int fd, std::vector &ids) sensor = dynamic_cast(it->second); if (!sensor) { - ERR("Failed to get sensor"); + _E("Failed to get sensor"); return false; } diff --git a/src/server/sensor_event_queue.cpp b/src/server/sensor_event_queue.cpp index 79b8baf..c26e83e 100644 --- a/src/server/sensor_event_queue.cpp +++ b/src/server/sensor_event_queue.cpp @@ -32,7 +32,7 @@ void sensor_event_queue::push_internal(void *event) bool wake = m_queue.empty(); if (m_queue.size() >= QUEUE_FULL_SIZE) { - ERR("Queue is full, drop it!"); + _E("Queue is full, drop it!"); free(event); } else m_queue.push(event); diff --git a/src/server/sensor_loader.cpp b/src/server/sensor_loader.cpp index 43d0395..7a90ffb 100644 --- a/src/server/sensor_loader.cpp +++ b/src/server/sensor_loader.cpp @@ -55,12 +55,12 @@ bool sensor_loader::load_devices(const string &path, vector &de int size; sensor_device_t *_devices = NULL; - INFO("load device: [%s]", path.c_str()); + _I("load device: [%s]", path.c_str()); void *_handle = dlopen(path.c_str(), RTLD_NOW); if (!_handle) { - ERR("Failed to dlopen(%s), dlerror : %s", path.c_str(), dlerror()); + _E("Failed to dlopen(%s), dlerror : %s", path.c_str(), dlerror()); return false; } @@ -69,7 +69,7 @@ bool sensor_loader::load_devices(const string &path, vector &de create_t create_devices = (create_t) dlsym(_handle, "create"); if (!create_devices) { - ERR("Failed to find symbols in %s", path.c_str()); + _E("Failed to find symbols in %s", path.c_str()); dlclose(_handle); return false; } @@ -77,7 +77,7 @@ bool sensor_loader::load_devices(const string &path, vector &de size = create_devices(&_devices); if (!_devices) { - ERR("Failed to create devices, path is %s\n", path.c_str()); + _E("Failed to create devices, path is %s\n", path.c_str()); dlclose(_handle); return false; } @@ -103,7 +103,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); + _E("Memory allocation failed[%s]", handle.name); return NULL; } @@ -134,7 +134,7 @@ bool sensor_loader::load_physical_sensors(std::vector &devices) std::shared_ptr sensor_ptr(sensor); m_sensors.insert(std::make_pair((sensor_type_t)(handles[i].type), sensor_ptr)); - INFO("inserted [%s] sensor", sensor->get_name()); + _I("inserted [%s] sensor", sensor->get_name()); } } @@ -186,15 +186,15 @@ void sensor_loader::load_virtual_sensor(const char *name) try { instance = new _sensor; } catch (std::exception &e) { - ERR("Failed to create %s sensor, exception: %s", name, e.what()); + _E("Failed to create %s sensor, exception: %s", name, e.what()); return; } catch (int err) { - ERR("Failed to create %s sensor err: %d, cause: %s", name, err, strerror(err)); + _E("Failed to create %s sensor err: %d, cause: %s", name, err, strerror(err)); return; } if (!instance->init()) { - ERR("Failed to init %s", name); + _E("Failed to init %s", name); delete instance; return; } @@ -216,7 +216,7 @@ void sensor_loader::load_virtual_sensors(void) void sensor_loader::show_sensor_info(void) { - INFO("========== Loaded sensor information ==========\n"); + _I("========== Loaded sensor information ==========\n"); int index = 0; @@ -227,12 +227,12 @@ void sensor_loader::show_sensor_info(void) sensor_info info; sensor->get_sensor_info(info); - INFO("No:%d [%s]\n", ++index, sensor->get_name()); + _I("No:%d [%s]\n", ++index, sensor->get_name()); info.show(); it++; } - INFO("===============================================\n"); + _I("===============================================\n"); } bool sensor_loader::get_paths_from_dir(const string &dir_path, vector &plugin_paths) @@ -243,7 +243,7 @@ bool sensor_loader::get_paths_from_dir(const string &dir_path, vector &p dir = opendir(dir_path.c_str()); if (!dir) { - ERR("Failed to open dir: %s", dir_path.c_str()); + _E("Failed to open dir: %s", dir_path.c_str()); return false; } diff --git a/src/server/sensor_usage.cpp b/src/server/sensor_usage.cpp index cc114ff..6f604fa 100644 --- a/src/server/sensor_usage.cpp +++ b/src/server/sensor_usage.cpp @@ -40,7 +40,7 @@ bool sensor_usage::register_event(unsigned int event_type) auto it_event = find(m_reg_events.begin(), m_reg_events.end(), event_type); if (it_event != m_reg_events.end()) { - ERR("Event[0x%x] is already registered", event_type); + _E("Event[0x%x] is already registered", event_type); return false; } @@ -53,7 +53,7 @@ bool sensor_usage::unregister_event(unsigned int event_type) auto it_event = find(m_reg_events.begin(), m_reg_events.end(), event_type); if (it_event == m_reg_events.end()) { - ERR("Event[0x%x] is not found",event_type); + _E("Event[0x%x] is not found",event_type); return false; } @@ -67,7 +67,7 @@ bool sensor_usage::is_event_registered(unsigned int event_type) auto it_event = find (m_reg_events.begin(), m_reg_events.end(), event_type); if (it_event == m_reg_events.end()){ - DBG("Event[0x%x] is not registered",event_type); + _D("Event[0x%x] is not registered",event_type); return false; } diff --git a/src/server/server.cpp b/src/server/server.cpp index ad28539..39900bc 100644 --- a/src/server/server.cpp +++ b/src/server/server.cpp @@ -61,22 +61,22 @@ void server::accept_client(void) { command_worker *cmd_worker; - INFO("Client acceptor is started"); + _I("Client acceptor is started"); while (true) { csocket client_command_socket; if (!m_client_accep_socket.accept(client_command_socket)) { - ERR("Failed to accept connection request from a client"); + _E("Failed to accept connection request from a client"); continue; } - DBG("New client (socket_fd : %d) connected", client_command_socket.get_socket_fd()); + _D("New client (socket_fd : %d) connected", client_command_socket.get_socket_fd()); cmd_worker = new(std::nothrow) command_worker(client_command_socket); if (!cmd_worker) { - ERR("Failed to allocate memory"); + _E("Failed to allocate memory"); continue; } @@ -87,12 +87,12 @@ void server::accept_client(void) void server::poll_event(void) { - INFO("Event poller is started"); + _I("Event poller is started"); sensor_event_poller poller; if (!poller.poll()) { - ERR("Failed to poll event"); + _E("Failed to poll event"); return; } } @@ -107,23 +107,23 @@ void server::run(void) sock_fd = get_systemd_socket(COMMAND_CHANNEL_PATH); if (sock_fd >= 0) { - INFO("Succeeded to get systemd socket(%d)", sock_fd); + _I("Succeeded to get systemd socket(%d)", sock_fd); m_client_accep_socket = csocket(sock_fd); } else { - ERR("Failed to get systemd socket, create it by myself!"); + _E("Failed to get systemd socket, create it by myself!"); if (!m_client_accep_socket.create(SOCK_STREAM)) { - ERR("Failed to create command channel"); + _E("Failed to create command channel"); return; } if(!m_client_accep_socket.bind(COMMAND_CHANNEL_PATH)) { - ERR("Failed to bind command channel"); + _E("Failed to bind command channel"); m_client_accep_socket.close(); return; } if(!m_client_accep_socket.listen(MAX_PENDING_CONNECTION)) { - ERR("Failed to listen command channel"); + _E("Failed to listen command channel"); return; } } diff --git a/src/server/virtual_sensor_config.cpp b/src/server/virtual_sensor_config.cpp index 1741239..ae23c1c 100644 --- a/src/server/virtual_sensor_config.cpp +++ b/src/server/virtual_sensor_config.cpp @@ -50,9 +50,9 @@ virtual_sensor_config& virtual_sensor_config::get_instance(void) inst.load_config(VIRTUAL_SENSOR_CONFIG_FILE_PATH); inst.get_device_id(); if (!inst.m_device_id.empty()) - INFO("Device ID = %s", inst.m_device_id.c_str()); + _I("Device ID = %s", inst.m_device_id.c_str()); else - ERR("Failed to get Device ID"); + _E("Failed to get Device ID"); load_done = true; } @@ -64,24 +64,24 @@ bool virtual_sensor_config::load_config(const string& config_path) xmlDocPtr doc; xmlNodePtr cur; - DBG("virtual_sensor_config::load_config(\"%s\") is called!\n",config_path.c_str()); + _D("virtual_sensor_config::load_config(\"%s\") is called!\n",config_path.c_str()); doc = xmlParseFile(config_path.c_str()); if (doc == NULL) { - ERR("There is no %s\n",config_path.c_str()); + _E("There is no %s\n",config_path.c_str()); return false; } cur = xmlDocGetRootElement(doc); if(cur == NULL) { - ERR("There is no root element in %s\n",config_path.c_str()); + _E("There is no root element in %s\n",config_path.c_str()); xmlFreeDoc(doc); return false; } if(xmlStrcmp(cur->name, (const xmlChar *)ROOT_ELEMENT)) { - ERR("Wrong type document: there is no [%s] root element in %s\n",ROOT_ELEMENT,config_path.c_str()); + _E("Wrong type document: there is no [%s] root element in %s\n",ROOT_ELEMENT,config_path.c_str()); xmlFreeDoc(doc); return false; } @@ -108,7 +108,7 @@ bool virtual_sensor_config::load_config(const string& config_path) //insert device to device_list m_virtual_sensor_configs[device_type]; - DBG("\n",device_type.c_str()); + _D("\n",device_type.c_str()); virtual_sensor_node_ptr = device_node_ptr->xmlChildrenNode; @@ -120,7 +120,7 @@ bool virtual_sensor_config::load_config(const string& config_path) } m_virtual_sensor_configs[device_type][(const char*)virtual_sensor_node_ptr->name]; - DBG("<%s>\n",device_type.c_str(),(const char*)virtual_sensor_node_ptr->name); + _D("<%s>\n",device_type.c_str(),(const char*)virtual_sensor_node_ptr->name); element_node_ptr = virtual_sensor_node_ptr->xmlChildrenNode; while (element_node_ptr != NULL) { @@ -132,7 +132,7 @@ bool virtual_sensor_config::load_config(const string& config_path) //insert Element to Model m_virtual_sensor_configs[device_type][(const char*)virtual_sensor_node_ptr->name][(const char*)element_node_ptr->name]; - DBG("<%s><%s>\n",device_type.c_str(),(const char*)virtual_sensor_node_ptr->name,(const char*)element_node_ptr->name); + _D("<%s><%s>\n",device_type.c_str(),(const char*)virtual_sensor_node_ptr->name,(const char*)element_node_ptr->name); attr_ptr = element_node_ptr->properties; while (attr_ptr != NULL) { @@ -145,14 +145,14 @@ bool virtual_sensor_config::load_config(const string& config_path) //insert attribute to Element m_virtual_sensor_configs[device_type][(const char*)virtual_sensor_node_ptr->name][(const char*)element_node_ptr->name][key]=value; - DBG("<%s><%s \"%s\"=\"%s\">\n",device_type.c_str(),(const char*)virtual_sensor_node_ptr->name,(const char*)element_node_ptr->name,key.c_str(),value.c_str()); + _D("<%s><%s \"%s\"=\"%s\">\n",device_type.c_str(),(const char*)virtual_sensor_node_ptr->name,(const char*)element_node_ptr->name,key.c_str(),value.c_str()); attr_ptr = attr_ptr->next; } element_node_ptr = element_node_ptr->next; } - DBG("\n"); + _D("\n"); virtual_sensor_node_ptr = virtual_sensor_node_ptr->next; } @@ -168,37 +168,37 @@ bool virtual_sensor_config::get(const string& sensor_type, const string& element auto it_device_list = m_virtual_sensor_configs.find(m_device_id); if (it_device_list == m_virtual_sensor_configs.end()) { - ERR("There is no <%s> device\n",m_device_id.c_str()); + _E("There is no <%s> device\n",m_device_id.c_str()); m_device_id = DEFAULT_DEVICE; it_device_list = m_virtual_sensor_configs.find(m_device_id); if (it_device_list == m_virtual_sensor_configs.end()) { - ERR("There is no Default device\n"); + _E("There is no Default device\n"); return false; } - INFO("m_device_id is set to Default\n"); + _I("m_device_id is set to Default\n"); } auto it_virtual_sensor_list = it_device_list->second.find(sensor_type); if (it_virtual_sensor_list == it_device_list->second.end()) { - ERR("There is no <%s> sensor\n",sensor_type.c_str()); + _E("There is no <%s> sensor\n",sensor_type.c_str()); return false; } auto it_element = it_virtual_sensor_list->second.find(element); if (it_element == it_virtual_sensor_list->second.end()) { - ERR("There is no <%s><%s> element\n",sensor_type.c_str(),element.c_str()); + _E("There is no <%s><%s> element\n",sensor_type.c_str(),element.c_str()); return false; } auto it_attr = it_element->second.find(attr); if (it_attr == it_element->second.end()) { - DBG("There is no <%s><%s \"%s\">\n",sensor_type.c_str(),element.c_str(),attr.c_str()); + _D("There is no <%s><%s \"%s\">\n",sensor_type.c_str(),element.c_str(),attr.c_str()); return false; } @@ -269,7 +269,7 @@ bool virtual_sensor_config::get(const string& sensor_type, const string& element } else { - DBG("Count value not supported.\n"); + _D("Count value not supported.\n"); } return false; @@ -301,7 +301,7 @@ bool virtual_sensor_config::get(const string& sensor_type, const string& element } else { - DBG("Count value not supported.\n"); + _D("Count value not supported.\n"); } return false; diff --git a/src/server/worker_thread.cpp b/src/server/worker_thread.cpp index e6e7d4a..2590588 100644 --- a/src/server/worker_thread.cpp +++ b/src/server/worker_thread.cpp @@ -41,7 +41,7 @@ bool worker_thread::transition_function(trans_func_index index) { if (m_trans_func[index] != NULL) { if(!m_trans_func[index](m_context)) { - ERR("Transition[%d] function returning false", index); + _E("Transition[%d] function returning false", index); return false; } } @@ -61,7 +61,7 @@ bool worker_thread::start(void) lock l(m_mutex); if (m_state == WORKER_STATE_WORKING) { - INFO("Worker thread is already working"); + _I("Worker thread is already working"); return true; } @@ -79,7 +79,7 @@ bool worker_thread::start(void) return true; } - ERR("Failed to start, because current state(%d) is not for START", m_state); + _E("Failed to start, because current state(%d) is not for START", m_state); return false; } @@ -89,7 +89,7 @@ bool worker_thread::stop(void) lock l(m_mutex); if (m_state == WORKER_STATE_STOPPED) { - INFO("Worker thread is already stopped"); + _I("Worker thread is already stopped"); return true; } @@ -102,7 +102,7 @@ bool worker_thread::stop(void) return true; } - ERR("Failed to stop, because current state(%d) is not for STOP", m_state); + _E("Failed to stop, because current state(%d) is not for STOP", m_state); return false; } @@ -111,7 +111,7 @@ bool worker_thread::pause(void) lock l(m_mutex); if (m_state == WORKER_STATE_PAUSED) { - INFO("Worker thread is already paused"); + _I("Worker thread is already paused"); return true; } @@ -120,7 +120,7 @@ bool worker_thread::pause(void) return true; } - ERR("Failed to pause, because current state(%d) is not for PAUSE", m_state); + _E("Failed to pause, because current state(%d) is not for PAUSE", m_state); return false; @@ -131,7 +131,7 @@ bool worker_thread::resume(void) lock l(m_mutex); if (m_state == WORKER_STATE_WORKING) { - INFO("Worker thread is already working"); + _I("Worker thread is already working"); return true; } @@ -141,7 +141,7 @@ bool worker_thread::resume(void) return true; } - ERR("Failed to resume, because current state(%d) is not for RESUME", m_state); + _E("Failed to resume, because current state(%d) is not for RESUME", m_state); return false; } @@ -153,7 +153,7 @@ bool worker_thread::resume(void) void worker_thread::main(void) { - DBG("Worker thread(0x%x) is created", std::this_thread::get_id()); + _D("Worker thread(0x%x) is created", std::this_thread::get_id()); transition_function(STARTED); @@ -164,7 +164,7 @@ void worker_thread::main(void) if (state == WORKER_STATE_WORKING) { if (!transition_function(WORKING)) { m_state = WORKER_STATE_STOPPED; - DBG("Worker thread(0x%x) exits from working state", std::this_thread::get_id()); + _D("Worker thread(0x%x) exits from working state", std::this_thread::get_id()); m_thread_created = false; transition_function(STOPPED); break; @@ -177,12 +177,12 @@ void worker_thread::main(void) if (m_state == WORKER_STATE_PAUSED) { transition_function(PAUSED); - DBG("Worker thread(0x%x) is paused", std::this_thread::get_id()); + _D("Worker thread(0x%x) is paused", std::this_thread::get_id()); m_cond_working.wait(u); if (m_state == WORKER_STATE_WORKING) { transition_function(RESUMED); - DBG("Worker thread(0x%x) is resumed", std::this_thread::get_id()); + _D("Worker thread(0x%x) is resumed", std::this_thread::get_id()); } else if (m_state == WORKER_STATE_STOPPED) { m_thread_created = false; transition_function(STOPPED); @@ -194,7 +194,7 @@ void worker_thread::main(void) break; } } - INFO("Worker thread(0x%x)'s main is terminated", std::this_thread::get_id()); + _I("Worker thread(0x%x)'s main is terminated", std::this_thread::get_id()); } void worker_thread::set_started(trans_func_t func) diff --git a/src/shared/cbase_lock.cpp b/src/shared/cbase_lock.cpp index 2b085e3..bc85c19 100644 --- a/src/shared/cbase_lock.cpp +++ b/src/shared/cbase_lock.cpp @@ -64,7 +64,7 @@ void cbase_lock::lock(lock_type type, const char* expr, const char *module, cons lock_waiting_start_time = MICROSECONDS(sv); pthread_mutex_lock(&m_history_mutex); - INFO("%s is waiting for getting %s(0x%x) owned in %s", + _I("%s is waiting for getting %s(0x%x) owned in %s", m_curent_info, expr, this, m_owner_info); pthread_mutex_unlock(&m_history_mutex); @@ -82,7 +82,7 @@ void cbase_lock::lock(lock_type type, const char* expr, const char *module, cons waiting_time = lock_acquired_time - lock_waiting_start_time; pthread_mutex_lock(&m_history_mutex); - INFO("%s acquires lock after waiting %lluus, %s(0x%x) was previously owned in %s", + _I("%s acquires lock after waiting %lluus, %s(0x%x) was previously owned in %s", m_curent_info, waiting_time, expr, this, m_owner_info); snprintf(m_owner_info, OWNER_INFO_LEN, "%s", m_curent_info); pthread_mutex_unlock(&m_history_mutex); diff --git a/src/shared/csocket.cpp b/src/shared/csocket.cpp index 5fbb2c1..a58b22a 100644 --- a/src/shared/csocket.cpp +++ b/src/shared/csocket.cpp @@ -68,7 +68,7 @@ bool csocket::create(int sock_type) m_sock_fd = socket(AF_UNIX, sock_type, 0); if (!is_valid()) { - ERR("Failed to create socket for %s, errno : %d , errstr : %s ", + _E("Failed to create socket for %s, errno : %d , errstr : %s ", get_client_name(), errno, strerror(errno)); return false; } @@ -84,14 +84,14 @@ bool csocket::bind (const char *sock_path) mode_t socket_mode; if (!is_valid()) { - ERR("%s's socket is invalid", get_client_name()); + _E("%s's socket is invalid", get_client_name()); return false; } if((fsetxattr(m_sock_fd, "security.SMACK64IPOUT", "@", 2, 0)) < 0) { if(errno != EOPNOTSUPP) { close(); - ERR("security.SMACK64IPOUT error = [%d][%s]\n", errno, strerror(errno) ); + _E("security.SMACK64IPOUT error = [%d][%s]\n", errno, strerror(errno) ); return false; } } @@ -99,7 +99,7 @@ bool csocket::bind (const char *sock_path) if((fsetxattr(m_sock_fd, "security.SMACK64IPIN", "*", 2, 0)) < 0) { if(errno != EOPNOTSUPP) { close(); - ERR("security.SMACK64IPIN error = [%d][%s]\n", errno, strerror(errno) ); + _E("security.SMACK64IPIN error = [%d][%s]\n", errno, strerror(errno) ); return false; } } @@ -116,14 +116,14 @@ bool csocket::bind (const char *sock_path) length = strlen(m_addr.sun_path) + sizeof(m_addr.sun_family); if (::bind(m_sock_fd, (struct sockaddr *)&m_addr, length) < 0) { - ERR("Binding failed for socket(%d), errno : %d , errstr : %s", m_sock_fd, errno, strerror(errno)); + _E("Binding failed for socket(%d), errno : %d , errstr : %s", m_sock_fd, errno, strerror(errno)); close(); return false; } socket_mode = ( S_IRWXU | S_IRWXG | S_IRWXO ); if (chmod(sock_path, socket_mode) < 0) { - ERR("chmod failed for socket(%d), errno : %d , errstr : %s", m_sock_fd, errno, strerror(errno)); + _E("chmod failed for socket(%d), errno : %d , errstr : %s", m_sock_fd, errno, strerror(errno)); close(); return false; } @@ -134,12 +134,12 @@ bool csocket::bind (const char *sock_path) bool csocket::listen(const int max_connections) { if (!is_valid()) { - ERR("Socket(%d) is invalid", m_sock_fd); + _E("Socket(%d) is invalid", m_sock_fd); return false; } if (::listen(m_sock_fd, max_connections) < 0) { - ERR("Listening failed for socket(%d), errno : %d , errstr : %s", m_sock_fd, errno, strerror(errno)); + _E("Listening failed for socket(%d), errno : %d , errstr : %s", m_sock_fd, errno, strerror(errno)); close(); return false; } @@ -161,7 +161,7 @@ bool csocket::accept(csocket& client_socket) const } while (err == EINTR); if (!client_socket.is_valid()) { - ERR("Accept failed for socket(%d), errno : %d , errstr : %s", m_sock_fd, errno, strerror(errno)); + _E("Accept failed for socket(%d), errno : %d , errstr : %s", m_sock_fd, errno, strerror(errno)); return false; } @@ -178,7 +178,7 @@ ssize_t csocket::send_for_seqpacket(const void *buffer, size_t size) const } while (err == EINTR); if (err) { - ERR("send(%d, 0x%x, %d, 0x%x) = %d cause = %s(%d)", + _E("send(%d, 0x%x, %d, 0x%x) = %d cause = %s(%d)", m_sock_fd, buffer, size, m_send_flags, len, strerror(errno), errno); } @@ -195,7 +195,7 @@ ssize_t csocket::recv_for_seqpacket(void* buffer, size_t size) const if (len > 0) { err = 0; } else if (len == 0) { - ERR("recv(%d, 0x%p , %d) = %d, because the peer performed shutdown!", + _E("recv(%d, 0x%p , %d) = %d, because the peer performed shutdown!", m_sock_fd, buffer, size, len); err = 1; } else { @@ -204,13 +204,13 @@ ssize_t csocket::recv_for_seqpacket(void* buffer, size_t size) const } while (err == EINTR); if ((err == EAGAIN) || (err == EWOULDBLOCK)) { - DBG("recv(%d, 0x%x, %d, 0x%x) = %d cause = %s(%d)", + _D("recv(%d, 0x%x, %d, 0x%x) = %d cause = %s(%d)", m_sock_fd, buffer, size, m_recv_flags, len, strerror(errno), errno); return 0; } if (err) { - ERR("recv(%d, 0x%x, %d, 0x%x) = %d cause = %s(%d)", + _E("recv(%d, 0x%x, %d, 0x%x) = %d cause = %s(%d)", m_sock_fd, buffer, size, m_recv_flags, len, strerror(errno), errno); } @@ -231,7 +231,7 @@ ssize_t csocket::send_for_stream(const void *buffer, size_t size) const total_sent_size += len; err = 0; } else { - ERR("send(%d, 0x%p + %d, %d - %d) = %d, error: %s(%d) for %s", + _E("send(%d, 0x%p + %d, %d - %d) = %d, error: %s(%d) for %s", m_sock_fd, buffer, total_sent_size, size, total_sent_size, len, strerror(errno), errno, get_client_name()); @@ -257,12 +257,12 @@ ssize_t csocket::recv_for_stream(void* buffer, size_t size) const if (len > 0) { total_recv_size += len; } else if (len == 0) { - ERR("recv(%d, 0x%p + %d, %d - %d) = %d, because the peer of %s performed shutdown!", + _E("recv(%d, 0x%p + %d, %d - %d) = %d, because the peer of %s performed shutdown!", m_sock_fd, buffer, total_recv_size, size, total_recv_size, len, get_client_name()); err = 1; break; } else { - ERR("recv(%d, 0x%p + %d, %d - %d) = %d, error: %s(%d) for %s", + _E("recv(%d, 0x%p + %d, %d - %d) = %d, error: %s(%d) for %s", m_sock_fd, buffer, total_recv_size, size, total_recv_size, len, strerror(errno), errno, get_client_name()); @@ -302,7 +302,7 @@ bool csocket::connect(const char *sock_path) bool prev_blocking_mode; if (!is_valid()) { - ERR("%s's socket is invalid", get_client_name()); + _E("%s's socket is invalid", get_client_name()); return false; } @@ -318,7 +318,7 @@ bool csocket::connect(const char *sock_path) addr_len = strlen(m_addr.sun_path) + sizeof(m_addr.sun_family); if (::connect(m_sock_fd,(sockaddr *) &m_addr, addr_len) < 0) { - ERR("connect error: %s sock_fd: %d\n for %s", strerror(errno), m_sock_fd, get_client_name()); + _E("connect error: %s sock_fd: %d\n for %s", strerror(errno), m_sock_fd, get_client_name()); return false; } @@ -332,17 +332,17 @@ bool csocket::connect(const char *sock_path) ret = select(m_sock_fd + 1, NULL, &write_fds, NULL, &tv); if (ret == -1) { - ERR("select error: %s sock_fd: %d\n for %s", strerror(errno), m_sock_fd, get_client_name()); + _E("select error: %s sock_fd: %d\n for %s", strerror(errno), m_sock_fd, get_client_name()); close(); return false; } else if (!ret) { - ERR("select timeout: %d seconds elapsed for %s", tv.tv_sec, get_client_name()); + _E("select timeout: %d seconds elapsed for %s", tv.tv_sec, get_client_name()); close(); return false; } if (!FD_ISSET(m_sock_fd, &write_fds)) { - ERR("select failed for %s, nothing to write, m_sock_fd : %d", get_client_name(), m_sock_fd); + _E("select failed for %s, nothing to write, m_sock_fd : %d", get_client_name(), m_sock_fd); close(); return false; } @@ -351,14 +351,14 @@ bool csocket::connect(const char *sock_path) socklen_t len = sizeof(so_error); if (getsockopt(m_sock_fd, SOL_SOCKET, SO_ERROR, &so_error, &len) == -1) { - ERR("getsockopt failed for %s, m_sock_fd : %d, errno : %d , errstr : %s", + _E("getsockopt failed for %s, m_sock_fd : %d, errno : %d , errstr : %s", get_client_name(), m_sock_fd, errno, strerror(errno)); close(); return false; } if (so_error) { - ERR("SO_ERROR occurred for %s, m_sock_fd : %d, so_error : %d", + _E("SO_ERROR occurred for %s, m_sock_fd : %d, so_error : %d", get_client_name(), m_sock_fd, so_error); close(); return false; @@ -377,7 +377,7 @@ bool csocket::set_blocking_mode(bool blocking) flags = fcntl(m_sock_fd, F_GETFL); if (flags == -1) { - ERR("fcntl(F_GETFL) failed for %s, m_sock_fd: %d, errno : %d , errstr : %s", get_client_name(), m_sock_fd, errno, strerror(errno)); + _E("fcntl(F_GETFL) failed for %s, m_sock_fd: %d, errno : %d , errstr : %s", get_client_name(), m_sock_fd, errno, strerror(errno)); return false; } @@ -386,7 +386,7 @@ bool csocket::set_blocking_mode(bool blocking) flags = fcntl(m_sock_fd, F_SETFL, flags); if (flags == -1) { - ERR("fcntl(F_SETFL) failed for %s, m_sock_fd: %d, errno : %d , errstr : %s", get_client_name(), m_sock_fd, errno, strerror(errno)); + _E("fcntl(F_SETFL) failed for %s, m_sock_fd: %d, errno : %d , errstr : %s", get_client_name(), m_sock_fd, errno, strerror(errno)); return false; } @@ -402,7 +402,7 @@ bool csocket::set_sock_type(void) opt_len = sizeof(sock_type); if (getsockopt(m_sock_fd, SOL_SOCKET, SO_TYPE, &sock_type, &opt_len) < 0) { - ERR("getsockopt(SOL_SOCKET, SO_TYPE) failed for %s, m_sock_fd: %d, errno : %d , errstr : %s", get_client_name(), m_sock_fd, errno, strerror(errno)); + _E("getsockopt(SOL_SOCKET, SO_TYPE) failed for %s, m_sock_fd: %d, errno : %d , errstr : %s", get_client_name(), m_sock_fd, errno, strerror(errno)); return false; } @@ -421,7 +421,7 @@ bool csocket::set_connection_mode(void) tv.tv_usec = 0; if(setsockopt(m_sock_fd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)) < 0) { - ERR("Set SO_RCVTIMEO failed for %s, m_sock_fd : %d, errno : %d , errstr : %s", + _E("Set SO_RCVTIMEO failed for %s, m_sock_fd : %d, errno : %d , errstr : %s", get_client_name(), m_sock_fd, errno, strerror(errno)); close(); return false; @@ -451,7 +451,7 @@ bool csocket::is_blocking_mode(void) flags = fcntl(m_sock_fd, F_GETFL); if (flags == -1) { - ERR("fcntl(F_GETFL) failed for %s, m_sock_fd: %d, errno : %d , errstr : %s", get_client_name(), m_sock_fd, errno, strerror(errno)); + _E("fcntl(F_GETFL) failed for %s, m_sock_fd: %d, errno : %d , errstr : %s", get_client_name(), m_sock_fd, errno, strerror(errno)); return false; } @@ -473,7 +473,7 @@ bool csocket::close(void) { if (m_sock_fd >= 0) { if (::close(m_sock_fd) < 0) { - ERR("Socket(%d) close failed, errno : %d , errstr : %s", m_sock_fd, errno, strerror(errno)); + _E("Socket(%d) close failed, errno : %d , errstr : %s", m_sock_fd, errno, strerror(errno)); return false; } m_sock_fd = -1; diff --git a/src/shared/poller.cpp b/src/shared/poller.cpp index aaa43fe..fa5500e 100644 --- a/src/shared/poller.cpp +++ b/src/shared/poller.cpp @@ -53,7 +53,7 @@ bool poller::add_fd(int fd) event.events = EPOLLIN | EPOLLERR | EPOLLHUP; if (epoll_ctl(m_epfd, EPOLL_CTL_ADD, fd, &event)) { - ERR("errno : %d , errstr : %s", errno, strerror(errno)); + _E("errno : %d , errstr : %s", errno, strerror(errno)); return false; } @@ -71,12 +71,12 @@ bool poller::fill_event_queue(void) if (errno == EINTR) return true; - ERR("Epoll failed errrno : %d , errstr : %s", errno, strerror(errno)); + _E("Epoll failed errrno : %d , errstr : %s", errno, strerror(errno)); return false; } if (nr_events == 0) { - ERR("Epoll timeout!"); + _E("Epoll timeout!"); return false; } @@ -100,12 +100,12 @@ bool poller::poll(struct epoll_event &event) m_event_queue.pop(); if (event.events & EPOLLERR) { - DBG("Poll error!"); + _D("Poll error!"); return false; } if (event.events & EPOLLHUP) { - INFO("Poll: Connetion is closed from the other side"); + _I("Poll: Connetion is closed from the other side"); return false; } diff --git a/src/shared/sensor_info.cpp b/src/shared/sensor_info.cpp index dfa0fe5..0f6a188 100644 --- a/src/shared/sensor_info.cpp +++ b/src/shared/sensor_info.cpp @@ -210,20 +210,20 @@ 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%llx", (int64_t)m_id); - INFO("Privilege = %d", (int)m_privilege); - INFO("Name = %s", m_name.c_str()); - INFO("Vendor = %s", m_vendor.c_str()); - INFO("Min_range = %f", m_min_range); - INFO("Max_range = %f", m_max_range); - INFO("Resolution = %f", m_resolution); - INFO("Min_interval = %d", m_min_interval); - INFO("Fifo_count = %d", m_fifo_count); - INFO("Max_batch_count = %d", m_max_batch_count); - INFO("supported_event = 0x%x", m_supported_event); - - INFO("Wakeup_supported = %d", m_wakeup_supported); + _I("Type = %d", m_type); + _I("ID = 0x%llx", (int64_t)m_id); + _I("Privilege = %d", (int)m_privilege); + _I("Name = %s", m_name.c_str()); + _I("Vendor = %s", m_vendor.c_str()); + _I("Min_range = %f", m_min_range); + _I("Max_range = %f", m_max_range); + _I("Resolution = %f", m_resolution); + _I("Min_interval = %d", m_min_interval); + _I("Fifo_count = %d", m_fifo_count); + _I("Max_batch_count = %d", m_max_batch_count); + _I("supported_event = 0x%x", m_supported_event); + + _I("Wakeup_supported = %d", m_wakeup_supported); } diff --git a/src/shared/sensor_logs.h b/src/shared/sensor_logs.h index aa01eb7..2b78532 100644 --- a/src/shared/sensor_logs.h +++ b/src/shared/sensor_logs.h @@ -36,7 +36,7 @@ #ifdef _DEBUG #define DBG SLOGD #else -#define DBG(...) do{} while(0) +#define _D(...) do{} while(0) #endif #define ERR SLOGE @@ -50,32 +50,32 @@ #if defined(_DEBUG) # define warn_if(expr, fmt, arg...) do { \ if(expr) { \ - DBG("(%s) -> " fmt, #expr, ##arg); \ + _D("(%s) -> " fmt, #expr, ##arg); \ } \ } while (0) # define ret_if(expr) do { \ if(expr) { \ - DBG("(%s) -> %s() return", #expr, __FUNCTION__); \ + _D("(%s) -> %s() return", #expr, __FUNCTION__); \ return; \ } \ } while (0) # define retv_if(expr, val) do { \ if(expr) { \ - DBG("(%s) -> %s() return", #expr, __FUNCTION__); \ + _D("(%s) -> %s() return", #expr, __FUNCTION__); \ return (val); \ } \ } while (0) # define retm_if(expr, fmt, arg...) do { \ if(expr) { \ - ERR(fmt, ##arg); \ - DBG("(%s) -> %s() return", #expr, __FUNCTION__); \ + _E(fmt, ##arg); \ + _D("(%s) -> %s() return", #expr, __FUNCTION__); \ return; \ } \ } while (0) # define retvm_if(expr, val, fmt, arg...) do { \ if(expr) { \ - ERR(fmt, ##arg); \ - DBG("(%s) -> %s() return", #expr, __FUNCTION__); \ + _E(fmt, ##arg); \ + _D("(%s) -> %s() return", #expr, __FUNCTION__); \ return (val); \ } \ } while (0) @@ -83,7 +83,7 @@ #else # define warn_if(expr, fmt, arg...) do { \ if(expr) { \ - ERR(fmt, ##arg); \ + _E(fmt, ##arg); \ } \ } while (0) # define ret_if(expr) do { \ @@ -98,13 +98,13 @@ } while (0) # define retm_if(expr, fmt, arg...) do { \ if(expr) { \ - ERR(fmt, ##arg); \ + _E(fmt, ##arg); \ return; \ } \ } while (0) # define retvm_if(expr, val, fmt, arg...) do { \ if(expr) { \ - ERR(fmt, ##arg); \ + _E(fmt, ##arg); \ return (val); \ } \ } while (0) -- 2.7.4 From d48da508dad3b330aa3ceaf02cabcc01ba8ba7d0 Mon Sep 17 00:00:00 2001 From: "kibak.yoon" Date: Sat, 13 Feb 2016 17:43:32 +0900 Subject: [PATCH 16/16] sensord: add the sensord plugin logic for flexibility - if sensord has specific-type sensor plugin, then sensor_loader creates specific-type sensor object and set the handle info to it. - but sensord doesn't have specific-type sensor plugin based on physical_sensor, sensor_loader creates physical_sensor object basically and use it. Change-Id: Iceb5047d6db660c36a63d9deda1c45518eb24570 Signed-off-by: kibak.yoon --- src/server/main.cpp | 2 +- src/server/physical_sensor.cpp | 59 +++---- src/server/physical_sensor.h | 4 +- src/server/plugins/CMakeLists.txt | 3 + src/server/plugins/accel/accel_sensor.cpp | 37 +++++ src/server/plugins/accel/accel_sensor.h | 34 ++++ .../plugins/auto_rotation/auto_rotation_sensor.cpp | 2 +- src/server/sensor_loader.cpp | 185 +++++++++++---------- src/server/sensor_loader.h | 15 +- src/shared/sensor_logs.h | 2 +- 10 files changed, 210 insertions(+), 133 deletions(-) create mode 100644 src/server/plugins/accel/accel_sensor.cpp create mode 100644 src/server/plugins/accel/accel_sensor.h diff --git a/src/server/main.cpp b/src/server/main.cpp index bcf0bb2..6bda15a 100644 --- a/src/server/main.cpp +++ b/src/server/main.cpp @@ -56,7 +56,7 @@ int main(int argc, char *argv[]) signal_init(); - sensor_loader::get_instance().load_sensors(); + sensor_loader::get_instance().load(); server::get_instance().run(); diff --git a/src/server/physical_sensor.cpp b/src/server/physical_sensor.cpp index 7d17901..b230e1c 100644 --- a/src/server/physical_sensor.cpp +++ b/src/server/physical_sensor.cpp @@ -33,20 +33,9 @@ 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.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_handle(const sensor_handle_t *handle) +{ + m_handle = handle; } void physical_sensor::set_sensor_device(sensor_device *device) @@ -56,25 +45,25 @@ void physical_sensor::set_sensor_device(sensor_device *device) sensor_type_t physical_sensor::get_type(void) { - return static_cast(m_handle.type); + return static_cast(m_handle->type); } unsigned int physical_sensor::get_event_type(void) { - return m_handle.event_type; + return m_handle->event_type; } const char* physical_sensor::get_name(void) { - if (!m_handle.name) + if (!m_handle->name) return UNKNOWN_NAME; - return m_handle.name; + return m_handle->name; } uint32_t physical_sensor::get_hal_id(void) { - return m_handle.id; + return m_handle->id; } int physical_sensor::get_poll_fd() @@ -112,7 +101,7 @@ int physical_sensor::get_data(sensor_data_t **data, int *length) return -1; int remains = 0; - remains = m_sensor_device->get_data(m_handle.id, data, length); + remains = m_sensor_device->get_data(m_handle->id, data, length); if (*length < 0) { _E("Failed to get sensor event"); @@ -129,7 +118,7 @@ bool physical_sensor::flush(void) if (!m_sensor_device) return false; - return m_sensor_device->flush(m_handle.id); + return m_sensor_device->flush(m_handle->id); } bool physical_sensor::set_interval(unsigned long interval) @@ -141,7 +130,7 @@ bool physical_sensor::set_interval(unsigned long interval) _I("Polling interval is set to %dms", interval); - return m_sensor_device->set_interval(m_handle.id, interval); + return m_sensor_device->set_interval(m_handle->id, interval); } bool physical_sensor::set_batch_latency(unsigned long latency) @@ -153,7 +142,7 @@ bool physical_sensor::set_batch_latency(unsigned long latency) _I("Polling interval is set to %dms", latency); - return m_sensor_device->set_batch_latency(m_handle.id, latency); + return m_sensor_device->set_batch_latency(m_handle->id, latency); } int physical_sensor::set_attribute(int32_t attribute, int32_t value) @@ -163,7 +152,7 @@ int physical_sensor::set_attribute(int32_t attribute, int32_t value) if (!m_sensor_device) return false; - return m_sensor_device->set_attribute_int(m_handle.id, attribute, value); + return m_sensor_device->set_attribute_int(m_handle->id, attribute, value); } int physical_sensor::set_attribute(int32_t attribute, char *value, int value_len) @@ -173,7 +162,7 @@ int physical_sensor::set_attribute(int32_t attribute, char *value, int value_len if (!m_sensor_device) return false; - return m_sensor_device->set_attribute_str(m_handle.id, attribute, value, value_len); + return m_sensor_device->set_attribute_str(m_handle->id, attribute, value, value_len); } bool physical_sensor::set_wakeup(int wakeup) @@ -188,7 +177,7 @@ bool physical_sensor::on_start() if (!m_sensor_device) return false; - return m_sensor_device->enable(m_handle.id); + return m_sensor_device->enable(m_handle->id); } bool physical_sensor::on_stop() @@ -198,7 +187,7 @@ bool physical_sensor::on_stop() if (!m_sensor_device) return false; - return m_sensor_device->disable(m_handle.id); + return m_sensor_device->disable(m_handle->id); } bool physical_sensor::get_sensor_info(sensor_info &info) @@ -206,16 +195,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.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_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.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.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 32cfa38..7722929 100644 --- a/src/server/physical_sensor.h +++ b/src/server/physical_sensor.h @@ -29,7 +29,7 @@ public: virtual ~physical_sensor(); /* setting module */ - void set_sensor_handle(sensor_handle_t handle); + void set_sensor_handle(const sensor_handle_t *handle); void set_sensor_device(sensor_device *device); /* module info */ @@ -46,7 +46,7 @@ public: private: static cmutex m_mutex; - sensor_handle_t m_handle; + const sensor_handle_t *m_handle; sensor_device *m_sensor_device; uint32_t hal_id; diff --git a/src/server/plugins/CMakeLists.txt b/src/server/plugins/CMakeLists.txt index db69cf0..432e427 100644 --- a/src/server/plugins/CMakeLists.txt +++ b/src/server/plugins/CMakeLists.txt @@ -16,6 +16,9 @@ SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC") include_directories(${CMAKE_CURRENT_SOURCE_DIR}) +SET(DIR_INCLUDE "${DIR_INCLUDE} ${CMAKE_CURRENT_SOURCE_DIR}/accel") +list (APPEND PLUGIN_SRCS "${CMAKE_CURRENT_SOURCE_DIR}/accel/accel_sensor.cpp") + IF("${AUTO_ROTATION}" STREQUAL "ON") list (APPEND DIR_INCLUDE "${CMAKE_CURRENT_SOURCE_DIR}/auto_rotation") list (APPEND PLUGIN_SRCS "${CMAKE_CURRENT_SOURCE_DIR}/auto_rotation/auto_rotation_alg.cpp") diff --git a/src/server/plugins/accel/accel_sensor.cpp b/src/server/plugins/accel/accel_sensor.cpp new file mode 100644 index 0000000..0c71bc8 --- /dev/null +++ b/src/server/plugins/accel/accel_sensor.cpp @@ -0,0 +1,37 @@ +/* + * sensord + * + * 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. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include + +accel_sensor::accel_sensor() +{ + _E("accel_sensor is created : 0x%x", this); +} + +accel_sensor::~accel_sensor() +{ + +} + +sensor_type_t accel_sensor::get_type(void) +{ + return ACCELEROMETER_SENSOR; +} diff --git a/src/server/plugins/accel/accel_sensor.h b/src/server/plugins/accel/accel_sensor.h new file mode 100644 index 0000000..309f91b --- /dev/null +++ b/src/server/plugins/accel/accel_sensor.h @@ -0,0 +1,34 @@ +/* + * sensord + * + * 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. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef _ACCEL_SENSOR_H_ +#define _ACCEL_SENSOR_H_ + +#include + +class accel_sensor : public physical_sensor { +public: + accel_sensor(); + ~accel_sensor(); + + sensor_type_t get_type(void); +}; + +#endif /* _ACCEL_SENSOR_H_ */ + diff --git a/src/server/plugins/auto_rotation/auto_rotation_sensor.cpp b/src/server/plugins/auto_rotation/auto_rotation_sensor.cpp index e819c2b..68e4b80 100644 --- a/src/server/plugins/auto_rotation/auto_rotation_sensor.cpp +++ b/src/server/plugins/auto_rotation/auto_rotation_sensor.cpp @@ -186,7 +186,7 @@ void auto_rotation_sensor::synthesize(const sensor_event_t& event) push(rotation_event); - _D("Rotation: %d, ACC[0]: %f, ACC[1]: %f, ACC[2]: %f", rotation, event.data.values[0], event.data.values[1], event.data.values[2]); + _D("Rotation: %d, ACC[0]: %f, ACC[1]: %f, ACC[2]: %f", rotation, event.data->values[0], event.data->values[1], event.data->values[2]); return; } diff --git a/src/server/sensor_loader.cpp b/src/server/sensor_loader.cpp index 7a90ffb..a2bee31 100644 --- a/src/server/sensor_loader.cpp +++ b/src/server/sensor_loader.cpp @@ -29,6 +29,7 @@ #include #include +#include #ifdef ENABLE_AUTO_ROTATION #include #endif @@ -50,15 +51,47 @@ sensor_loader& sensor_loader::get_instance() return inst; } -bool sensor_loader::load_devices(const string &path, vector &devices, void* &handle) +bool sensor_loader::load(void) +{ + std::vector device_plugin_paths; + std::vector unique_device_plugin_paths; + + get_paths_from_dir(string(DEVICE_PLUGINS_DIR_PATH), device_plugin_paths); + + std::unordered_set s; + auto unique = [&s](vector &paths, const string &path) { + if (s.insert(path).second) + paths.push_back(path); + }; + + for_each(device_plugin_paths.begin(), device_plugin_paths.end(), + [&](const string &path) { + unique(unique_device_plugin_paths, path); + } + ); + + for_each(unique_device_plugin_paths.begin(), unique_device_plugin_paths.end(), + [&](const string &path) { + void *handle; + load_sensor_devices(path, handle); + } + ); + + create_sensors(); + show_sensor_info(); + + return true; +} + +bool sensor_loader::load_sensor_devices(const string &path, void* &handle) { - int size; sensor_device_t *_devices = NULL; + sensor_device *device; + const sensor_handle_t *handles; _I("load device: [%s]", path.c_str()); void *_handle = dlopen(path.c_str(), RTLD_NOW); - if (!_handle) { _E("Failed to dlopen(%s), dlerror : %s", path.c_str(), dlerror()); return false; @@ -67,129 +100,95 @@ bool sensor_loader::load_devices(const string &path, vector &de dlerror(); create_t create_devices = (create_t) dlsym(_handle, "create"); - if (!create_devices) { _E("Failed to find symbols in %s", path.c_str()); dlclose(_handle); return false; } - size = create_devices(&_devices); - + int device_size = create_devices(&_devices); if (!_devices) { _E("Failed to create devices, path is %s\n", path.c_str()); dlclose(_handle); return false; } - devices.clear(); + for (int i = 0; i < device_size; ++i) { + device = static_cast(_devices[i]); - for (int i = 0; i < size; ++i) - devices.push_back(_devices[i]); + int handle_size = device->get_sensors(&handles); + for (int j = 0; j < handle_size; ++j) + m_devices[&handles[j]] = device; + } handle = _handle; delete _devices; - return true; } -physical_sensor* sensor_loader::create_sensor(sensor_handle_t handle, sensor_device *device) +void sensor_loader::create_sensors(void) { - int32_t index; - physical_sensor *sensor; - - index = (int32_t) (m_sensors.count((sensor_type_t)handle.type)); - - sensor = new(std::nothrow) physical_sensor(); - if (!sensor) { - _E("Memory allocation failed[%s]", handle.name); - return NULL; - } - - sensor->set_id((int64_t)handle.type << SENSOR_TYPE_SHIFT | index); - sensor->set_sensor_handle(handle); - sensor->set_sensor_device(device); + create_physical_sensors(ACCELEROMETER_SENSOR); + create_physical_sensors(UNKNOWN_SENSOR); - return sensor; + create_virtual_sensors("Auto Rotation"); } -bool sensor_loader::load_physical_sensors(std::vector &devices) +template +void sensor_loader::create_physical_sensors(sensor_type_t type) { - int size; - sensor_device *device; - const sensor_handle_t *handles; + int32_t index; + const sensor_handle_t *handle; physical_sensor *sensor; + sensor_device *device; - for (void *device_ptr : devices) { - device = static_cast(device_ptr); + sensor_device_map_t::iterator it = m_devices.begin(); - size = device->get_sensors(&handles); + for (sensor_device_map_t::iterator it = m_devices.begin(); it != m_devices.end(); ++it) { + handle = it->first; + device = it->second; + if (m_devices[handle] == NULL) + continue; - for (int i = 0; i < size; ++i) { - sensor = create_sensor(handles[i], device); - if (!sensor) + if (type != UNKNOWN_SENSOR) { + if (type != (sensor_type_t)(handle->type)) continue; - - std::shared_ptr sensor_ptr(sensor); - m_sensors.insert(std::make_pair((sensor_type_t)(handles[i].type), sensor_ptr)); - - _I("inserted [%s] sensor", sensor->get_name()); } - } - - return true; -} - -bool sensor_loader::load_sensors(void) -{ - vector device_plugin_paths; - vector unique_device_plugin_paths; - get_paths_from_dir(string(DEVICE_PLUGINS_DIR_PATH), device_plugin_paths); + sensor = reinterpret_cast(create_sensor<_sensor>()); - std::unordered_set s; - auto unique = [&s](vector &paths, const string &path) { - if (s.insert(path).second) - paths.push_back(path); - }; - - for_each(device_plugin_paths.begin(), device_plugin_paths.end(), - [&](const string &path) { - unique(unique_device_plugin_paths, path); + if (!sensor) { + _E("Memory allocation failed[%s]", handle->name); + return; } - ); - for_each(unique_device_plugin_paths.begin(), unique_device_plugin_paths.end(), - [&](const string &path) { - void *handle; - std::vector devices; + index = (int32_t) (m_sensors.count(type)); - load_devices(path, devices, handle); - load_physical_sensors(devices); - } - ); + sensor->set_id(((int64_t)handle->type << SENSOR_TYPE_SHIFT) | index); + sensor->set_sensor_handle(handle); + sensor->set_sensor_device(device); - load_virtual_sensors(); + std::shared_ptr sensor_ptr(sensor); + m_sensors.insert(std::make_pair(type, sensor_ptr)); - show_sensor_info(); - return true; + _I("created [%s] sensor", sensor->get_name()); + + m_devices[handle] = NULL; + } + return; } template -void sensor_loader::load_virtual_sensor(const char *name) +void sensor_loader::create_virtual_sensors(const char *name) { + int32_t index; sensor_type_t type; - int16_t index; - virtual_sensor *instance = NULL; + virtual_sensor *instance; - try { - instance = new _sensor; - } catch (std::exception &e) { - _E("Failed to create %s sensor, exception: %s", name, e.what()); - return; - } catch (int err) { - _E("Failed to create %s sensor err: %d, cause: %s", name, err, strerror(err)); + instance = reinterpret_cast(create_sensor<_sensor>()); + if (!instance) { + _E("Memory allocation failed[%s]", name); return; } @@ -200,18 +199,32 @@ void sensor_loader::load_virtual_sensor(const char *name) } std::shared_ptr sensor(instance); - type = sensor->get_type(); - index = (int16_t)(m_sensors.count(type)); + index = (int32_t)(m_sensors.count(type)); sensor->set_id((int64_t)type << SENSOR_TYPE_SHIFT | index); m_sensors.insert(std::make_pair(type, sensor)); + + _I("created [%s] sensor", sensor->get_name()); } -void sensor_loader::load_virtual_sensors(void) +template +sensor_base* sensor_loader::create_sensor(void) { - load_virtual_sensor("Auto Rotation"); + sensor_base *instance = NULL; + + try { + instance = new _sensor; + } catch (std::exception &e) { + _E("Failed to create sensor, exception: %s", e.what()); + return NULL; + } catch (int err) { + _E("Failed to create sensor err: %d, cause: %s", err, strerror(err)); + return NULL; + } + + return instance; } void sensor_loader::show_sensor_info(void) diff --git a/src/server/sensor_loader.h b/src/server/sensor_loader.h index 9a6a18d..d10d216 100644 --- a/src/server/sensor_loader.h +++ b/src/server/sensor_loader.h @@ -38,26 +38,27 @@ class sensor_base; typedef std::multimap> sensor_map_t; +typedef std::map sensor_device_map_t; class sensor_loader { private: sensor_loader(); - bool load_devices(const std::string &path, std::vector &devices, void* &handle); + bool load_sensor_devices(const std::string &path, void* &handle); - physical_sensor* create_sensor(sensor_handle_t handle, sensor_device *device); - bool load_physical_sensors(std::vector &devices); - - template void load_virtual_sensor(const char *name); - void load_virtual_sensors(void); + void create_sensors(void); + template void create_physical_sensors(sensor_type_t type); + template void create_virtual_sensors(const char *name); + template sensor_base* create_sensor(void); void show_sensor_info(void); bool get_paths_from_dir(const std::string &dir_path, std::vector &plugin_paths); sensor_map_t m_sensors; + sensor_device_map_t m_devices; public: static sensor_loader& get_instance(); - bool load_sensors(void); + bool load(void); sensor_base* get_sensor(sensor_type_t type); sensor_base* get_sensor(sensor_id_t id); diff --git a/src/shared/sensor_logs.h b/src/shared/sensor_logs.h index 2b78532..c414264 100644 --- a/src/shared/sensor_logs.h +++ b/src/shared/sensor_logs.h @@ -36,7 +36,7 @@ #ifdef _DEBUG #define DBG SLOGD #else -#define _D(...) do{} while(0) +#define DBG(...) do{} while(0) #endif #define ERR SLOGE -- 2.7.4