src/client/sensor_listener.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 "sensor_listener.h"
  21
  22 #include <channel_handler.h>
  23 #include <sensor_log.h>
  24 #include <sensor_types.h>
  25 #include <command_types.h>
  26 #include <ipc_client.h>
  27
  28 using namespace sensor;
  29
  30 class listener_handler : public ipc::channel_handler
  31 {
  32 public:
  33         listener_handler(sensor_listener *listener)
  34         : m_listener(listener)
  35         {}
  36         void connected(ipc::channel *ch) {}
  37         void disconnected(ipc::channel *ch)
  38         {
  39                 /* If channel->disconnect() is not explicitly called,
  40                  * listener will be restored */
  41                 m_listener->restore();
  42         }
  43
  44         void read(ipc::channel *ch, ipc::message &msg)
  45         {
  46                 switch (msg.header()->type) {
  47                 case CMD_LISTENER_EVENT:
  48                         if (m_listener->get_event_handler())
  49                                 m_listener->get_event_handler()->read(ch, msg);
  50                         break;
  51                 case CMD_LISTENER_ACC_EVENT:
  52                         if (m_listener->get_accuracy_handler())
  53                                 m_listener->get_accuracy_handler()->read(ch, msg);
  54                         break;
  55                 }
  56         }
  57
  58         void read_complete(ipc::channel *ch) {}
  59         void error_caught(ipc::channel *ch, int error) {}
  60
  61 private:
  62         sensor_listener *m_listener;
  63 };
  64
  65 sensor_listener::sensor_listener(sensor_t sensor)
  66 : m_id(0)
  67 , m_sensor(reinterpret_cast<sensor_info *>(sensor))
  68 , m_client(NULL)
  69 , m_cmd_channel(NULL)
  70 , m_evt_channel(NULL)
  71 , m_handler(NULL)
  72 , m_evt_handler(NULL)
  73 , m_acc_handler(NULL)
  74 , m_connected(false)
  75 , m_started(false)
  76 {
  77         init();
  78 }
  79
  80 sensor_listener::~sensor_listener()
  81 {
  82         deinit();
  83 }
  84
  85 bool sensor_listener::init(void)
  86 {
  87         m_client = new(std::nothrow) ipc::ipc_client(SENSOR_CHANNEL_PATH);
  88         retvm_if(!m_client, false, "Failed to allocate memory");
  89
  90         m_handler = new(std::nothrow) listener_handler(this);
  91         if (!m_handler) {
  92                 delete m_client;
  93                 return false;
  94         }
  95
  96         if (!connect()) {
  97                 delete m_handler;
  98                 delete m_client;
  99                 m_handler = NULL;
 100                 m_client = NULL;
 101                 return false;
 102         }
 103
 104         return true;
 105 }
 106
 107 void sensor_listener::deinit(void)
 108 {
 109         disconnect();
 110
 111         delete m_handler;
 112         m_handler = NULL;
 113
 114         delete m_client;
 115         m_client = NULL;
 116
 117         m_attributes.clear();
 118 }
 119
 120 int sensor_listener::get_id(void)
 121 {
 122         return m_id;
 123 }
 124
 125 sensor_t sensor_listener::get_sensor(void)
 126 {
 127         return static_cast<sensor_t>(m_sensor);
 128 }
 129
 130 void sensor_listener::restore(void)
 131 {
 132         ret_if(!is_connected());
 133         retm_if(!connect(), "Failed to restore listener");
 134
 135         /* Restore attributes/status */
 136         if (m_started.load())
 137                 start();
 138
 139         auto interval = m_attributes.find(SENSORD_ATTRIBUTE_INTERVAL);
 140         if (interval != m_attributes.end())
 141                 set_interval(m_attributes[SENSORD_ATTRIBUTE_INTERVAL]);
 142
 143         auto latency = m_attributes.find(SENSORD_ATTRIBUTE_MAX_BATCH_LATENCY);
 144         if (latency != m_attributes.end())
 145                 set_max_batch_latency(m_attributes[SENSORD_ATTRIBUTE_MAX_BATCH_LATENCY]);
 146
 147         _D("Restored listener[%d]", get_id());
 148 }
 149
 150 bool sensor_listener::connect(void)
 151 {
 152         m_cmd_channel = m_client->connect(NULL);
 153         retvm_if(!m_cmd_channel, false, "Failed to connect to server");
 154
 155         m_evt_channel = m_client->connect(m_handler, &m_loop);
 156         retvm_if(!m_evt_channel, false, "Failed to connect to server");
 157
 158         ipc::message msg;
 159         ipc::message reply;
 160         cmd_listener_connect_t buf = {0, };
 161
 162         memcpy(buf.sensor, m_sensor->get_uri().c_str(), m_sensor->get_uri().size());
 163         msg.set_type(CMD_LISTENER_CONNECT);
 164         msg.enclose((const char *)&buf, sizeof(buf));
 165         m_evt_channel->send_sync(&msg);
 166
 167         m_evt_channel->read_sync(reply);
 168         reply.disclose((char *)&buf);
 169
 170         m_id = buf.listener_id;
 171         m_connected.store(true);
 172
 173         _D("Listener ID[%d]", get_id());
 174
 175         return true;
 176 }
 177
 178 void sensor_listener::disconnect(void)
 179 {
 180         ret_if(!is_connected());
 181         m_connected.store(false);
 182
 183         ipc::message msg;
 184         ipc::message reply;
 185
 186         msg.set_type(CMD_LISTENER_DISCONNECT);
 187         m_evt_channel->send_sync(&msg);
 188
 189         m_evt_channel->read_sync(reply);
 190         m_evt_channel->disconnect();
 191
 192         delete m_evt_channel;
 193         m_evt_channel = NULL;
 194
 195         m_cmd_channel->disconnect();
 196         delete m_cmd_channel;
 197         m_cmd_channel = NULL;
 198
 199         _I("Disconnected[%d]", get_id());
 200 }
 201
 202 bool sensor_listener::is_connected(void)
 203 {
 204         return m_connected.load();
 205 }
 206
 207 ipc::channel_handler *sensor_listener::get_event_handler(void)
 208 {
 209         return m_evt_handler;
 210 }
 211
 212 void sensor_listener::set_event_handler(ipc::channel_handler *handler)
 213 {
 214         m_evt_handler = handler;
 215 }
 216
 217 void sensor_listener::unset_event_handler(void)
 218 {
 219         delete m_evt_handler;
 220         m_evt_handler = NULL;
 221 }
 222
 223 ipc::channel_handler *sensor_listener::get_accuracy_handler(void)
 224 {
 225         return m_acc_handler;
 226 }
 227
 228 void sensor_listener::set_accuracy_handler(ipc::channel_handler *handler)
 229 {
 230         m_acc_handler = handler;
 231 }
 232
 233 void sensor_listener::unset_accuracy_handler(void)
 234 {
 235         delete m_acc_handler;
 236         m_acc_handler = NULL;
 237 }
 238
 239 int sensor_listener::start(void)
 240 {
 241         ipc::message msg;
 242         ipc::message reply;
 243         cmd_listener_start_t buf;
 244
 245         retvm_if(!m_cmd_channel, -EINVAL, "Failed to connect to server");
 246
 247         buf.listener_id = m_id;
 248         msg.set_type(CMD_LISTENER_START);
 249         msg.enclose((char *)&buf, sizeof(buf));
 250
 251         m_cmd_channel->send_sync(&msg);
 252         m_cmd_channel->read_sync(reply);
 253
 254         if (reply.header()->err < 0)
 255                 return reply.header()->err;
 256
 257         m_started.store(true);
 258
 259         return OP_SUCCESS;
 260 }
 261
 262 int sensor_listener::stop(void)
 263 {
 264         ipc::message msg;
 265         ipc::message reply;
 266         cmd_listener_stop_t buf;
 267
 268         retvm_if(!m_cmd_channel, -EINVAL, "Failed to connect to server");
 269         retvm_if(!m_started.load(), -EAGAIN, "Already stopped");
 270
 271         buf.listener_id = m_id;
 272         msg.set_type(CMD_LISTENER_STOP);
 273         msg.enclose((char *)&buf, sizeof(buf));
 274
 275         m_cmd_channel->send_sync(&msg);
 276         m_cmd_channel->read_sync(reply);
 277
 278         if (reply.header()->err < 0)
 279                 return reply.header()->err;
 280
 281         m_started.store(false);
 282
 283         return OP_SUCCESS;
 284 }
 285
 286 int sensor_listener::get_interval(void)
 287 {
 288         auto it = m_attributes.find(SENSORD_ATTRIBUTE_INTERVAL);
 289         retv_if(it == m_attributes.end(), -1);
 290
 291         return m_attributes[SENSORD_ATTRIBUTE_INTERVAL];
 292 }
 293
 294 int sensor_listener::get_max_batch_latency(void)
 295 {
 296         auto it = m_attributes.find(SENSORD_ATTRIBUTE_MAX_BATCH_LATENCY);
 297         retv_if(it == m_attributes.end(), -1);
 298
 299         return m_attributes[SENSORD_ATTRIBUTE_MAX_BATCH_LATENCY];
 300 }
 301
 302 int sensor_listener::get_pause_policy(void)
 303 {
 304         auto it = m_attributes.find(SENSORD_ATTRIBUTE_PAUSE_POLICY);
 305         retv_if(it == m_attributes.end(), -1);
 306
 307         return m_attributes[SENSORD_ATTRIBUTE_PAUSE_POLICY];
 308 }
 309
 310 int sensor_listener::get_passive_mode(void)
 311 {
 312         auto it = m_attributes.find(SENSORD_ATTRIBUTE_PASSIVE_MODE);
 313         retv_if(it == m_attributes.end(), -1);
 314
 315         return m_attributes[SENSORD_ATTRIBUTE_PASSIVE_MODE];
 316 }
 317
 318 int sensor_listener::set_interval(unsigned int interval)
 319 {
 320         int _interval;
 321
 322         /* TODO: move this logic to server */
 323         if (interval == 0)
 324                 _interval = DEFAULT_INTERVAL;
 325         else if (interval < (unsigned int)m_sensor->get_min_interval())
 326                 _interval = m_sensor->get_min_interval();
 327         else
 328                 _interval = interval;
 329
 330         return set_attribute(SENSORD_ATTRIBUTE_INTERVAL, _interval);
 331 }
 332
 333 int sensor_listener::set_max_batch_latency(unsigned int max_batch_latency)
 334 {
 335         return set_attribute(SENSORD_ATTRIBUTE_MAX_BATCH_LATENCY, max_batch_latency);
 336 }
 337
 338 int sensor_listener::set_passive_mode(bool passive)
 339 {
 340         return set_attribute(SENSORD_ATTRIBUTE_PASSIVE_MODE, passive);
 341 }
 342
 343 int sensor_listener::flush(void)
 344 {
 345         return set_attribute(SENSORD_ATTRIBUTE_FLUSH, 1);
 346 }
 347
 348 int sensor_listener::set_attribute(int attribute, int value)
 349 {
 350         ipc::message msg;
 351         ipc::message reply;
 352         cmd_listener_attr_int_t buf;
 353
 354         retvm_if(!m_cmd_channel, false, "Failed to connect to server");
 355
 356         buf.listener_id = m_id;
 357         buf.attribute = attribute;
 358         buf.value = value;
 359         msg.set_type(CMD_LISTENER_ATTR_INT);
 360         msg.enclose((char *)&buf, sizeof(buf));
 361
 362         m_cmd_channel->send_sync(&msg);
 363         m_cmd_channel->read_sync(reply);
 364
 365         if (reply.header()->err < 0)
 366                 return reply.header()->err;
 367
 368         m_attributes[attribute] = value;
 369
 370         return OP_SUCCESS;
 371 }
 372
 373 int sensor_listener::set_attribute(int attribute, const char *value, int len)
 374 {
 375         ipc::message msg;
 376         ipc::message reply;
 377         cmd_listener_attr_str_t buf;
 378
 379         retvm_if(!m_cmd_channel, false, "Failed to connect to server");
 380
 381         msg.set_type(CMD_LISTENER_ATTR_STR);
 382         buf.listener_id = m_id;
 383         buf.attribute = attribute;
 384         memcpy(buf.value, value, len);
 385         buf.len = len;
 386
 387         msg.enclose((char *)&buf, sizeof(buf) + len);
 388
 389         m_cmd_channel->send_sync(&msg);
 390         m_cmd_channel->read_sync(reply);
 391
 392         return reply.header()->err;
 393 }
 394
 395 int sensor_listener::get_sensor_data(sensor_data_t *data)
 396 {
 397         ipc::message msg;
 398         ipc::message reply;
 399         cmd_listener_get_data_t buf;
 400
 401         retvm_if(!m_cmd_channel, false, "Failed to connect to server");
 402
 403         buf.listener_id = m_id;
 404         msg.set_type(CMD_LISTENER_GET_DATA);
 405         msg.enclose((char *)&buf, sizeof(buf));
 406
 407         m_cmd_channel->send_sync(&msg);
 408         m_cmd_channel->read_sync(reply);
 409
 410         reply.disclose((char *)&buf);
 411         int size = sizeof(sensor_data_t);
 412
 413         if (buf.len > size || buf.len < 0) {
 414                 data->accuracy = -1;
 415                 data->value_count = 0;
 416                 /* TODO: it should return OP_ERROR */
 417                 return OP_SUCCESS;
 418         }
 419
 420         memcpy(data, &buf.data, buf.len);
 421
 422         return OP_SUCCESS;
 423 }
 424