src/server/fusion_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 "fusion_sensor_handler.h"
  21 #include "fusion_sensor.h"
  22
  23 #include <message.h>
  24 #include <sensor_log.h>
  25 #include <algorithm>
  26
  27 const int MAX_INTERVAL = 255000;
  28
  29 using namespace sensor;
  30
  31 fusion_sensor_handler::fusion_sensor_handler(const sensor_info &info,
  32                 fusion_sensor *sensor)
  33 : sensor_handler(info)
  34 , m_sensor(sensor)
  35 {
  36 }
  37
  38 fusion_sensor_handler::~fusion_sensor_handler()
  39 {
  40         m_required_sensors.clear();
  41 }
  42
  43 void fusion_sensor_handler::add_required_sensor(uint32_t id, sensor_handler *sensor)
  44 {
  45         sensor_info info = sensor->get_sensor_info();
  46         m_required_sensors.emplace(info.get_uri(), required_sensor(id, sensor));
  47 }
  48
  49 int fusion_sensor_handler::update(const char *uri, std::shared_ptr<ipc::message> msg)
  50 {
  51         retv_if(!m_sensor, -EINVAL);
  52
  53         auto it = m_required_sensors.find(uri);
  54         retv_if(it == m_required_sensors.end(), OP_SUCCESS);
  55
  56         if (m_sensor->update(it->second.id, (sensor_data_t *)msg->body(), msg->size()) < 0)
  57                 return OP_SUCCESS;
  58
  59         sensor_data_t *data;
  60         int len;
  61
  62         if (m_sensor->get_data(&data, &len) < 0)
  63                 return OP_ERROR;
  64
  65         return notify(m_info.get_uri().c_str(), data, len);
  66 }
  67
  68 const sensor_info &fusion_sensor_handler::get_sensor_info(void)
  69 {
  70         return m_info;
  71 }
  72
  73 int fusion_sensor_handler::start(sensor_observer *ob)
  74 {
  75         retv_if(!m_sensor, -EINVAL);
  76
  77         int policy = OP_DEFAULT;
  78
  79         policy = m_sensor->start(ob);
  80         retv_if(policy <= OP_ERROR, policy);
  81
  82         add_observer(ob);
  83
  84         if (policy == OP_DEFAULT) {
  85                 if (observer_count() > 1)
  86                         return OP_SUCCESS;
  87         }
  88
  89         _I("Started[%s]", m_info.get_uri().c_str());
  90
  91         return start_required_sensors();
  92 }
  93
  94 int fusion_sensor_handler::stop(sensor_observer *ob)
  95 {
  96         retv_if(!m_sensor, -EINVAL);
  97
  98         int policy = OP_DEFAULT;
  99
 100         policy = m_sensor->stop(ob);
 101         retv_if(policy <= OP_ERROR, policy);
 102
 103         remove_observer(ob);
 104
 105         if (policy == OP_DEFAULT) {
 106                 if (observer_count() >= 1)
 107                         return OP_SUCCESS; /* already started */
 108         }
 109
 110         _I("Stopped[%s]", m_info.get_uri().c_str());
 111
 112         return stop_required_sensors();
 113 }
 114
 115 int fusion_sensor_handler::get_min_interval(void)
 116 {
 117         int interval;
 118         std::vector<int> temp;
 119
 120         for (auto it = m_interval_map.begin(); it != m_interval_map.end(); ++it)
 121                 if (it->second > 0)
 122                     temp.push_back(it->second);
 123
 124         if (temp.empty())
 125                 return m_info.get_min_interval();
 126
 127         interval = *std::min_element(temp.begin(), temp.end());
 128
 129         if (interval > m_info.get_min_interval())
 130                 return m_info.get_min_interval();
 131
 132         return interval;
 133 }
 134
 135 int fusion_sensor_handler::get_max_interval(void)
 136 {
 137         int ret = m_info.get_max_interval();
 138         if (ret)
 139                 return ret;
 140         return MAX_INTERVAL;
 141 }
 142
 143 int fusion_sensor_handler::set_interval(sensor_observer *ob, int32_t interval)
 144 {
 145         retv_if(!m_sensor, -EINVAL);
 146
 147         int _interval = interval;
 148         int max_interval = get_max_interval();
 149         int min_interval = get_min_interval();
 150
 151         if (max_interval > 0 && _interval > max_interval)
 152                 _interval = max_interval;
 153         else if (min_interval > 0 && _interval < min_interval)
 154                 _interval = min_interval;
 155
 156         int policy = OP_DEFAULT;
 157
 158         policy = m_sensor->set_interval(ob, _interval);
 159         retv_if(policy <= OP_ERROR, policy);
 160
 161         m_interval_map[ob] = _interval;
 162
 163         update_prev_interval(_interval);
 164
 165         return set_interval_internal(_interval);
 166 }
 167
 168 int fusion_sensor_handler::get_interval(sensor_observer *ob, int32_t& interval)
 169 {
 170         retv_if(!m_sensor, -EINVAL);
 171
 172         interval = m_prev_interval;
 173         return OP_SUCCESS;
 174 }
 175
 176 int fusion_sensor_handler::get_min_batch_latency(void)
 177 {
 178         int batch_latency;
 179         std::vector<int> temp;
 180
 181         for (auto it = m_batch_latency_map.begin(); it != m_batch_latency_map.end(); ++it)
 182                 if (it->second > 0)
 183                     temp.push_back(it->second);
 184
 185         if (temp.empty())
 186                 return 0;
 187
 188         batch_latency = *std::min_element(temp.begin(), temp.end());
 189
 190         return batch_latency;
 191 }
 192
 193 int fusion_sensor_handler::set_batch_latency(sensor_observer *ob, int32_t latency)
 194 {
 195         retv_if(!m_sensor, -EINVAL);
 196
 197         int _latency = latency;
 198         int policy = OP_DEFAULT;
 199
 200         if (m_sensor) {
 201                 policy = m_sensor->set_batch_latency(ob, _latency);
 202                 retv_if(policy <= OP_ERROR, policy);
 203         }
 204
 205         m_batch_latency_map[ob] = _latency;
 206
 207         if (policy == OP_DEFAULT)
 208                 _latency = get_min_batch_latency();
 209
 210         update_prev_latency(_latency);
 211
 212         return set_batch_latency_internal(_latency);
 213 }
 214
 215 int fusion_sensor_handler::get_batch_latency(sensor_observer *ob, int32_t &latency)
 216 {
 217         retv_if(!m_sensor, -EINVAL);
 218
 219         latency = m_prev_latency;
 220         return OP_SUCCESS;
 221 }
 222
 223 int fusion_sensor_handler::set_attribute(sensor_observer *ob, int32_t attr, int32_t value)
 224 {
 225         retv_if(!m_sensor, -EINVAL);
 226
 227         int policy = OP_DEFAULT;
 228
 229         policy = m_sensor->set_attribute(ob, attr, value);
 230         retv_if(policy <= OP_ERROR, policy);
 231
 232         if (policy == OP_DEFAULT) {
 233                 /* default logic */
 234         }
 235
 236         update_attribute(attr, value);
 237
 238         return set_attribute_internal(attr, value);
 239 }
 240
 241 int fusion_sensor_handler::set_attribute(sensor_observer *ob, int32_t attr, const char *value, int len)
 242 {
 243         retv_if(!m_sensor, -EINVAL);
 244
 245         int policy = OP_DEFAULT;
 246
 247         policy = m_sensor->set_attribute(ob, attr, value, len);
 248         retv_if(policy <= OP_ERROR, policy);
 249
 250         if (policy == OP_DEFAULT) {
 251                 /* default logic */
 252         }
 253
 254         update_attribute(attr, value, len);
 255
 256         return set_attribute_internal(attr, value, len);
 257 }
 258
 259 int fusion_sensor_handler::get_data(sensor_data_t **data, int *len)
 260 {
 261         retv_if(!m_sensor, -EINVAL);
 262
 263         return m_sensor->get_data(data, len);
 264 }
 265
 266 int fusion_sensor_handler::flush(sensor_observer *ob)
 267 {
 268         retv_if(!m_sensor, -EINVAL);
 269
 270         m_sensor->flush(this);
 271
 272         return OP_SUCCESS;
 273 }
 274
 275 int fusion_sensor_handler::start_required_sensors(void)
 276 {
 277         auto it = m_required_sensors.begin();
 278         for (; it != m_required_sensors.end(); ++it) {
 279                 if (it->second.sensor->start(this) < 0)
 280                         return OP_ERROR;
 281         }
 282
 283         return OP_SUCCESS;
 284 }
 285
 286 int fusion_sensor_handler::stop_required_sensors(void)
 287 {
 288         auto it = m_required_sensors.begin();
 289         for (; it != m_required_sensors.end(); ++it) {
 290                 if (it->second.sensor->stop(this) < 0)
 291                         return OP_ERROR;
 292         }
 293
 294         return OP_SUCCESS;
 295 }
 296
 297 int fusion_sensor_handler::set_interval_internal(int32_t interval)
 298 {
 299         auto it = m_required_sensors.begin();
 300         for (; it != m_required_sensors.end(); ++it) {
 301                 if (it->second.sensor->set_interval(this, interval) < 0)
 302                         return OP_ERROR;
 303         }
 304
 305         return OP_SUCCESS;
 306 }
 307
 308 int fusion_sensor_handler::set_batch_latency_internal(int32_t latency)
 309 {
 310         auto it = m_required_sensors.begin();
 311         for (; it != m_required_sensors.end(); ++it) {
 312                 if (it->second.sensor->set_batch_latency(this, latency) < 0)
 313                         return OP_ERROR;
 314         }
 315
 316         return OP_SUCCESS;
 317 }
 318
 319 int fusion_sensor_handler::set_attribute_internal(int32_t attr, int32_t value)
 320 {
 321         auto it = m_required_sensors.begin();
 322         for (; it != m_required_sensors.end(); ++it) {
 323                 if (it->second.sensor->set_attribute(this, attr, value) < 0)
 324                         return OP_ERROR;
 325         }
 326
 327         return OP_SUCCESS;
 328 }
 329
 330 int fusion_sensor_handler::set_attribute_internal(int32_t attr, const char *value, int len)
 331 {
 332         auto it = m_required_sensors.begin();
 333         for (; it != m_required_sensors.end(); ++it) {
 334                 if (it->second.sensor->set_attribute(this, attr, value, len) < 0)
 335                         return OP_ERROR;
 336         }
 337
 338         return OP_SUCCESS;
 339 }