Add SensorManager support in inputflinger. (f59a2f48) · Commits · e / os / android_frameworks_native

include/android/input.h

+2 −0

Original line number	Diff line number	Diff line
		@@ -856,6 +856,8 @@ enum {
		AINPUT_SOURCE_TOUCH_NAVIGATION = 0x00200000 \| AINPUT_SOURCE_CLASS_NONE,
		/** joystick */
		AINPUT_SOURCE_JOYSTICK = 0x01000000 \| AINPUT_SOURCE_CLASS_JOYSTICK,
		/** sensor */
		AINPUT_SOURCE_SENSOR = 0x02000000 \| AINPUT_SOURCE_CLASS_JOYSTICK,
		/** rotary encoder */
		AINPUT_SOURCE_ROTARY_ENCODER = 0x00400000 \| AINPUT_SOURCE_CLASS_NONE,

include/input/InputDevice.h

+103 −0

Original line number	Diff line number	Diff line
		@@ -17,8 +17,10 @@
		#ifndef _LIBINPUT_INPUT_DEVICE_H
		#define _LIBINPUT_INPUT_DEVICE_H

		#include <android/sensor.h>
		#include <input/Input.h>
		#include <input/KeyCharacterMap.h>
		#include <unordered_map>
		#include <vector>

		namespace android {
		@@ -63,6 +65,97 @@ struct InputDeviceIdentifier {
		std::string getCanonicalName() const;
		};

		/* Types of input device sensors. Keep sync with core/java/android/hardware/Sensor.java */
		enum class InputDeviceSensorType : int32_t {
		ACCELEROMETER = ASENSOR_TYPE_ACCELEROMETER,
		MAGNETIC_FIELD = ASENSOR_TYPE_MAGNETIC_FIELD,
		ORIENTATION = 3,
		GYROSCOPE = ASENSOR_TYPE_GYROSCOPE,
		LIGHT = ASENSOR_TYPE_LIGHT,
		PRESSURE = ASENSOR_TYPE_PRESSURE,
		TEMPERATURE = 7,
		PROXIMITY = ASENSOR_TYPE_PROXIMITY,
		GRAVITY = ASENSOR_TYPE_GRAVITY,
		LINEAR_ACCELERATION = ASENSOR_TYPE_LINEAR_ACCELERATION,
		ROTATION_VECTOR = ASENSOR_TYPE_ROTATION_VECTOR,
		RELATIVE_HUMIDITY = ASENSOR_TYPE_RELATIVE_HUMIDITY,
		AMBIENT_TEMPERATURE = ASENSOR_TYPE_AMBIENT_TEMPERATURE,
		MAGNETIC_FIELD_UNCALIBRATED = ASENSOR_TYPE_MAGNETIC_FIELD_UNCALIBRATED,
		GAME_ROTATION_VECTOR = ASENSOR_TYPE_GAME_ROTATION_VECTOR,
		GYROSCOPE_UNCALIBRATED = ASENSOR_TYPE_GYROSCOPE_UNCALIBRATED,
		SIGNIFICANT_MOTION = ASENSOR_TYPE_SIGNIFICANT_MOTION,
		};

		enum class InputDeviceSensorAccuracy : int32_t {
		ACCURACY_NONE = 0,
		ACCURACY_LOW = 1,
		ACCURACY_MEDIUM = 2,
		ACCURACY_HIGH = 3,
		};

		enum class InputDeviceSensorReportingMode : int32_t {
		CONTINUOUS = 0,
		ON_CHANGE = 1,
		ONE_SHOT = 2,
		SPECIAL_TRIGGER = 3,
		};

		struct InputDeviceSensorInfo {
		explicit InputDeviceSensorInfo(std::string name, std::string vendor, int32_t version,
		InputDeviceSensorType type, InputDeviceSensorAccuracy accuracy,
		float maxRange, float resolution, float power, int32_t minDelay,
		int32_t fifoReservedEventCount, int32_t fifoMaxEventCount,
		std::string stringType, int32_t maxDelay, int32_t flags,
		int32_t id)
		: name(name),
		vendor(vendor),
		version(version),
		type(type),
		accuracy(accuracy),
		maxRange(maxRange),
		resolution(resolution),
		power(power),
		minDelay(minDelay),
		fifoReservedEventCount(fifoReservedEventCount),
		fifoMaxEventCount(fifoMaxEventCount),
		stringType(stringType),
		maxDelay(maxDelay),
		flags(flags),
		id(id) {}
		// Name string of the sensor.
		std::string name;
		// Vendor string of this sensor.
		std::string vendor;
		// Version of the sensor's module.
		int32_t version;
		// Generic type of this sensor.
		InputDeviceSensorType type;
		// The current accuracy of sensor event.
		InputDeviceSensorAccuracy accuracy;
		// Maximum range of the sensor in the sensor's unit.
		float maxRange;
		// Resolution of the sensor in the sensor's unit.
		float resolution;
		// The power in mA used by this sensor while in use.
		float power;
		// The minimum delay allowed between two events in microsecond or zero if this sensor only
		// returns a value when the data it's measuring changes.
		int32_t minDelay;
		// Number of events reserved for this sensor in the batch mode FIFO.
		int32_t fifoReservedEventCount;
		// Maximum number of events of this sensor that could be batched.
		int32_t fifoMaxEventCount;
		// The type of this sensor as a string.
		std::string stringType;
		// The delay between two sensor events corresponding to the lowest frequency that this sensor
		// supports.
		int32_t maxDelay;
		// Sensor flags
		int32_t flags;
		// Sensor id, same as the input device ID it belongs to.
		int32_t id;
		};

		/*
		* Describes the characteristics and capabilities of an input device.
		*/
		@@ -104,6 +197,7 @@ public:
		void addMotionRange(int32_t axis, uint32_t source,
		float min, float max, float flat, float fuzz, float resolution);
		void addMotionRange(const MotionRange& range);
		void addSensorInfo(const InputDeviceSensorInfo& info);

		inline void setKeyboardType(int32_t keyboardType) { mKeyboardType = keyboardType; }
		inline int32_t getKeyboardType() const { return mKeyboardType; }
		@@ -122,10 +216,17 @@ public:
		inline void setButtonUnderPad(bool hasButton) { mHasButtonUnderPad = hasButton; }
		inline bool hasButtonUnderPad() const { return mHasButtonUnderPad; }

		inline void setHasSensor(bool hasSensor) { mHasSensor = hasSensor; }
		inline bool hasSensor() const { return mHasSensor; }

		inline const std::vector<MotionRange>& getMotionRanges() const {
		return mMotionRanges;
		}

		const InputDeviceSensorInfo* getSensorInfo(InputDeviceSensorType type);

		const std::vector<InputDeviceSensorType> getSensorTypes();

		private:
		int32_t mId;
		int32_t mGeneration;
		@@ -139,8 +240,10 @@ private:
		std::shared_ptr<KeyCharacterMap> mKeyCharacterMap;
		bool mHasVibrator;
		bool mHasButtonUnderPad;
		bool mHasSensor;

		std::vector<MotionRange> mMotionRanges;
		std::unordered_map<InputDeviceSensorType, InputDeviceSensorInfo> mSensors;
		};

		/* Types of input device configuration files. */

include/input/KeyCharacterMap.h

+2 −0

Original line number	Diff line number	Diff line
		@@ -142,6 +142,8 @@ public:
		void writeToParcel(Parcel* parcel) const;
		#endif

		bool operator==(const KeyCharacterMap& other) const;

		KeyCharacterMap(const KeyCharacterMap& other);

		virtual ~KeyCharacterMap();

include/input/KeyLayoutMap.h

+10 −0

Original line number	Diff line number	Diff line
		@@ -24,6 +24,8 @@
		#include <utils/RefBase.h>
		#include <utils/Tokenizer.h>

		#include <input/InputDevice.h>

		namespace android {

		struct AxisInfo {
		@@ -76,6 +78,8 @@ public:

		status_t mapAxis(int32_t scanCode, AxisInfo* outAxisInfo) const;
		const std::string getLoadFileName() const;
		// Return pair of sensor type and sensor data index, for the input device abs code
		base::Result<std::pair<InputDeviceSensorType, int32_t>> mapSensor(int32_t absCode);

		virtual ~KeyLayoutMap();

		@@ -89,12 +93,17 @@ private:
		int32_t ledCode;
		};

		struct Sensor {
		InputDeviceSensorType sensorType;
		int32_t sensorDataIndex;
		};

		KeyedVector<int32_t, Key> mKeysByScanCode;
		KeyedVector<int32_t, Key> mKeysByUsageCode;
		KeyedVector<int32_t, AxisInfo> mAxes;
		KeyedVector<int32_t, Led> mLedsByScanCode;
		KeyedVector<int32_t, Led> mLedsByUsageCode;
		std::unordered_map<int32_t, Sensor> mSensorsByAbsCode;
		std::string mLoadFileName;

		KeyLayoutMap();
		@@ -114,6 +123,7 @@ private:
		status_t parseKey();
		status_t parseAxis();
		status_t parseLed();
		status_t parseSensor();
		};
		};

