src/server/external_sensor_handler.cpp

   1 /*
   2  * sensord
   3  *
   4  * Copyright (c) 2017 Samsung Electronics Co., Ltd.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  * http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  */
  19
  20 #include "external_sensor_handler.h"
  21
  22 #include <message.h>
  23 #include <sensor_log.h>
  24 #include <external_sensor.h>
  25 #include <algorithm>
  26
  27 using namespace sensor;
  28
  29 class external_sensor_notifier : public sensor_notifier {
  30 public:
  31         external_sensor_notifier(external_sensor_handler *sensor);
  32
  33         int notify(void);
  34
  35 private:
  36         external_sensor_handler *m_sensor;
  37 };
  38
  39 external_sensor_notifier::external_sensor_notifier(external_sensor_handler *sensor)
  40 : m_sensor(sensor)
  41 {
  42 }
  43
  44 int external_sensor_notifier::notify(void)
  45 {
  46         /* TODO: Change thread-safe function(add handler to event-loop) */
  47         sensor_data_t *data;
  48         int len;
  49
  50         if (m_sensor->get_data(&data, &len) < 0)
  51                 return OP_ERROR;
  52
  53         /* TODO: pointer would be better */
  54         sensor_info info = m_sensor->get_sensor_info();
  55
  56         return m_sensor->notify(info.get_uri().c_str(), data, len);
  57 }
  58
  59 external_sensor_handler::external_sensor_handler(const sensor_info &info,
  60                 external_sensor *sensor)
  61 : sensor_handler(info)
  62 , m_sensor(sensor)
  63 , m_notifier(NULL)
  64 , m_policy(OP_DEFAULT)
  65 {
  66         init();
  67 }
  68
  69 external_sensor_handler::~external_sensor_handler()
  70 {
  71         deinit();
  72 }
  73
  74 bool external_sensor_handler::init(void)
  75 {
  76         m_notifier = new(std::nothrow) external_sensor_notifier(this);
  77         retvm_if(!m_notifier, false, "Failed to allocate memory");
  78
  79         m_sensor->set_notifier(m_notifier);
  80         return true;
  81 }
  82
  83 void external_sensor_handler::deinit(void)
  84 {
  85         delete m_notifier;
  86         m_notifier = NULL;
  87 }
  88
  89 const sensor_info &external_sensor_handler::get_sensor_info(void)
  90 {
  91         return m_info;
  92 }
  93
  94 int external_sensor_handler::start(sensor_observer *ob)
  95 {
  96         retv_if(!m_sensor, -EINVAL);
  97
  98         int policy = m_sensor->start(ob);
  99         retv_if(policy <= OP_ERROR, policy);
 100
 101         add_observer(ob);
 102
 103         _I("Started[%s]", m_info.get_uri().c_str());
 104
 105         return OP_SUCCESS;
 106 }
 107
 108 int external_sensor_handler::stop(sensor_observer *ob)
 109 {
 110         retv_if(!m_sensor, -EINVAL);
 111
 112         int policy = m_sensor->stop(ob);
 113         retv_if(policy <= OP_ERROR, policy);
 114
 115         remove_observer(ob);
 116
 117         _I("Stopped[%s]", m_info.get_uri().c_str());
 118
 119         return OP_SUCCESS;
 120 }
 121
 122 int external_sensor_handler::get_min_interval(void)
 123 {
 124         int interval;
 125         std::vector<int> temp;
 126
 127         for (auto it = m_interval_map.begin(); it != m_interval_map.end(); ++it)
 128                 if (it->second > 0)
 129                     temp.push_back(it->second);
 130
 131         if (temp.empty())
 132                 return m_info.get_min_interval();
 133
 134         interval = *std::min_element(temp.begin(), temp.end());
 135
 136         if (interval < m_info.get_min_interval())
 137                 return m_info.get_min_interval();
 138
 139         return interval;
 140 }
 141
 142 int external_sensor_handler::set_interval(sensor_observer *ob, int32_t interval)
 143 {
 144         retv_if(!m_sensor, -EINVAL);
 145
 146         int _interval = interval;
 147
 148         if ((m_policy == OP_DEFAULT && observer_count() == 0) || m_policy == OP_SUCCESS) {
 149                 m_policy = m_sensor->set_interval(ob, interval);
 150                 retv_if(m_policy <= OP_ERROR, m_policy);
 151         }
 152
 153         m_interval_map[ob] = interval;
 154
 155         if (m_policy == OP_DEFAULT && observer_count() > 0) {
 156                 _interval = get_min_interval();
 157                 return m_sensor->set_interval(ob, _interval);
 158         }
 159
 160         _I("Set interval[%d] to sensor[%s]", _interval, m_info.get_uri().c_str());
 161
 162         return OP_SUCCESS;
 163 }
 164
 165 int external_sensor_handler::get_min_batch_latency(void)
 166 {
 167         int batch_latency;
 168         std::vector<int> temp;
 169
 170         for (auto it = m_batch_latency_map.begin(); it != m_batch_latency_map.end(); ++it)
 171                 if (it->second > 0)
 172                     temp.push_back(it->second);
 173
 174         if (temp.empty())
 175                 return 0;
 176
 177         batch_latency = *std::min_element(temp.begin(), temp.end());
 178
 179         return batch_latency;
 180 }
 181
 182 int external_sensor_handler::set_batch_latency(sensor_observer *ob, int32_t latency)
 183 {
 184         retv_if(!m_sensor, -EINVAL);
 185
 186         int _latency = latency;
 187
 188         if ((m_policy == OP_DEFAULT && observer_count() == 0) || m_policy == OP_SUCCESS) {
 189                 m_policy = m_sensor->set_batch_latency(ob, latency);
 190                 retv_if(m_policy <= OP_ERROR, m_policy);
 191         }
 192
 193         m_batch_latency_map[ob] = _latency;
 194
 195         if (m_policy == OP_DEFAULT && observer_count() > 0) {
 196                 _latency = get_min_batch_latency();
 197                 return m_sensor->set_batch_latency(ob, latency);
 198         }
 199         return OP_SUCCESS;
 200 }
 201
 202 int external_sensor_handler::set_attribute(sensor_observer *ob, int32_t attr, int32_t value)
 203 {
 204         retv_if(!m_sensor, -EINVAL);
 205
 206         if ((m_policy == OP_DEFAULT && observer_count() == 0) || m_policy == OP_SUCCESS) {
 207                 m_policy = m_sensor->set_attribute(ob, attr, value);
 208                 retv_if(m_policy <= OP_ERROR, m_policy);
 209         }
 210
 211         if (m_policy == OP_DEFAULT) {
 212                 /* default logic */
 213         }
 214         return OP_SUCCESS;
 215 }
 216
 217 int external_sensor_handler::set_attribute(sensor_observer *ob, int32_t attr, const char *value, int len)
 218 {
 219         retv_if(!m_sensor, -EINVAL);
 220
 221         if ((m_policy == OP_DEFAULT && observer_count() == 0) || m_policy == OP_SUCCESS) {
 222                 m_policy = m_sensor->set_attribute(ob, attr, value, len);
 223                 retv_if(m_policy <= OP_ERROR, m_policy);
 224         }
 225
 226         if (m_policy == OP_DEFAULT) {
 227                 /* default logic */
 228         }
 229         return OP_SUCCESS;
 230 }
 231
 232 int external_sensor_handler::get_data(sensor_data_t **data, int *len)
 233 {
 234         return m_sensor->get_data(data, len);
 235 }
 236
 237 int external_sensor_handler::flush(sensor_observer *ob)
 238 {
 239         retv_if(!m_sensor, -EINVAL);
 240
 241         m_sensor->flush(this);
 242
 243         return OP_SUCCESS;
 244 }