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         int ret = OP_SUCCESS;
 156         if (m_policy == OP_DEFAULT && observer_count() > 0) {
 157                 _interval = get_min_interval();
 158                 ret = m_sensor->set_interval(ob, _interval);
 159         }
 160
 161         update_prev_interval(_interval);
 162         return ret;
 163 }
 164
 165 int external_sensor_handler::get_interval(sensor_observer *ob, int32_t& interval)
 166 {
 167         retv_if(!m_sensor, -EINVAL);
 168         interval = m_prev_interval;
 169         return OP_SUCCESS;
 170 }
 171
 172 int external_sensor_handler::get_min_batch_latency(void)
 173 {
 174         int batch_latency;
 175         std::vector<int> temp;
 176
 177         for (auto it = m_batch_latency_map.begin(); it != m_batch_latency_map.end(); ++it)
 178                 if (it->second > 0)
 179                     temp.push_back(it->second);
 180
 181         if (temp.empty())
 182                 return 0;
 183
 184         batch_latency = *std::min_element(temp.begin(), temp.end());
 185
 186         return batch_latency;
 187 }
 188
 189 int external_sensor_handler::set_batch_latency(sensor_observer *ob, int32_t latency)
 190 {
 191         retv_if(!m_sensor, -EINVAL);
 192
 193         int _latency = latency;
 194
 195         if ((m_policy == OP_DEFAULT && observer_count() == 0) || m_policy == OP_SUCCESS) {
 196                 m_policy = m_sensor->set_batch_latency(ob, latency);
 197                 retv_if(m_policy <= OP_ERROR, m_policy);
 198         }
 199
 200         m_batch_latency_map[ob] = _latency;
 201
 202         int ret = OP_SUCCESS;
 203         if (m_policy == OP_DEFAULT && observer_count() > 0) {
 204                 _latency = get_min_batch_latency();
 205                 ret = m_sensor->set_batch_latency(ob, latency);
 206         }
 207
 208         update_prev_latency(_latency);
 209         return ret;
 210 }
 211
 212 int external_sensor_handler::get_batch_latency(sensor_observer *ob, int32_t &latency)
 213 {
 214         retv_if(!m_sensor, -EINVAL);
 215         latency = m_prev_latency;
 216         return OP_SUCCESS;
 217 }
 218
 219 int external_sensor_handler::set_attribute(sensor_observer *ob, int32_t attr, int32_t value)
 220 {
 221         retv_if(!m_sensor, -EINVAL);
 222
 223         if ((m_policy == OP_DEFAULT && observer_count() == 0) || m_policy == OP_SUCCESS) {
 224                 m_policy = m_sensor->set_attribute(ob, attr, value);
 225                 retv_if(m_policy <= OP_ERROR, m_policy);
 226         }
 227
 228         if (m_policy == OP_DEFAULT) {
 229                 /* default logic */
 230         }
 231
 232         update_attribute(attr, value);
 233
 234         return OP_SUCCESS;
 235 }
 236
 237 int external_sensor_handler::set_attribute(sensor_observer *ob, int32_t attr, const char *value, int len)
 238 {
 239         retv_if(!m_sensor, -EINVAL);
 240
 241         if ((m_policy == OP_DEFAULT && observer_count() == 0) || m_policy == OP_SUCCESS) {
 242                 m_policy = m_sensor->set_attribute(ob, attr, value, len);
 243                 retv_if(m_policy <= OP_ERROR, m_policy);
 244         }
 245
 246         if (m_policy == OP_DEFAULT) {
 247                 /* default logic */
 248         }
 249
 250         update_attribute(attr, value, len);
 251
 252         return OP_SUCCESS;
 253 }
 254
 255 int external_sensor_handler::get_data(sensor_data_t **data, int *len)
 256 {
 257         return m_sensor->get_data(data, len);
 258 }
 259
 260 int external_sensor_handler::flush(sensor_observer *ob)
 261 {
 262         retv_if(!m_sensor, -EINVAL);
 263
 264         m_sensor->flush(this);
 265
 266         return OP_SUCCESS;
 267 }