libs/input/InputDevice.cpp

+30 −1

Original line number	Diff line number	Diff line
		@@ -23,6 +23,7 @@
		#include <android-base/stringprintf.h>
		#include <input/InputDevice.h>
		#include <input/InputEventLabels.h>
		#include <input/NamedEnum.h>

		using android::base::StringPrintf;

		@@ -166,7 +167,9 @@ InputDeviceInfo::InputDeviceInfo(const InputDeviceInfo& other)
		mKeyCharacterMap(other.mKeyCharacterMap),
		mHasVibrator(other.mHasVibrator),
		mHasButtonUnderPad(other.mHasButtonUnderPad),
		mMotionRanges(other.mMotionRanges) {}
		mHasSensor(other.mHasSensor),
		mMotionRanges(other.mMotionRanges),
		mSensors(other.mSensors) {}

		InputDeviceInfo::~InputDeviceInfo() {
		}
		@@ -185,7 +188,9 @@ void InputDeviceInfo::initialize(int32_t id, int32_t generation, int32_t control
		mKeyboardType = AINPUT_KEYBOARD_TYPE_NONE;
		mHasVibrator = false;
		mHasButtonUnderPad = false;
		mHasSensor = false;
		mMotionRanges.clear();
		mSensors.clear();
		}

		const InputDeviceInfo::MotionRange* InputDeviceInfo::getMotionRange(
		@@ -214,4 +219,28 @@ void InputDeviceInfo::addMotionRange(const MotionRange& range) {
		mMotionRanges.push_back(range);
		}

		void InputDeviceInfo::addSensorInfo(const InputDeviceSensorInfo& info) {
		if (mSensors.find(info.type) != mSensors.end()) {
		ALOGW("Sensor type %s already exists, will be replaced by new sensor added.",
		NamedEnum::string(info.type).c_str());
		}
		mSensors.insert_or_assign(info.type, info);
		}

		const std::vector<InputDeviceSensorType> InputDeviceInfo::getSensorTypes() {
		std::vector<InputDeviceSensorType> types;
		for (const auto& [type, info] : mSensors) {
		types.push_back(type);
		}
		return types;
		}

		const InputDeviceSensorInfo* InputDeviceInfo::getSensorInfo(InputDeviceSensorType type) {
		auto it = mSensors.find(type);
		if (it == mSensors.end()) {
		return nullptr;
		}
		return &it->second;
		}

		} // namespace android