sensors/common/default/2.X/Sensors.h - platform/hardware/interfaces - Git at Google

 /*
  * Copyright (C) 2018 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_HARDWARE_SENSORS_V2_X_SENSORS_H
 #define ANDROID_HARDWARE_SENSORS_V2_X_SENSORS_H

 #include "EventMessageQueueWrapper.h"
 #include "Sensor.h"

 #include <android/hardware/sensors/2.0/ISensors.h>
 #include <android/hardware/sensors/2.0/types.h>
 #include <fmq/MessageQueue.h>
 #include <hardware_legacy/power.h>
 #include <hidl/MQDescriptor.h>
 #include <hidl/Status.h>
 #include <log/log.h>

 #include <atomic>
 #include <memory>
 #include <thread>

 namespace android {
 namespace hardware {
 namespace sensors {
 namespace V2_X {
 namespace implementation {

 template <class ISensorsInterface>
 struct Sensors : public ISensorsInterface, public ISensorsEventCallback {
     using Event = ::android::hardware::sensors::V1_0::Event;
     using OperationMode = ::android::hardware::sensors::V1_0::OperationMode;
     using RateLevel = ::android::hardware::sensors::V1_0::RateLevel;
     using Result = ::android::hardware::sensors::V1_0::Result;
     using SharedMemInfo = ::android::hardware::sensors::V1_0::SharedMemInfo;
     using EventQueueFlagBits = ::android::hardware::sensors::V2_0::EventQueueFlagBits;
     using SensorTimeout = ::android::hardware::sensors::V2_0::SensorTimeout;
     using WakeLockQueueFlagBits = ::android::hardware::sensors::V2_0::WakeLockQueueFlagBits;
     using ISensorsCallback = ::android::hardware::sensors::V2_0::ISensorsCallback;
     using EventMessageQueue = MessageQueue<Event, kSynchronizedReadWrite>;
     using WakeLockMessageQueue = MessageQueue<uint32_t, kSynchronizedReadWrite>;

     static constexpr const char* kWakeLockName = "SensorsHAL_WAKEUP";

     Sensors()
         : mEventQueueFlag(nullptr),
           mNextHandle(1),
           mOutstandingWakeUpEvents(0),
           mReadWakeLockQueueRun(false),
           mAutoReleaseWakeLockTime(0),
           mHasWakeLock(false) {
         AddSensor<AccelSensor>();
         AddSensor<GyroSensor>();
         AddSensor<AmbientTempSensor>();
         AddSensor<PressureSensor>();
         AddSensor<MagnetometerSensor>();
         AddSensor<LightSensor>();
         AddSensor<ProximitySensor>();
         AddSensor<RelativeHumiditySensor>();
     }

     virtual ~Sensors() {
         deleteEventFlag();
         mReadWakeLockQueueRun = false;
         mWakeLockThread.join();
     }

     // Methods from ::android::hardware::sensors::V2_0::ISensors follow.
     Return<Result> setOperationMode(OperationMode mode) override {
         for (auto sensor : mSensors) {
             sensor.second->setOperationMode(mode);
         }
         return Result::OK;
     }

     Return<Result> activate(int32_t sensorHandle, bool enabled) override {
         auto sensor = mSensors.find(sensorHandle);
         if (sensor != mSensors.end()) {
             sensor->second->activate(enabled);
             return Result::OK;
         }
         return Result::BAD_VALUE;
     }

     Return<Result> initialize(
             const ::android::hardware::MQDescriptorSync<Event>& eventQueueDescriptor,
             const ::android::hardware::MQDescriptorSync<uint32_t>& wakeLockDescriptor,
             const sp<ISensorsCallback>& sensorsCallback) override {
         auto eventQueue =
                 std::make_unique<EventMessageQueue>(eventQueueDescriptor, true /* resetPointers */);
         std::unique_ptr<V2_1::implementation::EventMessageQueueWrapperBase> wrapper =
                 std::make_unique<V2_1::implementation::EventMessageQueueWrapperV1_0>(eventQueue);
         return initializeBase(wrapper, wakeLockDescriptor, sensorsCallback);
     }

     Return<Result> initializeBase(
             std::unique_ptr<V2_1::implementation::EventMessageQueueWrapperBase>& eventQueue,
             const ::android::hardware::MQDescriptorSync<uint32_t>& wakeLockDescriptor,
             const sp<ISensorsCallback>& sensorsCallback) {
         Result result = Result::OK;

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

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

         // Save a reference to the callback
         mCallback = sensorsCallback;

         // Save the event queue.
         mEventQueue = std::move(eventQueue);

         // 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 = Result::BAD_VALUE;
         }

         // 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<WakeLockMessageQueue>(wakeLockDescriptor,
                                                                 true /* resetPointers */);

         if (!mCallback || !mEventQueue || !mWakeLockQueue || mEventQueueFlag == nullptr) {
             result = Result::BAD_VALUE;
         }

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

         return result;
     }

     Return<Result> batch(int32_t sensorHandle, int64_t samplingPeriodNs,
                          int64_t /* maxReportLatencyNs */) override {
         auto sensor = mSensors.find(sensorHandle);
         if (sensor != mSensors.end()) {
             sensor->second->batch(samplingPeriodNs);
             return Result::OK;
         }
         return Result::BAD_VALUE;
     }

     Return<Result> flush(int32_t sensorHandle) override {
         auto sensor = mSensors.find(sensorHandle);
         if (sensor != mSensors.end()) {
             return sensor->second->flush();
         }
         return Result::BAD_VALUE;
     }

     Return<Result> injectSensorData(const Event& event) override {
         auto sensor = mSensors.find(event.sensorHandle);
         if (sensor != mSensors.end()) {
             return sensor->second->injectEvent(V2_1::implementation::convertToNewEvent(event));
         }

         return Result::BAD_VALUE;
     }

     Return<void> registerDirectChannel(const SharedMemInfo& /* mem */,
                                        V2_0::ISensors::registerDirectChannel_cb _hidl_cb) override {
         _hidl_cb(Result::INVALID_OPERATION, -1 /* channelHandle */);
         return Return<void>();
     }

     Return<Result> unregisterDirectChannel(int32_t /* channelHandle */) override {
         return Result::INVALID_OPERATION;
     }

     Return<void> configDirectReport(int32_t /* sensorHandle */, int32_t /* channelHandle */,
                                     RateLevel /* rate */,
                                     V2_0::ISensors::configDirectReport_cb _hidl_cb) override {
         _hidl_cb(Result::INVALID_OPERATION, 0 /* reportToken */);
         return Return<void>();
     }

     void postEvents(const std::vector<V2_1::Event>& events, bool wakeup) override {
         std::lock_guard<std::mutex> lock(mWriteLock);
         if (mEventQueue->write(events)) {
             mEventQueueFlag->wake(static_cast<uint32_t>(EventQueueFlagBits::READ_AND_PROCESS));

             if (wakeup) {
                 // Keep track of the number of outstanding WAKE_UP events in order to properly hold
                 // a wake lock until the framework has secured a wake lock
                 updateWakeLock(events.size(), 0 /* eventsHandled */);
             }
         }
     }

   protected:
     /**
      * Add a new sensor
      */
     template <class SensorType>
     void AddSensor() {
         std::shared_ptr<SensorType> sensor =
                 std::make_shared<SensorType>(mNextHandle++ /* sensorHandle */, this /* callback */);
         mSensors[sensor->getSensorInfo().sensorHandle] = sensor;
     }

     /**
      * Utility function to delete the Event Flag
      */
     void deleteEventFlag() {
         status_t status = EventFlag::deleteEventFlag(&mEventQueueFlag);
         if (status != OK) {
             ALOGI("Failed to delete event flag: %d", status);
         }
     }

     static void startReadWakeLockThread(Sensors* sensors) { sensors->readWakeLockFMQ(); }

     /**
      * Function to read the Wake Lock FMQ and release the wake lock when appropriate
      */
     void readWakeLockFMQ() {
         while (mReadWakeLockQueueRun.load()) {
             constexpr int64_t kReadTimeoutNs = 500 * 1000 * 1000;  // 500 ms
             uint32_t eventsHandled = 0;

             // Read events from the Wake Lock FMQ. Timeout after a reasonable amount of time to
             // ensure that any held wake lock is able to be released if it is held for too long.
             mWakeLockQueue->readBlocking(&eventsHandled, 1 /* count */, 0 /* readNotification */,
                                          static_cast<uint32_t>(WakeLockQueueFlagBits::DATA_WRITTEN),
                                          kReadTimeoutNs);
             updateWakeLock(0 /* eventsWritten */, eventsHandled);
         }
     }

     /**
      * Responsible for acquiring and releasing a wake lock when there are unhandled WAKE_UP events
      */
     void updateWakeLock(int32_t eventsWritten, int32_t eventsHandled) {
         std::lock_guard<std::mutex> lock(mWakeLockLock);
         int32_t newVal = mOutstandingWakeUpEvents + eventsWritten - eventsHandled;
         if (newVal < 0) {
             mOutstandingWakeUpEvents = 0;
         } else {
             mOutstandingWakeUpEvents = newVal;
         }

         if (eventsWritten > 0) {
             // Update the time at which the last WAKE_UP event was sent
             mAutoReleaseWakeLockTime =
                     ::android::uptimeMillis() +
                     static_cast<uint32_t>(SensorTimeout::WAKE_LOCK_SECONDS) * 1000;
         }

         if (!mHasWakeLock && mOutstandingWakeUpEvents > 0 &&
             acquire_wake_lock(PARTIAL_WAKE_LOCK, kWakeLockName) == 0) {
             mHasWakeLock = true;
         } else if (mHasWakeLock) {
             // Check if the wake lock should be released automatically if
             // SensorTimeout::WAKE_LOCK_SECONDS has elapsed since the last WAKE_UP event was written
             // to the Wake Lock FMQ.
             if (::android::uptimeMillis() > mAutoReleaseWakeLockTime) {
                 ALOGD("No events read from wake lock FMQ for %d seconds, auto releasing wake lock",
                       SensorTimeout::WAKE_LOCK_SECONDS);
                 mOutstandingWakeUpEvents = 0;
             }

             if (mOutstandingWakeUpEvents == 0 && release_wake_lock(kWakeLockName) == 0) {
                 mHasWakeLock = false;
             }
         }
     }

     /**
      * The Event FMQ where sensor events are written
      */
     std::unique_ptr<V2_1::implementation::EventMessageQueueWrapperBase> mEventQueue;

     /**
      * The Wake Lock FMQ that is read to determine when the framework has handled WAKE_UP events
      */
     std::unique_ptr<WakeLockMessageQueue> mWakeLockQueue;

     /**
      * Event Flag to signal to the framework when sensor events are available to be read
      */
     EventFlag* mEventQueueFlag;

     /**
      * Callback for asynchronous events, such as dynamic sensor connections.
      */
     sp<ISensorsCallback> mCallback;

     /**
      * A map of the available sensors
      */
     std::map<int32_t, std::shared_ptr<Sensor>> mSensors;

     /**
      * The next available sensor handle
      */
     int32_t mNextHandle;

     /**
      * Lock to protect writes to the FMQs
      */
     std::mutex mWriteLock;

     /**
      * Lock to protect acquiring and releasing the wake lock
      */
     std::mutex mWakeLockLock;

     /**
      * Track the number of WAKE_UP events that have not been handled by the framework
      */
     uint32_t mOutstandingWakeUpEvents;

     /**
      * A thread to read the Wake Lock FMQ
      */
     std::thread mWakeLockThread;

     /**
      * Flag to indicate that the Wake Lock Thread should continue to run
      */
     std::atomic_bool mReadWakeLockQueueRun;

     /**
      * Track the time when the wake lock should automatically be released
      */
     int64_t mAutoReleaseWakeLockTime;

     /**
      * Flag to indicate if a wake lock has been acquired
      */
     bool mHasWakeLock;
 };

 }  // namespace implementation
 }  // namespace V2_X
 }  // namespace sensors
 }  // namespace hardware
 }  // namespace android

 #endif  // ANDROID_HARDWARE_SENSORS_V2_X_SENSORS_H
	/*
	* Copyright (C) 2018 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_HARDWARE_SENSORS_V2_X_SENSORS_H
	#define ANDROID_HARDWARE_SENSORS_V2_X_SENSORS_H

	#include "EventMessageQueueWrapper.h"
	#include "Sensor.h"

	#include <android/hardware/sensors/2.0/ISensors.h>
	#include <android/hardware/sensors/2.0/types.h>
	#include <fmq/MessageQueue.h>
	#include <hardware_legacy/power.h>
	#include <hidl/MQDescriptor.h>
	#include <hidl/Status.h>
	#include <log/log.h>

	#include <atomic>
	#include <memory>
	#include <thread>

	namespace android {
	namespace hardware {
	namespace sensors {
	namespace V2_X {
	namespace implementation {

	template <class ISensorsInterface>
	struct Sensors : public ISensorsInterface, public ISensorsEventCallback {
	using Event = ::android::hardware::sensors::V1_0::Event;
	using OperationMode = ::android::hardware::sensors::V1_0::OperationMode;
	using RateLevel = ::android::hardware::sensors::V1_0::RateLevel;
	using Result = ::android::hardware::sensors::V1_0::Result;
	using SharedMemInfo = ::android::hardware::sensors::V1_0::SharedMemInfo;
	using EventQueueFlagBits = ::android::hardware::sensors::V2_0::EventQueueFlagBits;
	using SensorTimeout = ::android::hardware::sensors::V2_0::SensorTimeout;
	using WakeLockQueueFlagBits = ::android::hardware::sensors::V2_0::WakeLockQueueFlagBits;
	using ISensorsCallback = ::android::hardware::sensors::V2_0::ISensorsCallback;
	using EventMessageQueue = MessageQueue<Event, kSynchronizedReadWrite>;
	using WakeLockMessageQueue = MessageQueue<uint32_t, kSynchronizedReadWrite>;

	static constexpr const char* kWakeLockName = "SensorsHAL_WAKEUP";

	Sensors()
	: mEventQueueFlag(nullptr),
	mNextHandle(1),
	mOutstandingWakeUpEvents(0),
	mReadWakeLockQueueRun(false),
	mAutoReleaseWakeLockTime(0),
	mHasWakeLock(false) {
	AddSensor<AccelSensor>();
	AddSensor<GyroSensor>();
	AddSensor<AmbientTempSensor>();
	AddSensor<PressureSensor>();
	AddSensor<MagnetometerSensor>();
	AddSensor<LightSensor>();
	AddSensor<ProximitySensor>();
	AddSensor<RelativeHumiditySensor>();
	}

	virtual ~Sensors() {
	deleteEventFlag();
	mReadWakeLockQueueRun = false;
	mWakeLockThread.join();
	}

	// Methods from ::android::hardware::sensors::V2_0::ISensors follow.
	Return<Result> setOperationMode(OperationMode mode) override {
	for (auto sensor : mSensors) {
	sensor.second->setOperationMode(mode);
	}
	return Result::OK;
	}

	Return<Result> activate(int32_t sensorHandle, bool enabled) override {
	auto sensor = mSensors.find(sensorHandle);
	if (sensor != mSensors.end()) {
	sensor->second->activate(enabled);
	return Result::OK;
	}
	return Result::BAD_VALUE;
	}

	Return<Result> initialize(
	const ::android::hardware::MQDescriptorSync<Event>& eventQueueDescriptor,
	const ::android::hardware::MQDescriptorSync<uint32_t>& wakeLockDescriptor,
	const sp<ISensorsCallback>& sensorsCallback) override {
	auto eventQueue =
	std::make_unique<EventMessageQueue>(eventQueueDescriptor, true /* resetPointers */);
	std::unique_ptr<V2_1::implementation::EventMessageQueueWrapperBase> wrapper =
	std::make_unique<V2_1::implementation::EventMessageQueueWrapperV1_0>(eventQueue);
	return initializeBase(wrapper, wakeLockDescriptor, sensorsCallback);
	}

	Return<Result> initializeBase(
	std::unique_ptr<V2_1::implementation::EventMessageQueueWrapperBase>& eventQueue,
	const ::android::hardware::MQDescriptorSync<uint32_t>& wakeLockDescriptor,
	const sp<ISensorsCallback>& sensorsCallback) {
	Result result = Result::OK;

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

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

	// Save a reference to the callback
	mCallback = sensorsCallback;

	// Save the event queue.
	mEventQueue = std::move(eventQueue);

	// 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 = Result::BAD_VALUE;
	}

	// 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<WakeLockMessageQueue>(wakeLockDescriptor,
	true /* resetPointers */);

	if (!mCallback \|\| !mEventQueue \|\| !mWakeLockQueue \|\| mEventQueueFlag == nullptr) {
	result = Result::BAD_VALUE;
	}

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

	return result;
	}

	Return<Result> batch(int32_t sensorHandle, int64_t samplingPeriodNs,
	int64_t /* maxReportLatencyNs */) override {
	auto sensor = mSensors.find(sensorHandle);
	if (sensor != mSensors.end()) {
	sensor->second->batch(samplingPeriodNs);
	return Result::OK;
	}
	return Result::BAD_VALUE;
	}

	Return<Result> flush(int32_t sensorHandle) override {
	auto sensor = mSensors.find(sensorHandle);
	if (sensor != mSensors.end()) {
	return sensor->second->flush();
	}
	return Result::BAD_VALUE;
	}

	Return<Result> injectSensorData(const Event& event) override {
	auto sensor = mSensors.find(event.sensorHandle);
	if (sensor != mSensors.end()) {
	return sensor->second->injectEvent(V2_1::implementation::convertToNewEvent(event));
	}

	return Result::BAD_VALUE;
	}

	Return<void> registerDirectChannel(const SharedMemInfo& /* mem */,
	V2_0::ISensors::registerDirectChannel_cb _hidl_cb) override {
	_hidl_cb(Result::INVALID_OPERATION, -1 /* channelHandle */);
	return Return<void>();
	}

	Return<Result> unregisterDirectChannel(int32_t /* channelHandle */) override {
	return Result::INVALID_OPERATION;
	}

	Return<void> configDirectReport(int32_t /* sensorHandle /, int32_t / channelHandle */,
	RateLevel /* rate */,
	V2_0::ISensors::configDirectReport_cb _hidl_cb) override {
	_hidl_cb(Result::INVALID_OPERATION, 0 /* reportToken */);
	return Return<void>();
	}

	void postEvents(const std::vector<V2_1::Event>& events, bool wakeup) override {
	std::lock_guard<std::mutex> lock(mWriteLock);
	if (mEventQueue->write(events)) {
	mEventQueueFlag->wake(static_cast<uint32_t>(EventQueueFlagBits::READ_AND_PROCESS));

	if (wakeup) {
	// Keep track of the number of outstanding WAKE_UP events in order to properly hold
	// a wake lock until the framework has secured a wake lock
	updateWakeLock(events.size(), 0 /* eventsHandled */);
	}
	}
	}

	protected:
	/**
	* Add a new sensor
	*/
	template <class SensorType>
	void AddSensor() {
	std::shared_ptr<SensorType> sensor =
	std::make_shared<SensorType>(mNextHandle++ /* sensorHandle /, this / callback */);
	mSensors[sensor->getSensorInfo().sensorHandle] = sensor;
	}

	/**
	* Utility function to delete the Event Flag
	*/
	void deleteEventFlag() {
	status_t status = EventFlag::deleteEventFlag(&mEventQueueFlag);
	if (status != OK) {
	ALOGI("Failed to delete event flag: %d", status);
	}
	}

	static void startReadWakeLockThread(Sensors* sensors) { sensors->readWakeLockFMQ(); }

	/**
	* Function to read the Wake Lock FMQ and release the wake lock when appropriate
	*/
	void readWakeLockFMQ() {
	while (mReadWakeLockQueueRun.load()) {
	constexpr int64_t kReadTimeoutNs = 500 * 1000 * 1000; // 500 ms
	uint32_t eventsHandled = 0;

	// Read events from the Wake Lock FMQ. Timeout after a reasonable amount of time to
	// ensure that any held wake lock is able to be released if it is held for too long.
	mWakeLockQueue->readBlocking(&eventsHandled, 1 /* count /, 0 / readNotification */,
	static_cast<uint32_t>(WakeLockQueueFlagBits::DATA_WRITTEN),
	kReadTimeoutNs);
	updateWakeLock(0 /* eventsWritten */, eventsHandled);
	}
	}

	/**
	* Responsible for acquiring and releasing a wake lock when there are unhandled WAKE_UP events
	*/
	void updateWakeLock(int32_t eventsWritten, int32_t eventsHandled) {
	std::lock_guard<std::mutex> lock(mWakeLockLock);
	int32_t newVal = mOutstandingWakeUpEvents + eventsWritten - eventsHandled;
	if (newVal < 0) {
	mOutstandingWakeUpEvents = 0;
	} else {
	mOutstandingWakeUpEvents = newVal;
	}

	if (eventsWritten > 0) {
	// Update the time at which the last WAKE_UP event was sent
	mAutoReleaseWakeLockTime =
	::android::uptimeMillis() +
	static_cast<uint32_t>(SensorTimeout::WAKE_LOCK_SECONDS) * 1000;
	}

	if (!mHasWakeLock && mOutstandingWakeUpEvents > 0 &&
	acquire_wake_lock(PARTIAL_WAKE_LOCK, kWakeLockName) == 0) {
	mHasWakeLock = true;
	} else if (mHasWakeLock) {
	// Check if the wake lock should be released automatically if
	// SensorTimeout::WAKE_LOCK_SECONDS has elapsed since the last WAKE_UP event was written
	// to the Wake Lock FMQ.
	if (::android::uptimeMillis() > mAutoReleaseWakeLockTime) {
	ALOGD("No events read from wake lock FMQ for %d seconds, auto releasing wake lock",
	SensorTimeout::WAKE_LOCK_SECONDS);
	mOutstandingWakeUpEvents = 0;
	}

	if (mOutstandingWakeUpEvents == 0 && release_wake_lock(kWakeLockName) == 0) {
	mHasWakeLock = false;
	}
	}
	}

	/**
	* The Event FMQ where sensor events are written
	*/
	std::unique_ptr<V2_1::implementation::EventMessageQueueWrapperBase> mEventQueue;

	/**
	* The Wake Lock FMQ that is read to determine when the framework has handled WAKE_UP events
	*/
	std::unique_ptr<WakeLockMessageQueue> mWakeLockQueue;

	/**
	* Event Flag to signal to the framework when sensor events are available to be read
	*/
	EventFlag* mEventQueueFlag;

	/**
	* Callback for asynchronous events, such as dynamic sensor connections.
	*/
	sp<ISensorsCallback> mCallback;

	/**
	* A map of the available sensors
	*/
	std::map<int32_t, std::shared_ptr<Sensor>> mSensors;

	/**
	* The next available sensor handle
	*/
	int32_t mNextHandle;

	/**
	* Lock to protect writes to the FMQs
	*/
	std::mutex mWriteLock;

	/**
	* Lock to protect acquiring and releasing the wake lock
	*/
	std::mutex mWakeLockLock;

	/**
	* Track the number of WAKE_UP events that have not been handled by the framework
	*/
	uint32_t mOutstandingWakeUpEvents;

	/**
	* A thread to read the Wake Lock FMQ
	*/
	std::thread mWakeLockThread;

	/**
	* Flag to indicate that the Wake Lock Thread should continue to run
	*/
	std::atomic_bool mReadWakeLockQueueRun;

	/**
	* Track the time when the wake lock should automatically be released
	*/
	int64_t mAutoReleaseWakeLockTime;

	/**
	* Flag to indicate if a wake lock has been acquired
	*/
	bool mHasWakeLock;
	};

	} // namespace implementation
	} // namespace V2_X
	} // namespace sensors
	} // namespace hardware
	} // namespace android

	#endif // ANDROID_HARDWARE_SENSORS_V2_X_SENSORS_H