Adds sensors aidl default (cuttlefish) implementation (bc2a1b73) · Commits · e / os / android_hardware_interfaces

sensors/aidl/default/Android.bp

+8 −0

Original line number	Diff line number	Diff line
		@@ -28,12 +28,15 @@ cc_library_static {
		vendor: true,
		shared_libs: [
		"libbase",
		"libfmq",
		"libpower",
		"libbinder_ndk",
		"android.hardware.sensors-V1-ndk",
		],
		export_include_dirs: ["include"],
		srcs: [
		"Sensors.cpp",
		"Sensor.cpp",
		],
		visibility: [
		":__subpackages__",
		@@ -50,6 +53,11 @@ cc_binary {
		shared_libs: [
		"libbase",
		"libbinder_ndk",
		"libfmq",
		"libpower",
		"libcutils",
		"liblog",
		"libutils",
		"android.hardware.sensors-V1-ndk",
		],
		static_libs: [

sensors/aidl/default/Sensor.cpp

0 → 100644

+434 −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.
		*/

		#include "sensors-impl/Sensor.h"

		#include "utils/SystemClock.h"

		#include <cmath>

		using ::ndk::ScopedAStatus;

		namespace aidl {
		namespace android {
		namespace hardware {
		namespace sensors {

		static constexpr int32_t 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(int64_t samplingPeriodNs) {
		if (samplingPeriodNs < mSensorInfo.minDelayUs * 1000ll) {
		samplingPeriodNs = mSensorInfo.minDelayUs * 1000ll;
		} else if (samplingPeriodNs > mSensorInfo.maxDelayUs * 1000ll) {
		samplingPeriodNs = mSensorInfo.maxDelayUs * 1000ll;
		}

		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();
		}
		}

		ScopedAStatus 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>(SensorInfo::SENSOR_FLAG_BITS_ONE_SHOT_MODE))) {
		return ScopedAStatus::fromServiceSpecificError(
		static_cast<int32_t>(BnSensors::ERROR_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;
		EventPayload::MetaData meta = {
		.what = MetaDataEventType::META_DATA_FLUSH_COMPLETE,
		};
		ev.payload.set<EventPayload::Tag::meta>(meta);
		std::vector<Event> evs{ev};
		mCallback->postEvents(evs, isWakeUpSensor());

		return ScopedAStatus::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_BOOTTIME, &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>(SensorInfo::SENSOR_FLAG_BITS_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();
		memset(&event.payload, 0, sizeof(event.payload));
		readEventPayload(event.payload);
		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>(SensorInfo::SENSOR_FLAG_BITS_DATA_INJECTION);
		}

		ScopedAStatus Sensor::injectEvent(const Event& event) {
		if (event.sensorType == SensorType::ADDITIONAL_INFO) {
		return ScopedAStatus::ok();
		// When in OperationMode::NORMAL, SensorType::ADDITIONAL_INFO is used to push operation
		// environment data into the device.
		}

		if (!supportsDataInjection()) {
		return ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
		}

		if (mMode == OperationMode::DATA_INJECTION) {
		mCallback->postEvents(std::vector<Event>{event}, isWakeUpSensor());
		return ScopedAStatus::ok();
		}

		return ScopedAStatus::fromServiceSpecificError(
		static_cast<int32_t>(BnSensors::ERROR_BAD_VALUE));
		}

		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 (!mPreviousEventSet \|\|
		memcmp(&mPreviousEvent.payload, &ev.payload, sizeof(ev.payload)) != 0) {
		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.minDelayUs = 10 * 1000; // microseconds
		mSensorInfo.maxDelayUs = kDefaultMaxDelayUs;
		mSensorInfo.fifoReservedEventCount = 0;
		mSensorInfo.fifoMaxEventCount = 0;
		mSensorInfo.requiredPermission = "";
		mSensorInfo.flags = static_cast<uint32_t>(SensorInfo::SENSOR_FLAG_BITS_DATA_INJECTION);
		};

		void AccelSensor::readEventPayload(EventPayload& payload) {
		EventPayload::Vec3 vec3 = {
		.x = 0,
		.y = 0,
		.z = -9.8,
		.status = SensorStatus::ACCURACY_HIGH,
		};
		payload.set<EventPayload::Tag::vec3>(vec3);
		}

		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.minDelayUs = 100 * 1000; // microseconds
		mSensorInfo.maxDelayUs = kDefaultMaxDelayUs;
		mSensorInfo.fifoReservedEventCount = 0;
		mSensorInfo.fifoMaxEventCount = 0;
		mSensorInfo.requiredPermission = "";
		mSensorInfo.flags = 0;
		};

		void PressureSensor::readEventPayload(EventPayload& payload) {
		payload.set<EventPayload::Tag::scalar>(1013.25f);
		}

		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.minDelayUs = 20 * 1000; // microseconds
		mSensorInfo.maxDelayUs = kDefaultMaxDelayUs;
		mSensorInfo.fifoReservedEventCount = 0;
		mSensorInfo.fifoMaxEventCount = 0;
		mSensorInfo.requiredPermission = "";
		mSensorInfo.flags = 0;
		};

		void MagnetometerSensor::readEventPayload(EventPayload& payload) {
		EventPayload::Vec3 vec3 = {
		.x = 100.0,
		.y = 0,
		.z = 50.0,
		.status = SensorStatus::ACCURACY_HIGH,
		};
		payload.set<EventPayload::Tag::vec3>(vec3);
		}

		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.minDelayUs = 200 * 1000; // microseconds
		mSensorInfo.maxDelayUs = kDefaultMaxDelayUs;
		mSensorInfo.fifoReservedEventCount = 0;
		mSensorInfo.fifoMaxEventCount = 0;
		mSensorInfo.requiredPermission = "";
		mSensorInfo.flags = static_cast<uint32_t>(SensorInfo::SENSOR_FLAG_BITS_ON_CHANGE_MODE);
		};

		void LightSensor::readEventPayload(EventPayload& payload) {
		payload.set<EventPayload::Tag::scalar>(80.0f);
		}

		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.minDelayUs = 200 * 1000; // microseconds
		mSensorInfo.maxDelayUs = kDefaultMaxDelayUs;
		mSensorInfo.fifoReservedEventCount = 0;
		mSensorInfo.fifoMaxEventCount = 0;
		mSensorInfo.requiredPermission = "";
		mSensorInfo.flags = static_cast<uint32_t>(SensorInfo::SENSOR_FLAG_BITS_ON_CHANGE_MODE \|
		SensorInfo::SENSOR_FLAG_BITS_WAKE_UP);
		};

		void ProximitySensor::readEventPayload(EventPayload& payload) {
		payload.set<EventPayload::Tag::scalar>(2.5f);
		}

		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.minDelayUs = 10 * 1000; // microseconds
		mSensorInfo.maxDelayUs = kDefaultMaxDelayUs;
		mSensorInfo.fifoReservedEventCount = 0;
		mSensorInfo.fifoMaxEventCount = 0;
		mSensorInfo.requiredPermission = "";
		mSensorInfo.flags = 0;
		};

		void GyroSensor::readEventPayload(EventPayload& payload) {
		EventPayload::Vec3 vec3 = {
		.x = 0,
		.y = 0,
		.z = 0,
		.status = SensorStatus::ACCURACY_HIGH,
		};
		payload.set<EventPayload::Tag::vec3>(vec3);
		}

		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.minDelayUs = 40 * 1000; // microseconds
		mSensorInfo.maxDelayUs = kDefaultMaxDelayUs;
		mSensorInfo.fifoReservedEventCount = 0;
		mSensorInfo.fifoMaxEventCount = 0;
		mSensorInfo.requiredPermission = "";
		mSensorInfo.flags = static_cast<uint32_t>(SensorInfo::SENSOR_FLAG_BITS_ON_CHANGE_MODE);
		};

		void AmbientTempSensor::readEventPayload(EventPayload& payload) {
		payload.set<EventPayload::Tag::scalar>(40.0f);
		}

		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.minDelayUs = 40 * 1000; // microseconds
		mSensorInfo.maxDelayUs = kDefaultMaxDelayUs;
		mSensorInfo.fifoReservedEventCount = 0;
		mSensorInfo.fifoMaxEventCount = 0;
		mSensorInfo.requiredPermission = "";
		mSensorInfo.flags = static_cast<uint32_t>(SensorInfo::SENSOR_FLAG_BITS_ON_CHANGE_MODE);
		}

		void RelativeHumiditySensor::readEventPayload(EventPayload& payload) {
		payload.set<EventPayload::Tag::scalar>(50.0f);
		}

		HingeAngleSensor::HingeAngleSensor(int32_t sensorHandle, ISensorsEventCallback* callback)
		: OnChangeSensor(callback) {
		mSensorInfo.sensorHandle = sensorHandle;
		mSensorInfo.name = "Hinge Angle Sensor";
		mSensorInfo.vendor = "Vendor String";
		mSensorInfo.version = 1;
		mSensorInfo.type = SensorType::HINGE_ANGLE;
		mSensorInfo.typeAsString = "";
		mSensorInfo.maxRange = 360.0f;
		mSensorInfo.resolution = 1.0f;
		mSensorInfo.power = 0.001f;
		mSensorInfo.minDelayUs = 40 * 1000; // microseconds
		mSensorInfo.maxDelayUs = kDefaultMaxDelayUs;
		mSensorInfo.fifoReservedEventCount = 0;
		mSensorInfo.fifoMaxEventCount = 0;
		mSensorInfo.requiredPermission = "";
		mSensorInfo.flags = static_cast<uint32_t>(SensorInfo::SENSOR_FLAG_BITS_ON_CHANGE_MODE \|
		SensorInfo::SENSOR_FLAG_BITS_WAKE_UP \|
		SensorInfo::SENSOR_FLAG_BITS_DATA_INJECTION);
		}

		void HingeAngleSensor::readEventPayload(EventPayload& payload) {
		payload.set<EventPayload::Tag::scalar>(180.0f);
		}

		} // namespace sensors
		} // namespace hardware
		} // namespace android
		} // namespace aidl

