2 * Copyright (C) 2010 The Android Open Source Project
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
19 #include <sys/types.h>
20 #include <sys/limits.h>
22 #include <utils/Errors.h>
23 #include <utils/String8.h>
24 #include <utils/Flattenable.h>
26 #include <hardware/sensors.h>
28 #include <gui/Sensor.h>
31 // ----------------------------------------------------------------------------
33 // ----------------------------------------------------------------------------
36 : mHandle(0), mType(0),
37 mMinValue(0), mMaxValue(0), mResolution(0),
38 mPower(0), mMinDelay(0), mFifoReservedEventCount(0), mFifoMaxEventCount(0),
39 mMaxDelay(0), mFlags(0)
43 Sensor::Sensor(struct sensor_t const* hwSensor, int halVersion)
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;
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_0) {
60 mFifoReservedEventCount = hwSensor->fifoReservedEventCount;
61 mFifoMaxEventCount = hwSensor->fifoMaxEventCount;
63 mFifoReservedEventCount = 0;
64 mFifoMaxEventCount = 0;
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));
75 mMaxDelay = static_cast<int32_t>(hwSensor->maxDelay);
78 // For older hals set maxDelay to 0.
82 // Ensure existing sensors have correct string type, required permissions and reporting mode.
83 // Set reportingMode for all android defined sensor types, set wake-up flag only for proximity
84 // sensor, significant motion, tilt, pick_up gesture, wake gesture and glance gesture on older
85 // HALs. Newer HALs can define both wake-up and non wake-up proximity sensors.
86 // All the OEM defined defined sensors have flags set to whatever is provided by the HAL.
88 case SENSOR_TYPE_ACCELEROMETER:
89 mStringType = SENSOR_STRING_TYPE_ACCELEROMETER;
90 mFlags |= SENSOR_FLAG_CONTINUOUS_MODE;
92 case SENSOR_TYPE_AMBIENT_TEMPERATURE:
93 mStringType = SENSOR_STRING_TYPE_AMBIENT_TEMPERATURE;
94 mFlags |= SENSOR_FLAG_ON_CHANGE_MODE;
96 case SENSOR_TYPE_GAME_ROTATION_VECTOR:
97 mStringType = SENSOR_STRING_TYPE_GAME_ROTATION_VECTOR;
98 mFlags |= SENSOR_FLAG_CONTINUOUS_MODE;
100 case SENSOR_TYPE_GEOMAGNETIC_ROTATION_VECTOR:
101 mStringType = SENSOR_STRING_TYPE_GEOMAGNETIC_ROTATION_VECTOR;
102 mFlags |= SENSOR_FLAG_CONTINUOUS_MODE;
104 case SENSOR_TYPE_GRAVITY:
105 mStringType = SENSOR_STRING_TYPE_GRAVITY;
106 mFlags |= SENSOR_FLAG_CONTINUOUS_MODE;
108 case SENSOR_TYPE_GYROSCOPE:
109 mStringType = SENSOR_STRING_TYPE_GYROSCOPE;
110 mFlags |= SENSOR_FLAG_CONTINUOUS_MODE;
112 case SENSOR_TYPE_GYROSCOPE_UNCALIBRATED:
113 mStringType = SENSOR_STRING_TYPE_GYROSCOPE_UNCALIBRATED;
114 mFlags |= SENSOR_FLAG_CONTINUOUS_MODE;
116 case SENSOR_TYPE_HEART_RATE:
117 mStringType = SENSOR_STRING_TYPE_HEART_RATE;
118 mRequiredPermission = SENSOR_PERMISSION_BODY_SENSORS;
119 mFlags |= SENSOR_FLAG_ON_CHANGE_MODE;
121 case SENSOR_TYPE_LIGHT:
122 mStringType = SENSOR_STRING_TYPE_LIGHT;
123 mFlags |= SENSOR_FLAG_ON_CHANGE_MODE;
125 case SENSOR_TYPE_LINEAR_ACCELERATION:
126 mStringType = SENSOR_STRING_TYPE_LINEAR_ACCELERATION;
127 mFlags |= SENSOR_FLAG_CONTINUOUS_MODE;
129 case SENSOR_TYPE_MAGNETIC_FIELD:
130 mStringType = SENSOR_STRING_TYPE_MAGNETIC_FIELD;
131 mFlags |= SENSOR_FLAG_CONTINUOUS_MODE;
133 case SENSOR_TYPE_MAGNETIC_FIELD_UNCALIBRATED:
134 mStringType = SENSOR_STRING_TYPE_MAGNETIC_FIELD_UNCALIBRATED;
135 mFlags |= SENSOR_FLAG_CONTINUOUS_MODE;
137 case SENSOR_TYPE_ORIENTATION:
138 mStringType = SENSOR_STRING_TYPE_ORIENTATION;
139 mFlags |= SENSOR_FLAG_CONTINUOUS_MODE;
141 case SENSOR_TYPE_PRESSURE:
142 mStringType = SENSOR_STRING_TYPE_PRESSURE;
143 mFlags |= SENSOR_FLAG_CONTINUOUS_MODE;
145 case SENSOR_TYPE_PROXIMITY:
146 mStringType = SENSOR_STRING_TYPE_PROXIMITY;
147 mFlags |= SENSOR_FLAG_ON_CHANGE_MODE;
148 if (halVersion < SENSORS_DEVICE_API_VERSION_1_3) {
149 mFlags |= SENSOR_FLAG_WAKE_UP;
152 case SENSOR_TYPE_RELATIVE_HUMIDITY:
153 mStringType = SENSOR_STRING_TYPE_RELATIVE_HUMIDITY;
154 mFlags |= SENSOR_FLAG_ON_CHANGE_MODE;
156 case SENSOR_TYPE_ROTATION_VECTOR:
157 mStringType = SENSOR_STRING_TYPE_ROTATION_VECTOR;
158 mFlags |= SENSOR_FLAG_CONTINUOUS_MODE;
160 case SENSOR_TYPE_SIGNIFICANT_MOTION:
161 mStringType = SENSOR_STRING_TYPE_SIGNIFICANT_MOTION;
162 mFlags |= SENSOR_FLAG_ONE_SHOT_MODE;
163 if (halVersion < SENSORS_DEVICE_API_VERSION_1_3) {
164 mFlags |= SENSOR_FLAG_WAKE_UP;
167 case SENSOR_TYPE_STEP_COUNTER:
168 mStringType = SENSOR_STRING_TYPE_STEP_COUNTER;
169 mFlags |= SENSOR_FLAG_ON_CHANGE_MODE;
171 case SENSOR_TYPE_STEP_DETECTOR:
172 mStringType = SENSOR_STRING_TYPE_STEP_DETECTOR;
173 mFlags |= SENSOR_FLAG_SPECIAL_REPORTING_MODE;
175 case SENSOR_TYPE_TEMPERATURE:
176 mStringType = SENSOR_STRING_TYPE_TEMPERATURE;
177 mFlags |= SENSOR_FLAG_ON_CHANGE_MODE;
179 case SENSOR_TYPE_TILT_DETECTOR:
180 mStringType = SENSOR_STRING_TYPE_TILT_DETECTOR;
181 mFlags |= SENSOR_FLAG_SPECIAL_REPORTING_MODE;
182 if (halVersion < SENSORS_DEVICE_API_VERSION_1_3) {
183 mFlags |= SENSOR_FLAG_WAKE_UP;
186 case SENSOR_TYPE_WAKE_GESTURE:
187 mStringType = SENSOR_STRING_TYPE_WAKE_GESTURE;
188 mFlags |= SENSOR_FLAG_ONE_SHOT_MODE;
189 if (halVersion < SENSORS_DEVICE_API_VERSION_1_3) {
190 mFlags |= SENSOR_FLAG_WAKE_UP;
193 case SENSOR_TYPE_GLANCE_GESTURE:
194 mStringType = SENSOR_STRING_TYPE_GLANCE_GESTURE;
195 mFlags |= SENSOR_FLAG_ONE_SHOT_MODE;
196 if (halVersion < SENSORS_DEVICE_API_VERSION_1_3) {
197 mFlags |= SENSOR_FLAG_WAKE_UP;
200 case SENSOR_TYPE_PICK_UP_GESTURE:
201 mStringType = SENSOR_STRING_TYPE_PICK_UP_GESTURE;
202 mFlags |= SENSOR_FLAG_ONE_SHOT_MODE;
203 if (halVersion < SENSORS_DEVICE_API_VERSION_1_3) {
204 mFlags |= SENSOR_FLAG_WAKE_UP;
207 case SENSOR_TYPE_WRIST_TILT_GESTURE:
208 mStringType = SENSOR_STRING_TYPE_WRIST_TILT_GESTURE;
209 mFlags |= SENSOR_FLAG_SPECIAL_REPORTING_MODE;
210 if (halVersion < SENSORS_DEVICE_API_VERSION_1_3) {
211 mFlags |= SENSOR_FLAG_WAKE_UP;
215 // Only pipe the stringType, requiredPermission and flags for custom sensors.
216 if (halVersion > SENSORS_DEVICE_API_VERSION_1_0 && hwSensor->stringType) {
217 mStringType = hwSensor->stringType;
219 if (halVersion > SENSORS_DEVICE_API_VERSION_1_0 && hwSensor->requiredPermission) {
220 mRequiredPermission = hwSensor->requiredPermission;
223 if (halVersion >= SENSORS_DEVICE_API_VERSION_1_3) {
224 mFlags = static_cast<uint32_t>(hwSensor->flags);
226 // This is an OEM defined sensor on an older HAL. Use minDelay to determine the
227 // reporting mode of the sensor.
229 mFlags |= SENSOR_FLAG_CONTINUOUS_MODE;
230 } else if (mMinDelay == 0) {
231 mFlags |= SENSOR_FLAG_ON_CHANGE_MODE;
232 } else if (mMinDelay < 0) {
233 mFlags |= SENSOR_FLAG_ONE_SHOT_MODE;
239 // For the newer HALs log errors if reporting mask flags are set incorrectly.
240 if (halVersion >= SENSORS_DEVICE_API_VERSION_1_3) {
241 // Wake-up flag is set here.
242 mFlags |= (hwSensor->flags & SENSOR_FLAG_WAKE_UP);
243 if (mFlags != hwSensor->flags) {
244 int actualReportingMode =
245 (hwSensor->flags & REPORTING_MODE_MASK) >> REPORTING_MODE_SHIFT;
246 int expectedReportingMode = (mFlags & REPORTING_MODE_MASK) >> REPORTING_MODE_SHIFT;
247 if (actualReportingMode != expectedReportingMode) {
248 ALOGE("Reporting Mode incorrect: sensor %s handle=%d type=%d "
249 "actual=%d expected=%d",
250 mName.string(), mHandle, mType, actualReportingMode, expectedReportingMode);
261 const String8& Sensor::getName() const {
265 const String8& Sensor::getVendor() const {
269 int32_t Sensor::getHandle() const {
273 int32_t Sensor::getType() const {
277 float Sensor::getMinValue() const {
281 float Sensor::getMaxValue() const {
285 float Sensor::getResolution() const {
289 float Sensor::getPowerUsage() const {
293 int32_t Sensor::getMinDelay() const {
297 nsecs_t Sensor::getMinDelayNs() const {
298 return getMinDelay() * 1000;
301 int32_t Sensor::getVersion() const {
305 uint32_t Sensor::getFifoReservedEventCount() const {
306 return mFifoReservedEventCount;
309 uint32_t Sensor::getFifoMaxEventCount() const {
310 return mFifoMaxEventCount;
313 const String8& Sensor::getStringType() const {
317 const String8& Sensor::getRequiredPermission() const {
318 return mRequiredPermission;
321 int32_t Sensor::getMaxDelay() const {
325 uint32_t Sensor::getFlags() const {
329 bool Sensor::isWakeUpSensor() const {
330 return mFlags & SENSOR_FLAG_WAKE_UP;
333 int32_t Sensor::getReportingMode() const {
334 return ((mFlags & REPORTING_MODE_MASK) >> REPORTING_MODE_SHIFT);
337 size_t Sensor::getFlattenedSize() const
340 sizeof(int32_t) * 3 +
344 size_t variableSize =
345 sizeof(uint32_t) + FlattenableUtils::align<4>(mName.length()) +
346 sizeof(uint32_t) + FlattenableUtils::align<4>(mVendor.length()) +
347 sizeof(uint32_t) + FlattenableUtils::align<4>(mStringType.length()) +
348 sizeof(uint32_t) + FlattenableUtils::align<4>(mRequiredPermission.length());
350 return fixedSize + variableSize;
353 status_t Sensor::flatten(void* buffer, size_t size) const {
354 if (size < getFlattenedSize()) {
358 flattenString8(buffer, size, mName);
359 flattenString8(buffer, size, mVendor);
360 FlattenableUtils::write(buffer, size, mVersion);
361 FlattenableUtils::write(buffer, size, mHandle);
362 FlattenableUtils::write(buffer, size, mType);
363 FlattenableUtils::write(buffer, size, mMinValue);
364 FlattenableUtils::write(buffer, size, mMaxValue);
365 FlattenableUtils::write(buffer, size, mResolution);
366 FlattenableUtils::write(buffer, size, mPower);
367 FlattenableUtils::write(buffer, size, mMinDelay);
368 FlattenableUtils::write(buffer, size, mFifoReservedEventCount);
369 FlattenableUtils::write(buffer, size, mFifoMaxEventCount);
370 flattenString8(buffer, size, mStringType);
371 flattenString8(buffer, size, mRequiredPermission);
372 FlattenableUtils::write(buffer, size, mMaxDelay);
373 FlattenableUtils::write(buffer, size, mFlags);
377 status_t Sensor::unflatten(void const* buffer, size_t size) {
378 if (!unflattenString8(buffer, size, mName)) {
381 if (!unflattenString8(buffer, size, mVendor)) {
386 sizeof(int32_t) * 3 +
389 if (size < fixedSize) {
393 FlattenableUtils::read(buffer, size, mVersion);
394 FlattenableUtils::read(buffer, size, mHandle);
395 FlattenableUtils::read(buffer, size, mType);
396 FlattenableUtils::read(buffer, size, mMinValue);
397 FlattenableUtils::read(buffer, size, mMaxValue);
398 FlattenableUtils::read(buffer, size, mResolution);
399 FlattenableUtils::read(buffer, size, mPower);
400 FlattenableUtils::read(buffer, size, mMinDelay);
401 FlattenableUtils::read(buffer, size, mFifoReservedEventCount);
402 FlattenableUtils::read(buffer, size, mFifoMaxEventCount);
404 if (!unflattenString8(buffer, size, mStringType)) {
407 if (!unflattenString8(buffer, size, mRequiredPermission)) {
410 FlattenableUtils::read(buffer, size, mMaxDelay);
411 FlattenableUtils::read(buffer, size, mFlags);
415 void Sensor::flattenString8(void*& buffer, size_t& size,
416 const String8& string8) {
417 uint32_t len = static_cast<uint32_t>(string8.length());
418 FlattenableUtils::write(buffer, size, len);
419 memcpy(static_cast<char*>(buffer), string8.string(), len);
420 FlattenableUtils::advance(buffer, size, FlattenableUtils::align<4>(len));
423 bool Sensor::unflattenString8(void const*& buffer, size_t& size, String8& outputString8) {
425 if (size < sizeof(len)) {
428 FlattenableUtils::read(buffer, size, len);
432 outputString8.setTo(static_cast<char const*>(buffer), len);
433 FlattenableUtils::advance(buffer, size, FlattenableUtils::align<4>(len));
437 // ----------------------------------------------------------------------------
438 }; // namespace android