Merge changes from topic "sensors-hal-aidl" (a366d1cb) · Commits · e / os / android_frameworks_native

services/sensorservice/AidlSensorHalWrapper.cpp

0 → 100644

+656 −0

File added.

Preview size limit exceeded, changes collapsed.

services/sensorservice/AidlSensorHalWrapper.h

0 → 100644

+97 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2021 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_AIDL_SENSOR_HAL_WRAPPER_H
		#define ANDROID_AIDL_SENSOR_HAL_WRAPPER_H

		#include "ISensorHalWrapper.h"

		#include <aidl/android/hardware/sensors/ISensors.h>
		#include <fmq/AidlMessageQueue.h>
		#include <sensor/SensorEventQueue.h>

		namespace android {

		class AidlSensorHalWrapper : public ISensorHalWrapper {
		public:
		AidlSensorHalWrapper();

		~AidlSensorHalWrapper() override {
		if (mEventQueueFlag != nullptr) {
		::android::hardware::EventFlag::deleteEventFlag(&mEventQueueFlag);
		mEventQueueFlag = nullptr;
		}
		if (mWakeLockQueueFlag != nullptr) {
		::android::hardware::EventFlag::deleteEventFlag(&mWakeLockQueueFlag);
		mWakeLockQueueFlag = nullptr;
		}
		}

		virtual bool connect(SensorDeviceCallback *callback) override;

		virtual void prepareForReconnect() override;

		virtual bool supportsPolling() override;

		virtual bool supportsMessageQueues() override;

		virtual ssize_t poll(sensors_event_t *buffer, size_t count) override;

		virtual ssize_t pollFmq(sensors_event_t *buffer, size_t count) override;

		virtual std::vector<sensor_t> getSensorsList() override;

		virtual status_t setOperationMode(SensorService::Mode mode) override;

		virtual status_t activate(int32_t sensorHandle, bool enabled) override;

		virtual status_t batch(int32_t sensorHandle, int64_t samplingPeriodNs,
		int64_t maxReportLatencyNs) override;

		virtual status_t flush(int32_t sensorHandle) override;

		virtual status_t injectSensorData(const sensors_event_t *event) override;

		virtual status_t registerDirectChannel(const sensors_direct_mem_t *memory,
		int32_t *channelHandle) override;

		virtual status_t unregisterDirectChannel(int32_t channelHandle) override;

		virtual status_t configureDirectChannel(int32_t sensorHandle, int32_t channelHandle,
		const struct sensors_direct_cfg_t *config) override;

		virtual void writeWakeLockHandled(uint32_t count) override;

		private:
		std::shared_ptr<aidl::android::hardware::sensors::ISensors> mSensors;
		std::shared_ptr<::aidl::android::hardware::sensors::ISensorsCallback> mCallback;
		std::unique_ptr<::android::AidlMessageQueue<::aidl::android::hardware::sensors::Event,
		SynchronizedReadWrite>>
		mEventQueue;
		std::unique_ptr<::android::AidlMessageQueue<int, SynchronizedReadWrite>> mWakeLockQueue;
		::android::hardware::EventFlag *mEventQueueFlag;
		::android::hardware::EventFlag *mWakeLockQueueFlag;
		SensorDeviceCallback *mSensorDeviceCallback;
		std::array<::aidl::android::hardware::sensors::Event,
		::android::SensorEventQueue::MAX_RECEIVE_BUFFER_EVENT_COUNT>
		mEventBuffer;

		ndk::ScopedAIBinder_DeathRecipient mDeathRecipient;
		};

		} // namespace android

		#endif // ANDROID_AIDL_SENSOR_HAL_WRAPPER_H

services/sensorservice/Android.bp

+6 −0

