src/shared/sensor_info.cpp

   1 /*
   2  * libsensord
   3  *
   4  * Copyright (c) 2014 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_info.h>
  21 #include <sensor_logs.h>
  22 #include <algorithm>
  23 #include <vector>
  24 #include <string>
  25
  26 using std::vector;
  27 using std::string;
  28
  29 sensor_type_t sensor_info::get_type(void)
  30 {
  31         return m_type;
  32 }
  33
  34 sensor_id_t sensor_info::get_id(void)
  35 {
  36         return m_id;
  37 }
  38
  39 sensor_privilege_t sensor_info::get_privilege(void)
  40 {
  41         return m_privilege;
  42 }
  43
  44 const char* sensor_info::get_name(void)
  45 {
  46         return m_name.c_str();
  47 }
  48
  49 const char* sensor_info::get_vendor(void)
  50 {
  51         return m_vendor.c_str();
  52 }
  53
  54 float sensor_info::get_min_range(void)
  55 {
  56         return m_min_range;
  57 }
  58
  59 float sensor_info::get_max_range(void)
  60 {
  61         return m_max_range;
  62 }
  63
  64 float sensor_info::get_resolution(void)
  65 {
  66         return m_resolution;
  67 }
  68
  69 int sensor_info::get_min_interval(void)
  70 {
  71         return m_min_interval;
  72 }
  73
  74 int sensor_info::get_fifo_count(void)
  75 {
  76         return m_fifo_count;
  77 }
  78
  79 int sensor_info::get_max_batch_count(void)
  80 {
  81         return m_max_batch_count;
  82 }
  83
  84 unsigned int sensor_info::get_supported_event()
  85 {
  86         return m_supported_event;
  87 }
  88
  89 bool sensor_info::is_supported_event(unsigned int event)
  90 {
  91         if (event != m_supported_event)
  92                 return false;
  93
  94         return true;
  95 }
  96
  97 bool sensor_info::is_wakeup_supported(void)
  98 {
  99         return m_wakeup_supported;
 100 }
 101
 102 void sensor_info::set_type(sensor_type_t type)
 103 {
 104         m_type = type;
 105 }
 106
 107 void sensor_info::set_id(sensor_id_t id)
 108 {
 109         m_id = id;
 110 }
 111
 112 void sensor_info::set_privilege(sensor_privilege_t privilege)
 113 {
 114         m_privilege = privilege;
 115 }
 116
 117 void sensor_info::set_name(const char *name)
 118 {
 119         m_name = name;
 120 }
 121
 122 void sensor_info::set_vendor(const char *vendor)
 123 {
 124         m_vendor = vendor;
 125 }
 126
 127 void sensor_info::set_min_range(float min_range)
 128 {
 129         m_min_range = min_range;
 130 }
 131
 132 void sensor_info::set_max_range(float max_range)
 133 {
 134         m_max_range = max_range;
 135 }
 136
 137 void sensor_info::set_resolution(float resolution)
 138 {
 139         m_resolution = resolution;
 140 }
 141
 142 void sensor_info::set_min_interval(int min_interval)
 143 {
 144         m_min_interval = min_interval;
 145 }
 146
 147 void sensor_info::set_fifo_count(int fifo_count)
 148 {
 149         m_fifo_count = fifo_count;
 150 }
 151
 152 void sensor_info::set_max_batch_count(int max_batch_count)
 153 {
 154         m_max_batch_count = max_batch_count;
 155 }
 156
 157 void sensor_info::set_supported_event(unsigned int event)
 158 {
 159         m_supported_event = event;
 160 }
 161
 162 void sensor_info::set_wakeup_supported(bool supported)
 163 {
 164         m_wakeup_supported = supported;
 165 }
 166
 167 void sensor_info::get_raw_data(raw_data_t &data)
 168 {
 169         put(data, (int) m_type);
 170         put(data, m_id);
 171         put(data, (int) m_privilege);
 172         put(data, m_name);
 173         put(data, m_vendor);
 174         put(data, m_min_range);
 175         put(data, m_max_range);
 176         put(data, m_resolution);
 177         put(data, m_min_interval);
 178         put(data, m_fifo_count);
 179         put(data, m_max_batch_count);
 180         put(data, m_supported_event);
 181         put(data, m_wakeup_supported);
 182 }
 183
 184 void sensor_info::set_raw_data(const char *data, int data_len)
 185 {
 186         raw_data_t raw_data(&data[0], &data[data_len]);
 187
 188         auto it_r_data = raw_data.begin();
 189
 190         int type, privilege;
 191         int64_t id;
 192
 193         it_r_data = get(it_r_data, type);
 194         m_type = (sensor_type_t) type;
 195         it_r_data = get(it_r_data, id);
 196         m_id = (sensor_id_t) id;
 197         it_r_data = get(it_r_data, privilege);
 198         m_privilege = (sensor_privilege_t) privilege;
 199         it_r_data = get(it_r_data, m_name);
 200         it_r_data = get(it_r_data, m_vendor);
 201         it_r_data = get(it_r_data, m_min_range);
 202         it_r_data = get(it_r_data, m_max_range);
 203         it_r_data = get(it_r_data, m_resolution);
 204         it_r_data = get(it_r_data, m_min_interval);
 205         it_r_data = get(it_r_data, m_fifo_count);
 206         it_r_data = get(it_r_data, m_max_batch_count);
 207         it_r_data = get(it_r_data, m_supported_event);
 208         it_r_data = get(it_r_data, m_wakeup_supported);
 209 }
 210
 211 void sensor_info::show(void)
 212 {
 213         _I("Type = %d", m_type);
 214         _I("ID = 0x%llx", (int64_t)m_id);
 215         _I("Privilege = %d", (int)m_privilege);
 216         _I("Name = %s", m_name.c_str());
 217         _I("Vendor = %s", m_vendor.c_str());
 218         _I("Min_range = %f", m_min_range);
 219         _I("Max_range = %f", m_max_range);
 220         _I("Resolution = %f", m_resolution);
 221         _I("Min_interval = %d", m_min_interval);
 222         _I("Fifo_count = %d", m_fifo_count);
 223         _I("Max_batch_count = %d", m_max_batch_count);
 224         _I("supported_event = 0x%x", m_supported_event);
 225
 226         _I("Wakeup_supported = %d", m_wakeup_supported);
 227 }
 228
 229
 230 void sensor_info::clear(void)
 231 {
 232         m_type = UNKNOWN_SENSOR;
 233         m_id = -1;
 234         m_privilege = SENSOR_PRIVILEGE_PUBLIC;
 235         m_name.clear();
 236         m_vendor.clear();
 237         m_min_range = 0.0f;
 238         m_max_range = 0.0f;
 239         m_resolution = 0.0f;
 240         m_min_interval = 0;
 241         m_fifo_count = 0;
 242         m_max_batch_count = 0;
 243         m_supported_event = 0;
 244         m_wakeup_supported = false;
 245 }
 246
 247
 248 void sensor_info::put(raw_data_t &data, int value)
 249 {
 250         char buffer[sizeof(value)];
 251
 252         int *temp = (int *) buffer;
 253         *temp = value;
 254
 255         copy(&buffer[0], &buffer[sizeof(buffer)], back_inserter(data));
 256 }
 257
 258 void sensor_info::put(raw_data_t &data, unsigned int value)
 259 {
 260         char buffer[sizeof(value)];
 261
 262         unsigned int *temp = (unsigned int *) buffer;
 263         *temp = value;
 264
 265         copy(&buffer[0], &buffer[sizeof(buffer)], back_inserter(data));
 266 }
 267
 268 void sensor_info::put(raw_data_t &data, int64_t value)
 269 {
 270         char buffer[sizeof(value)];
 271
 272         int64_t *temp = (int64_t *) buffer;
 273         *temp = value;
 274
 275         copy(&buffer[0], &buffer[sizeof(buffer)], back_inserter(data));
 276 }
 277
 278 void sensor_info::put(raw_data_t &data, float value)
 279 {
 280         char buffer[sizeof(value)];
 281
 282         float *temp = (float *) buffer;
 283         *temp = value;
 284
 285         copy(&buffer[0], &buffer[sizeof(buffer)], back_inserter(data));
 286 }
 287
 288 void sensor_info::put(raw_data_t &data, string &value)
 289 {
 290         put(data, (int) value.size());
 291
 292         copy(value.begin(), value.end(), back_inserter(data));
 293 }
 294
 295 void sensor_info::put(raw_data_t &data, bool value)
 296 {
 297         char buffer[sizeof(value)];
 298
 299         bool *temp = (bool *) buffer;
 300         *temp = value;
 301
 302         copy(&buffer[0], &buffer[sizeof(buffer)], back_inserter(data));
 303 }
 304
 305 raw_data_iterator sensor_info::get(raw_data_iterator it, int &value)
 306 {
 307         copy(it, it + sizeof(value), (char*) &value);
 308
 309         return it + sizeof(value);
 310 }
 311
 312 raw_data_iterator sensor_info::get(raw_data_iterator it, unsigned int &value)
 313 {
 314         copy(it, it + sizeof(value), (char*) &value);
 315
 316         return it + sizeof(value);
 317 }
 318
 319 raw_data_iterator sensor_info::get(raw_data_iterator it, int64_t &value)
 320 {
 321         copy(it, it + sizeof(value), (char*) &value);
 322
 323         return it + sizeof(value);
 324 }
 325
 326 raw_data_iterator sensor_info::get(raw_data_iterator it, float &value)
 327 {
 328         copy(it, it + sizeof(value), (char*) &value);
 329
 330         return it + sizeof(value);
 331 }
 332
 333 raw_data_iterator sensor_info::get(raw_data_iterator it, string &value)
 334 {
 335         int len;
 336
 337         it = get(it, len);
 338
 339         copy(it, it + len, back_inserter(value));
 340
 341         return it + len;
 342 }
 343
 344 raw_data_iterator sensor_info::get(raw_data_iterator it, bool &value)
 345 {
 346         copy(it, it + sizeof(value), (char*) &value);
 347
 348         return it + sizeof(value);
 349 }