From: kibak.yoon Date: Thu, 6 Apr 2017 09:47:29 +0000 (+0900) Subject: sensord: add external_sensor_handler class X-Git-Tag: accepted/tizen/unified/20170414.164053^2~40 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=refs%2Fchanges%2F48%2F123648%2F2;p=platform%2Fcore%2Fsystem%2Fsensord.git sensord: add external_sensor_handler class - external_sensor_handler provides: - controls for operating external_sensor - controls for operation policy - listening event from notifier and notify it to observers Change-Id: I3213c7798873833b8bb5e0307275fd2a3bd52bf6 Signed-off-by: kibak.yoon --- diff --git a/src/server/external_sensor_handler.cpp b/src/server/external_sensor_handler.cpp new file mode 100644 index 0000000..110e15b --- /dev/null +++ b/src/server/external_sensor_handler.cpp @@ -0,0 +1,236 @@ +/* + * sensord + * + * Copyright (c) 2017 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 "external_sensor_handler.h" + +#include +#include +#include +#include + +using namespace sensor; + +class external_sensor_notifier : public sensor_notifier { +public: + external_sensor_notifier(external_sensor_handler *sensor); + + int notify(void); + +private: + external_sensor_handler *m_sensor; +}; + +external_sensor_notifier::external_sensor_notifier(external_sensor_handler *sensor) +: m_sensor(sensor) +{ +} + +int external_sensor_notifier::notify(void) +{ + /* TODO: Change thread-safe function(add handler to event-loop) */ + sensor_data_t *data; + int len; + + if (m_sensor->get_data(&data, &len) < 0) + return OP_ERROR; + + /* TODO: pointer would be better */ + sensor_info info = m_sensor->get_sensor_info(); + std::string uri = info.get_type_uri(); + + return m_sensor->notify(uri.c_str(), data, len); +} + +external_sensor_handler::external_sensor_handler(const sensor_info &info, + external_sensor *sensor) +: m_info(info) +, m_sensor(sensor) +, m_notifier(NULL) +{ + init(); +} + +external_sensor_handler::~external_sensor_handler() +{ + deinit(); +} + +bool external_sensor_handler::init(void) +{ + m_notifier = new(std::nothrow) external_sensor_notifier(this); + retvm_if(!m_notifier, false, "Failed to allocate memory"); + + m_sensor->set_notifier(m_notifier); + return true; +} + +void external_sensor_handler::deinit(void) +{ + delete m_notifier; + m_notifier = NULL; +} + +const sensor_info &external_sensor_handler::get_sensor_info(void) +{ + return m_info; +} + +int external_sensor_handler::start(sensor_observer *ob) +{ + retv_if(!m_sensor, -EINVAL); + + int policy = m_sensor->start(ob); + retv_if(policy <= OP_ERROR, policy); + + return OP_SUCCESS; +} + +int external_sensor_handler::stop(sensor_observer *ob) +{ + retv_if(!m_sensor, -EINVAL); + + int policy = m_sensor->stop(ob); + retv_if(policy <= OP_ERROR, policy); + + remove_observer(ob); + + return OP_SUCCESS; +} + +int external_sensor_handler::get_min_interval(void) +{ + int interval; + std::vector temp; + + for (auto it = m_interval_map.begin(); it != m_interval_map.end(); ++it) + if (it->second > 0) + temp.push_back(it->second); + + if (temp.empty()) + return m_info.get_min_interval(); + + interval = *std::min_element(temp.begin(), temp.end()); + + if (interval < m_info.get_min_interval()) + return m_info.get_min_interval(); + + return interval; +} + +int external_sensor_handler::set_interval(sensor_observer *ob, int32_t interval) +{ + retv_if(!m_sensor, -EINVAL); + + int _interval = interval; + + if ((m_policy == OP_DEFAULT && observer_count() == 0) || m_policy == OP_SUCCESS) { + m_policy = m_sensor->set_interval(ob, interval); + retv_if(m_policy <= OP_ERROR, m_policy); + } + + m_interval_map[ob] = interval; + + if (m_policy == OP_DEFAULT && observer_count() > 0) { + _interval = get_min_interval(); + return m_sensor->set_interval(ob, _interval); + } + + return OP_SUCCESS; +} + +int external_sensor_handler::get_min_batch_latency(void) +{ + int batch_latency; + std::vector temp; + + for (auto it = m_batch_latency_map.begin(); it != m_batch_latency_map.end(); ++it) + if (it->second > 0) + temp.push_back(it->second); + + if (temp.empty()) + return 0; + + batch_latency = *std::min_element(temp.begin(), temp.end()); + + return batch_latency; +} + +int external_sensor_handler::set_batch_latency(sensor_observer *ob, int32_t latency) +{ + retv_if(!m_sensor, -EINVAL); + + int _latency = latency; + + if ((m_policy == OP_DEFAULT && observer_count() == 0) || m_policy == OP_SUCCESS) { + m_policy = m_sensor->set_batch_latency(ob, latency); + retv_if(m_policy <= OP_ERROR, m_policy); + } + + m_batch_latency_map[ob] = _latency; + + if (m_policy == OP_DEFAULT && observer_count() > 0) { + _latency = get_min_batch_latency(); + return m_sensor->set_batch_latency(ob, latency); + } + return OP_SUCCESS; +} + +int external_sensor_handler::set_attribute(sensor_observer *ob, int32_t attr, int32_t value) +{ + retv_if(!m_sensor, -EINVAL); + + if ((m_policy == OP_DEFAULT && observer_count() == 0) || m_policy == OP_SUCCESS) { + m_policy = m_sensor->set_attribute(ob, attr, value); + retv_if(m_policy <= OP_ERROR, m_policy); + } + + if (m_policy == OP_DEFAULT) { + /* default logic */ + } + return OP_SUCCESS; +} + +int external_sensor_handler::set_attribute(sensor_observer *ob, int32_t attr, const char *value, int len) +{ + retv_if(!m_sensor, -EINVAL); + + if ((m_policy == OP_DEFAULT && observer_count() == 0) || m_policy == OP_SUCCESS) { + m_policy = m_sensor->set_attribute(ob, attr, value, len); + retv_if(m_policy <= OP_ERROR, m_policy); + } + + if (m_policy == OP_DEFAULT) { + /* default logic */ + } + return OP_SUCCESS; +} + +int external_sensor_handler::get_data(sensor_data_t **data, int *len) +{ + return m_sensor->get_data(data, len); +} + +int external_sensor_handler::flush(sensor_observer *ob) +{ + retv_if(!m_sensor, -EINVAL); + + m_sensor->flush(this); + + return OP_SUCCESS; +} diff --git a/src/server/external_sensor_handler.h b/src/server/external_sensor_handler.h new file mode 100644 index 0000000..6fe386a --- /dev/null +++ b/src/server/external_sensor_handler.h @@ -0,0 +1,69 @@ +/* + * sensord + * + * Copyright (c) 2017 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 __EXTERNAL_SENSOR_HANDLER_H__ +#define __EXTERNAL_SENSOR_HANDLER_H__ + +#include +#include +#include +#include + +#include "sensor_handler.h" + +namespace sensor { + +class external_sensor_handler : public sensor_handler { +public: + external_sensor_handler(const sensor_info &info, + external_sensor *sensor); + ~external_sensor_handler(); + + /* sensor interface */ + const sensor_info &get_sensor_info(void); + + int start(sensor_observer *ob); + int stop(sensor_observer *ob); + + int set_interval(sensor_observer *ob, int32_t interval); + int set_batch_latency(sensor_observer *ob, int32_t latency); + int set_attribute(sensor_observer *ob, int32_t attr, int32_t value); + int set_attribute(sensor_observer *ob, int32_t attr, const char *value, int len); + int flush(sensor_observer *ob); + int get_data(sensor_data_t **data, int *len); + +private: + bool init(); + void deinit(); + + int get_min_interval(void); + int get_min_batch_latency(void); + + sensor_info m_info; + external_sensor *m_sensor; + sensor_notifier *m_notifier; + int m_policy; + + std::unordered_map m_interval_map; + std::unordered_map m_batch_latency_map; +}; + +} + +#endif /* __EXTERNAL_SENSOR_HANDLER_H__ */