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