Add a sub-HAL implementation for testing multi-HAL (c34e6683) · Commits · e / os / android_hardware_interfaces

sensors/2.0/multihal/Android.bp

+9 −0

Original line number	Diff line number	Diff line
		@@ -23,6 +23,9 @@ cc_binary {
		"HalProxy.cpp",
		],
		init_rc: ["android.hardware.sensors@2.0-service-multihal.rc"],
		header_libs: [
		"android.hardware.sensors@2.0-subhal.header",
		],
		shared_libs: [
		"android.hardware.sensors@1.0",
		"android.hardware.sensors@2.0",
		@@ -36,3 +39,9 @@ cc_binary {
		],
		vintf_fragments: ["android.hardware.sensors@2.0-multihal.xml"],
		}

		cc_library_headers {
		name: "android.hardware.sensors@2.0-subhal.header",
		vendor: true,
		export_include_dirs: ["include"],
		}
		No newline at end of file

sensors/2.0/multihal/SubHal.h→sensors/2.0/multihal/include/SubHal.h

+1 −1

Original line number	Diff line number	Diff line
		@@ -163,7 +163,7 @@ class ISensorsSubHal : public ISensors {
		/**
		* @return A human-readable name for use in wake locks and logging.
		*/
		virtual const std::string& getName() = 0;
		virtual const std::string getName() = 0;

		/**
		* First method invoked on the sub-HAL after it's allocated through sensorsHalGetSubHal() by the

sensors/2.0/multihal/testing/Android.bp

0 → 100644

+55 −0

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

		cc_defaults {
		name: "android.hardware.sensors@2.0-fakesubhal-defaults",
		vendor: true,
		srcs: [
		"Sensor.cpp",
		"SensorsSubHal.cpp",
		],
		header_libs: [
		"android.hardware.sensors@2.0-subhal.header",
		],
		shared_libs: [
		"android.hardware.sensors@1.0",
		"android.hardware.sensors@2.0",
		"libcutils",
		"libfmq",
		"libhidlbase",
		"libhidltransport",
		"liblog",
		"libpower",
		"libutils",
		],
		}

		cc_library {
		name: "android.hardware.sensors@2.0-fakesubhal-config1",
		defaults: ["android.hardware.sensors@2.0-fakesubhal-defaults"],
		cflags: [
		"-DSUPPORT_CONTINUOUS_SENSORS",
		"-DSUB_HAL_NAME=\"FakeSubHal-Continuous\"",
		],
		}

		cc_library {
		name: "android.hardware.sensors@2.0-fakesubhal-config2",
		defaults: ["android.hardware.sensors@2.0-fakesubhal-defaults"],
		cflags: [
		"-DSUPPORT_ON_CHANGE_SENSORS",
		"-DSUB_HAL_NAME=\"FakeSubHal-OnChange\"",
		],
		}
		No newline at end of file

sensors/2.0/multihal/testing/README

0 → 100644

+19 −0

Original line number	Diff line number	Diff line
		This directory contains a modified version of the default implementation
		provided for sensors HAL 2.0 to support multi-HAL 2.0. It should be used as a
		means to verify the multi-HAL 2.0 implementation can successfully load and
		interact with sub-HALs.

		This sub-HAL implementation has two macros that can be used to configure support
		for different sets of sensors. One "SUPPORT_CONTINUOUS_SENSORS", enables
		support for continuous sensors like accel, and gyro whereas the other
		"SUPPORT_ON_CHANGE_SENSORS" enables support for on change sensors like the
		light and proximity sensor. A build target is defined for each of these macros,
		but more targets could be added to support both in one sub-HAL or none at all,
		if necessary.

		When built, the library will be written to
		out/target/product/<device>/vendor/lib64/android.hardware.sensors@2.0-fakesubhal.so

		Take this .so and place it where the multi-HAL config will cause the HalProxy to
		look and then restart the system server with adb shell stop / adb shell start
		to cause the multi-HAL to restart and attempt to load in the sub-HAL.

sensors/2.0/multihal/testing/Sensor.cpp

0 → 100644

+372 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2019 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 "Sensor.h"

		#include <utils/SystemClock.h>

		#include <cmath>

		namespace android {
		namespace hardware {
		namespace sensors {
		namespace V2_0 {
		namespace subhal {
		namespace implementation {

		using ::android::hardware::sensors::V1_0::MetaDataEventType;
		using ::android::hardware::sensors::V1_0::SensorFlagBits;
		using ::android::hardware::sensors::V1_0::SensorStatus;

		static constexpr float kDefaultMaxDelayUs = 10 * 1000 * 1000;

		Sensor::Sensor(ISensorsEventCallback* callback)
		: mIsEnabled(false),
		mSamplingPeriodNs(0),
		mLastSampleTimeNs(0),
		mCallback(callback),
		mMode(OperationMode::NORMAL) {
		mRunThread = std::thread(startThread, this);
		}

		Sensor::~Sensor() {
		std::unique_lock<std::mutex> lock(mRunMutex);
		mStopThread = true;
		mIsEnabled = false;
		mWaitCV.notify_all();
		lock.release();
		mRunThread.join();
		}

		const SensorInfo& Sensor::getSensorInfo() const {
		return mSensorInfo;
		}

		void Sensor::batch(int32_t samplingPeriodNs) {
		samplingPeriodNs =
		std::clamp(samplingPeriodNs, mSensorInfo.minDelay * 1000, mSensorInfo.maxDelay * 1000);

		if (mSamplingPeriodNs != samplingPeriodNs) {
		mSamplingPeriodNs = samplingPeriodNs;
		// Wake up the 'run' thread to check if a new event should be generated now
		mWaitCV.notify_all();
		}
		}

		void Sensor::activate(bool enable) {
		if (mIsEnabled != enable) {
		std::unique_lock<std::mutex> lock(mRunMutex);
		mIsEnabled = enable;
		mWaitCV.notify_all();
		}
		}

		Result Sensor::flush() {
		// Only generate a flush complete event if the sensor is enabled and if the sensor is not a
		// one-shot sensor.
		if (!mIsEnabled \|\| (mSensorInfo.flags & static_cast<uint32_t>(SensorFlagBits::ONE_SHOT_MODE))) {
		return Result::BAD_VALUE;
		}

		// Note: If a sensor supports batching, write all of the currently batched events for the sensor
		// to the Event FMQ prior to writing the flush complete event.
		Event ev;
		ev.sensorHandle = mSensorInfo.sensorHandle;
		ev.sensorType = SensorType::META_DATA;
		ev.u.meta.what = MetaDataEventType::META_DATA_FLUSH_COMPLETE;
		std::vector<Event> evs{ev};
		mCallback->postEvents(evs, isWakeUpSensor());

		return Result::OK;
		}

		void Sensor::startThread(Sensor* sensor) {
		sensor->run();
		}

		void Sensor::run() {
		std::unique_lock<std::mutex> runLock(mRunMutex);
		constexpr int64_t kNanosecondsInSeconds = 1000 * 1000 * 1000;

		while (!mStopThread) {
		if (!mIsEnabled \|\| mMode == OperationMode::DATA_INJECTION) {
		mWaitCV.wait(runLock, [&] {
		return ((mIsEnabled && mMode == OperationMode::NORMAL) \|\| mStopThread);
		});
		} else {
		timespec curTime;
		clock_gettime(CLOCK_REALTIME, &curTime);
		int64_t now = (curTime.tv_sec * kNanosecondsInSeconds) + curTime.tv_nsec;
		int64_t nextSampleTime = mLastSampleTimeNs + mSamplingPeriodNs;

		if (now >= nextSampleTime) {
		mLastSampleTimeNs = now;
		nextSampleTime = mLastSampleTimeNs + mSamplingPeriodNs;
		mCallback->postEvents(readEvents(), isWakeUpSensor());
		}

		mWaitCV.wait_for(runLock, std::chrono::nanoseconds(nextSampleTime - now));
		}
		}
		}

		bool Sensor::isWakeUpSensor() {
		return mSensorInfo.flags & static_cast<uint32_t>(SensorFlagBits::WAKE_UP);
		}

		std::vector<Event> Sensor::readEvents() {
		std::vector<Event> events;
		Event event;
		event.sensorHandle = mSensorInfo.sensorHandle;
		event.sensorType = mSensorInfo.type;
		event.timestamp = ::android::elapsedRealtimeNano();
		event.u.vec3.x = 0;
		event.u.vec3.y = 0;
		event.u.vec3.z = 0;
		event.u.vec3.status = SensorStatus::ACCURACY_HIGH;
		events.push_back(event);
		return events;
		}

		void Sensor::setOperationMode(OperationMode mode) {
		if (mMode != mode) {
		std::unique_lock<std::mutex> lock(mRunMutex);
		mMode = mode;
		mWaitCV.notify_all();
		}
		}

		bool Sensor::supportsDataInjection() const {
		return mSensorInfo.flags & static_cast<uint32_t>(SensorFlagBits::DATA_INJECTION);
		}

		Result Sensor::injectEvent(const Event& event) {
		Result result = Result::OK;
		if (event.sensorType == SensorType::ADDITIONAL_INFO) {
		// When in OperationMode::NORMAL, SensorType::ADDITIONAL_INFO is used to push operation
		// environment data into the device.
		} else if (!supportsDataInjection()) {
		result = Result::INVALID_OPERATION;
		} else if (mMode == OperationMode::DATA_INJECTION) {
		mCallback->postEvents(std::vector<Event>{event}, isWakeUpSensor());
		} else {
		result = Result::BAD_VALUE;
		}
		return result;
		}

		OnChangeSensor::OnChangeSensor(ISensorsEventCallback* callback)
		: Sensor(callback), mPreviousEventSet(false) {}

		void OnChangeSensor::activate(bool enable) {
		Sensor::activate(enable);
		if (!enable) {
		mPreviousEventSet = false;
		}
		}

		std::vector<Event> OnChangeSensor::readEvents() {
		std::vector<Event> events = Sensor::readEvents();
		std::vector<Event> outputEvents;

		for (auto iter = events.begin(); iter != events.end(); ++iter) {
		Event ev = *iter;
		if (ev.u.vec3 != mPreviousEvent.u.vec3 \|\| !mPreviousEventSet) {
		outputEvents.push_back(ev);
		mPreviousEvent = ev;
		mPreviousEventSet = true;
		}
		}
		return outputEvents;
		}

		AccelSensor::AccelSensor(int32_t sensorHandle, ISensorsEventCallback* callback) : Sensor(callback) {
		mSensorInfo.sensorHandle = sensorHandle;
		mSensorInfo.name = "Accel Sensor";
		mSensorInfo.vendor = "Vendor String";
		mSensorInfo.version = 1;
		mSensorInfo.type = SensorType::ACCELEROMETER;
		mSensorInfo.typeAsString = "";
		mSensorInfo.maxRange = 78.4f; // +/- 8g
		mSensorInfo.resolution = 1.52e-5;
		mSensorInfo.power = 0.001f; // mA
		mSensorInfo.minDelay = 20 * 1000; // microseconds
		mSensorInfo.maxDelay = kDefaultMaxDelayUs;
		mSensorInfo.fifoReservedEventCount = 0;
		mSensorInfo.fifoMaxEventCount = 0;
		mSensorInfo.requiredPermission = "";
		mSensorInfo.flags = static_cast<uint32_t>(SensorFlagBits::DATA_INJECTION);
		};

		PressureSensor::PressureSensor(int32_t sensorHandle, ISensorsEventCallback* callback)
		: Sensor(callback) {
		mSensorInfo.sensorHandle = sensorHandle;
		mSensorInfo.name = "Pressure Sensor";
		mSensorInfo.vendor = "Vendor String";
		mSensorInfo.version = 1;
		mSensorInfo.type = SensorType::PRESSURE;
		mSensorInfo.typeAsString = "";
		mSensorInfo.maxRange = 1100.0f; // hPa
		mSensorInfo.resolution = 0.005f; // hPa
		mSensorInfo.power = 0.001f; // mA
		mSensorInfo.minDelay = 100 * 1000; // microseconds
		mSensorInfo.maxDelay = kDefaultMaxDelayUs;
		mSensorInfo.fifoReservedEventCount = 0;
		mSensorInfo.fifoMaxEventCount = 0;
		mSensorInfo.requiredPermission = "";
		mSensorInfo.flags = 0;
		};

		MagnetometerSensor::MagnetometerSensor(int32_t sensorHandle, ISensorsEventCallback* callback)
		: Sensor(callback) {
		mSensorInfo.sensorHandle = sensorHandle;
		mSensorInfo.name = "Magnetic Field Sensor";
		mSensorInfo.vendor = "Vendor String";
		mSensorInfo.version = 1;
		mSensorInfo.type = SensorType::MAGNETIC_FIELD;
		mSensorInfo.typeAsString = "";
		mSensorInfo.maxRange = 1300.0f;
		mSensorInfo.resolution = 0.01f;
		mSensorInfo.power = 0.001f; // mA
		mSensorInfo.minDelay = 20 * 1000; // microseconds
		mSensorInfo.maxDelay = kDefaultMaxDelayUs;
		mSensorInfo.fifoReservedEventCount = 0;
		mSensorInfo.fifoMaxEventCount = 0;
		mSensorInfo.requiredPermission = "";
		mSensorInfo.flags = 0;
		};

		LightSensor::LightSensor(int32_t sensorHandle, ISensorsEventCallback* callback)
		: OnChangeSensor(callback) {
		mSensorInfo.sensorHandle = sensorHandle;
		mSensorInfo.name = "Light Sensor";
		mSensorInfo.vendor = "Vendor String";
		mSensorInfo.version = 1;
		mSensorInfo.type = SensorType::LIGHT;
		mSensorInfo.typeAsString = "";
		mSensorInfo.maxRange = 43000.0f;
		mSensorInfo.resolution = 10.0f;
		mSensorInfo.power = 0.001f; // mA
		mSensorInfo.minDelay = 200 * 1000; // microseconds
		mSensorInfo.maxDelay = kDefaultMaxDelayUs;
		mSensorInfo.fifoReservedEventCount = 0;
		mSensorInfo.fifoMaxEventCount = 0;
		mSensorInfo.requiredPermission = "";
		mSensorInfo.flags = static_cast<uint32_t>(SensorFlagBits::ON_CHANGE_MODE);
		};

		ProximitySensor::ProximitySensor(int32_t sensorHandle, ISensorsEventCallback* callback)
		: OnChangeSensor(callback) {
		mSensorInfo.sensorHandle = sensorHandle;
		mSensorInfo.name = "Proximity Sensor";
		mSensorInfo.vendor = "Vendor String";
		mSensorInfo.version = 1;
		mSensorInfo.type = SensorType::PROXIMITY;
		mSensorInfo.typeAsString = "";
		mSensorInfo.maxRange = 5.0f;
		mSensorInfo.resolution = 1.0f;
		mSensorInfo.power = 0.012f; // mA
		mSensorInfo.minDelay = 200 * 1000; // microseconds
		mSensorInfo.maxDelay = kDefaultMaxDelayUs;
		mSensorInfo.fifoReservedEventCount = 0;
		mSensorInfo.fifoMaxEventCount = 0;
		mSensorInfo.requiredPermission = "";
		mSensorInfo.flags =
		static_cast<uint32_t>(SensorFlagBits::ON_CHANGE_MODE \| SensorFlagBits::WAKE_UP);
		};

		GyroSensor::GyroSensor(int32_t sensorHandle, ISensorsEventCallback* callback) : Sensor(callback) {
		mSensorInfo.sensorHandle = sensorHandle;
		mSensorInfo.name = "Gyro Sensor";
		mSensorInfo.vendor = "Vendor String";
		mSensorInfo.version = 1;
		mSensorInfo.type = SensorType::GYROSCOPE;
		mSensorInfo.typeAsString = "";
		mSensorInfo.maxRange = 1000.0f * M_PI / 180.0f;
		mSensorInfo.resolution = 1000.0f * M_PI / (180.0f * 32768.0f);
		mSensorInfo.power = 0.001f;
		mSensorInfo.minDelay = 2.5f * 1000; // microseconds
		mSensorInfo.maxDelay = kDefaultMaxDelayUs;
		mSensorInfo.fifoReservedEventCount = 0;
		mSensorInfo.fifoMaxEventCount = 0;
		mSensorInfo.requiredPermission = "";
		mSensorInfo.flags = 0;
		};

		AmbientTempSensor::AmbientTempSensor(int32_t sensorHandle, ISensorsEventCallback* callback)
		: OnChangeSensor(callback) {
		mSensorInfo.sensorHandle = sensorHandle;
		mSensorInfo.name = "Ambient Temp Sensor";
		mSensorInfo.vendor = "Vendor String";
		mSensorInfo.version = 1;
		mSensorInfo.type = SensorType::AMBIENT_TEMPERATURE;
		mSensorInfo.typeAsString = "";
		mSensorInfo.maxRange = 80.0f;
		mSensorInfo.resolution = 0.01f;
		mSensorInfo.power = 0.001f;
		mSensorInfo.minDelay = 40 * 1000; // microseconds
		mSensorInfo.maxDelay = kDefaultMaxDelayUs;
		mSensorInfo.fifoReservedEventCount = 0;
		mSensorInfo.fifoMaxEventCount = 0;
		mSensorInfo.requiredPermission = "";
		mSensorInfo.flags = static_cast<uint32_t>(SensorFlagBits::ON_CHANGE_MODE);
		};

		DeviceTempSensor::DeviceTempSensor(int32_t sensorHandle, ISensorsEventCallback* callback)
		: OnChangeSensor(callback) {
		mSensorInfo.sensorHandle = sensorHandle;
		mSensorInfo.name = "Device Temp Sensor";
		mSensorInfo.vendor = "Vendor String";
		mSensorInfo.version = 1;
		mSensorInfo.type = SensorType::TEMPERATURE;
		mSensorInfo.typeAsString = "";
		mSensorInfo.maxRange = 80.0f;
		mSensorInfo.resolution = 0.01f;
		mSensorInfo.power = 0.001f;
		mSensorInfo.minDelay = 40 * 1000; // microseconds
		mSensorInfo.maxDelay = kDefaultMaxDelayUs;
		mSensorInfo.fifoReservedEventCount = 0;
		mSensorInfo.fifoMaxEventCount = 0;
		mSensorInfo.requiredPermission = "";
		mSensorInfo.flags = static_cast<uint32_t>(SensorFlagBits::ON_CHANGE_MODE);
		}

		RelativeHumiditySensor::RelativeHumiditySensor(int32_t sensorHandle,
		ISensorsEventCallback* callback)
		: OnChangeSensor(callback) {
		mSensorInfo.sensorHandle = sensorHandle;
		mSensorInfo.name = "Relative Humidity Sensor";
		mSensorInfo.vendor = "Vendor String";
		mSensorInfo.version = 1;
		mSensorInfo.type = SensorType::RELATIVE_HUMIDITY;
		mSensorInfo.typeAsString = "";
		mSensorInfo.maxRange = 100.0f;
		mSensorInfo.resolution = 0.1f;
		mSensorInfo.power = 0.001f;
		mSensorInfo.minDelay = 40 * 1000; // microseconds
		mSensorInfo.maxDelay = kDefaultMaxDelayUs;
		mSensorInfo.fifoReservedEventCount = 0;
		mSensorInfo.fifoMaxEventCount = 0;
		mSensorInfo.requiredPermission = "";
		mSensorInfo.flags = static_cast<uint32_t>(SensorFlagBits::ON_CHANGE_MODE);
		}

		} // namespace implementation
		} // namespace subhal
		} // namespace V2_0
		} // namespace sensors
		} // namespace hardware
		} // namespace android