Merge "Split NotifyArgs into a separate file" (a0265c6d) · Commits · e / os / platform_frameworks_native

services/inputflinger/Android.bp

+1 −0

Original line number	Diff line number	Diff line
		@@ -139,6 +139,7 @@ filegroup {
		"InputListener.cpp",
		"InputReaderBase.cpp",
		"InputThread.cpp",
		"NotifyArgs.cpp",
		"VibrationElement.cpp",
		],
		}

services/inputflinger/InputListener.cpp

+0 −200

Original line number	Diff line number	Diff line
		@@ -31,206 +31,6 @@ using android::base::StringPrintf;

		namespace android {

		// --- NotifyConfigurationChangedArgs ---

		NotifyConfigurationChangedArgs::NotifyConfigurationChangedArgs(int32_t id, nsecs_t eventTime)
		: id(id), eventTime(eventTime) {}

		// --- NotifyKeyArgs ---

		NotifyKeyArgs::NotifyKeyArgs(int32_t id, nsecs_t eventTime, nsecs_t readTime, int32_t deviceId,
		uint32_t source, int32_t displayId, uint32_t policyFlags,
		int32_t action, int32_t flags, int32_t keyCode, int32_t scanCode,
		int32_t metaState, nsecs_t downTime)
		: id(id),
		eventTime(eventTime),
		deviceId(deviceId),
		source(source),
		displayId(displayId),
		policyFlags(policyFlags),
		action(action),
		flags(flags),
		keyCode(keyCode),
		scanCode(scanCode),
		metaState(metaState),
		downTime(downTime),
		readTime(readTime) {}

		// --- NotifyMotionArgs ---

		NotifyMotionArgs::NotifyMotionArgs(
		int32_t id, nsecs_t eventTime, nsecs_t readTime, int32_t deviceId, uint32_t source,
		int32_t displayId, uint32_t policyFlags, int32_t action, int32_t actionButton,
		int32_t flags, int32_t metaState, int32_t buttonState, MotionClassification classification,
		int32_t edgeFlags, uint32_t pointerCount, const PointerProperties* pointerProperties,
		const PointerCoords* pointerCoords, float xPrecision, float yPrecision,
		float xCursorPosition, float yCursorPosition, nsecs_t downTime,
		const std::vector<TouchVideoFrame>& videoFrames)
		: id(id),
		eventTime(eventTime),
		deviceId(deviceId),
		source(source),
		displayId(displayId),
		policyFlags(policyFlags),
		action(action),
		actionButton(actionButton),
		flags(flags),
		metaState(metaState),
		buttonState(buttonState),
		classification(classification),
		edgeFlags(edgeFlags),
		pointerCount(pointerCount),
		xPrecision(xPrecision),
		yPrecision(yPrecision),
		xCursorPosition(xCursorPosition),
		yCursorPosition(yCursorPosition),
		downTime(downTime),
		readTime(readTime),
		videoFrames(videoFrames) {
		for (uint32_t i = 0; i < pointerCount; i++) {
		this->pointerProperties[i].copyFrom(pointerProperties[i]);
		this->pointerCoords[i].copyFrom(pointerCoords[i]);
		}
		}

		NotifyMotionArgs::NotifyMotionArgs(const NotifyMotionArgs& other)
		: id(other.id),
		eventTime(other.eventTime),
		deviceId(other.deviceId),
		source(other.source),
		displayId(other.displayId),
		policyFlags(other.policyFlags),
		action(other.action),
		actionButton(other.actionButton),
		flags(other.flags),
		metaState(other.metaState),
		buttonState(other.buttonState),
		classification(other.classification),
		edgeFlags(other.edgeFlags),
		pointerCount(other.pointerCount),
		xPrecision(other.xPrecision),
		yPrecision(other.yPrecision),
		xCursorPosition(other.xCursorPosition),
		yCursorPosition(other.yCursorPosition),
		downTime(other.downTime),
		readTime(other.readTime),
		videoFrames(other.videoFrames) {
		for (uint32_t i = 0; i < pointerCount; i++) {
		pointerProperties[i].copyFrom(other.pointerProperties[i]);
		pointerCoords[i].copyFrom(other.pointerCoords[i]);
		}
		}

		static inline bool isCursorPositionEqual(float lhs, float rhs) {
		return (isnan(lhs) && isnan(rhs)) \|\| lhs == rhs;
		}

		bool NotifyMotionArgs::operator==(const NotifyMotionArgs& rhs) const {
		bool equal = id == rhs.id && eventTime == rhs.eventTime && readTime == rhs.readTime &&
		deviceId == rhs.deviceId && source == rhs.source && displayId == rhs.displayId &&
		policyFlags == rhs.policyFlags && action == rhs.action &&
		actionButton == rhs.actionButton && flags == rhs.flags && metaState == rhs.metaState &&
		buttonState == rhs.buttonState && classification == rhs.classification &&
		edgeFlags == rhs.edgeFlags &&
		pointerCount == rhs.pointerCount
		// PointerProperties and PointerCoords are compared separately below
		&& xPrecision == rhs.xPrecision && yPrecision == rhs.yPrecision &&
		isCursorPositionEqual(xCursorPosition, rhs.xCursorPosition) &&
		isCursorPositionEqual(yCursorPosition, rhs.yCursorPosition) &&
		downTime == rhs.downTime && videoFrames == rhs.videoFrames;
		if (!equal) {
		return false;
		}

		for (size_t i = 0; i < pointerCount; i++) {
		equal =
		pointerProperties[i] == rhs.pointerProperties[i]
		&& pointerCoords[i] == rhs.pointerCoords[i];
		if (!equal) {
		return false;
		}
		}
		return true;
		}

		std::string NotifyMotionArgs::dump() const {
		std::string coords;
		for (uint32_t i = 0; i < pointerCount; i++) {
		if (!coords.empty()) {
		coords += ", ";
		}
		coords += StringPrintf("{%" PRIu32 ": ", i);
		coords +=
		StringPrintf("id=%" PRIu32 " x=%.1f y=%.1f pressure=%.1f", pointerProperties[i].id,
		pointerCoords[i].getX(), pointerCoords[i].getY(),
		pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_PRESSURE));
		const int32_t toolType = pointerProperties[i].toolType;
		if (toolType != AMOTION_EVENT_TOOL_TYPE_FINGER) {
		coords += StringPrintf(" toolType=%s", motionToolTypeToString(toolType));
		}
		const float major = pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR);
		const float minor = pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR);
		const float orientation = pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_ORIENTATION);
		if (major != 0 \|\| minor != 0) {
		coords += StringPrintf(" major=%.1f minor=%.1f orientation=%.1f", major, minor,
		orientation);
		}
		coords += "}";
		}
		return StringPrintf("NotifyMotionArgs(id=%" PRId32 ", eventTime=%" PRId64 ", deviceId=%" PRId32
		", source=%s, action=%s, pointerCount=%" PRIu32
		" pointers=%s, flags=0x%08x)",
		id, eventTime, deviceId, inputEventSourceToString(source).c_str(),
		MotionEvent::actionToString(action).c_str(), pointerCount, coords.c_str(),
		flags);
		}

		// --- NotifySwitchArgs ---

		NotifySwitchArgs::NotifySwitchArgs(int32_t id, nsecs_t eventTime, uint32_t policyFlags,
		uint32_t switchValues, uint32_t switchMask)
		: id(id),
		eventTime(eventTime),
		policyFlags(policyFlags),
		switchValues(switchValues),
		switchMask(switchMask) {}

		// --- NotifySensorArgs ---

		NotifySensorArgs::NotifySensorArgs(int32_t id, nsecs_t eventTime, int32_t deviceId, uint32_t source,
		InputDeviceSensorType sensorType,
		InputDeviceSensorAccuracy accuracy, bool accuracyChanged,
		nsecs_t hwTimestamp, std::vector<float> values)
		: id(id),
		eventTime(eventTime),
		deviceId(deviceId),
		source(source),
		sensorType(sensorType),
		accuracy(accuracy),
		accuracyChanged(accuracyChanged),
		hwTimestamp(hwTimestamp),
		values(std::move(values)) {}

		// --- NotifyVibratorStateArgs ---

		NotifyVibratorStateArgs::NotifyVibratorStateArgs(int32_t id, nsecs_t eventTime, int32_t deviceId,
		bool isOn)
		: id(id), eventTime(eventTime), deviceId(deviceId), isOn(isOn) {}

		NotifyVibratorStateArgs::NotifyVibratorStateArgs(const NotifyVibratorStateArgs& other)
		: id(other.id), eventTime(other.eventTime), deviceId(other.deviceId), isOn(other.isOn) {}

		// --- NotifyDeviceResetArgs ---

		NotifyDeviceResetArgs::NotifyDeviceResetArgs(int32_t id, nsecs_t eventTime, int32_t deviceId)
		: id(id), eventTime(eventTime), deviceId(deviceId) {}

		// --- NotifyPointerCaptureChangedArgs ---

		NotifyPointerCaptureChangedArgs::NotifyPointerCaptureChangedArgs(
		int32_t id, nsecs_t eventTime, const PointerCaptureRequest& request)
		: id(id), eventTime(eventTime), request(request) {}

		// --- InputListenerInterface ---

		// Helper to std::visit with lambdas.

