Initialize SensorDevice's FMQs (979887bc) · Commits · e / os / platform_frameworks_native

services/sensorservice/Android.bp

+1 −0

Original line number	Diff line number	Diff line
		@@ -46,6 +46,7 @@ cc_library_shared {
		"libhidlbase",
		"libhidltransport",
		"libhwbinder",
		"libfmq",
		"android.hardware.sensors@1.0",
		"android.hardware.sensors@2.0",
		],

services/sensorservice/SensorDevice.cpp

+41 −10

Original line number	Diff line number	Diff line
		@@ -17,6 +17,7 @@
		#include "SensorService.h"

		#include <android-base/logging.h>
		#include <sensor/SensorEventQueue.h>
		#include <sensors/convert.h>
		#include <cutils/atomic.h>
		#include <utils/Errors.h>
		@@ -88,21 +89,23 @@ SensorDevice::SensorDevice()
		}

		bool SensorDevice::connectHidlService() {
		bool connected = connectHidlServiceV2_0();
		if (!connected) {
		connected = connectHidlServiceV1_0();
		HalConnectionStatus status = connectHidlServiceV2_0();
		if (status == HalConnectionStatus::DOES_NOT_EXIST) {
		status = connectHidlServiceV1_0();
		}
		return connected;
		return (status == HalConnectionStatus::CONNECTED);
		}

		bool SensorDevice::connectHidlServiceV1_0() {
		SensorDevice::HalConnectionStatus SensorDevice::connectHidlServiceV1_0() {
		// SensorDevice will wait for HAL service to start if HAL is declared in device manifest.
		size_t retry = 10;
		HalConnectionStatus connectionStatus = HalConnectionStatus::UNKNOWN;

		while (retry-- > 0) {
		sp<V1_0::ISensors> sensors = V1_0::ISensors::getService();
		if (sensors == nullptr) {
		// no sensor hidl service found
		connectionStatus = HalConnectionStatus::DOES_NOT_EXIST;
		break;
		}

		@@ -113,25 +116,53 @@ bool SensorDevice::connectHidlServiceV1_0() {
		// which will be done since the size is 0.
		if(mSensors->poll(0, [](auto, const auto &, const auto &) {}).isOk()) {
		// ok to continue
		connectionStatus = HalConnectionStatus::CONNECTED;
		break;
		}

		// hidl service is restarting, pointer is invalid.
		mSensors = nullptr;
		connectionStatus = HalConnectionStatus::FAILED_TO_CONNECT;
		ALOGI("%s unsuccessful, remaining retry %zu.", __FUNCTION__, retry);
		mRestartWaiter->wait();
		}
		return (mSensors != nullptr);

		return connectionStatus;
		}

		bool SensorDevice::connectHidlServiceV2_0() {
		SensorDevice::HalConnectionStatus SensorDevice::connectHidlServiceV2_0() {
		HalConnectionStatus connectionStatus = HalConnectionStatus::UNKNOWN;
		sp<V2_0::ISensors> sensors = V2_0::ISensors::getService();
		if (sensors != nullptr) {

		if (sensors == nullptr) {
		connectionStatus = HalConnectionStatus::DOES_NOT_EXIST;
		} else {
		mSensors = new SensorServiceUtil::SensorsWrapperV2_0(sensors);

		// TODO: initialize message queues
		mEventQueue = std::make_unique<EventMessageQueue>(
		SensorEventQueue::MAX_RECEIVE_BUFFER_EVENT_COUNT,
		true /* configureEventFlagWord */);

		mWakeLockQueue = std::make_unique<WakeLockQueue>(
		SensorEventQueue::MAX_RECEIVE_BUFFER_EVENT_COUNT,
		true /* configureEventFlagWord */);

		CHECK(mSensors != nullptr && mEventQueue != nullptr &&
		mWakeLockQueue != nullptr);

		status_t status = StatusFromResult(checkReturn(mSensors->initializeMessageQueues(
		*mEventQueue->getDesc(),
		*mWakeLockQueue->getDesc())));

		if (status != NO_ERROR) {
		connectionStatus = HalConnectionStatus::FAILED_TO_CONNECT;
		ALOGE("Failed to initialize message queues (%s)", strerror(-status));
		} else {
		connectionStatus = HalConnectionStatus::CONNECTED;
		}
		return (mSensors != nullptr);
		}

		return connectionStatus;
		}

		void SensorDevice::handleDynamicSensorConnection(int handle, bool connected) {

services/sensorservice/SensorDevice.h

+15 −2

Original line number	Diff line number	Diff line
		@@ -21,6 +21,7 @@
		#include "SensorServiceUtils.h"
		#include "SensorsWrapper.h"

		#include <fmq/MessageQueue.h>
		#include <sensor/Sensor.h>
		#include <stdint.h>
		#include <sys/types.h>
		@@ -162,8 +163,15 @@ private:
		SortedVector<void *> mDisabledClients;
		SensorDevice();
		bool connectHidlService();
		bool connectHidlServiceV1_0();
		bool connectHidlServiceV2_0();

		enum HalConnectionStatus {
		CONNECTED, // Successfully connected to the HAL
		DOES_NOT_EXIST, // Could not find the HAL
		FAILED_TO_CONNECT, // Found the HAL but failed to connect/initialize
		UNKNOWN,
		};
		HalConnectionStatus connectHidlServiceV1_0();
		HalConnectionStatus connectHidlServiceV2_0();

		static void handleHidlDeath(const std::string &detail);
		template<typename T>
		@@ -190,6 +198,11 @@ private:
		sensors_event_t *dst);

		bool mIsDirectReportSupported;

		typedef hardware::MessageQueue<Event, hardware::kSynchronizedReadWrite> EventMessageQueue;
		typedef hardware::MessageQueue<uint32_t, hardware::kSynchronizedReadWrite> WakeLockQueue;
		std::unique_ptr<EventMessageQueue> mEventQueue;
		std::unique_ptr<WakeLockQueue> mWakeLockQueue;
		};

		// ---------------------------------------------------------------------------