src/api/sensor-provider.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-provider.h"
  21
  22 #include <message.h>
  23 #include <channel.h>
  24 #include <sensor-log-private.h>
  25 #include <sensor-types-private.h>
  26 #include <sensor-utils.h>
  27 #include <command-types.h>
  28 #include <cfloat>
  29 #include <cmath>
  30
  31 #include "sensor-provider-channel-handler.h"
  32
  33 #define DEFAULT_RESOLUTION 0.1
  34
  35 using namespace sensor;
  36
  37 sensor_provider::sensor_provider(const char *uri)
  38 : m_channel(NULL)
  39 , m_handler(NULL)
  40 , m_connected(false)
  41 {
  42         init(uri);
  43 }
  44
  45 sensor_provider::~sensor_provider()
  46 {
  47         deinit();
  48 }
  49
  50 bool sensor_provider::init(const char *uri)
  51 {
  52         m_handler = new(std::nothrow) channel_handler(this);
  53         if (!m_handler) {
  54                 return false;
  55         }
  56
  57         m_sensor.set_uri(uri);
  58         m_sensor.set_min_range(-FLT_MAX);
  59         m_sensor.set_max_range(FLT_MAX);
  60         m_sensor.set_resolution(DEFAULT_RESOLUTION);
  61         /* TODO: temporary walkaround */
  62         const char *priv = sensor::utils::get_privilege(uri);
  63         m_sensor.set_privilege(priv);
  64
  65         return true;
  66 }
  67
  68 void sensor_provider::deinit(void)
  69 {
  70         disconnect();
  71
  72         delete m_handler;
  73         m_handler = NULL;
  74 }
  75
  76 const char *sensor_provider::get_uri(void)
  77 {
  78         return m_sensor.get_uri().c_str();
  79 }
  80
  81 sensor_info *sensor_provider::get_sensor_info(void)
  82 {
  83         return &m_sensor;
  84 }
  85
  86 int sensor_provider::serialize(sensor_info *info, char **bytes)
  87 {
  88         int size;
  89         raw_data_t *raw = new(std::nothrow) raw_data_t;
  90         retvm_if(!raw, -ENOMEM, "Failed to allocated memory");
  91
  92         info->serialize(*raw);
  93
  94         *bytes = (char *) malloc(raw->size());
  95
  96         if (!(*bytes)) {
  97                 delete(raw);
  98                 _E("Failed to allocate memory");
  99                 return -ENOMEM;
 100         }
 101
 102         std::copy(raw->begin(), raw->end(), *bytes);
 103
 104         size = raw->size();
 105         delete raw;
 106
 107         return size;
 108 }
 109
 110 int sensor_provider::send_sensor_info(sensor_info *info)
 111 {
 112         char *bytes;
 113         int size;
 114
 115         size = serialize(info, &bytes);
 116         if (size < 0)
 117                 return OP_ERROR;
 118
 119         ipc::message msg((const char *)bytes, size);
 120         msg.set_type(CMD_PROVIDER_CONNECT);
 121
 122         m_channel->send_sync(msg);
 123
 124         return OP_SUCCESS;
 125 }
 126
 127 int sensor_provider::connect(void)
 128 {
 129         m_channel = new(std::nothrow) ipc::channel();
 130         retvm_if(!m_channel, -EIO, "Failed to allocate memory");
 131         m_channel->connect(m_handler, &m_loop, true);
 132
 133         /* serialize and send sensor info */
 134         send_sensor_info(get_sensor_info());
 135
 136         /* check error */
 137         ipc::message reply;
 138         m_channel->read_sync(reply);
 139         retv_if(reply.header()->err < 0, reply.header()->err);
 140
 141         m_connected.store(true);
 142
 143         _I("Provider URI[%s]", get_uri());
 144
 145         return OP_SUCCESS;
 146 }
 147
 148 bool sensor_provider::disconnect(void)
 149 {
 150         retv_if(!is_connected(), false);
 151         m_connected.store(false);
 152
 153         m_channel->disconnect();
 154         delete m_channel;
 155         m_channel = NULL;
 156
 157         _I("Disconnected[%s]", get_uri());
 158
 159         return true;
 160 }
 161
 162 void sensor_provider::restore(void)
 163 {
 164         ret_if(!is_connected());
 165         retm_if(!connect(), "Failed to restore provider");
 166
 167         _D("Restored provider[%s]", get_uri());
 168 }
 169
 170 int sensor_provider::publish(const sensor_data_t &data)
 171 {
 172         ipc::message msg;
 173         msg.set_type(CMD_PROVIDER_PUBLISH);
 174         msg.enclose((const void *)(&data), sizeof(data));
 175
 176         m_channel->send_sync(msg);
 177
 178         return OP_SUCCESS;
 179 }
 180
 181 int sensor_provider::publish(const sensor_data_t data[], const int count)
 182 {
 183         ipc::message msg;
 184         msg.set_type(CMD_PROVIDER_PUBLISH);
 185         msg.enclose((const void *)data, sizeof(sensor_data_t) * count);
 186
 187         m_channel->send_sync(msg);
 188
 189         return OP_SUCCESS;
 190 }
 191
 192 bool sensor_provider::is_connected(void)
 193 {
 194         return m_connected.load();
 195 }
 196
 197 void sensor_provider::set_start_cb(sensord_provider_start_cb cb, void *user_data)
 198 {
 199         m_handler->set_start_cb(cb, user_data);
 200 }
 201
 202 void sensor_provider::set_stop_cb(sensord_provider_stop_cb cb, void *user_data)
 203 {
 204         m_handler->set_stop_cb(cb, user_data);
 205 }
 206
 207 void sensor_provider::set_interval_cb(sensord_provider_interval_changed_cb cb, void *user_data)
 208 {
 209         m_handler->set_interval_cb(cb, user_data);
 210 }
 211
 212 void sensor_provider::set_attribute_str_cb(sensord_provider_attribute_str_cb cb, void *user_data)
 213 {
 214         m_handler->set_attribute_str_cb(cb, user_data);
 215 }
 216