Merge "Updated MotionEvent to use Transform" (d5dc0406) · Commits · e / os / platform_frameworks_native

include/input/Input.h

+6 −12

Original line number	Original line	Diff line number	Diff line
	@@ -527,13 +527,11 @@ public:

	inline void setActionButton(int32_t button) { mActionButton = button; }		inline void setActionButton(int32_t button) { mActionButton = button; }

	inline float getXScale() const { return mXScale; }		inline float getXOffset() const { return mTransform.tx(); }

	inline float getYScale() const { return mYScale; }		inline float getYOffset() const { return mTransform.ty(); }

	inline float getXOffset() const { return mXOffset; }		inline ui::Transform getTransform() const { return mTransform; }

	inline float getYOffset() const { return mYOffset; }

	inline float getXPrecision() const { return mXPrecision; }		inline float getXPrecision() const { return mXPrecision; }

	@@ -695,8 +693,8 @@ public:
	void initialize(int32_t id, int32_t deviceId, uint32_t source, int32_t displayId,		void initialize(int32_t id, int32_t deviceId, uint32_t source, int32_t displayId,
	std::array<uint8_t, 32> hmac, int32_t action, int32_t actionButton,		std::array<uint8_t, 32> hmac, int32_t action, int32_t actionButton,
	int32_t flags, int32_t edgeFlags, int32_t metaState, int32_t buttonState,		int32_t flags, int32_t edgeFlags, int32_t metaState, int32_t buttonState,
	MotionClassification classification, float xScale, float yScale, float xOffset,		MotionClassification classification, const ui::Transform& transform,
	float yOffset, float xPrecision, float yPrecision, float rawXCursorPosition,		float xPrecision, float yPrecision, float rawXCursorPosition,
	float rawYCursorPosition, nsecs_t downTime, nsecs_t eventTime,		float rawYCursorPosition, nsecs_t downTime, nsecs_t eventTime,
	size_t pointerCount, const PointerProperties* pointerProperties,		size_t pointerCount, const PointerProperties* pointerProperties,
	const PointerCoords* pointerCoords);		const PointerCoords* pointerCoords);
	@@ -713,7 +711,7 @@ public:

	// Apply 3x3 perspective matrix transformation.		// Apply 3x3 perspective matrix transformation.
	// Matrix is in row-major form and compatible with SkMatrix.		// Matrix is in row-major form and compatible with SkMatrix.
	void transform(const float matrix[9]);		void transform(const std::array<float, 9>& matrix);

	#ifdef __ANDROID__		#ifdef __ANDROID__
	status_t readFromParcel(Parcel* parcel);		status_t readFromParcel(Parcel* parcel);
	@@ -747,10 +745,6 @@ protected:
	int32_t mMetaState;		int32_t mMetaState;
	int32_t mButtonState;		int32_t mButtonState;
	MotionClassification mClassification;		MotionClassification mClassification;
	float mXScale;
	float mYScale;
	float mXOffset;
	float mYOffset;
	ui::Transform mTransform;		ui::Transform mTransform;
	float mXPrecision;		float mXPrecision;
	float mYPrecision;		float mYPrecision;

include/input/InputTransport.h

+11 −9

