sensors/aidl/default/Sensor.cpp - third_party/android/platform/hardware/interfaces - Git at Google

 /*
  * 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
	/*
	* 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