sensors/aidl/default/Sensors.cpp

+103 −30

Original line number	Diff line number	Diff line
		@@ -16,66 +16,139 @@

		#include "sensors-impl/Sensors.h"

		#include <aidl/android/hardware/common/fmq/SynchronizedReadWrite.h>

		using ::aidl::android::hardware::common::fmq::MQDescriptor;
		using ::aidl::android::hardware::common::fmq::SynchronizedReadWrite;
		using ::aidl::android::hardware::sensors::Event;
		using ::aidl::android::hardware::sensors::ISensors;
		using ::aidl::android::hardware::sensors::ISensorsCallback;
		using ::aidl::android::hardware::sensors::SensorInfo;
		using ::ndk::ScopedAStatus;

		namespace aidl {
		namespace android {
		namespace hardware {
		namespace sensors {

		// TODO(b/195593357): Implement AIDL HAL
		::ndk::ScopedAStatus Sensors::activate(int32_t /* in_sensorHandle /, bool / in_enabled */) {
		return ndk::ScopedAStatus::ok();
		ScopedAStatus Sensors::activate(int32_t in_sensorHandle, bool in_enabled) {
		auto sensor = mSensors.find(in_sensorHandle);
		if (sensor != mSensors.end()) {
		sensor->second->activate(in_enabled);
		return ScopedAStatus::ok();
		}

		return ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
		}

		::ndk::ScopedAStatus Sensors::batch(int32_t /* in_sensorHandle */,
		int64_t /* in_samplingPeriodNs */,
		ScopedAStatus Sensors::batch(int32_t in_sensorHandle, int64_t in_samplingPeriodNs,
		int64_t /* in_maxReportLatencyNs */) {
		return ndk::ScopedAStatus::ok();
		auto sensor = mSensors.find(in_sensorHandle);
		if (sensor != mSensors.end()) {
		sensor->second->batch(in_samplingPeriodNs);
		return ScopedAStatus::ok();
		}

		::ndk::ScopedAStatus Sensors::configDirectReport(int32_t /* in_sensorHandle */,
		return ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
		}

		ScopedAStatus Sensors::configDirectReport(int32_t /* in_sensorHandle */,
		int32_t /* in_channelHandle */,
		ISensors::RateLevel /* in_rate */,
		int32_t* /* _aidl_return */) {
		return ndk::ScopedAStatus::ok();
		int32_t* _aidl_return) {
		*_aidl_return = EX_UNSUPPORTED_OPERATION;

		return ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
		}

		::ndk::ScopedAStatus Sensors::flush(int32_t /* in_sensorHandle */) {
		return ndk::ScopedAStatus::ok();
		ScopedAStatus Sensors::flush(int32_t in_sensorHandle) {
		auto sensor = mSensors.find(in_sensorHandle);
		if (sensor != mSensors.end()) {
		return sensor->second->flush();
		}

		::ndk::ScopedAStatus Sensors::getSensorsList(std::vector<SensorInfo>* /* _aidl_return */) {
		return ndk::ScopedAStatus::ok();
		return ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
		}

		::ndk::ScopedAStatus Sensors::initialize(
		const MQDescriptor<Event, SynchronizedReadWrite>& /* in_eventQueueDescriptor */,
		const MQDescriptor<int32_t, SynchronizedReadWrite>& /* in_wakeLockDescriptor */,
		const std::shared_ptr<ISensorsCallback>& /* in_sensorsCallback */) {
		return ndk::ScopedAStatus::ok();
		ScopedAStatus Sensors::getSensorsList(std::vector<SensorInfo>* _aidl_return) {
		for (const auto& sensor : mSensors) {
		_aidl_return->push_back(sensor.second->getSensorInfo());
		}
		return ScopedAStatus::ok();
		}

		::ndk::ScopedAStatus Sensors::injectSensorData(const Event& /* in_event */) {
		return ndk::ScopedAStatus::ok();
		ScopedAStatus Sensors::initialize(
		const MQDescriptor<Event, SynchronizedReadWrite>& in_eventQueueDescriptor,
		const MQDescriptor<int32_t, SynchronizedReadWrite>& in_wakeLockDescriptor,
		const std::shared_ptr<::aidl::android::hardware::sensors::ISensorsCallback>&
		in_sensorsCallback) {
		ScopedAStatus result = ScopedAStatus::ok();

		mEventQueue = std::make_unique<AidlMessageQueue<Event, SynchronizedReadWrite>>(
		in_eventQueueDescriptor, true /* resetPointers */);

		// Ensure that all sensors are disabled.
		for (auto sensor : mSensors) {
		sensor.second->activate(false);
		}

		// Stop the Wake Lock thread if it is currently running
		if (mReadWakeLockQueueRun.load()) {
		mReadWakeLockQueueRun = false;
		mWakeLockThread.join();
		}

		::ndk::ScopedAStatus Sensors::registerDirectChannel(const ISensors::SharedMemInfo& /* in_mem */,
		int32_t* /* _aidl_return */) {
		return ndk::ScopedAStatus::ok();
		// Save a reference to the callback
		mCallback = in_sensorsCallback;

		// Ensure that any existing EventFlag is properly deleted
		deleteEventFlag();

		// Create the EventFlag that is used to signal to the framework that sensor events have been
		// written to the Event FMQ
		if (EventFlag::createEventFlag(mEventQueue->getEventFlagWord(), &mEventQueueFlag) != OK) {
		result = ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
		}

		::ndk::ScopedAStatus Sensors::setOperationMode(OperationMode /* in_mode */) {
		return ndk::ScopedAStatus::ok();
		// Create the Wake Lock FMQ that is used by the framework to communicate whenever WAKE_UP
		// events have been successfully read and handled by the framework.
		mWakeLockQueue = std::make_unique<AidlMessageQueue<int32_t, SynchronizedReadWrite>>(
		in_wakeLockDescriptor, true /* resetPointers */);

		if (!mCallback \|\| !mEventQueue \|\| !mWakeLockQueue \|\| mEventQueueFlag == nullptr) {
		result = ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
		}

		// Start the thread to read events from the Wake Lock FMQ
		mReadWakeLockQueueRun = true;
		mWakeLockThread = std::thread(startReadWakeLockThread, this);
		return result;
		}

		ScopedAStatus Sensors::injectSensorData(const Event& in_event) {
		auto sensor = mSensors.find(in_event.sensorHandle);
		if (sensor != mSensors.end()) {
		return sensor->second->injectEvent(in_event);
		}
		return ScopedAStatus::fromServiceSpecificError(static_cast<int32_t>(ERROR_BAD_VALUE));
		}

		ScopedAStatus Sensors::registerDirectChannel(const ISensors::SharedMemInfo& /* in_mem */,
		int32_t* _aidl_return) {
		*_aidl_return = EX_UNSUPPORTED_OPERATION;

		return ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
		}

		ScopedAStatus Sensors::setOperationMode(OperationMode in_mode) {
		for (auto sensor : mSensors) {
		sensor.second->setOperationMode(in_mode);
		}
		return ScopedAStatus::ok();
		}

		::ndk::ScopedAStatus Sensors::unregisterDirectChannel(int32_t /* in_channelHandle */) {
		return ndk::ScopedAStatus::ok();
		ScopedAStatus Sensors::unregisterDirectChannel(int32_t /* in_channelHandle */) {
		return ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
		}

		} // namespace sensors

sensors/aidl/default/include/sensors-impl/Sensor.h

0 → 100644

+168 −0

File added.

Preview size limit exceeded, changes collapsed.

sensors/aidl/default/include/sensors-impl/Sensors.h

+157 −1

File changed.

Preview size limit exceeded, changes collapsed.