Original line number	Original line	Diff line number	Diff line
	@@ -37,6 +37,7 @@
	#include <binder/Parcelable.h>		#include <binder/Parcelable.h>
	#include <input/Input.h>		#include <input/Input.h>
	#include <sys/stat.h>		#include <sys/stat.h>
			#include <ui/Transform.h>
	#include <utils/BitSet.h>		#include <utils/BitSet.h>
	#include <utils/Errors.h>		#include <utils/Errors.h>
	#include <utils/RefBase.h>		#include <utils/RefBase.h>
	@@ -115,10 +116,12 @@ struct InputMessage {
	uint8_t empty2[3]; // 3 bytes to fill gap created by classification		uint8_t empty2[3]; // 3 bytes to fill gap created by classification
	int32_t edgeFlags;		int32_t edgeFlags;
	nsecs_t downTime __attribute__((aligned(8)));		nsecs_t downTime __attribute__((aligned(8)));
	float xScale;		float dsdx;
	float yScale;		float dtdx;
	float xOffset;		float dtdy;
	float yOffset;		float dsdy;
			float tx;
			float ty;
	float xPrecision;		float xPrecision;
	float yPrecision;		float yPrecision;
	float xCursorPosition;		float xCursorPosition;
	@@ -319,11 +322,10 @@ public:
	int32_t displayId, std::array<uint8_t, 32> hmac, int32_t action,		int32_t displayId, std::array<uint8_t, 32> hmac, int32_t action,
	int32_t actionButton, int32_t flags, int32_t edgeFlags,		int32_t actionButton, int32_t flags, int32_t edgeFlags,
	int32_t metaState, int32_t buttonState,		int32_t metaState, int32_t buttonState,
	MotionClassification classification, float xScale, float yScale,		MotionClassification classification, const ui::Transform& transform,
	float xOffset, float yOffset, float xPrecision, float yPrecision,		float xPrecision, float yPrecision, float xCursorPosition,
	float xCursorPosition, float yCursorPosition, nsecs_t downTime,		float yCursorPosition, nsecs_t downTime, nsecs_t eventTime,
	nsecs_t eventTime, uint32_t pointerCount,		uint32_t pointerCount, const PointerProperties* pointerProperties,
	const PointerProperties* pointerProperties,
	const PointerCoords* pointerCoords);		const PointerCoords* pointerCoords);

	/* Publishes a focus event to the input channel.		/* Publishes a focus event to the input channel.

libs/input/Input.cpp

+87 −83

Original line number	Original line	Diff line number	Diff line
	@@ -325,10 +325,10 @@ void PointerProperties::copyFrom(const PointerProperties& other) {
	void MotionEvent::initialize(int32_t id, int32_t deviceId, uint32_t source, int32_t displayId,		void MotionEvent::initialize(int32_t id, int32_t deviceId, uint32_t source, int32_t displayId,
	std::array<uint8_t, 32> hmac, int32_t action, int32_t actionButton,		std::array<uint8_t, 32> hmac, int32_t action, int32_t actionButton,
	int32_t flags, int32_t edgeFlags, int32_t metaState,		int32_t flags, int32_t edgeFlags, int32_t metaState,
	int32_t buttonState, MotionClassification classification, float xScale,		int32_t buttonState, MotionClassification classification,
	float yScale, float xOffset, float yOffset, float xPrecision,		const ui::Transform& transform, float xPrecision, float yPrecision,
	float yPrecision, float rawXCursorPosition, float rawYCursorPosition,		float rawXCursorPosition, float rawYCursorPosition, nsecs_t downTime,
	nsecs_t downTime, nsecs_t eventTime, size_t pointerCount,		nsecs_t eventTime, size_t pointerCount,
	const PointerProperties* pointerProperties,		const PointerProperties* pointerProperties,
	const PointerCoords* pointerCoords) {		const PointerCoords* pointerCoords) {
	InputEvent::initialize(id, deviceId, source, displayId, hmac);		InputEvent::initialize(id, deviceId, source, displayId, hmac);
	@@ -339,10 +339,7 @@ void MotionEvent::initialize(int32_t id, int32_t deviceId, uint32_t source, int3
	mMetaState = metaState;		mMetaState = metaState;
	mButtonState = buttonState;		mButtonState = buttonState;
	mClassification = classification;		mClassification = classification;
	mXScale = xScale;		mTransform = transform;
	mYScale = yScale;
	mXOffset = xOffset;
	mYOffset = yOffset;
	mXPrecision = xPrecision;		mXPrecision = xPrecision;
	mYPrecision = yPrecision;		mYPrecision = yPrecision;
	mRawXCursorPosition = rawXCursorPosition;		mRawXCursorPosition = rawXCursorPosition;
	@@ -365,10 +362,7 @@ void MotionEvent::copyFrom(const MotionEvent* other, bool keepHistory) {
	mMetaState = other->mMetaState;		mMetaState = other->mMetaState;
	mButtonState = other->mButtonState;		mButtonState = other->mButtonState;
	mClassification = other->mClassification;		mClassification = other->mClassification;
	mXScale = other->mXScale;		mTransform = other->mTransform;
	mYScale = other->mYScale;
	mXOffset = other->mXOffset;
	mYOffset = other->mYOffset;
	mXPrecision = other->mXPrecision;		mXPrecision = other->mXPrecision;
	mYPrecision = other->mYPrecision;		mYPrecision = other->mYPrecision;
	mRawXCursorPosition = other->mRawXCursorPosition;		mRawXCursorPosition = other->mRawXCursorPosition;
	@@ -398,18 +392,20 @@ void MotionEvent::addSample(
	}		}

	float MotionEvent::getXCursorPosition() const {		float MotionEvent::getXCursorPosition() const {
	const float rawX = getRawXCursorPosition();		vec2 vals = mTransform.transform(getRawXCursorPosition(), getRawYCursorPosition());
	return rawX * mXScale + mXOffset;		return vals.x;
	}		}

	float MotionEvent::getYCursorPosition() const {		float MotionEvent::getYCursorPosition() const {
	const float rawY = getRawYCursorPosition();		vec2 vals = mTransform.transform(getRawXCursorPosition(), getRawYCursorPosition());
	return rawY * mYScale + mYOffset;		return vals.y;
	}		}

	void MotionEvent::setCursorPosition(float x, float y) {		void MotionEvent::setCursorPosition(float x, float y) {
	mRawXCursorPosition = (x - mXOffset) / mXScale;		ui::Transform inverse = mTransform.inverse();
	mRawYCursorPosition = (y - mYOffset) / mYScale;		vec2 vals = inverse.transform(x, y);
			mRawXCursorPosition = vals.x;
			mRawYCursorPosition = vals.y;
	}		}

	const PointerCoords* MotionEvent::getRawPointerCoords(size_t pointerIndex) const {		const PointerCoords* MotionEvent::getRawPointerCoords(size_t pointerIndex) const {
	@@ -421,14 +417,7 @@ float MotionEvent::getRawAxisValue(int32_t axis, size_t pointerIndex) const {
	}		}

	float MotionEvent::getAxisValue(int32_t axis, size_t pointerIndex) const {		float MotionEvent::getAxisValue(int32_t axis, size_t pointerIndex) const {
	float value = getRawPointerCoords(pointerIndex)->getAxisValue(axis);		return getHistoricalAxisValue(axis, pointerIndex, getHistorySize());
	switch (axis) {
	case AMOTION_EVENT_AXIS_X:
	return value * mXScale + mXOffset;
	case AMOTION_EVENT_AXIS_Y:
	return value * mYScale + mYOffset;
	}
	return value;
	}		}

	const PointerCoords* MotionEvent::getHistoricalRawPointerCoords(		const PointerCoords* MotionEvent::getHistoricalRawPointerCoords(
	@@ -443,14 +432,23 @@ float MotionEvent::getHistoricalRawAxisValue(int32_t axis, size_t pointerIndex,

	float MotionEvent::getHistoricalAxisValue(int32_t axis, size_t pointerIndex,		float MotionEvent::getHistoricalAxisValue(int32_t axis, size_t pointerIndex,
	size_t historicalIndex) const {		size_t historicalIndex) const {
	float value = getHistoricalRawPointerCoords(pointerIndex, historicalIndex)->getAxisValue(axis);		if (axis != AMOTION_EVENT_AXIS_X && axis != AMOTION_EVENT_AXIS_Y) {
			return getHistoricalRawPointerCoords(pointerIndex, historicalIndex)->getAxisValue(axis);
			}

			float rawX = getHistoricalRawPointerCoords(pointerIndex, historicalIndex)->getX();
			float rawY = getHistoricalRawPointerCoords(pointerIndex, historicalIndex)->getY();
			vec2 vals = mTransform.transform(rawX, rawY);

	switch (axis) {		switch (axis) {
	case AMOTION_EVENT_AXIS_X:		case AMOTION_EVENT_AXIS_X:
	return value * mXScale + mXOffset;		return vals.x;
	case AMOTION_EVENT_AXIS_Y:		case AMOTION_EVENT_AXIS_Y:
	return value * mYScale + mYOffset;		return vals.y;
	}		}
	return value;
			// This should never happen
			return 0;
	}		}

	ssize_t MotionEvent::findPointerIndex(int32_t pointerId) const {		ssize_t MotionEvent::findPointerIndex(int32_t pointerId) const {
	@@ -464,23 +462,24 @@ ssize_t MotionEvent::findPointerIndex(int32_t pointerId) const {
	}		}

	void MotionEvent::offsetLocation(float xOffset, float yOffset) {		void MotionEvent::offsetLocation(float xOffset, float yOffset) {
	mXOffset += xOffset;		float currXOffset = mTransform.tx();
	mYOffset += yOffset;		float currYOffset = mTransform.ty();
			mTransform.set(currXOffset + xOffset, currYOffset + yOffset);
	}		}

	void MotionEvent::scale(float globalScaleFactor) {		void MotionEvent::scale(float globalScaleFactor) {
	mXOffset *= globalScaleFactor;		mTransform.set(mTransform.tx() * globalScaleFactor, mTransform.ty() * globalScaleFactor);
	mYOffset *= globalScaleFactor;
	mXPrecision *= globalScaleFactor;		mXPrecision *= globalScaleFactor;
	mYPrecision *= globalScaleFactor;		mYPrecision *= globalScaleFactor;

	size_t numSamples = mSamplePointerCoords.size();		size_t numSamples = mSamplePointerCoords.size();
	for (size_t i = 0; i < numSamples; i++) {		for (size_t i = 0; i < numSamples; i++) {
	mSamplePointerCoords.editItemAt(i).scale(globalScaleFactor);		mSamplePointerCoords.editItemAt(i).scale(globalScaleFactor, globalScaleFactor,
			globalScaleFactor);
	}		}
	}		}

	static void transformPoint(const float matrix[9], float x, float y, float outX, float outY) {		static vec2 transformPoint(const std::array<float, 9>& matrix, float x, float y) {
	// Apply perspective transform like Skia.		// Apply perspective transform like Skia.
	float newX = matrix[0] * x + matrix[1] * y + matrix[2];		float newX = matrix[0] * x + matrix[1] * y + matrix[2];
	float newY = matrix[3] * x + matrix[4] * y + matrix[5];		float newY = matrix[3] * x + matrix[4] * y + matrix[5];
	@@ -488,22 +487,25 @@ static void transformPoint(const float matrix[9], float x, float y, float *outX,
	if (newZ) {		if (newZ) {
	newZ = 1.0f / newZ;		newZ = 1.0f / newZ;
	}		}
	outX = newX newZ;		vec2 transformedPoint;
	outY = newY newZ;		transformedPoint.x = newX * newZ;
			transformedPoint.y = newY * newZ;
			return transformedPoint;
	}		}

	static float transformAngle(const float matrix[9], float angleRadians,		static float transformAngle(const std::array<float, 9>& matrix, float angleRadians, float originX,
	float originX, float originY) {		float originY) {
	// Construct and transform a vector oriented at the specified clockwise angle from vertical.		// Construct and transform a vector oriented at the specified clockwise angle from vertical.
	// Coordinate system: down is increasing Y, right is increasing X.		// Coordinate system: down is increasing Y, right is increasing X.
	float x = sinf(angleRadians);		float x = sinf(angleRadians);
	float y = -cosf(angleRadians);		float y = -cosf(angleRadians);
	transformPoint(matrix, x, y, &x, &y);		vec2 transformedPoint = transformPoint(matrix, x, y);
	x -= originX;
	y -= originY;		transformedPoint.x -= originX;
			transformedPoint.y -= originY;

	// Derive the transformed vector's clockwise angle from vertical.		// Derive the transformed vector's clockwise angle from vertical.
	float result = atan2f(x, -y);		float result = atan2f(transformedPoint.x, -transformedPoint.y);
	if (result < - M_PI_2) {		if (result < - M_PI_2) {
	result += M_PI;		result += M_PI;
	} else if (result > M_PI_2) {		} else if (result > M_PI_2) {
	@@ -512,51 +514,51 @@ static float transformAngle(const float matrix[9], float angleRadians,
	return result;		return result;
	}		}

	void MotionEvent::transform(const float matrix[9]) {		void MotionEvent::transform(const std::array<float, 9>& matrix) {
	// The tricky part of this implementation is to preserve the value of		// We want to preserve the rawX and rawY so we just update the transform
	// rawX and rawY. So we apply the transformation to the first point		// using the values of the transform passed in
	// then derive an appropriate new X/Y offset that will preserve rawX		ui::Transform newTransform;
	// and rawY for that point.		newTransform.set(matrix);
	float oldXOffset = mXOffset;		mTransform = newTransform * mTransform;
	float oldYOffset = mYOffset;
	float newX, newY;
	float scaledRawX = getRawX(0) * mXScale;
	float scaledRawY = getRawY(0) * mYScale;
	transformPoint(matrix, scaledRawX + oldXOffset, scaledRawY + oldYOffset, &newX, &newY);
	mXOffset = newX - scaledRawX;
	mYOffset = newY - scaledRawY;

	// Determine how the origin is transformed by the matrix so that we		// Determine how the origin is transformed by the matrix so that we
	// can transform orientation vectors.		// can transform orientation vectors.
	float originX, originY;		vec2 origin = transformPoint(matrix, 0, 0);
	transformPoint(matrix, 0, 0, &originX, &originY);

	// Apply the transformation to cursor position.
	if (isValidCursorPosition(mRawXCursorPosition, mRawYCursorPosition)) {
	float x = mRawXCursorPosition * mXScale + oldXOffset;
	float y = mRawYCursorPosition * mYScale + oldYOffset;
	transformPoint(matrix, x, y, &x, &y);
	mRawXCursorPosition = (x - mXOffset) / mXScale;
	mRawYCursorPosition = (y - mYOffset) / mYScale;
	}

	// Apply the transformation to all samples.		// Apply the transformation to all samples.
	size_t numSamples = mSamplePointerCoords.size();		size_t numSamples = mSamplePointerCoords.size();
	for (size_t i = 0; i < numSamples; i++) {		for (size_t i = 0; i < numSamples; i++) {
	PointerCoords& c = mSamplePointerCoords.editItemAt(i);		PointerCoords& c = mSamplePointerCoords.editItemAt(i);
	float x = c.getAxisValue(AMOTION_EVENT_AXIS_X) * mXScale + oldXOffset;
	float y = c.getAxisValue(AMOTION_EVENT_AXIS_Y) * mYScale + oldYOffset;
	transformPoint(matrix, x, y, &x, &y);
	c.setAxisValue(AMOTION_EVENT_AXIS_X, (x - mXOffset) / mXScale);
	c.setAxisValue(AMOTION_EVENT_AXIS_Y, (y - mYOffset) / mYScale);

	float orientation = c.getAxisValue(AMOTION_EVENT_AXIS_ORIENTATION);		float orientation = c.getAxisValue(AMOTION_EVENT_AXIS_ORIENTATION);
	c.setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION,		c.setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION,
	transformAngle(matrix, orientation, originX, originY));		transformAngle(matrix, orientation, origin.x, origin.y));
	}		}
	}		}

	#ifdef __ANDROID__		#ifdef __ANDROID__
			static status_t readFromParcel(ui::Transform& transform, const Parcel& parcel) {
			float dsdx, dtdx, tx, dtdy, dsdy, ty;
			status_t status = parcel.readFloat(&dsdx);
			status \|= parcel.readFloat(&dtdx);
			status \|= parcel.readFloat(&tx);
			status \|= parcel.readFloat(&dtdy);
			status \|= parcel.readFloat(&dsdy);
			status \|= parcel.readFloat(&ty);

			transform.set({dsdx, dtdx, tx, dtdy, dsdy, ty, 0, 0, 1});
			return status;
			}

			static status_t writeToParcel(const ui::Transform& transform, Parcel& parcel) {
			status_t status = parcel.writeFloat(transform.dsdx());
			status \|= parcel.writeFloat(transform.dtdx());
			status \|= parcel.writeFloat(transform.tx());
			status \|= parcel.writeFloat(transform.dtdy());
			status \|= parcel.writeFloat(transform.dsdy());
			status \|= parcel.writeFloat(transform.ty());
			return status;
			}

	status_t MotionEvent::readFromParcel(Parcel* parcel) {		status_t MotionEvent::readFromParcel(Parcel* parcel) {
	size_t pointerCount = parcel->readInt32();		size_t pointerCount = parcel->readInt32();
	size_t sampleCount = parcel->readInt32();		size_t sampleCount = parcel->readInt32();
	@@ -582,10 +584,11 @@ status_t MotionEvent::readFromParcel(Parcel* parcel) {
	mMetaState = parcel->readInt32();		mMetaState = parcel->readInt32();
	mButtonState = parcel->readInt32();		mButtonState = parcel->readInt32();
	mClassification = static_cast<MotionClassification>(parcel->readByte());		mClassification = static_cast<MotionClassification>(parcel->readByte());
	mXScale = parcel->readFloat();
	mYScale = parcel->readFloat();		result = android::readFromParcel(mTransform, *parcel);
	mXOffset = parcel->readFloat();		if (result != OK) {
	mYOffset = parcel->readFloat();		return result;
			}
	mXPrecision = parcel->readFloat();		mXPrecision = parcel->readFloat();
	mYPrecision = parcel->readFloat();		mYPrecision = parcel->readFloat();
	mRawXCursorPosition = parcel->readFloat();		mRawXCursorPosition = parcel->readFloat();
	@@ -640,10 +643,11 @@ status_t MotionEvent::writeToParcel(Parcel* parcel) const {
	parcel->writeInt32(mMetaState);		parcel->writeInt32(mMetaState);
	parcel->writeInt32(mButtonState);		parcel->writeInt32(mButtonState);
	parcel->writeByte(static_cast<int8_t>(mClassification));		parcel->writeByte(static_cast<int8_t>(mClassification));
	parcel->writeFloat(mXScale);
	parcel->writeFloat(mYScale);		status_t result = android::writeToParcel(mTransform, *parcel);
	parcel->writeFloat(mXOffset);		if (result != OK) {
	parcel->writeFloat(mYOffset);		return result;
			}
	parcel->writeFloat(mXPrecision);		parcel->writeFloat(mXPrecision);
	parcel->writeFloat(mYPrecision);		parcel->writeFloat(mYPrecision);
	parcel->writeFloat(mRawXCursorPosition);		parcel->writeFloat(mRawXCursorPosition);

libs/input/InputTransport.cpp

+32 −27

Original line number	Original line	Diff line number	Diff line
	@@ -195,14 +195,14 @@ void InputMessage::getSanitizedCopy(InputMessage* msg) const {
	msg->body.motion.edgeFlags = body.motion.edgeFlags;		msg->body.motion.edgeFlags = body.motion.edgeFlags;
	// nsecs_t downTime		// nsecs_t downTime
	msg->body.motion.downTime = body.motion.downTime;		msg->body.motion.downTime = body.motion.downTime;
	// float xScale
	msg->body.motion.xScale = body.motion.xScale;		msg->body.motion.dsdx = body.motion.dsdx;
	// float yScale		msg->body.motion.dtdx = body.motion.dtdx;
	msg->body.motion.yScale = body.motion.yScale;		msg->body.motion.dtdy = body.motion.dtdy;
	// float xOffset		msg->body.motion.dsdy = body.motion.dsdy;
	msg->body.motion.xOffset = body.motion.xOffset;		msg->body.motion.tx = body.motion.tx;
	// float yOffset		msg->body.motion.ty = body.motion.ty;
	msg->body.motion.yOffset = body.motion.yOffset;
	// float xPrecision		// float xPrecision
	msg->body.motion.xPrecision = body.motion.xPrecision;		msg->body.motion.xPrecision = body.motion.xPrecision;
	// float yPrecision		// float yPrecision
	@@ -469,10 +469,10 @@ status_t InputPublisher::publishMotionEvent(
	uint32_t seq, int32_t eventId, int32_t deviceId, int32_t source, int32_t displayId,		uint32_t seq, int32_t eventId, int32_t deviceId, int32_t source, int32_t displayId,
	std::array<uint8_t, 32> hmac, int32_t action, int32_t actionButton, int32_t flags,		std::array<uint8_t, 32> hmac, int32_t action, int32_t actionButton, int32_t flags,
	int32_t edgeFlags, int32_t metaState, int32_t buttonState,		int32_t edgeFlags, int32_t metaState, int32_t buttonState,
	MotionClassification classification, float xScale, float yScale, float xOffset,		MotionClassification classification, const ui::Transform& transform, float xPrecision,
	float yOffset, float xPrecision, float yPrecision, float xCursorPosition,		float yPrecision, float xCursorPosition, float yCursorPosition, nsecs_t downTime,
	float yCursorPosition, nsecs_t downTime, nsecs_t eventTime, uint32_t pointerCount,		nsecs_t eventTime, uint32_t pointerCount, const PointerProperties* pointerProperties,
	const PointerProperties* pointerProperties, const PointerCoords* pointerCoords) {		const PointerCoords* pointerCoords) {
	if (ATRACE_ENABLED()) {		if (ATRACE_ENABLED()) {
	std::string message = StringPrintf(		std::string message = StringPrintf(
	"publishMotionEvent(inputChannel=%s, action=%" PRId32 ")",		"publishMotionEvent(inputChannel=%s, action=%" PRId32 ")",
	@@ -480,17 +480,18 @@ status_t InputPublisher::publishMotionEvent(
	ATRACE_NAME(message.c_str());		ATRACE_NAME(message.c_str());
	}		}
	if (DEBUG_TRANSPORT_ACTIONS) {		if (DEBUG_TRANSPORT_ACTIONS) {
			std::string transformString;
			transform.dump(transformString, "");
	ALOGD("channel '%s' publisher ~ publishMotionEvent: seq=%u, deviceId=%d, source=0x%x, "		ALOGD("channel '%s' publisher ~ publishMotionEvent: seq=%u, deviceId=%d, source=0x%x, "
	"displayId=%" PRId32 ", "		"displayId=%" PRId32 ", "
	"action=0x%x, actionButton=0x%08x, flags=0x%x, edgeFlags=0x%x, "		"action=0x%x, actionButton=0x%08x, flags=0x%x, edgeFlags=0x%x, "
	"metaState=0x%x, buttonState=0x%x, classification=%s, xScale=%.1f, yScale=%.1f, "		"metaState=0x%x, buttonState=0x%x, classification=%s,"
	"xOffset=%.1f, yOffset=%.1f, "
	"xPrecision=%f, yPrecision=%f, downTime=%" PRId64 ", eventTime=%" PRId64 ", "		"xPrecision=%f, yPrecision=%f, downTime=%" PRId64 ", eventTime=%" PRId64 ", "
	"pointerCount=%" PRIu32,		"pointerCount=%" PRIu32 " transform=%s",
	mChannel->getName().c_str(), seq, deviceId, source, displayId, action, actionButton,		mChannel->getName().c_str(), seq, deviceId, source, displayId, action, actionButton,
	flags, edgeFlags, metaState, buttonState,		flags, edgeFlags, metaState, buttonState,
	motionClassificationToString(classification), xScale, yScale, xOffset, yOffset,		motionClassificationToString(classification), xPrecision, yPrecision, downTime,
	xPrecision, yPrecision, downTime, eventTime, pointerCount);		eventTime, pointerCount, transformString.c_str());
	}		}

	if (!seq) {		if (!seq) {
	@@ -519,10 +520,12 @@ status_t InputPublisher::publishMotionEvent(
	msg.body.motion.metaState = metaState;		msg.body.motion.metaState = metaState;
	msg.body.motion.buttonState = buttonState;		msg.body.motion.buttonState = buttonState;
	msg.body.motion.classification = classification;		msg.body.motion.classification = classification;
	msg.body.motion.xScale = xScale;		msg.body.motion.dsdx = transform.dsdx();
	msg.body.motion.yScale = yScale;		msg.body.motion.dtdx = transform.dtdx();
	msg.body.motion.xOffset = xOffset;		msg.body.motion.dtdy = transform.dtdy();
	msg.body.motion.yOffset = yOffset;		msg.body.motion.dsdy = transform.dsdy();
			msg.body.motion.tx = transform.tx();
			msg.body.motion.ty = transform.ty();
	msg.body.motion.xPrecision = xPrecision;		msg.body.motion.xPrecision = xPrecision;
	msg.body.motion.yPrecision = yPrecision;		msg.body.motion.yPrecision = yPrecision;
	msg.body.motion.xCursorPosition = xCursorPosition;		msg.body.motion.xCursorPosition = xCursorPosition;
	@@ -1166,16 +1169,18 @@ void InputConsumer::initializeMotionEvent(MotionEvent* event, const InputMessage
	pointerCoords[i].copyFrom(msg->body.motion.pointers[i].coords);		pointerCoords[i].copyFrom(msg->body.motion.pointers[i].coords);
	}		}

			ui::Transform transform;
			transform.set({msg->body.motion.dsdx, msg->body.motion.dtdx, msg->body.motion.tx,
			msg->body.motion.dtdy, msg->body.motion.dsdy, msg->body.motion.ty, 0, 0, 1});
	event->initialize(msg->body.motion.eventId, msg->body.motion.deviceId, msg->body.motion.source,		event->initialize(msg->body.motion.eventId, msg->body.motion.deviceId, msg->body.motion.source,
	msg->body.motion.displayId, msg->body.motion.hmac, msg->body.motion.action,		msg->body.motion.displayId, msg->body.motion.hmac, msg->body.motion.action,
	msg->body.motion.actionButton, msg->body.motion.flags,		msg->body.motion.actionButton, msg->body.motion.flags,
	msg->body.motion.edgeFlags, msg->body.motion.metaState,		msg->body.motion.edgeFlags, msg->body.motion.metaState,
	msg->body.motion.buttonState, msg->body.motion.classification,		msg->body.motion.buttonState, msg->body.motion.classification, transform,
	msg->body.motion.xScale, msg->body.motion.yScale, msg->body.motion.xOffset,		msg->body.motion.xPrecision, msg->body.motion.yPrecision,
	msg->body.motion.yOffset, msg->body.motion.xPrecision,		msg->body.motion.xCursorPosition, msg->body.motion.yCursorPosition,
	msg->body.motion.yPrecision, msg->body.motion.xCursorPosition,		msg->body.motion.downTime, msg->body.motion.eventTime, pointerCount,
	msg->body.motion.yCursorPosition, msg->body.motion.downTime,		pointerProperties, pointerCoords);
	msg->body.motion.eventTime, pointerCount, pointerProperties, pointerCoords);
	}		}

	void InputConsumer::addSample(MotionEvent* event, const InputMessage* msg) {		void InputConsumer::addSample(MotionEvent* event, const InputMessage* msg) {

libs/input/InputWindow.cpp

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -174,7 +174,7 @@ status_t InputWindowInfo::readFromParcel(const android::Parcel* parcel) {
	}		}

	touchableRegionCropHandle = parcel->readStrongBinder();		touchableRegionCropHandle = parcel->readStrongBinder();
	transform.set(std::array<float, 9>{dsdx, dtdx, tx, dtdy, dsdy, ty, 0, 0, 1});		transform.set({dsdx, dtdx, tx, dtdy, dsdy, ty, 0, 0, 1});

	return OK;		return OK;
	}		}