src/sensor/auto_rotation/auto_rotation_sensor.cpp

   1 /*
   2  * sensord
   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 <stdio.h>
  21 #include <stdlib.h>
  22 #include <unistd.h>
  23 #include <errno.h>
  24 #include <math.h>
  25 #include <time.h>
  26 #include <sys/types.h>
  27 #include <dlfcn.h>
  28
  29 #include <sensor_log.h>
  30 #include <sensor_types.h>
  31
  32 #include <sensor_common.h>
  33 #include <virtual_sensor.h>
  34 #include <auto_rotation_sensor.h>
  35 #include <sensor_loader.h>
  36 #include <auto_rotation_alg.h>
  37 #include <auto_rotation_alg_emul.h>
  38
  39 #define SENSOR_NAME "SENSOR_AUTO_ROTATION"
  40
  41 auto_rotation_sensor::auto_rotation_sensor()
  42 : m_accel_sensor(NULL)
  43 , m_alg(NULL)
  44 , m_rotation(0)
  45 , m_interval(100)
  46 , m_rotation_time(0)
  47 {
  48 }
  49
  50 auto_rotation_sensor::~auto_rotation_sensor()
  51 {
  52         delete m_alg;
  53
  54         _I("auto_rotation_sensor is destroyed!\n");
  55 }
  56
  57 bool auto_rotation_sensor::init(void)
  58 {
  59         m_accel_sensor = sensor_loader::get_instance().get_sensor(ACCELEROMETER_SENSOR);
  60
  61         if (!m_accel_sensor) {
  62                 _E("cannot load accel sensor_hal from %s", get_name());
  63                 return false;
  64         }
  65
  66         m_alg = get_alg();
  67
  68         if (!m_alg) {
  69                 _E("Not supported AUTO ROTATION sensor");
  70                 return false;
  71         }
  72
  73         if (!m_alg->open())
  74                 return false;
  75
  76         _I("%s is created!\n", get_name());
  77
  78         return true;
  79 }
  80
  81 sensor_type_t auto_rotation_sensor::get_type(void)
  82 {
  83         return AUTO_ROTATION_SENSOR;
  84 }
  85
  86 unsigned int auto_rotation_sensor::get_event_type(void)
  87 {
  88         return AUTO_ROTATION_EVENT_CHANGE_STATE;
  89 }
  90
  91 const char* auto_rotation_sensor::get_name(void)
  92 {
  93         return SENSOR_NAME;
  94 }
  95
  96 bool auto_rotation_sensor::get_sensor_info(sensor_info &info)
  97 {
  98         info.set_type(get_type());
  99         info.set_id(get_id());
 100         info.set_privilege(SENSOR_PRIVILEGE_PUBLIC); // FIXME
 101         info.set_name("Auto Rotation Sensor");
 102         info.set_vendor("Samsung Electronics");
 103         info.set_min_range(AUTO_ROTATION_DEGREE_UNKNOWN);
 104         info.set_max_range(AUTO_ROTATION_DEGREE_270);
 105         info.set_resolution(1);
 106         info.set_min_interval(1);
 107         info.set_fifo_count(0);
 108         info.set_max_batch_count(0);
 109         info.set_supported_event(get_event_type());
 110         info.set_wakeup_supported(false);
 111
 112         return true;
 113 }
 114
 115 void auto_rotation_sensor::synthesize(const sensor_event_t& event)
 116 {
 117         if (event.event_type != ACCELEROMETER_EVENT_RAW_DATA_REPORT_ON_TIME)
 118                 return;
 119
 120         int rotation;
 121         float acc[3];
 122         acc[0] = event.data->values[0];
 123         acc[1] = event.data->values[1];
 124         acc[2] = event.data->values[2];
 125
 126         if (!m_alg->get_rotation(acc, event.data->timestamp, m_rotation, rotation))
 127                 return;
 128
 129         m_rotation = rotation;
 130         m_rotation_time = event.data->timestamp;
 131
 132         sensor_event_t *rotation_event;
 133         sensor_data_t *rotation_data;
 134         int data_length;
 135         int remains;
 136
 137         rotation_event = (sensor_event_t *)malloc(sizeof(sensor_event_t));
 138         if (!rotation_event) {
 139                 _E("Failed to allocate memory");
 140                 return;
 141         }
 142
 143         remains = get_data(&rotation_data, &data_length);
 144
 145         if (remains < 0) {
 146                 free(rotation_event);
 147                 return;
 148         }
 149
 150         rotation_event->sensor_id = get_id();
 151         rotation_event->event_type = AUTO_ROTATION_EVENT_CHANGE_STATE;
 152         rotation_event->data_length = data_length;
 153         rotation_event->data = rotation_data;
 154
 155         push(rotation_event);
 156
 157         _D("Rotation: %d, ACC[0]: %f, ACC[1]: %f, ACC[2]: %f", rotation, event.data->values[0], event.data->values[1], event.data->values[2]);
 158         return;
 159 }
 160
 161 int auto_rotation_sensor::get_data(sensor_data_t **data, int *length)
 162 {
 163         /* if It is batch sensor, remains can be 2+ */
 164         int remains = 1;
 165
 166         sensor_data_t *sensor_data;
 167         sensor_data = (sensor_data_t *)malloc(sizeof(sensor_data_t));
 168
 169         sensor_data->accuracy = SENSOR_ACCURACY_GOOD;
 170         sensor_data->timestamp = m_rotation_time;
 171         sensor_data->values[0] = m_rotation;
 172         sensor_data->value_count = 1;
 173
 174         *data = sensor_data;
 175         *length = sizeof(sensor_data_t);
 176
 177         return --remains;
 178 }
 179
 180 bool auto_rotation_sensor::set_interval(unsigned long interval)
 181 {
 182         m_accel_sensor->add_interval((intptr_t)this , m_interval, true);
 183
 184         m_interval = interval;
 185         return false;
 186 }
 187
 188 bool auto_rotation_sensor::set_batch_latency(unsigned long latency)
 189 {
 190         return false;
 191 }
 192
 193 bool auto_rotation_sensor::set_wakeup(int wakeup)
 194 {
 195         return false;
 196 }
 197
 198 bool auto_rotation_sensor::on_start(void)
 199 {
 200         m_rotation = AUTO_ROTATION_DEGREE_UNKNOWN;
 201
 202         m_alg->start();
 203
 204         m_accel_sensor->add_interval((intptr_t)this , m_interval, true);
 205         m_accel_sensor->start();
 206
 207         return activate();
 208 }
 209
 210 bool auto_rotation_sensor::on_stop(void)
 211 {
 212         m_accel_sensor->delete_interval((intptr_t)this , true);
 213         m_accel_sensor->stop();
 214
 215         return deactivate();
 216 }
 217
 218 auto_rotation_alg *auto_rotation_sensor::get_alg()
 219 {
 220         auto_rotation_alg *alg = new(std::nothrow) auto_rotation_alg_emul();
 221         retvm_if(!alg, NULL, "Failed to allocate memory");
 222
 223         return alg;
 224 }