Sensor.cpp revision 8f515ce1c57379cafac4357bc4fdb61dd346ec5f 
1/*
2 * Copyright (C) 2010 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include <inttypes.h>
18#include <stdint.h>
19#include <sys/types.h>
20#include <sys/limits.h>
21
22#include <utils/Errors.h>
23#include <utils/String8.h>
24#include <utils/Flattenable.h>
25
26#include <hardware/sensors.h>
27
28#include <gui/Sensor.h>
29#include <log/log.h>
30
31// ----------------------------------------------------------------------------
32namespace android {
33// ----------------------------------------------------------------------------
34
35Sensor::Sensor()
36    : mHandle(0), mType(0),
37      mMinValue(0), mMaxValue(0), mResolution(0),
38      mPower(0), mMinDelay(0), mFifoReservedEventCount(0), mFifoMaxEventCount(0),
39      mMaxDelay(0), mWakeUpSensor(false)
40{
41}
42
43Sensor::Sensor(struct sensor_t const* hwSensor, int halVersion)
44{
45    mName = hwSensor->name;
46    mVendor = hwSensor->vendor;
47    mVersion = hwSensor->version;
48    mHandle = hwSensor->handle;
49    mType = hwSensor->type;
50    mMinValue = 0;                      // FIXME: minValue
51    mMaxValue = hwSensor->maxRange;     // FIXME: maxValue
52    mResolution = hwSensor->resolution;
53    mPower = hwSensor->power;
54    mMinDelay = hwSensor->minDelay;
55    mWakeUpSensor = false;
56
57    // Set fifo event count zero for older devices which do not support batching. Fused
58    // sensors also have their fifo counts set to zero.
59    if (halVersion >= SENSORS_DEVICE_API_VERSION_1_1) {
60        mFifoReservedEventCount = hwSensor->fifoReservedEventCount;
61        mFifoMaxEventCount = hwSensor->fifoMaxEventCount;
62    } else {
63        mFifoReservedEventCount = 0;
64        mFifoMaxEventCount = 0;
65    }
66
67    if (halVersion >= SENSORS_DEVICE_API_VERSION_1_3) {
68        if (hwSensor->maxDelay > INT_MAX) {
69            // Max delay is declared as a 64 bit integer for 64 bit architectures. But it should
70            // always fit in a 32 bit integer, log error and cap it to INT_MAX.
71            ALOGE("Sensor maxDelay overflow error %s %" PRId64, mName.string(),
72                  static_cast<int64_t>(hwSensor->maxDelay));
73            mMaxDelay = INT_MAX;
74        } else {
75            mMaxDelay = (int32_t) hwSensor->maxDelay;
76        }
77    } else {
78        // For older hals set maxDelay to 0.
79        mMaxDelay = 0;
80    }
81
82    // Ensure existing sensors have correct string type and required
83    // permissions.
84    switch (mType) {
85    case SENSOR_TYPE_ACCELEROMETER:
86        mStringType = SENSOR_STRING_TYPE_ACCELEROMETER;
87        break;
88    case SENSOR_TYPE_AMBIENT_TEMPERATURE:
89        mStringType = SENSOR_STRING_TYPE_AMBIENT_TEMPERATURE;
90        break;
91    case SENSOR_TYPE_GAME_ROTATION_VECTOR:
92        mStringType = SENSOR_STRING_TYPE_GAME_ROTATION_VECTOR;
93        break;
94    case SENSOR_TYPE_GEOMAGNETIC_ROTATION_VECTOR:
95        mStringType = SENSOR_STRING_TYPE_GEOMAGNETIC_ROTATION_VECTOR;
96        break;
97    case SENSOR_TYPE_GRAVITY:
98        mStringType = SENSOR_STRING_TYPE_GRAVITY;
99        break;
100    case SENSOR_TYPE_GYROSCOPE:
101        mStringType = SENSOR_STRING_TYPE_GYROSCOPE;
102        break;
103    case SENSOR_TYPE_GYROSCOPE_UNCALIBRATED:
104        mStringType = SENSOR_STRING_TYPE_GYROSCOPE_UNCALIBRATED;
105        break;
106    case SENSOR_TYPE_HEART_RATE:
107        mStringType = SENSOR_STRING_TYPE_HEART_RATE;
108        mRequiredPermission = SENSOR_PERMISSION_BODY_SENSORS;
109        break;
110    case SENSOR_TYPE_LIGHT:
111        mStringType = SENSOR_STRING_TYPE_LIGHT;
112        break;
113    case SENSOR_TYPE_LINEAR_ACCELERATION:
114        mStringType = SENSOR_STRING_TYPE_LINEAR_ACCELERATION;
115        break;
116    case SENSOR_TYPE_MAGNETIC_FIELD:
117        mStringType = SENSOR_STRING_TYPE_MAGNETIC_FIELD;
118        break;
119    case SENSOR_TYPE_MAGNETIC_FIELD_UNCALIBRATED:
120        mStringType = SENSOR_STRING_TYPE_MAGNETIC_FIELD_UNCALIBRATED;
121        break;
122    case SENSOR_TYPE_ORIENTATION:
123        mStringType = SENSOR_STRING_TYPE_ORIENTATION;
124        break;
125    case SENSOR_TYPE_PRESSURE:
126        mStringType = SENSOR_STRING_TYPE_PRESSURE;
127        break;
128    case SENSOR_TYPE_PROXIMITY:
129        mStringType = SENSOR_STRING_TYPE_PROXIMITY;
130        mWakeUpSensor = true;
131        break;
132    case SENSOR_TYPE_RELATIVE_HUMIDITY:
133        mStringType = SENSOR_STRING_TYPE_RELATIVE_HUMIDITY;
134        break;
135    case SENSOR_TYPE_ROTATION_VECTOR:
136        mStringType = SENSOR_STRING_TYPE_ROTATION_VECTOR;
137        break;
138    case SENSOR_TYPE_SIGNIFICANT_MOTION:
139        mStringType = SENSOR_STRING_TYPE_SIGNIFICANT_MOTION;
140        mWakeUpSensor = true;
141        break;
142    case SENSOR_TYPE_STEP_COUNTER:
143        mStringType = SENSOR_STRING_TYPE_STEP_COUNTER;
144        break;
145    case SENSOR_TYPE_STEP_DETECTOR:
146        mStringType = SENSOR_STRING_TYPE_STEP_DETECTOR;
147        break;
148    case SENSOR_TYPE_TEMPERATURE:
149        mStringType = SENSOR_STRING_TYPE_TEMPERATURE;
150        break;
151    case SENSOR_TYPE_NON_WAKE_UP_PROXIMITY_SENSOR:
152        mStringType = SENSOR_STRING_TYPE_NON_WAKE_UP_PROXIMITY_SENSOR;
153        break;
154    case SENSOR_TYPE_WAKE_UP_ACCELEROMETER:
155        mStringType = SENSOR_STRING_TYPE_WAKE_UP_ACCELEROMETER;
156        mWakeUpSensor = true;
157        break;
158    case SENSOR_TYPE_WAKE_UP_MAGNETIC_FIELD:
159        mStringType = SENSOR_STRING_TYPE_WAKE_UP_MAGNETIC_FIELD;
160        mWakeUpSensor = true;
161        break;
162    case SENSOR_TYPE_WAKE_UP_ORIENTATION:
163        mStringType = SENSOR_STRING_TYPE_WAKE_UP_ORIENTATION;
164        mWakeUpSensor = true;
165        break;
166    case SENSOR_TYPE_WAKE_UP_GYROSCOPE:
167        mStringType = SENSOR_STRING_TYPE_WAKE_UP_GYROSCOPE;
168        mWakeUpSensor = true;
169        break;
170    case SENSOR_TYPE_WAKE_UP_LIGHT:
171        mStringType = SENSOR_STRING_TYPE_WAKE_UP_LIGHT;
172        mWakeUpSensor = true;
173        break;
174    case SENSOR_TYPE_WAKE_UP_PRESSURE:
175        mStringType = SENSOR_STRING_TYPE_WAKE_UP_PRESSURE;
176        mWakeUpSensor = true;
177        break;
178    case SENSOR_TYPE_WAKE_UP_GRAVITY:
179        mStringType = SENSOR_STRING_TYPE_WAKE_UP_GRAVITY;
180        mWakeUpSensor = true;
181        break;
182    case SENSOR_TYPE_WAKE_UP_LINEAR_ACCELERATION:
183        mStringType = SENSOR_STRING_TYPE_WAKE_UP_LINEAR_ACCELERATION;
184        mWakeUpSensor = true;
185        break;
186    case SENSOR_TYPE_WAKE_UP_ROTATION_VECTOR:
187        mStringType = SENSOR_STRING_TYPE_WAKE_UP_ROTATION_VECTOR;
188        mWakeUpSensor = true;
189        break;
190    case SENSOR_TYPE_WAKE_UP_RELATIVE_HUMIDITY:
191        mStringType = SENSOR_STRING_TYPE_WAKE_UP_RELATIVE_HUMIDITY;
192        mWakeUpSensor = true;
193        break;
194    case SENSOR_TYPE_WAKE_UP_AMBIENT_TEMPERATURE:
195        mStringType = SENSOR_STRING_TYPE_WAKE_UP_AMBIENT_TEMPERATURE;
196        mWakeUpSensor = true;
197        break;
198    case SENSOR_TYPE_WAKE_UP_MAGNETIC_FIELD_UNCALIBRATED:
199        mStringType = SENSOR_STRING_TYPE_WAKE_UP_MAGNETIC_FIELD_UNCALIBRATED;
200        mWakeUpSensor = true;
201        break;
202    case SENSOR_TYPE_WAKE_UP_GAME_ROTATION_VECTOR:
203        mStringType = SENSOR_STRING_TYPE_WAKE_UP_GAME_ROTATION_VECTOR;
204        mWakeUpSensor = true;
205        break;
206    case SENSOR_TYPE_WAKE_UP_GYROSCOPE_UNCALIBRATED:
207        mStringType = SENSOR_STRING_TYPE_WAKE_UP_GYROSCOPE_UNCALIBRATED;
208        mWakeUpSensor = true;
209        break;
210    case SENSOR_TYPE_WAKE_UP_STEP_DETECTOR:
211        mStringType = SENSOR_STRING_TYPE_WAKE_UP_STEP_DETECTOR;
212        mWakeUpSensor = true;
213        break;
214    case SENSOR_TYPE_WAKE_UP_STEP_COUNTER:
215        mStringType = SENSOR_STRING_TYPE_WAKE_UP_STEP_COUNTER;
216        mWakeUpSensor = true;
217        break;
218    case SENSOR_TYPE_WAKE_UP_GEOMAGNETIC_ROTATION_VECTOR:
219        mStringType = SENSOR_STRING_TYPE_WAKE_UP_GEOMAGNETIC_ROTATION_VECTOR;
220        mWakeUpSensor = true;
221        break;
222    case SENSOR_TYPE_WAKE_UP_HEART_RATE:
223        mStringType = SENSOR_STRING_TYPE_WAKE_UP_HEART_RATE;
224        mRequiredPermission = SENSOR_PERMISSION_BODY_SENSORS;
225        mWakeUpSensor = true;
226        break;
227    case SENSOR_TYPE_WAKE_GESTURE:
228        mStringType = SENSOR_STRING_TYPE_WAKE_GESTURE;
229        mWakeUpSensor = true;
230        break;
231    default:
232        // Only pipe the stringType, requiredPermission and flags for custom sensors.
233        if (halVersion >= SENSORS_DEVICE_API_VERSION_1_2 && hwSensor->stringType) {
234            mStringType = hwSensor->stringType;
235        }
236        if (halVersion >= SENSORS_DEVICE_API_VERSION_1_2 && hwSensor->requiredPermission) {
237            mRequiredPermission = hwSensor->requiredPermission;
238        }
239        if (halVersion >= SENSORS_DEVICE_API_VERSION_1_3) {
240            mWakeUpSensor = hwSensor->flags & SENSOR_FLAG_WAKE_UP;
241        }
242        break;
243    }
244}
245
246Sensor::~Sensor()
247{
248}
249
250const String8& Sensor::getName() const {
251    return mName;
252}
253
254const String8& Sensor::getVendor() const {
255    return mVendor;
256}
257
258int32_t Sensor::getHandle() const {
259    return mHandle;
260}
261
262int32_t Sensor::getType() const {
263    return mType;
264}
265
266float Sensor::getMinValue() const {
267    return mMinValue;
268}
269
270float Sensor::getMaxValue() const {
271    return mMaxValue;
272}
273
274float Sensor::getResolution() const {
275    return mResolution;
276}
277
278float Sensor::getPowerUsage() const {
279    return mPower;
280}
281
282int32_t Sensor::getMinDelay() const {
283    return mMinDelay;
284}
285
286nsecs_t Sensor::getMinDelayNs() const {
287    return getMinDelay() * 1000;
288}
289
290int32_t Sensor::getVersion() const {
291    return mVersion;
292}
293
294int32_t Sensor::getFifoReservedEventCount() const {
295    return mFifoReservedEventCount;
296}
297
298int32_t Sensor::getFifoMaxEventCount() const {
299    return mFifoMaxEventCount;
300}
301
302const String8& Sensor::getStringType() const {
303    return mStringType;
304}
305
306const String8& Sensor::getRequiredPermission() const {
307    return mRequiredPermission;
308}
309
310int32_t Sensor::getMaxDelay() const {
311    return mMaxDelay;
312}
313
314bool Sensor::isWakeUpSensor() const {
315    return mWakeUpSensor;
316}
317
318size_t Sensor::getFlattenedSize() const
319{
320    size_t fixedSize =
321            sizeof(int32_t) * 3 +
322            sizeof(float) * 4 +
323            sizeof(int32_t) * 4 +
324            sizeof(bool) * 1;
325
326    size_t variableSize =
327            sizeof(uint32_t) + FlattenableUtils::align<4>(mName.length()) +
328            sizeof(uint32_t) + FlattenableUtils::align<4>(mVendor.length()) +
329            sizeof(uint32_t) + FlattenableUtils::align<4>(mStringType.length()) +
330            sizeof(uint32_t) + FlattenableUtils::align<4>(mRequiredPermission.length());
331
332    return fixedSize + variableSize;
333}
334
335status_t Sensor::flatten(void* buffer, size_t size) const {
336    if (size < getFlattenedSize()) {
337        return NO_MEMORY;
338    }
339
340    flattenString8(buffer, size, mName);
341    flattenString8(buffer, size, mVendor);
342    FlattenableUtils::write(buffer, size, mVersion);
343    FlattenableUtils::write(buffer, size, mHandle);
344    FlattenableUtils::write(buffer, size, mType);
345    FlattenableUtils::write(buffer, size, mMinValue);
346    FlattenableUtils::write(buffer, size, mMaxValue);
347    FlattenableUtils::write(buffer, size, mResolution);
348    FlattenableUtils::write(buffer, size, mPower);
349    FlattenableUtils::write(buffer, size, mMinDelay);
350    FlattenableUtils::write(buffer, size, mFifoReservedEventCount);
351    FlattenableUtils::write(buffer, size, mFifoMaxEventCount);
352    flattenString8(buffer, size, mStringType);
353    flattenString8(buffer, size, mRequiredPermission);
354    FlattenableUtils::write(buffer, size, mMaxDelay);
355    FlattenableUtils::write(buffer, size, mWakeUpSensor);
356    return NO_ERROR;
357}
358
359status_t Sensor::unflatten(void const* buffer, size_t size) {
360    if (!unflattenString8(buffer, size, mName)) {
361        return NO_MEMORY;
362    }
363    if (!unflattenString8(buffer, size, mVendor)) {
364        return NO_MEMORY;
365    }
366
367    size_t fixedSize =
368            sizeof(int32_t) * 3 +
369            sizeof(float) * 4 +
370            sizeof(int32_t) * 4 +
371            sizeof(bool) * 1;
372    if (size < fixedSize) {
373        return NO_MEMORY;
374    }
375
376    FlattenableUtils::read(buffer, size, mVersion);
377    FlattenableUtils::read(buffer, size, mHandle);
378    FlattenableUtils::read(buffer, size, mType);
379    FlattenableUtils::read(buffer, size, mMinValue);
380    FlattenableUtils::read(buffer, size, mMaxValue);
381    FlattenableUtils::read(buffer, size, mResolution);
382    FlattenableUtils::read(buffer, size, mPower);
383    FlattenableUtils::read(buffer, size, mMinDelay);
384    FlattenableUtils::read(buffer, size, mFifoReservedEventCount);
385    FlattenableUtils::read(buffer, size, mFifoMaxEventCount);
386
387    if (!unflattenString8(buffer, size, mStringType)) {
388        return NO_MEMORY;
389    }
390    if (!unflattenString8(buffer, size, mRequiredPermission)) {
391        return NO_MEMORY;
392    }
393    FlattenableUtils::read(buffer, size, mMaxDelay);
394    FlattenableUtils::read(buffer, size, mWakeUpSensor);
395    return NO_ERROR;
396}
397
398void Sensor::flattenString8(void*& buffer, size_t& size,
399        const String8& string8) {
400    uint32_t len = string8.length();
401    FlattenableUtils::write(buffer, size, len);
402    memcpy(static_cast<char*>(buffer), string8.string(), len);
403    FlattenableUtils::advance(buffer, size, FlattenableUtils::align<4>(len));
404}
405
406bool Sensor::unflattenString8(void const*& buffer, size_t& size, String8& outputString8) {
407    uint32_t len;
408    if (size < sizeof(len)) {
409        return false;
410    }
411    FlattenableUtils::read(buffer, size, len);
412    if (size < len) {
413        return false;
414    }
415    outputString8.setTo(static_cast<char const*>(buffer), len);
416    FlattenableUtils::advance(buffer, size, FlattenableUtils::align<4>(len));
417    return true;
418}
419
420// ----------------------------------------------------------------------------
421}; // namespace android
422