services/inputflinger/NotifyArgs.cpp

0 → 100644

+228 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2022 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.
		*/

		#define LOG_TAG "NotifyArgs"

		#define ATRACE_TAG ATRACE_TAG_INPUT

		#include "NotifyArgs.h"

		#include <android-base/stringprintf.h>
		#include <android/log.h>
		#include <math.h>
		#include <utils/Trace.h>

		using android::base::StringPrintf;

		namespace android {

		// --- NotifyConfigurationChangedArgs ---

		NotifyConfigurationChangedArgs::NotifyConfigurationChangedArgs(int32_t id, nsecs_t eventTime)
		: id(id), eventTime(eventTime) {}

		// --- NotifyKeyArgs ---

		NotifyKeyArgs::NotifyKeyArgs(int32_t id, nsecs_t eventTime, nsecs_t readTime, int32_t deviceId,
		uint32_t source, int32_t displayId, uint32_t policyFlags,
		int32_t action, int32_t flags, int32_t keyCode, int32_t scanCode,
		int32_t metaState, nsecs_t downTime)
		: id(id),
		eventTime(eventTime),
		deviceId(deviceId),
		source(source),
		displayId(displayId),
		policyFlags(policyFlags),
		action(action),
		flags(flags),
		keyCode(keyCode),
		scanCode(scanCode),
		metaState(metaState),
		downTime(downTime),
		readTime(readTime) {}

		// --- NotifyMotionArgs ---

		NotifyMotionArgs::NotifyMotionArgs(
		int32_t id, nsecs_t eventTime, nsecs_t readTime, int32_t deviceId, uint32_t source,
		int32_t displayId, uint32_t policyFlags, int32_t action, int32_t actionButton,
		int32_t flags, int32_t metaState, int32_t buttonState, MotionClassification classification,
		int32_t edgeFlags, uint32_t pointerCount, const PointerProperties* pointerProperties,
		const PointerCoords* pointerCoords, float xPrecision, float yPrecision,
		float xCursorPosition, float yCursorPosition, nsecs_t downTime,
		const std::vector<TouchVideoFrame>& videoFrames)
		: id(id),
		eventTime(eventTime),
		deviceId(deviceId),
		source(source),
		displayId(displayId),
		policyFlags(policyFlags),
		action(action),
		actionButton(actionButton),
		flags(flags),
		metaState(metaState),
		buttonState(buttonState),
		classification(classification),
		edgeFlags(edgeFlags),
		pointerCount(pointerCount),
		xPrecision(xPrecision),
		yPrecision(yPrecision),
		xCursorPosition(xCursorPosition),
		yCursorPosition(yCursorPosition),
		downTime(downTime),
		readTime(readTime),
		videoFrames(videoFrames) {
		for (uint32_t i = 0; i < pointerCount; i++) {
		this->pointerProperties[i].copyFrom(pointerProperties[i]);
		this->pointerCoords[i].copyFrom(pointerCoords[i]);
		}
		}

		NotifyMotionArgs::NotifyMotionArgs(const NotifyMotionArgs& other)
		: id(other.id),
		eventTime(other.eventTime),
		deviceId(other.deviceId),
		source(other.source),
		displayId(other.displayId),
		policyFlags(other.policyFlags),
		action(other.action),
		actionButton(other.actionButton),
		flags(other.flags),
		metaState(other.metaState),
		buttonState(other.buttonState),
		classification(other.classification),
		edgeFlags(other.edgeFlags),
		pointerCount(other.pointerCount),
		xPrecision(other.xPrecision),
		yPrecision(other.yPrecision),
		xCursorPosition(other.xCursorPosition),
		yCursorPosition(other.yCursorPosition),
		downTime(other.downTime),
		readTime(other.readTime),
		videoFrames(other.videoFrames) {
		for (uint32_t i = 0; i < pointerCount; i++) {
		pointerProperties[i].copyFrom(other.pointerProperties[i]);
		pointerCoords[i].copyFrom(other.pointerCoords[i]);
		}
		}

		static inline bool isCursorPositionEqual(float lhs, float rhs) {
		return (isnan(lhs) && isnan(rhs)) \|\| lhs == rhs;
		}

		bool NotifyMotionArgs::operator==(const NotifyMotionArgs& rhs) const {
		bool equal = id == rhs.id && eventTime == rhs.eventTime && readTime == rhs.readTime &&
		deviceId == rhs.deviceId && source == rhs.source && displayId == rhs.displayId &&
		policyFlags == rhs.policyFlags && action == rhs.action &&
		actionButton == rhs.actionButton && flags == rhs.flags && metaState == rhs.metaState &&
		buttonState == rhs.buttonState && classification == rhs.classification &&
		edgeFlags == rhs.edgeFlags &&
		pointerCount == rhs.pointerCount
		// PointerProperties and PointerCoords are compared separately below
		&& xPrecision == rhs.xPrecision && yPrecision == rhs.yPrecision &&
		isCursorPositionEqual(xCursorPosition, rhs.xCursorPosition) &&
		isCursorPositionEqual(yCursorPosition, rhs.yCursorPosition) &&
		downTime == rhs.downTime && videoFrames == rhs.videoFrames;
		if (!equal) {
		return false;
		}

		for (size_t i = 0; i < pointerCount; i++) {
		equal = pointerProperties[i] == rhs.pointerProperties[i] &&
		pointerCoords[i] == rhs.pointerCoords[i];
		if (!equal) {
		return false;
		}
		}
		return true;
		}

		std::string NotifyMotionArgs::dump() const {
		std::string coords;
		for (uint32_t i = 0; i < pointerCount; i++) {
		if (!coords.empty()) {
		coords += ", ";
		}
		coords += StringPrintf("{%" PRIu32 ": ", i);
		coords +=
		StringPrintf("id=%" PRIu32 " x=%.1f y=%.1f pressure=%.1f", pointerProperties[i].id,
		pointerCoords[i].getX(), pointerCoords[i].getY(),
		pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_PRESSURE));
		const int32_t toolType = pointerProperties[i].toolType;
		if (toolType != AMOTION_EVENT_TOOL_TYPE_FINGER) {
		coords += StringPrintf(" toolType=%s", motionToolTypeToString(toolType));
		}
		const float major = pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR);
		const float minor = pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR);
		const float orientation = pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_ORIENTATION);
		if (major != 0 \|\| minor != 0) {
		coords += StringPrintf(" major=%.1f minor=%.1f orientation=%.1f", major, minor,
		orientation);
		}
		coords += "}";
		}
		return StringPrintf("NotifyMotionArgs(id=%" PRId32 ", eventTime=%" PRId64 ", deviceId=%" PRId32
		", source=%s, action=%s, pointerCount=%" PRIu32
		" pointers=%s, flags=0x%08x)",
		id, eventTime, deviceId, inputEventSourceToString(source).c_str(),
		MotionEvent::actionToString(action).c_str(), pointerCount, coords.c_str(),
		flags);
		}

		// --- NotifySwitchArgs ---

		NotifySwitchArgs::NotifySwitchArgs(int32_t id, nsecs_t eventTime, uint32_t policyFlags,
		uint32_t switchValues, uint32_t switchMask)
		: id(id),
		eventTime(eventTime),
		policyFlags(policyFlags),
		switchValues(switchValues),
		switchMask(switchMask) {}

		// --- NotifySensorArgs ---

		NotifySensorArgs::NotifySensorArgs(int32_t id, nsecs_t eventTime, int32_t deviceId, uint32_t source,
		InputDeviceSensorType sensorType,
		InputDeviceSensorAccuracy accuracy, bool accuracyChanged,
		nsecs_t hwTimestamp, std::vector<float> values)
		: id(id),
		eventTime(eventTime),
		deviceId(deviceId),
		source(source),
		sensorType(sensorType),
		accuracy(accuracy),
		accuracyChanged(accuracyChanged),
		hwTimestamp(hwTimestamp),
		values(std::move(values)) {}

		// --- NotifyVibratorStateArgs ---

		NotifyVibratorStateArgs::NotifyVibratorStateArgs(int32_t id, nsecs_t eventTime, int32_t deviceId,
		bool isOn)
		: id(id), eventTime(eventTime), deviceId(deviceId), isOn(isOn) {}

		// --- NotifyDeviceResetArgs ---

		NotifyDeviceResetArgs::NotifyDeviceResetArgs(int32_t id, nsecs_t eventTime, int32_t deviceId)
		: id(id), eventTime(eventTime), deviceId(deviceId) {}

		// --- NotifyPointerCaptureChangedArgs ---

		NotifyPointerCaptureChangedArgs::NotifyPointerCaptureChangedArgs(
		int32_t id, nsecs_t eventTime, const PointerCaptureRequest& request)
		: id(id), eventTime(eventTime), request(request) {}

		} // namespace android

