Sensor.cpp revision 700180487ffec09d9df1657b018a7caadac24b75 
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 <stdint.h>
18#include <sys/types.h>
19
20#include <utils/Errors.h>
21#include <utils/String8.h>
22#include <utils/Flattenable.h>
23
24#include <hardware/sensors.h>
25
26#include <gui/Sensor.h>
27
28// ----------------------------------------------------------------------------
29namespace android {
30// ----------------------------------------------------------------------------
31
32Sensor::Sensor()
33    : mHandle(0), mType(0),
34      mMinValue(0), mMaxValue(0), mResolution(0),
35      mPower(0), mMinDelay(0), mFifoReservedEventCount(0), mFifoMaxEventCount(0)
36{
37}
38
39Sensor::Sensor(struct sensor_t const* hwSensor, int halVersion)
40{
41    mName = hwSensor->name;
42    mVendor = hwSensor->vendor;
43    mVersion = hwSensor->version;
44    mHandle = hwSensor->handle;
45    mType = hwSensor->type;
46    mMinValue = 0;                      // FIXME: minValue
47    mMaxValue = hwSensor->maxRange;     // FIXME: maxValue
48    mResolution = hwSensor->resolution;
49    mPower = hwSensor->power;
50    mMinDelay = hwSensor->minDelay;
51
52    // Set fifo event count zero for older devices which do not support batching. Fused
53    // sensors also have their fifo counts set to zero.
54    if (halVersion >= SENSORS_DEVICE_API_VERSION_1_1) {
55        mFifoReservedEventCount = hwSensor->fifoReservedEventCount;
56        mFifoMaxEventCount = hwSensor->fifoMaxEventCount;
57    }
58
59    // Ensure existing sensors have correct string type and required
60    // permissions.
61    switch (mType) {
62    case SENSOR_TYPE_ACCELEROMETER:
63        mStringType = SENSOR_STRING_TYPE_ACCELEROMETER;
64        break;
65    case SENSOR_TYPE_AMBIENT_TEMPERATURE:
66        mStringType = SENSOR_STRING_TYPE_AMBIENT_TEMPERATURE;
67        break;
68    case SENSOR_TYPE_GAME_ROTATION_VECTOR:
69        mStringType = SENSOR_STRING_TYPE_GAME_ROTATION_VECTOR;
70        break;
71    case SENSOR_TYPE_GEOMAGNETIC_ROTATION_VECTOR:
72        mStringType = SENSOR_STRING_TYPE_GEOMAGNETIC_ROTATION_VECTOR;
73        break;
74    case SENSOR_TYPE_GRAVITY:
75        mStringType = SENSOR_STRING_TYPE_GRAVITY;
76        break;
77    case SENSOR_TYPE_GYROSCOPE:
78        mStringType = SENSOR_STRING_TYPE_GYROSCOPE;
79        break;
80    case SENSOR_TYPE_GYROSCOPE_UNCALIBRATED:
81        mStringType = SENSOR_STRING_TYPE_GYROSCOPE_UNCALIBRATED;
82        break;
83    case SENSOR_TYPE_HEART_RATE:
84        mStringType = SENSOR_STRING_TYPE_HEART_RATE;
85        mRequiredPermission = SENSOR_PERMISSION_BODY_SENSORS;
86        break;
87    case SENSOR_TYPE_LIGHT:
88        mStringType = SENSOR_STRING_TYPE_LIGHT;
89        break;
90    case SENSOR_TYPE_LINEAR_ACCELERATION:
91        mStringType = SENSOR_STRING_TYPE_LINEAR_ACCELERATION;
92        break;
93    case SENSOR_TYPE_MAGNETIC_FIELD:
94        mStringType = SENSOR_STRING_TYPE_MAGNETIC_FIELD;
95        break;
96    case SENSOR_TYPE_MAGNETIC_FIELD_UNCALIBRATED:
97        mStringType = SENSOR_STRING_TYPE_MAGNETIC_FIELD_UNCALIBRATED;
98        break;
99    case SENSOR_TYPE_ORIENTATION:
100        mStringType = SENSOR_STRING_TYPE_ORIENTATION;
101        break;
102    case SENSOR_TYPE_PRESSURE:
103        mStringType = SENSOR_STRING_TYPE_PRESSURE;
104        break;
105    case SENSOR_TYPE_PROXIMITY:
106        mStringType = SENSOR_STRING_TYPE_PROXIMITY;
107        break;
108    case SENSOR_TYPE_RELATIVE_HUMIDITY:
109        mStringType = SENSOR_STRING_TYPE_RELATIVE_HUMIDITY;
110        break;
111    case SENSOR_TYPE_ROTATION_VECTOR:
112        mStringType = SENSOR_STRING_TYPE_ROTATION_VECTOR;
113        break;
114    case SENSOR_TYPE_SIGNIFICANT_MOTION:
115        mStringType = SENSOR_STRING_TYPE_SIGNIFICANT_MOTION;
116        break;
117    case SENSOR_TYPE_STEP_COUNTER:
118        mStringType = SENSOR_STRING_TYPE_STEP_COUNTER;
119        break;
120    case SENSOR_TYPE_STEP_DETECTOR:
121        mStringType = SENSOR_STRING_TYPE_STEP_DETECTOR;
122        break;
123    case SENSOR_TYPE_TEMPERATURE:
124        mStringType = SENSOR_STRING_TYPE_TEMPERATURE;
125        break;
126    default:
127        // Only pipe the stringType and requiredPermission for custom sensors.
128        if (halVersion >= SENSORS_DEVICE_API_VERSION_1_2 && hwSensor->stringType) {
129            mStringType = hwSensor->stringType;
130        }
131        if (halVersion >= SENSORS_DEVICE_API_VERSION_1_2 && hwSensor->requiredPermission) {
132            mRequiredPermission = hwSensor->requiredPermission;
133        }
134        break;
135    }
136}
137
138Sensor::~Sensor()
139{
140}
141
142const String8& Sensor::getName() const {
143    return mName;
144}
145
146const String8& Sensor::getVendor() const {
147    return mVendor;
148}
149
150int32_t Sensor::getHandle() const {
151    return mHandle;
152}
153
154int32_t Sensor::getType() const {
155    return mType;
156}
157
158float Sensor::getMinValue() const {
159    return mMinValue;
160}
161
162float Sensor::getMaxValue() const {
163    return mMaxValue;
164}
165
166float Sensor::getResolution() const {
167    return mResolution;
168}
169
170float Sensor::getPowerUsage() const {
171    return mPower;
172}
173
174int32_t Sensor::getMinDelay() const {
175    return mMinDelay;
176}
177
178nsecs_t Sensor::getMinDelayNs() const {
179    return getMinDelay() * 1000;
180}
181
182int32_t Sensor::getVersion() const {
183    return mVersion;
184}
185
186int32_t Sensor::getFifoReservedEventCount() const {
187    return mFifoReservedEventCount;
188}
189
190int32_t Sensor::getFifoMaxEventCount() const {
191    return mFifoMaxEventCount;
192}
193
194const String8& Sensor::getStringType() const {
195    return mStringType;
196}
197
198const String8& Sensor::getRequiredPermission() const {
199    return mRequiredPermission;
200}
201
202size_t Sensor::getFlattenedSize() const
203{
204    size_t fixedSize =
205            sizeof(int32_t) * 3 +
206            sizeof(float) * 4 +
207            sizeof(int32_t) * 3;
208
209    size_t variableSize =
210            sizeof(uint32_t) + FlattenableUtils::align<4>(mName.length()) +
211            sizeof(uint32_t) + FlattenableUtils::align<4>(mVendor.length()) +
212            sizeof(uint32_t) + FlattenableUtils::align<4>(mStringType.length()) +
213            sizeof(uint32_t) + FlattenableUtils::align<4>(mRequiredPermission.length());
214
215    return fixedSize + variableSize;
216}
217
218status_t Sensor::flatten(void* buffer, size_t size) const {
219    if (size < getFlattenedSize()) {
220        return NO_MEMORY;
221    }
222
223    flattenString8(buffer, size, mName);
224    flattenString8(buffer, size, mVendor);
225    FlattenableUtils::write(buffer, size, mVersion);
226    FlattenableUtils::write(buffer, size, mHandle);
227    FlattenableUtils::write(buffer, size, mType);
228    FlattenableUtils::write(buffer, size, mMinValue);
229    FlattenableUtils::write(buffer, size, mMaxValue);
230    FlattenableUtils::write(buffer, size, mResolution);
231    FlattenableUtils::write(buffer, size, mPower);
232    FlattenableUtils::write(buffer, size, mMinDelay);
233    FlattenableUtils::write(buffer, size, mFifoReservedEventCount);
234    FlattenableUtils::write(buffer, size, mFifoMaxEventCount);
235    flattenString8(buffer, size, mStringType);
236    flattenString8(buffer, size, mRequiredPermission);
237    return NO_ERROR;
238}
239
240status_t Sensor::unflatten(void const* buffer, size_t size) {
241    if (!unflattenString8(buffer, size, mName)) {
242        return NO_MEMORY;
243    }
244    if (!unflattenString8(buffer, size, mVendor)) {
245        return NO_MEMORY;
246    }
247
248    size_t fixedSize =
249            sizeof(int32_t) * 3 +
250            sizeof(float) * 4 +
251            sizeof(int32_t) * 3;
252    if (size < fixedSize) {
253        return NO_MEMORY;
254    }
255
256    FlattenableUtils::read(buffer, size, mVersion);
257    FlattenableUtils::read(buffer, size, mHandle);
258    FlattenableUtils::read(buffer, size, mType);
259    FlattenableUtils::read(buffer, size, mMinValue);
260    FlattenableUtils::read(buffer, size, mMaxValue);
261    FlattenableUtils::read(buffer, size, mResolution);
262    FlattenableUtils::read(buffer, size, mPower);
263    FlattenableUtils::read(buffer, size, mMinDelay);
264    FlattenableUtils::read(buffer, size, mFifoReservedEventCount);
265    FlattenableUtils::read(buffer, size, mFifoMaxEventCount);
266
267    if (!unflattenString8(buffer, size, mStringType)) {
268        return NO_MEMORY;
269    }
270    if (!unflattenString8(buffer, size, mRequiredPermission)) {
271        return NO_MEMORY;
272    }
273    return NO_ERROR;
274}
275
276void Sensor::flattenString8(void*& buffer, size_t& size,
277        const String8& string8) {
278    uint32_t len = string8.length();
279    FlattenableUtils::write(buffer, size, len);
280    memcpy(static_cast<char*>(buffer), string8.string(), len);
281    FlattenableUtils::advance(buffer, size, FlattenableUtils::align<4>(len));
282}
283
284bool Sensor::unflattenString8(void const*& buffer, size_t& size, String8& outputString8) {
285    uint32_t len;
286    if (size < sizeof(len)) {
287        return false;
288    }
289    FlattenableUtils::read(buffer, size, len);
290    if (size < len) {
291        return false;
292    }
293    outputString8.setTo(static_cast<char const*>(buffer), len);
294    FlattenableUtils::advance(buffer, size, FlattenableUtils::align<4>(len));
295    return true;
296}
297
298// ----------------------------------------------------------------------------
299}; // namespace android
300