src/sensorctl/sensor_adapter.cpp

   1 /*
   2  * sensorctl
   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_adapter.h"
  21
  22 #include <sensor_internal.h>
  23
  24 #include "log.h"
  25 #include "mainloop.h"
  26 #include "test_bench.h"
  27
  28 #define SENSOR_EVENT(type) ((type) << 16 | 0x1)
  29
  30 bool sensor_adapter::is_supported(sensor_type_t type)
  31 {
  32         sensor_t sensor;
  33
  34         int ret = sensord_get_default_sensor(type, &sensor);
  35         if (ret == 0)
  36                 return true;
  37
  38         return false;
  39 }
  40
  41 int sensor_adapter::get_count(sensor_type_t type)
  42 {
  43         sensor_t *sensors;
  44         int count = 0;
  45
  46         if (sensord_get_sensors(type, &sensors, &count) == 0)
  47                 free(sensors);
  48
  49         return count;
  50 }
  51
  52 bool sensor_adapter::get_handle(sensor_info info, int &handle)
  53 {
  54         int err;
  55         int count;
  56         sensor_t *sensors = NULL;
  57
  58         err = sensord_get_sensors(info.type, &sensors, &count);
  59         ASSERT_EQ(err, 0);
  60
  61         handle = sensord_connect(sensors[info.index]);
  62         ASSERT_FREE((handle < 0), sensors);
  63         ASSERT_GE(handle, 0);
  64
  65         free(sensors);
  66         sensors = NULL;
  67
  68         return true;
  69 }
  70
  71 bool sensor_adapter::start(sensor_info info, int &handle)
  72 {
  73         sensor_t *sensors = NULL;
  74         int count;
  75         int err;
  76         bool ret;
  77
  78         err = sensord_get_sensors(info.type, &sensors, &count);
  79         ASSERT_EQ(err, 0);
  80
  81         ASSERT_FREE((info.index >= count), sensors);
  82         ASSERT_LT(info.index, count);
  83
  84         ASSERT_FREE((info.index < 0), sensors);
  85         ASSERT_GE(info.index, 0);
  86
  87         handle = sensord_connect(sensors[info.index]);
  88         ASSERT_FREE((handle < 0), sensors);
  89         ASSERT_GE(handle, 0);
  90
  91         ret = sensord_register_event(handle, SENSOR_EVENT(info.type), info.interval, info.batch_latency, info.cb, NULL);
  92         ASSERT_FREE((ret != true), sensors);
  93         ASSERT_TRUE(ret);
  94
  95         ret = sensord_start(handle, info.powersave);
  96         ASSERT_FREE((ret != true), sensors);
  97         ASSERT_TRUE(ret);
  98
  99         free(sensors);
 100         sensors = NULL;
 101
 102         return true;
 103 }
 104
 105 bool sensor_adapter::stop(sensor_info info, int handle)
 106 {
 107         bool ret;
 108
 109         ret = sensord_stop(handle);
 110         EXPECT_TRUE(ret);
 111
 112         ret = sensord_unregister_event(handle, SENSOR_EVENT(info.type));
 113         EXPECT_TRUE(ret);
 114
 115         ret = sensord_disconnect(handle);
 116         EXPECT_TRUE(ret);
 117
 118         return true;
 119 }
 120
 121 bool sensor_adapter::change_interval(int handle, int interval)
 122 {
 123         return true;
 124 }
 125
 126 bool sensor_adapter::change_batch_latency(int handle, int batch_latency)
 127 {
 128         return true;
 129 }
 130
 131 bool sensor_adapter::change_powersave(int handle, int powersave)
 132 {
 133         return true;
 134 }
 135
 136 bool sensor_adapter::set_attribute(int handle, int attribute, int value)
 137 {
 138         bool ret;
 139
 140         ret = sensord_set_attribute_int(handle, attribute, value);
 141         ASSERT_TRUE(ret);
 142
 143         return true;
 144 }
 145
 146 bool sensor_adapter::set_attribute(int handle, int attribute, char *value, int size)
 147 {
 148         int ret;
 149
 150         ret = sensord_set_attribute_str(handle, attribute, value, size);
 151
 152         return ((ret == 0) ? true : false);
 153 }
 154
 155 bool sensor_adapter::get_data(int handle, sensor_type_t type, sensor_data_t &data)
 156 {
 157         bool ret;
 158
 159         ret = sensord_get_data(handle, SENSOR_EVENT(type), &data);
 160         ASSERT_TRUE(ret);
 161
 162         return true;
 163 }
 164
 165 bool sensor_adapter::flush(int handle)
 166 {
 167         bool ret;
 168
 169         ret = sensord_flush(handle);
 170         ASSERT_TRUE(ret);
 171
 172         return true;
 173 }
 174