services/inputflinger/include/InputListener.h

+1 −191

Original line number	Diff line number	Diff line
		@@ -21,200 +21,10 @@
		#include <input/Input.h>
		#include <input/InputDevice.h>
		#include <input/TouchVideoFrame.h>
		#include "NotifyArgs.h"

		namespace android {

		class InputListenerInterface;

		/* Describes a configuration change event. */
		struct NotifyConfigurationChangedArgs {
		int32_t id;
		nsecs_t eventTime;

		inline NotifyConfigurationChangedArgs() { }

		NotifyConfigurationChangedArgs(int32_t id, nsecs_t eventTime);

		bool operator==(const NotifyConfigurationChangedArgs& rhs) const = default;

		NotifyConfigurationChangedArgs(const NotifyConfigurationChangedArgs& other) = default;
		};

		/* Describes a key event. */
		struct NotifyKeyArgs {
		int32_t id;
		nsecs_t eventTime;

		int32_t deviceId;
		uint32_t source;
		int32_t displayId;
		uint32_t policyFlags;
		int32_t action;
		int32_t flags;
		int32_t keyCode;
		int32_t scanCode;
		int32_t metaState;
		nsecs_t downTime;
		nsecs_t readTime;

		inline NotifyKeyArgs() { }

		NotifyKeyArgs(int32_t id, nsecs_t eventTime, nsecs_t readTime, int32_t deviceId,
		uint32_t source, int32_t displayId, uint32_t policyFlags, int32_t action,
		int32_t flags, int32_t keyCode, int32_t scanCode, int32_t metaState,
		nsecs_t downTime);

		bool operator==(const NotifyKeyArgs& rhs) const = default;

		NotifyKeyArgs(const NotifyKeyArgs& other) = default;
		};

		/* Describes a motion event. */
		struct NotifyMotionArgs {
		int32_t id;
		nsecs_t eventTime;

		int32_t deviceId;
		uint32_t source;
		int32_t displayId;
		uint32_t policyFlags;
		int32_t action;
		int32_t actionButton;
		int32_t flags;
		int32_t metaState;
		int32_t buttonState;
		/**
		* Classification of the current touch gesture
		*/
		MotionClassification classification;
		int32_t edgeFlags;

		uint32_t pointerCount;
		PointerProperties pointerProperties[MAX_POINTERS];
		PointerCoords pointerCoords[MAX_POINTERS];
		float xPrecision;
		float yPrecision;
		/**
		* Mouse cursor position when this event is reported relative to the origin of the specified
		* display. Only valid if this is a mouse event (originates from a mouse or from a trackpad in
		* gestures enabled mode.
		*/
		float xCursorPosition;
		float yCursorPosition;
		nsecs_t downTime;
		nsecs_t readTime;
		std::vector<TouchVideoFrame> videoFrames;

		inline NotifyMotionArgs() { }

		NotifyMotionArgs(int32_t id, nsecs_t eventTime, nsecs_t readTime, int32_t deviceId,
		uint32_t source, int32_t displayId, uint32_t policyFlags, int32_t action,
		int32_t actionButton, int32_t flags, int32_t metaState, int32_t buttonState,
		MotionClassification classification, int32_t edgeFlags, uint32_t pointerCount,
		const PointerProperties* pointerProperties, const PointerCoords* pointerCoords,
		float xPrecision, float yPrecision, float xCursorPosition,
		float yCursorPosition, nsecs_t downTime,
		const std::vector<TouchVideoFrame>& videoFrames);

		NotifyMotionArgs(const NotifyMotionArgs& other);

		bool operator==(const NotifyMotionArgs& rhs) const;

		std::string dump() const;
		};

		/* Describes a sensor event. */
		struct NotifySensorArgs {
		int32_t id;
		nsecs_t eventTime;

		int32_t deviceId;
		uint32_t source;
		InputDeviceSensorType sensorType;
		InputDeviceSensorAccuracy accuracy;
		bool accuracyChanged;
		nsecs_t hwTimestamp;
		std::vector<float> values;

		inline NotifySensorArgs() {}

		NotifySensorArgs(int32_t id, nsecs_t eventTime, int32_t deviceId, uint32_t source,
		InputDeviceSensorType sensorType, InputDeviceSensorAccuracy accuracy,
		bool accuracyChanged, nsecs_t hwTimestamp, std::vector<float> values);

		NotifySensorArgs(const NotifySensorArgs& other) = default;
		};

		/* Describes a switch event. */
		struct NotifySwitchArgs {
		int32_t id;
		nsecs_t eventTime;

		uint32_t policyFlags;
		uint32_t switchValues;
		uint32_t switchMask;

		inline NotifySwitchArgs() { }

		NotifySwitchArgs(int32_t id, nsecs_t eventTime, uint32_t policyFlags, uint32_t switchValues,
		uint32_t switchMask);

		NotifySwitchArgs(const NotifySwitchArgs& other) = default;

		bool operator==(const NotifySwitchArgs& rhs) const = default;
		};

		/* Describes a device reset event, such as when a device is added,
		* reconfigured, or removed. */
		struct NotifyDeviceResetArgs {
		int32_t id;
		nsecs_t eventTime;

		int32_t deviceId;

		inline NotifyDeviceResetArgs() { }

		NotifyDeviceResetArgs(int32_t id, nsecs_t eventTime, int32_t deviceId);

		NotifyDeviceResetArgs(const NotifyDeviceResetArgs& other) = default;

		bool operator==(const NotifyDeviceResetArgs& rhs) const = default;
		};

		/* Describes a change in the state of Pointer Capture. */
		struct NotifyPointerCaptureChangedArgs {
		// The sequence number of the Pointer Capture request, if enabled.
		int32_t id;
		nsecs_t eventTime;

		PointerCaptureRequest request;

		inline NotifyPointerCaptureChangedArgs() {}

		NotifyPointerCaptureChangedArgs(int32_t id, nsecs_t eventTime, const PointerCaptureRequest&);

		NotifyPointerCaptureChangedArgs(const NotifyPointerCaptureChangedArgs& other) = default;
		};

		/* Describes a vibrator state event. */
		struct NotifyVibratorStateArgs {
		int32_t id;
		nsecs_t eventTime;

		int32_t deviceId;
		bool isOn;

		inline NotifyVibratorStateArgs() {}

		NotifyVibratorStateArgs(int32_t id, nsecs_t eventTIme, int32_t deviceId, bool isOn);

		NotifyVibratorStateArgs(const NotifyVibratorStateArgs& other);
		};

		using NotifyArgs = std::variant<NotifyConfigurationChangedArgs, NotifyKeyArgs, NotifyMotionArgs,
		NotifySensorArgs, NotifySwitchArgs, NotifyDeviceResetArgs,
		NotifyPointerCaptureChangedArgs, NotifyVibratorStateArgs>;

		/*
		* The interface used by the InputReader to notify the InputListener about input events.
		*/

services/inputflinger/include/NotifyArgs.h

0 → 100644

+216 −0

File added.

Preview size limit exceeded, changes collapsed.