Original line number	Diff line number	Diff line
		@@ -11,6 +11,7 @@ cc_library_shared {
		name: "libsensorservice",

		srcs: [
		"AidlSensorHalWrapper.cpp",
		"BatteryService.cpp",
		"CorrectedGyroSensor.cpp",
		"Fusion.cpp",
		@@ -61,14 +62,19 @@ cc_library_shared {
		"libbase",
		"libhidlbase",
		"libfmq",
		"libbinder_ndk",
		"packagemanager_aidl-cpp",
		"android.hardware.sensors@1.0",
		"android.hardware.sensors@2.0",
		"android.hardware.sensors@2.1",
		"android.hardware.common-V2-ndk",
		"android.hardware.common.fmq-V1-ndk",
		],

		static_libs: [
		"libaidlcommonsupport",
		"android.hardware.sensors@1.0-convert",
		"android.hardware.sensors-V1-ndk",
		],

		generated_headers: ["framework-cppstream-protos"],

services/sensorservice/HidlSensorHalWrapper.cpp

+20 −67

Original line number	Diff line number	Diff line
		@@ -76,11 +76,11 @@ void SensorsHalDeathReceiver::serviceDied(
		mHidlSensorHalWrapper->prepareForReconnect();
		}

		struct SensorsCallback : public ISensorsCallback {
		struct HidlSensorsCallback : public ISensorsCallback {
		using Result = ::android::hardware::sensors::V1_0::Result;
		using SensorInfo = ::android::hardware::sensors::V2_1::SensorInfo;

		SensorsCallback(ISensorHalWrapper::SensorDeviceCallback* sensorDeviceCallback) {
		HidlSensorsCallback(ISensorHalWrapper::SensorDeviceCallback* sensorDeviceCallback) {
		mSensorDeviceCallback = sensorDeviceCallback;
		}

		@@ -143,10 +143,11 @@ ssize_t HidlSensorHalWrapper::poll(sensors_event_t* buffer, size_t count) {
		bool hidlTransportError = false;

		do {
		auto ret = mSensors->poll(
		count, [&](auto result, const auto& events, const auto& dynamicSensorsAdded) {
		auto ret = mSensors->poll(count,
		[&](auto result, const auto& events,
		const auto& dynamicSensorsAdded) {
		if (result == Result::OK) {
		convertToSensorEventsAndQuantize(convertToNewEvents(events),
		convertToSensorEvents(convertToNewEvents(events),
		convertToNewSensorInfos(
		dynamicSensorsAdded),
		buffer);
		@@ -216,9 +217,6 @@ ssize_t HidlSensorHalWrapper::pollFmq(sensors_event_t* buffer, size_t maxNumEven

		for (size_t i = 0; i < eventsToRead; i++) {
		convertToSensorEvent(mEventBuffer[i], &buffer[i]);
		android::SensorDeviceUtils::quantizeSensorEventValues(&buffer[i],
		getResolutionForSensor(
		buffer[i].sensor));
		}
		eventsRead = eventsToRead;
		} else {
		@@ -482,7 +480,7 @@ ISensorHalWrapper::HalConnectionStatus HidlSensorHalWrapper::initializeHidlServi
		CHECK(mSensors != nullptr && mWakeLockQueue != nullptr && mEventQueueFlag != nullptr &&
		mWakeLockQueueFlag != nullptr);

		mCallback = new SensorsCallback(mSensorDeviceCallback);
		mCallback = sp<HidlSensorsCallback>::make(mSensorDeviceCallback);
		status_t status =
		checkReturnAndGetStatus(mSensors->initialize(*mWakeLockQueue->getDesc(), mCallback));

		@@ -500,63 +498,18 @@ ISensorHalWrapper::HalConnectionStatus HidlSensorHalWrapper::initializeHidlServi

		void HidlSensorHalWrapper::convertToSensorEvent(const Event& src, sensors_event_t* dst) {
		android::hardware::sensors::V2_1::implementation::convertToSensorEvent(src, dst);

		if (src.sensorType == android::hardware::sensors::V2_1::SensorType::DYNAMIC_SENSOR_META) {
		const hardware::sensors::V1_0::DynamicSensorInfo& dyn = src.u.dynamic;

		dst->dynamic_sensor_meta.connected = dyn.connected;
		dst->dynamic_sensor_meta.handle = dyn.sensorHandle;
		if (dyn.connected) {
		std::unique_lock<std::mutex> lock(mDynamicSensorsMutex);
		// Give MAX_DYN_SENSOR_WAIT_SEC for onDynamicSensorsConnected to be invoked since it
		// can be received out of order from this event due to a bug in the HIDL spec that
		// marks it as oneway.
		auto it = mConnectedDynamicSensors.find(dyn.sensorHandle);
		if (it == mConnectedDynamicSensors.end()) {
		mDynamicSensorsCv.wait_for(lock, MAX_DYN_SENSOR_WAIT, [&, dyn] {
		return mConnectedDynamicSensors.find(dyn.sensorHandle) !=
		mConnectedDynamicSensors.end();
		});
		it = mConnectedDynamicSensors.find(dyn.sensorHandle);
		CHECK(it != mConnectedDynamicSensors.end());
		}

		dst->dynamic_sensor_meta.sensor = &it->second;

		memcpy(dst->dynamic_sensor_meta.uuid, dyn.uuid.data(),
		sizeof(dst->dynamic_sensor_meta.uuid));
		}
		}
		}

		void HidlSensorHalWrapper::convertToSensorEventsAndQuantize(
		const hidl_vec<Event>& src, const hidl_vec<SensorInfo>& dynamicSensorsAdded,
		void HidlSensorHalWrapper::convertToSensorEvents(const hidl_vec<Event>& src,
		const hidl_vec<SensorInfo>& dynamicSensorsAdded,
		sensors_event_t* dst) {
		if (dynamicSensorsAdded.size() > 0 && mCallback != nullptr) {
		mCallback->onDynamicSensorsConnected_2_1(dynamicSensorsAdded);
		}

		for (size_t i = 0; i < src.size(); ++i) {
		android::hardware::sensors::V2_1::implementation::convertToSensorEvent(src[i], &dst[i]);
		android::SensorDeviceUtils::quantizeSensorEventValues(&dst[i],
		getResolutionForSensor(
		dst[i].sensor));
		convertToSensorEvent(src[i], &dst[i]);
		}
		}

		float HidlSensorHalWrapper::getResolutionForSensor(int sensorHandle) {
		for (size_t i = 0; i < mSensorList.size(); i++) {
		if (sensorHandle == mSensorList[i].handle) {
		return mSensorList[i].resolution;
		}
		}

		auto it = mConnectedDynamicSensors.find(sensorHandle);
		if (it != mConnectedDynamicSensors.end()) {
		return it->second.resolution;
		}

		return 0;
		}

		} // namespace android

services/sensorservice/HidlSensorHalWrapper.h

+3 −11

Original line number	Diff line number	Diff line
		@@ -124,12 +124,6 @@ public:
		private:
		sp<::android::hardware::sensors::V2_1::implementation::ISensorsWrapperBase> mSensors;
		sp<::android::hardware::sensors::V2_1::ISensorsCallback> mCallback;
		std::vector<sensor_t> mSensorList;
		std::unordered_map<int32_t, sensor_t> mConnectedDynamicSensors;

		std::mutex mDynamicSensorsMutex;
		std::condition_variable mDynamicSensorsCv;
		static constexpr std::chrono::seconds MAX_DYN_SENSOR_WAIT{5};

		// Keep track of any hidl transport failures
		SensorServiceUtil::RingBuffer<HidlTransportErrorLog> mHidlTransportErrors;
		@@ -153,7 +147,7 @@ private:

		void convertToSensorEvent(const Event& src, sensors_event_t* dst);

		void convertToSensorEventsAndQuantize(const hardware::hidl_vec<Event>& src,
		void convertToSensorEvents(const hardware::hidl_vec<Event>& src,
		const hardware::hidl_vec<SensorInfo>& dynamicSensorsAdded,
		sensors_event_t* dst);

		@@ -167,8 +161,6 @@ private:
		typedef hardware::MessageQueue<uint32_t, hardware::kSynchronizedReadWrite> WakeLockQueue;
		std::unique_ptr<WakeLockQueue> mWakeLockQueue;

		float getResolutionForSensor(int sensorHandle);

		hardware::EventFlag* mEventQueueFlag;
		hardware::EventFlag* mWakeLockQueueFlag;