am 550b1e17: am 671a6ff4: Add support for virtual sensors. (04d93980) · Commits · e / os / android_frameworks_base

services/sensorservice/Android.mk

+7 −1

Original line number	Diff line number	Diff line
		@@ -2,7 +2,13 @@ LOCAL_PATH:= $(call my-dir)
		include $(CLEAR_VARS)

		LOCAL_SRC_FILES:= \
		SensorService.cpp
		GravitySensor.cpp \
		LinearAccelerationSensor.cpp \
		RotationVectorSensor.cpp \
		SensorService.cpp \
		SensorInterface.cpp \
		SensorDevice.cpp \
		SecondOrderLowPassFilter.cpp

		LOCAL_CFLAGS:= -DLOG_TAG=\"SensorService\"

services/sensorservice/GravitySensor.cpp

0 → 100644

+112 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2010 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#include <stdint.h>
		#include <math.h>
		#include <sys/types.h>

		#include <utils/Errors.h>

		#include <hardware/sensors.h>

		#include "GravitySensor.h"

		namespace android {
		// ---------------------------------------------------------------------------

		GravitySensor::GravitySensor(sensor_t const* list, size_t count)
		: mSensorDevice(SensorDevice::getInstance()),
		mEnabled(false), mAccTime(0),
		mLowPass(M_SQRT1_2, 1),
		mX(mLowPass), mY(mLowPass), mZ(mLowPass)

		{
		for (size_t i=0 ; i<count ; i++) {
		if (list[i].type == SENSOR_TYPE_ACCELEROMETER) {
		mAccelerometer = Sensor(list + i);
		break;
		}
		}
		}

		bool GravitySensor::process(sensors_event_t* outEvent,
		const sensors_event_t& event)
		{
		const static double NS2S = 1.0 / 1000000000.0;
		if (event.type == SENSOR_TYPE_ACCELEROMETER) {
		float x, y, z;
		const double now = event.timestamp * NS2S;
		if (mAccTime == 0) {
		x = mX.init(event.acceleration.x);
		y = mY.init(event.acceleration.y);
		z = mZ.init(event.acceleration.z);
		} else {
		double dT = now - mAccTime;
		mLowPass.setSamplingPeriod(dT);
		x = mX(event.acceleration.x);
		y = mY(event.acceleration.y);
		z = mZ(event.acceleration.z);
		}
		mAccTime = now;
		*outEvent = event;
		outEvent->data[0] = x;
		outEvent->data[1] = y;
		outEvent->data[2] = z;
		outEvent->sensor = '_grv';
		outEvent->type = SENSOR_TYPE_GRAVITY;
		return true;
		}
		return false;
		}

		bool GravitySensor::isEnabled() const {
		return mEnabled;
		}

		status_t GravitySensor::activate(void* ident, bool enabled) {
		status_t err = mSensorDevice.activate(this, mAccelerometer.getHandle(), enabled);
		if (err == NO_ERROR) {
		mEnabled = enabled;
		if (enabled) {
		mAccTime = 0;
		}
		}
		return err;
		}

		status_t GravitySensor::setDelay(void* ident, int handle, int64_t ns)
		{
		return mSensorDevice.setDelay(this, mAccelerometer.getHandle(), ns);
		}

		Sensor GravitySensor::getSensor() const {
		sensor_t hwSensor;
		hwSensor.name = "Gravity Sensor";
		hwSensor.vendor = "Google Inc.";
		hwSensor.version = 1;
		hwSensor.handle = '_grv';
		hwSensor.type = SENSOR_TYPE_GRAVITY;
		hwSensor.maxRange = mAccelerometer.getMaxValue();
		hwSensor.resolution = mAccelerometer.getResolution();
		hwSensor.power = mAccelerometer.getPowerUsage();
		hwSensor.minDelay = mAccelerometer.getMinDelay();
		Sensor sensor(&hwSensor);
		return sensor;
		}

		// ---------------------------------------------------------------------------
		}; // namespace android

services/sensorservice/GravitySensor.h

0 → 100644

