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 : m_info(info)
  62 , m_notifier(NULL)
  63 , m_policy(OP_DEFAULT)
  64 {
  65         init();
  66 }
  67
  68 external_sensor_handler::~external_sensor_handler()
  69 {
  70         deinit();
  71 }
  72
  73 bool external_sensor_handler::init(void)
  74 {
  75         m_notifier = new(std::nothrow) external_sensor_notifier(this);
  76         retvm_if(!m_notifier, false, "Failed to allocate memory");
  77
  78         m_sensor->set_notifier(m_notifier);
  79         return true;
  80 }
  81
  82 void external_sensor_handler::deinit(void)
  83 {
  84         delete m_notifier;
  85         m_notifier = NULL;
  86 }
  87
  88 const sensor_info &external_sensor_handler::get_sensor_info(void)
  89 {
  90         return m_info;
  91 }
  92
  93 int external_sensor_handler::start(sensor_observer *ob)
  94 {
  95         retv_if(!m_sensor, -EINVAL);
  96
  97         int policy = m_sensor->start(ob);
  98         retv_if(policy <= OP_ERROR, policy);
  99
 100         return OP_SUCCESS;
 101 }
 102
 103 int external_sensor_handler::stop(sensor_observer *ob)
 104 {
 105         retv_if(!m_sensor, -EINVAL);
 106
 107         int policy = m_sensor->stop(ob);
 108         retv_if(policy <= OP_ERROR, policy);
 109
 110         remove_observer(ob);
 111
 112         return OP_SUCCESS;
 113 }
 114
 115 int external_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 external_sensor_handler::set_interval(sensor_observer *ob, int32_t interval)
 136 {
 137         retv_if(!m_sensor, -EINVAL);
 138
 139         int _interval = interval;
 140
 141         if ((m_policy == OP_DEFAULT && observer_count() == 0) || m_policy == OP_SUCCESS) {
 142                 m_policy = m_sensor->set_interval(ob, interval);
 143                 retv_if(m_policy <= OP_ERROR, m_policy);
 144         }
 145
 146         m_interval_map[ob] = interval;
 147
 148         if (m_policy == OP_DEFAULT && observer_count() > 0) {
 149                 _interval = get_min_interval();
 150                 return m_sensor->set_interval(ob, _interval);
 151         }
 152
 153         return OP_SUCCESS;
 154 }
 155
 156 int external_sensor_handler::get_min_batch_latency(void)
 157 {
 158         int batch_latency;
 159         std::vector<int> temp;
 160
 161         for (auto it = m_batch_latency_map.begin(); it != m_batch_latency_map.end(); ++it)
 162                 if (it->second > 0)
 163                     temp.push_back(it->second);
 164
 165         if (temp.empty())
 166                 return 0;
 167
 168         batch_latency = *std::min_element(temp.begin(), temp.end());
 169
 170         return batch_latency;
 171 }
 172
 173 int external_sensor_handler::set_batch_latency(sensor_observer *ob, int32_t latency)
 174 {
 175         retv_if(!m_sensor, -EINVAL);
 176
 177         int _latency = latency;
 178
 179         if ((m_policy == OP_DEFAULT && observer_count() == 0) || m_policy == OP_SUCCESS) {
 180                 m_policy = m_sensor->set_batch_latency(ob, latency);
 181                 retv_if(m_policy <= OP_ERROR, m_policy);
 182         }
 183
 184         m_batch_latency_map[ob] = _latency;
 185
 186         if (m_policy == OP_DEFAULT && observer_count() > 0) {
 187                 _latency = get_min_batch_latency();
 188                 return m_sensor->set_batch_latency(ob, latency);
 189         }
 190         return OP_SUCCESS;
 191 }
 192
 193 int external_sensor_handler::set_attribute(sensor_observer *ob, int32_t attr, int32_t value)
 194 {
 195         retv_if(!m_sensor, -EINVAL);
 196
 197         if ((m_policy == OP_DEFAULT && observer_count() == 0) || m_policy == OP_SUCCESS) {
 198                 m_policy = m_sensor->set_attribute(ob, attr, value);
 199                 retv_if(m_policy <= OP_ERROR, m_policy);
 200         }
 201
 202         if (m_policy == OP_DEFAULT) {
 203                 /* default logic */
 204         }
 205         return OP_SUCCESS;
 206 }
 207
 208 int external_sensor_handler::set_attribute(sensor_observer *ob, int32_t attr, const char *value, int len)
 209 {
 210         retv_if(!m_sensor, -EINVAL);
 211
 212         if ((m_policy == OP_DEFAULT && observer_count() == 0) || m_policy == OP_SUCCESS) {
 213                 m_policy = m_sensor->set_attribute(ob, attr, value, len);
 214                 retv_if(m_policy <= OP_ERROR, m_policy);
 215         }
 216
 217         if (m_policy == OP_DEFAULT) {
 218                 /* default logic */
 219         }
 220         return OP_SUCCESS;
 221 }
 222
 223 int external_sensor_handler::get_data(sensor_data_t **data, int *len)
 224 {
 225         return m_sensor->get_data(data, len);
 226 }
 227
 228 int external_sensor_handler::flush(sensor_observer *ob)
 229 {
 230         retv_if(!m_sensor, -EINVAL);
 231
 232         m_sensor->flush(this);
 233
 234         return OP_SUCCESS;
 235 }