Merge "Create wrapper interface for SensorDevice" (c1a69dfe) · Commits · e / os / android_frameworks_native-old

services/sensorservice/ISensorHalWrapper.h

0 → 100644

+81 −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_ISENSOR_HAL_WRAPPER_H
		#define ANDROID_ISENSOR_HAL_WRAPPER_H

		#include <hardware/sensors.h>
		#include <stdint.h>
		#include <sys/types.h>

		#include "SensorService.h"

		namespace android {

		/**
		* A wrapper for various types of HAL implementation, e.g. to distinguish HIDL and AIDL versions.
		*/
		class ISensorHalWrapper {
		public:
		class ICallback : public ISensorsCallback {

		void onDynamicSensorsConnected(
		const std::vector<sensor_t> &dynamicSensorsAdded) = 0;

		void onDynamicSensorsDisconnected(
		const std::vector<int32_t> &dynamicSensorHandlesRemoved) = 0;
		};

		/**
		* Connects to the underlying sensors HAL. This should also be used for any reconnections
		* due to HAL resets.
		*/
		virtual bool connect(ICallback *callback) = 0;

		/**
		* Polls for available sensor events. This could be using the traditional sensors
		* polling or from a FMQ.
		*/
		virtual ssize_t poll(sensors_event_t* buffer, size_t count) = 0;

		/**
		* The below functions directly mirrors the sensors HAL definitions.
		*/
		virtual std::vector<sensor_t> getSensorsList() = 0;

		virtual status_t setOperationMode(SensorService::Mode mode) = 0;

		virtual status_t activate(int32_t sensorHandle, bool enabled) = 0;

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

		virtual status_t flush(int32_t sensorHandle) = 0;

		virtual status_t injectSensorData(const sensors_event_t *event) = 0;

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

		virtual void unregisterDirectChannel(int32_t channelHandle) = 0;

		virtual status_t configureDirectChannel(int32_t sensorHandle, int32_t channelHandle,
		const struct sensors_direct_cfg_t *config) = 0;
		}

		} // namespace android

		#endif // ANDROID_ISENSOR_HAL_WRAPPER_H

services/sensorservice/SensorService.h

+46 −46

Original line number	Diff line number	Diff line
		@@ -89,6 +89,52 @@ public:
		UID_STATE_IDLE,
		};

		enum Mode {
		// The regular operating mode where any application can register/unregister/call flush on
		// sensors.
		NORMAL = 0,
		// This mode is only used for testing purposes. Not all HALs support this mode. In this mode,
		// the HAL ignores the sensor data provided by physical sensors and accepts the data that is
		// injected from the SensorService as if it were the real sensor data. This mode is primarily
		// used for testing various algorithms like vendor provided SensorFusion, Step Counter and
		// Step Detector etc. Typically in this mode, there will be a client (a
		// SensorEventConnection) which will be injecting sensor data into the HAL. Normal apps can
		// unregister and register for any sensor that supports injection. Registering to sensors
		// that do not support injection will give an error. TODO: Allow exactly one
		// client to inject sensor data at a time.
		DATA_INJECTION = 1,
		// This mode is used only for testing sensors. Each sensor can be tested in isolation with
		// the required sampling_rate and maxReportLatency parameters without having to think about
		// the data rates requested by other applications. End user devices are always expected to be
		// in NORMAL mode. When this mode is first activated, all active sensors from all connections
		// are disabled. Calling flush() will return an error. In this mode, only the requests from
		// selected apps whose package names are allowlisted are allowed (typically CTS apps). Only
		// these apps can register/unregister/call flush() on sensors. If SensorService switches to
		// NORMAL mode again, all sensors that were previously registered to are activated with the
		// corresponding parameters if the application hasn't unregistered for sensors in the mean
		// time. NOTE: Non allowlisted app whose sensors were previously deactivated may still
		// receive events if a allowlisted app requests data from the same sensor.
		RESTRICTED = 2

		// State Transitions supported.
		// RESTRICTED <--- NORMAL ---> DATA_INJECTION
		// ---> <---

		// Shell commands to switch modes in SensorService.
		// 1) Put SensorService in RESTRICTED mode with packageName .cts. If it is already in
		// restricted mode it is treated as a NO_OP (and packageName is NOT changed).
		//
		// $ adb shell dumpsys sensorservice restrict .cts.
		//
		// 2) Put SensorService in DATA_INJECTION mode with packageName .xts. If it is already in
		// data_injection mode it is treated as a NO_OP (and packageName is NOT changed).
		//
		// $ adb shell dumpsys sensorservice data_injection .xts.
		//
		// 3) Reset sensorservice back to NORMAL mode.
		// $ adb shell dumpsys sensorservice enable
		};

		class ProximityActiveListener : public virtual RefBase {
		public:
		// Note that the callback is invoked from an async thread and can interact with the
		@@ -276,52 +322,6 @@ private:
		const int64_t mToken;
		};

		enum Mode {
		// The regular operating mode where any application can register/unregister/call flush on
		// sensors.
		NORMAL = 0,
		// This mode is only used for testing purposes. Not all HALs support this mode. In this mode,
		// the HAL ignores the sensor data provided by physical sensors and accepts the data that is
		// injected from the SensorService as if it were the real sensor data. This mode is primarily
		// used for testing various algorithms like vendor provided SensorFusion, Step Counter and
		// Step Detector etc. Typically in this mode, there will be a client (a
		// SensorEventConnection) which will be injecting sensor data into the HAL. Normal apps can
		// unregister and register for any sensor that supports injection. Registering to sensors
		// that do not support injection will give an error. TODO(aakella) : Allow exactly one
		// client to inject sensor data at a time.
		DATA_INJECTION = 1,
		// This mode is used only for testing sensors. Each sensor can be tested in isolation with
		// the required sampling_rate and maxReportLatency parameters without having to think about
		// the data rates requested by other applications. End user devices are always expected to be
		// in NORMAL mode. When this mode is first activated, all active sensors from all connections
		// are disabled. Calling flush() will return an error. In this mode, only the requests from
		// selected apps whose package names are whitelisted are allowed (typically CTS apps). Only
		// these apps can register/unregister/call flush() on sensors. If SensorService switches to
		// NORMAL mode again, all sensors that were previously registered to are activated with the
		// corresponding paramaters if the application hasn't unregistered for sensors in the mean
		// time. NOTE: Non whitelisted app whose sensors were previously deactivated may still
		// receive events if a whitelisted app requests data from the same sensor.
		RESTRICTED = 2

		// State Transitions supported.
		// RESTRICTED <--- NORMAL ---> DATA_INJECTION
		// ---> <---

		// Shell commands to switch modes in SensorService.
		// 1) Put SensorService in RESTRICTED mode with packageName .cts. If it is already in
		// restricted mode it is treated as a NO_OP (and packageName is NOT changed).
		//
		// $ adb shell dumpsys sensorservice restrict .cts.
		//
		// 2) Put SensorService in DATA_INJECTION mode with packageName .xts. If it is already in
		// data_injection mode it is treated as a NO_OP (and packageName is NOT changed).
		//
		// $ adb shell dumpsys sensorservice data_injection .xts.
		//
		// 3) Reset sensorservice back to NORMAL mode.
		// $ adb shell dumpsys sensorservice enable
		};

		static const char* WAKE_LOCK_NAME;
		virtual ~SensorService();