src/server/physical_sensor.cpp

   1 /*
   2  * libsensord-share
   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 <physical_sensor.h>
  21 #include <sensor_event_queue.h>
  22
  23 #define UNKNOWN_NAME "UNKNOWN_SENSOR"
  24
  25 cmutex physical_sensor::m_mutex;
  26
  27 physical_sensor::physical_sensor()
  28 : m_sensor_device(NULL)
  29 {
  30 }
  31
  32 physical_sensor::~physical_sensor()
  33 {
  34 }
  35
  36 void physical_sensor::set_sensor_handle(sensor_handle_t handle)
  37 {
  38         m_handle.id = handle.id;
  39         m_handle.name = handle.name;
  40         m_handle.type = handle.type;
  41         m_handle.event_type = handle.event_type;
  42         m_handle.model_name = handle.model_name;
  43         m_handle.vendor = handle.vendor;
  44         m_handle.min_range = handle.min_range;
  45         m_handle.max_range = handle.max_range;
  46         m_handle.resolution = handle.resolution;
  47         m_handle.min_interval = handle.min_interval;
  48         m_handle.max_batch_count = handle.max_batch_count;
  49         m_handle.wakeup_supported = handle.wakeup_supported;
  50 }
  51
  52 void physical_sensor::set_sensor_device(sensor_device *device)
  53 {
  54         m_sensor_device = device;
  55 }
  56
  57 sensor_type_t physical_sensor::get_type(void)
  58 {
  59         return static_cast<sensor_type_t>(m_handle.type);
  60 }
  61
  62 unsigned int physical_sensor::get_event_type(void)
  63 {
  64         return m_handle.event_type;
  65 }
  66
  67 const char* physical_sensor::get_name(void)
  68 {
  69         if (!m_handle.name)
  70                 return UNKNOWN_NAME;
  71
  72         return m_handle.name;
  73 }
  74
  75 int physical_sensor::get_poll_fd()
  76 {
  77         AUTOLOCK(m_mutex);
  78
  79         if (!m_sensor_device)
  80                 return -1;
  81
  82         return m_sensor_device->get_poll_fd();
  83 }
  84
  85 bool physical_sensor::read_fd(std::vector<uint16_t> &ids)
  86 {
  87         AUTOLOCK(m_mutex);
  88         int size;
  89         uint16_t *_ids;
  90
  91         if (!m_sensor_device)
  92                 return false;
  93
  94         size = m_sensor_device->read_fd(&_ids);
  95
  96         for (int i = 0; i < size; ++i)
  97                 ids.push_back(_ids[i]);
  98
  99         return true;
 100 }
 101
 102 int physical_sensor::get_data(sensor_data_t **data, int *length)
 103 {
 104         AUTOLOCK(m_mutex);
 105
 106         if (!m_sensor_device)
 107                 return -1;
 108
 109         int remains = 0;
 110         remains = m_sensor_device->get_data(m_handle.id, data, length);
 111
 112         if (*length < 0) {
 113                 ERR("Failed to get sensor event");
 114                 return -1;
 115         }
 116
 117         return remains;
 118 }
 119
 120 bool physical_sensor::flush(void)
 121 {
 122         AUTOLOCK(m_mutex);
 123
 124         if (!m_sensor_device)
 125                 return false;
 126
 127         return m_sensor_device->flush(m_handle.id);
 128 }
 129
 130 bool physical_sensor::set_interval(unsigned long interval)
 131 {
 132         AUTOLOCK(m_mutex);
 133
 134         if (!m_sensor_device)
 135                 return false;
 136
 137         INFO("Polling interval is set to %dms", interval);
 138
 139         return m_sensor_device->set_interval(m_handle.id, interval);
 140 }
 141
 142 bool physical_sensor::set_batch_latency(unsigned long latency)
 143 {
 144         AUTOLOCK(m_mutex);
 145
 146         if (!m_sensor_device)
 147                 return false;
 148
 149         INFO("Polling interval is set to %dms", latency);
 150
 151         return m_sensor_device->set_batch_latency(m_handle.id, latency);
 152 }
 153
 154 int physical_sensor::set_attribute(int32_t attribute, int32_t value)
 155 {
 156         AUTOLOCK(m_mutex);
 157
 158         if (!m_sensor_device)
 159                 return false;
 160
 161         return m_sensor_device->set_attribute(m_handle.id, attribute, value);
 162 }
 163
 164 int physical_sensor::set_attribute(char *attribute, char *value, int value_len)
 165 {
 166         AUTOLOCK(m_mutex);
 167
 168         if (!m_sensor_device)
 169                 return false;
 170
 171         return m_sensor_device->set_attribute_str(m_handle.id, attribute, value, value_len);
 172 }
 173
 174 bool physical_sensor::set_wakeup(int wakeup)
 175 {
 176         return false;
 177 }
 178
 179 bool physical_sensor::on_start()
 180 {
 181         AUTOLOCK(m_mutex);
 182
 183         if (!m_sensor_device)
 184                 return false;
 185
 186         return m_sensor_device->enable(m_handle.id);
 187 }
 188
 189 bool physical_sensor::on_stop()
 190 {
 191         AUTOLOCK(m_mutex);
 192
 193         if (!m_sensor_device)
 194                 return false;
 195
 196         return m_sensor_device->disable(m_handle.id);
 197 }
 198
 199 bool physical_sensor::get_sensor_info(sensor_info &info)
 200 {
 201         info.set_type(get_type());
 202         info.set_id(get_id());
 203         info.set_privilege(SENSOR_PRIVILEGE_PUBLIC); // FIXME
 204         info.set_name(m_handle.model_name);
 205         info.set_vendor(m_handle.vendor);
 206         info.set_min_range(m_handle.min_range);
 207         info.set_max_range(m_handle.max_range);
 208         info.set_resolution(m_handle.resolution);
 209         info.set_min_interval(m_handle.min_interval);
 210         info.set_fifo_count(0); // FIXME
 211         info.set_max_batch_count(m_handle.max_batch_count);
 212         info.set_supported_event(get_event_type());
 213         info.set_wakeup_supported(m_handle.wakeup_supported);
 214
 215         return true;
 216 }
 217