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