Merge "Created new virtual LimitedAxesImuSensor." (0bce09f9) · Commits · e / os / android_frameworks_native

services/sensorservice/Android.bp

+1 −0

Original line number	Diff line number	Diff line
		@@ -17,6 +17,7 @@ cc_library_shared {
		"Fusion.cpp",
		"GravitySensor.cpp",
		"HidlSensorHalWrapper.cpp",
		"LimitedAxesImuSensor.cpp",
		"LinearAccelerationSensor.cpp",
		"OrientationSensor.cpp",
		"RecentEventLogger.cpp",

services/sensorservice/LimitedAxesImuSensor.cpp

0 → 100644

+134 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2022 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 <math.h>
		#include <stdint.h>
		#include <sys/types.h>

		#include <utils/Errors.h>

		#include <hardware/sensors.h>

		#include "LimitedAxesImuSensor.h"
		#include "SensorDevice.h"
		#include "SensorFusion.h"
		#include "SensorServiceUtils.h"

		namespace android {

		namespace {
		const sensor_t DUMMY_SENSOR = {.name = "",
		.vendor = "",
		.stringType = "",
		.requiredPermission = ""};
		} // unnamed namespace

		LimitedAxesImuSensor::LimitedAxesImuSensor(sensor_t const* list, size_t count,
		int32_t imu3dSensorType)
		: BaseSensor(DUMMY_SENSOR) {
		for (size_t i = 0; i < count; i++) {
		if (list[i].type == imu3dSensorType) {
		mImu3dSensor = Sensor(list + i);
		break;
		}
		}

		const int32_t imuLimitedAxesSensorType = convertImu3dToLimitedAxesSensorType(imu3dSensorType);

		const sensor_t sensor = {
		.name = convertLimitedAxesSensorTypeToName(imuLimitedAxesSensorType),
		.vendor = "AOSP",
		.version = 1,
		.handle = convertLimitedAxesSensorTypeToHandle(imuLimitedAxesSensorType),
		.type = imuLimitedAxesSensorType,
		.maxRange = mImu3dSensor.getMaxValue(),
		.resolution = mImu3dSensor.getResolution(),
		.power = mImu3dSensor.getPowerUsage(),
		.minDelay = mImu3dSensor.getMinDelay(),
		};
		mSensor = Sensor(&sensor);
		}

		bool LimitedAxesImuSensor::process(sensors_event_t* outEvent, const sensors_event_t& event) {
		if (event.type == mImu3dSensor.getType()) {
		*outEvent = event;
		size_t imu3dDataSize = SensorServiceUtil::eventSizeBySensorType(mImu3dSensor.getType());
		outEvent->data[0 + imu3dDataSize] = 1;
		outEvent->data[1 + imu3dDataSize] = 1;
		outEvent->data[2 + imu3dDataSize] = 1;
		outEvent->sensor = mSensor.getHandle();
		outEvent->type = mSensor.getType();
		return true;
		}
		return false;
		}

		status_t LimitedAxesImuSensor::activate(void* ident, bool enabled) {
		return mSensorDevice.activate(ident, mImu3dSensor.getHandle(), enabled);
		}

		status_t LimitedAxesImuSensor::setDelay(void* ident, int /handle/, int64_t ns) {
		return mSensorDevice.setDelay(ident, mImu3dSensor.getHandle(), ns);
		}

		int32_t LimitedAxesImuSensor::convertImu3dToLimitedAxesSensorType(int32_t imu3dSensorType) {
		switch (imu3dSensorType) {
		case SENSOR_TYPE_ACCELEROMETER:
		return SENSOR_TYPE_ACCELEROMETER_LIMITED_AXES;
		case SENSOR_TYPE_GYROSCOPE:
		return SENSOR_TYPE_GYROSCOPE_LIMITED_AXES;
		case SENSOR_TYPE_ACCELEROMETER_UNCALIBRATED:
		return SENSOR_TYPE_ACCELEROMETER_LIMITED_AXES_UNCALIBRATED;
		case SENSOR_TYPE_GYROSCOPE_UNCALIBRATED:
		return SENSOR_TYPE_GYROSCOPE_LIMITED_AXES_UNCALIBRATED;
		default:
		return 0;
		}
		}

		int32_t LimitedAxesImuSensor::convertLimitedAxesSensorTypeToHandle(
		int32_t imuLimitedAxesSensorType) {
		switch (imuLimitedAxesSensorType) {
		case SENSOR_TYPE_ACCELEROMETER_LIMITED_AXES:
		return '_ala';
		case SENSOR_TYPE_GYROSCOPE_LIMITED_AXES:
		return '_gla';
		case SENSOR_TYPE_ACCELEROMETER_LIMITED_AXES_UNCALIBRATED:
		return '_alc';
		case SENSOR_TYPE_GYROSCOPE_LIMITED_AXES_UNCALIBRATED:
		return '_glc';
		default:
		return 0;
		}
		}

		const char* LimitedAxesImuSensor::convertLimitedAxesSensorTypeToName(
		int32_t imuLimitedAxesSensorType) {
		switch (imuLimitedAxesSensorType) {
		case SENSOR_TYPE_ACCELEROMETER_LIMITED_AXES:
		return "Accelerometer Limited Axes Sensor";
		case SENSOR_TYPE_GYROSCOPE_LIMITED_AXES:
		return "Gyroscope Limited Axes Sensor";
		case SENSOR_TYPE_ACCELEROMETER_LIMITED_AXES_UNCALIBRATED:
		return "Accelerometer Limited Axes Uncalibrated Sensor";
		case SENSOR_TYPE_GYROSCOPE_LIMITED_AXES_UNCALIBRATED:
		return "Gyroscope Limited Axes Uncalibrated Sensor";
		default:
		return "";
		}
		}

		}; // namespace android

services/sensorservice/LimitedAxesImuSensor.h

0 → 100644

+46 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2022 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.
		*/

		#pragma once

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

		#include <sensor/Sensor.h>

		#include "SensorInterface.h"

		namespace android {

		class SensorDevice;

		class LimitedAxesImuSensor : public BaseSensor {
		Sensor mImu3dSensor;

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

		private:
		int32_t convertImu3dToLimitedAxesSensorType(int32_t imu3dSensorType);
		int32_t convertLimitedAxesSensorTypeToHandle(int32_t imuLimitedAxesSensorType);
		const char* convertLimitedAxesSensorTypeToName(int32_t imuLimitedAxesSensorType);
		};

		}; // namespace android
		No newline at end of file

services/sensorservice/SensorService.cpp

+62 −3

Original line number	Diff line number	Diff line
		@@ -38,6 +38,7 @@
		#include "BatteryService.h"
		#include "CorrectedGyroSensor.h"
		#include "GravitySensor.h"
		#include "LimitedAxesImuSensor.h"
		#include "LinearAccelerationSensor.h"
		#include "OrientationSensor.h"
		#include "RotationVectorSensor.h"
		@@ -101,6 +102,33 @@ static const String16 sDumpPermission("android.permission.DUMP");
		static const String16 sLocationHardwarePermission("android.permission.LOCATION_HARDWARE");
		static const String16 sManageSensorsPermission("android.permission.MANAGE_SENSORS");

		static bool isAutomotive() {
		sp<IServiceManager> serviceManager = defaultServiceManager();
		if (serviceManager.get() == nullptr) {
		ALOGE("%s: unable to access native ServiceManager", __func__);
		return false;
		}

		sp<content::pm::IPackageManagerNative> packageManager;
		sp<IBinder> binder = serviceManager->waitForService(String16("package_native"));
		packageManager = interface_cast<content::pm::IPackageManagerNative>(binder);
		if (packageManager == nullptr) {
		ALOGE("%s: unable to access native PackageManager", __func__);
		return false;
		}

		bool isAutomotive = false;
		binder::Status status =
		packageManager->hasSystemFeature(String16("android.hardware.type.automotive"), 0,
		&isAutomotive);
		if (!status.isOk()) {
		ALOGE("%s: hasSystemFeature failed: %s", __func__, status.exceptionMessage().c_str());
		return false;
		}

		return isAutomotive;
		}

		SensorService::SensorService()
		: mInitCheck(NO_INIT), mSocketBufferSize(SOCKET_BUFFER_SIZE_NON_BATCHED),
		mWakeLockAcquired(false), mLastReportedProxIsActive(false) {
		@@ -165,6 +193,8 @@ void SensorService::onFirstRef() {
		ssize_t count = dev.getSensorList(&list);
		if (count > 0) {
		bool hasGyro = false, hasAccel = false, hasMag = false;
		bool hasGyroUncalibrated = false;
		bool hasAccelUncalibrated = false;
		uint32_t virtualSensorsNeeds =
		(1<<SENSOR_TYPE_GRAVITY) \|
		(1<<SENSOR_TYPE_LINEAR_ACCELERATION) \|
		@@ -179,13 +209,18 @@ void SensorService::onFirstRef() {
		case SENSOR_TYPE_ACCELEROMETER:
		hasAccel = true;
		break;
		case SENSOR_TYPE_ACCELEROMETER_UNCALIBRATED:
		hasAccelUncalibrated = true;
		break;
		case SENSOR_TYPE_MAGNETIC_FIELD:
		hasMag = true;
		break;
		case SENSOR_TYPE_GYROSCOPE:
		case SENSOR_TYPE_GYROSCOPE_UNCALIBRATED:
		hasGyro = true;
		break;
		case SENSOR_TYPE_GYROSCOPE_UNCALIBRATED:
		hasGyroUncalibrated = true;
		break;
		case SENSOR_TYPE_GRAVITY:
		case SENSOR_TYPE_LINEAR_ACCELERATION:
		case SENSOR_TYPE_ROTATION_VECTOR:
		@@ -216,7 +251,7 @@ void SensorService::onFirstRef() {
		// registered)
		SensorFusion::getInstance();

		if (hasGyro && hasAccel && hasMag) {
		if ((hasGyro \|\| hasGyroUncalibrated) && hasAccel && hasMag) {
		// Add Android virtual sensors if they're not already
		// available in the HAL
		bool needRotationVector =
		@@ -230,7 +265,7 @@ void SensorService::onFirstRef() {
		registerSensor( new GyroDriftSensor(), true, true);
		}

		if (hasAccel && hasGyro) {
		if (hasAccel && (hasGyro \|\| hasGyroUncalibrated)) {
		bool needGravitySensor = (virtualSensorsNeeds & (1<<SENSOR_TYPE_GRAVITY)) != 0;
		registerSensor(new GravitySensor(list, count), !needGravitySensor, true);

		@@ -250,6 +285,30 @@ void SensorService::onFirstRef() {
		registerSensor(new GeoMagRotationVectorSensor(), !needGeoMagRotationVector, true);
		}

		if (isAutomotive()) {
		if (hasAccel) {
		registerSensor(new LimitedAxesImuSensor(list, count, SENSOR_TYPE_ACCELEROMETER),
		/isDebug=/false, /isVirtual=/true);
		}

		if (hasGyro) {
		registerSensor(new LimitedAxesImuSensor(list, count, SENSOR_TYPE_GYROSCOPE),
		/isDebug=/false, /isVirtual=/true);
		}

		if (hasAccelUncalibrated) {
		registerSensor(new LimitedAxesImuSensor(list, count,
		SENSOR_TYPE_ACCELEROMETER_UNCALIBRATED),
		/isDebug=/false, /isVirtual=/true);
		}

		if (hasGyroUncalibrated) {
		registerSensor(new LimitedAxesImuSensor(list, count,
		SENSOR_TYPE_GYROSCOPE_UNCALIBRATED),
		/isDebug=/false, /isVirtual=/true);
		}
		}

		// Check if the device really supports batching by looking at the FIFO event
		// counts for each sensor.
		bool batchingSupported = false;