+56 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2010 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#ifndef ANDROID_GRAVITY_SENSOR_H
		#define ANDROID_GRAVITY_SENSOR_H

		#include <stdint.h>
		#include <sys/types.h>

		#include <gui/Sensor.h>

		#include "SensorDevice.h"
		#include "SensorInterface.h"
		#include "SecondOrderLowPassFilter.h"

		// ---------------------------------------------------------------------------
		namespace android {
		// ---------------------------------------------------------------------------

		class GravitySensor : public SensorInterface {
		SensorDevice& mSensorDevice;
		Sensor mAccelerometer;
		bool mEnabled;
		double mAccTime;

		SecondOrderLowPassFilter mLowPass;
		BiquadFilter mX, mY, mZ;

		public:
		GravitySensor(sensor_t const* list, size_t count);
		virtual bool process(sensors_event_t* outEvent,
		const sensors_event_t& event);
		virtual bool isEnabled() const;
		virtual status_t activate(void* ident, bool enabled);
		virtual status_t setDelay(void* ident, int handle, int64_t ns);
		virtual Sensor getSensor() const;
		virtual bool isVirtual() const { return true; }
		};

		// ---------------------------------------------------------------------------
		}; // namespace android

		#endif // ANDROID_GRAVITY_SENSOR_H

services/sensorservice/LinearAccelerationSensor.cpp

0 → 100644

+86 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2010 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#include <stdint.h>
		#include <math.h>
		#include <sys/types.h>

		#include <utils/Errors.h>

		#include <hardware/sensors.h>

		#include "LinearAccelerationSensor.h"

		namespace android {
		// ---------------------------------------------------------------------------

		LinearAccelerationSensor::LinearAccelerationSensor(sensor_t const* list, size_t count)
		: mSensorDevice(SensorDevice::getInstance()),
		mGravitySensor(list, count)
		{
		mData[0] = mData[1] = mData[2] = 0;
		}

		bool LinearAccelerationSensor::process(sensors_event_t* outEvent,
		const sensors_event_t& event)
		{
		bool result = mGravitySensor.process(outEvent, event);
		if (result) {
		if (event.type == SENSOR_TYPE_ACCELEROMETER) {
		mData[0] = event.acceleration.x;
		mData[1] = event.acceleration.y;
		mData[2] = event.acceleration.z;
		}
		outEvent->data[0] = mData[0] - outEvent->data[0];
		outEvent->data[1] = mData[1] - outEvent->data[1];
		outEvent->data[2] = mData[2] - outEvent->data[2];
		outEvent->sensor = '_lin';
		outEvent->type = SENSOR_TYPE_LINEAR_ACCELERATION;
		}
		return result;
		}

		bool LinearAccelerationSensor::isEnabled() const {
		return mGravitySensor.isEnabled();
		}

		status_t LinearAccelerationSensor::activate(void* ident, bool enabled) {
		return mGravitySensor.activate(ident, enabled);
		}

		status_t LinearAccelerationSensor::setDelay(void* ident, int handle, int64_t ns) {
		return mGravitySensor.setDelay(ident, handle, ns);
		}

		Sensor LinearAccelerationSensor::getSensor() const {
		Sensor gsensor(mGravitySensor.getSensor());
		sensor_t hwSensor;
		hwSensor.name = "Linear Acceleration Sensor";
		hwSensor.vendor = "Google Inc.";
		hwSensor.version = 1;
		hwSensor.handle = '_lin';
		hwSensor.type = SENSOR_TYPE_LINEAR_ACCELERATION;
		hwSensor.maxRange = gsensor.getMaxValue();
		hwSensor.resolution = gsensor.getResolution();
		hwSensor.power = gsensor.getPowerUsage();
		hwSensor.minDelay = gsensor.getMinDelay();
		Sensor sensor(&hwSensor);
		return sensor;
		}

		// ---------------------------------------------------------------------------
		}; // namespace android

services/sensorservice/LinearAccelerationSensor.h

0 → 100644

+53 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2010 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#ifndef ANDROID_LINEAR_ACCELERATION_SENSOR_H
		#define ANDROID_LINEAR_ACCELERATION_SENSOR_H

		#include <stdint.h>
		#include <sys/types.h>

		#include <gui/Sensor.h>

		#include "SensorDevice.h"
		#include "SensorInterface.h"
		#include "GravitySensor.h"

		// ---------------------------------------------------------------------------

		namespace android {
		// ---------------------------------------------------------------------------

		class LinearAccelerationSensor : public SensorInterface {
		SensorDevice& mSensorDevice;
		GravitySensor mGravitySensor;
		float mData[3];

		virtual bool process(sensors_event_t* outEvent,
		const sensors_event_t& event);
		public:
		LinearAccelerationSensor(sensor_t const* list, size_t count);
		virtual bool isEnabled() const;
		virtual status_t activate(void* ident, bool enabled);
		virtual status_t setDelay(void* ident, int handle, int64_t ns);
		virtual Sensor getSensor() const;
		virtual bool isVirtual() const { return true; }
		};

		// ---------------------------------------------------------------------------
		}; // namespace android

		#endif // ANDROID_LINEAR_ACCELERATION_SENSOR_H