services/inputflinger/tests/FakeWindows.h - android_frameworks_native - Gitiles

 /*
  * Copyright 2024 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.
  */

 #pragma once

 #include "../dispatcher/InputDispatcher.h"
 #include "TestEventMatchers.h"

 #include <android-base/logging.h>
 #include <gtest/gtest.h>
 #include <input/Input.h>
 #include <input/InputConsumer.h>

 namespace android {

 /**
  * If we expect to receive the event, the timeout can be made very long. When the test are running
  * correctly, we will actually never wait until the end of the timeout because the wait will end
  * when the event comes in. Still, this value shouldn't be infinite. During development, a local
  * change may cause the test to fail. This timeout should be short enough to not annoy so that the
  * developer can see the failure quickly (on human scale).
  */
 static constexpr std::chrono::duration CONSUME_TIMEOUT_EVENT_EXPECTED = 1000ms;

 /**
  * When no event is expected, we can have a very short timeout. A large value here would slow down
  * the tests. In the unlikely event of system being too slow, the event may still be present but the
  * timeout would complete before it is consumed. This would result in test flakiness. If this
  * occurs, the flakiness rate would be high. Since the flakes are treated with high priority, this
  * would get noticed and addressed quickly.
  */
 static constexpr std::chrono::duration CONSUME_TIMEOUT_NO_EVENT_EXPECTED = 10ms;

 /**
  * The default pid and uid for windows created on the primary display by the test.
  */
 static constexpr gui::Pid WINDOW_PID{999};
 static constexpr gui::Uid WINDOW_UID{1001};

 /**
  * Default input dispatching timeout if there is no focused application or paused window
  * from which to determine an appropriate dispatching timeout.
  */
 static const std::chrono::duration DISPATCHING_TIMEOUT = std::chrono::milliseconds(
         android::os::IInputConstants::UNMULTIPLIED_DEFAULT_DISPATCHING_TIMEOUT_MILLIS *
         android::base::HwTimeoutMultiplier());

 // --- FakeInputReceiver ---

 class FakeInputReceiver {
 public:
     explicit FakeInputReceiver(std::unique_ptr<InputChannel> clientChannel, const std::string name);

     std::unique_ptr<InputEvent> consume(std::chrono::milliseconds timeout, bool handled = false);
     /**
      * Receive an event without acknowledging it.
      * Return the sequence number that could later be used to send finished signal.
      */
     std::pair<std::optional<uint32_t>, std::unique_ptr<InputEvent>> receiveEvent(
             std::chrono::milliseconds timeout);
     /**
      * To be used together with "receiveEvent" to complete the consumption of an event.
      */
     void finishEvent(uint32_t consumeSeq, bool handled = true);

     void sendTimeline(int32_t inputEventId, std::array<nsecs_t, GraphicsTimeline::SIZE> timeline);

     void consumeEvent(android::InputEventType expectedEventType, int32_t expectedAction,
                       std::optional<ui::LogicalDisplayId> expectedDisplayId,
                       std::optional<int32_t> expectedFlags);

     std::unique_ptr<MotionEvent> consumeMotion();
     void consumeMotionEvent(const ::testing::Matcher<MotionEvent>& matcher);

     void consumeFocusEvent(bool hasFocus, bool inTouchMode);
     void consumeCaptureEvent(bool hasCapture);
     void consumeDragEvent(bool isExiting, float x, float y);
     void consumeTouchModeEvent(bool inTouchMode);

     void assertNoEvents(std::chrono::milliseconds timeout);

     sp<IBinder> getToken();
     int getChannelFd();

 private:
     InputConsumer mConsumer;
     DynamicInputEventFactory mEventFactory;
     std::string mName;
 };

 // --- FakeWindowHandle ---

 class FakeWindowHandle : public gui::WindowInfoHandle {
 public:
     static const int32_t WIDTH = 600;
     static const int32_t HEIGHT = 800;
     using InputConfig = gui::WindowInfo::InputConfig;

     // This is a callback that is fired when an event is received by the window.
     // It is static to avoid having to pass it individually into all of the FakeWindowHandles
     // created by tests.
     // TODO(b/210460522): Update the tests to use a factory pattern so that we can avoid
     //   the need to make this static.
     static std::function<void(const std::unique_ptr<InputEvent>&, const gui::WindowInfo&)>
             sOnEventReceivedCallback;

     FakeWindowHandle(const std::shared_ptr<InputApplicationHandle>& inputApplicationHandle,
                      const std::unique_ptr<inputdispatcher::InputDispatcher>& dispatcher,
                      const std::string name, ui::LogicalDisplayId displayId,
                      bool createInputChannel = true);

     sp<FakeWindowHandle> clone(ui::LogicalDisplayId displayId);

     inline void setTouchable(bool touchable) {
         mInfo.setInputConfig(InputConfig::NOT_TOUCHABLE, !touchable);
     }

     inline void setFocusable(bool focusable) {
         mInfo.setInputConfig(InputConfig::NOT_FOCUSABLE, !focusable);
     }

     inline void setVisible(bool visible) {
         mInfo.setInputConfig(InputConfig::NOT_VISIBLE, !visible);
     }

     inline void setDispatchingTimeout(std::chrono::nanoseconds timeout) {
         mInfo.dispatchingTimeout = timeout;
     }

     inline void setPaused(bool paused) {
         mInfo.setInputConfig(InputConfig::PAUSE_DISPATCHING, paused);
     }

     inline void setPreventSplitting(bool preventSplitting) {
         mInfo.setInputConfig(InputConfig::PREVENT_SPLITTING, preventSplitting);
     }

     inline void setSlippery(bool slippery) {
         mInfo.setInputConfig(InputConfig::SLIPPERY, slippery);
     }

     inline void setWatchOutsideTouch(bool watchOutside) {
         mInfo.setInputConfig(InputConfig::WATCH_OUTSIDE_TOUCH, watchOutside);
     }

     inline void setSpy(bool spy) { mInfo.setInputConfig(InputConfig::SPY, spy); }

     inline void setSecure(bool secure) {
         if (secure) {
             mInfo.layoutParamsFlags |= gui::WindowInfo::Flag::SECURE;
         } else {
             using namespace ftl::flag_operators;
             mInfo.layoutParamsFlags &= ~gui::WindowInfo::Flag::SECURE;
         }
         mInfo.setInputConfig(InputConfig::SENSITIVE_FOR_PRIVACY, secure);
     }

     inline void setInterceptsStylus(bool interceptsStylus) {
         mInfo.setInputConfig(InputConfig::INTERCEPTS_STYLUS, interceptsStylus);
     }

     inline void setDropInput(bool dropInput) {
         mInfo.setInputConfig(InputConfig::DROP_INPUT, dropInput);
     }

     inline void setDropInputIfObscured(bool dropInputIfObscured) {
         mInfo.setInputConfig(InputConfig::DROP_INPUT_IF_OBSCURED, dropInputIfObscured);
     }

     inline void setNoInputChannel(bool noInputChannel) {
         mInfo.setInputConfig(InputConfig::NO_INPUT_CHANNEL, noInputChannel);
     }

     inline void setDisableUserActivity(bool disableUserActivity) {
         mInfo.setInputConfig(InputConfig::DISABLE_USER_ACTIVITY, disableUserActivity);
     }

     inline void setGlobalStylusBlocksTouch(bool shouldGlobalStylusBlockTouch) {
         mInfo.setInputConfig(InputConfig::GLOBAL_STYLUS_BLOCKS_TOUCH, shouldGlobalStylusBlockTouch);
     }

     inline void setAlpha(float alpha) { mInfo.alpha = alpha; }

     inline void setTouchOcclusionMode(gui::TouchOcclusionMode mode) {
         mInfo.touchOcclusionMode = mode;
     }

     inline void setApplicationToken(sp<IBinder> token) { mInfo.applicationInfo.token = token; }

     inline void setFrame(const Rect& frame,
                          const ui::Transform& displayTransform = ui::Transform()) {
         mInfo.frame = frame;
         mInfo.touchableRegion.clear();
         mInfo.addTouchableRegion(frame);

         const Rect logicalDisplayFrame = displayTransform.transform(frame);
         ui::Transform translate;
         translate.set(-logicalDisplayFrame.left, -logicalDisplayFrame.top);
         mInfo.transform = translate * displayTransform;
     }

     inline void setTouchableRegion(const Region& region) { mInfo.touchableRegion = region; }

     inline void setIsWallpaper(bool isWallpaper) {
         mInfo.setInputConfig(InputConfig::IS_WALLPAPER, isWallpaper);
     }

     inline void setDupTouchToWallpaper(bool hasWallpaper) {
         mInfo.setInputConfig(InputConfig::DUPLICATE_TOUCH_TO_WALLPAPER, hasWallpaper);
     }

     inline void setTrustedOverlay(bool trustedOverlay) {
         mInfo.setInputConfig(InputConfig::TRUSTED_OVERLAY, trustedOverlay);
     }

     inline void setWindowTransform(float dsdx, float dtdx, float dtdy, float dsdy) {
         mInfo.transform.set(dsdx, dtdx, dtdy, dsdy);
     }

     inline void setWindowScale(float xScale, float yScale) {
         setWindowTransform(xScale, 0, 0, yScale);
     }

     inline void setWindowOffset(float offsetX, float offsetY) {
         mInfo.transform.set(offsetX, offsetY);
     }

     std::unique_ptr<KeyEvent> consumeKey(bool handled = true);

     inline std::unique_ptr<KeyEvent> consumeKeyEvent(const ::testing::Matcher<KeyEvent>& matcher) {
         std::unique_ptr<KeyEvent> keyEvent = consumeKey();
         EXPECT_NE(nullptr, keyEvent);
         if (!keyEvent) {
             return nullptr;
         }
         EXPECT_THAT(*keyEvent, matcher);
         return keyEvent;
     }

     inline void consumeKeyDown(ui::LogicalDisplayId expectedDisplayId, int32_t expectedFlags = 0) {
         consumeKeyEvent(testing::AllOf(WithKeyAction(AKEY_EVENT_ACTION_DOWN),
                                        WithDisplayId(expectedDisplayId), WithFlags(expectedFlags)));
     }

     inline void consumeKeyUp(ui::LogicalDisplayId expectedDisplayId, int32_t expectedFlags = 0) {
         consumeKeyEvent(testing::AllOf(WithKeyAction(AKEY_EVENT_ACTION_UP),
                                        WithDisplayId(expectedDisplayId), WithFlags(expectedFlags)));
     }

     inline void consumeMotionCancel(
             ui::LogicalDisplayId expectedDisplayId = ui::LogicalDisplayId::DEFAULT,
             int32_t expectedFlags = 0) {
         consumeMotionEvent(testing::AllOf(WithMotionAction(AMOTION_EVENT_ACTION_CANCEL),
                                           WithDisplayId(expectedDisplayId),
                                           WithFlags(expectedFlags | AMOTION_EVENT_FLAG_CANCELED)));
     }

     inline void consumeMotionMove(
             ui::LogicalDisplayId expectedDisplayId = ui::LogicalDisplayId::DEFAULT,
             int32_t expectedFlags = 0) {
         consumeMotionEvent(testing::AllOf(WithMotionAction(AMOTION_EVENT_ACTION_MOVE),
                                           WithDisplayId(expectedDisplayId),
                                           WithFlags(expectedFlags)));
     }

     inline void consumeMotionDown(
             ui::LogicalDisplayId expectedDisplayId = ui::LogicalDisplayId::DEFAULT,
             int32_t expectedFlags = 0) {
         consumeAnyMotionDown(expectedDisplayId, expectedFlags);
     }

     inline void consumeAnyMotionDown(
             std::optional<ui::LogicalDisplayId> expectedDisplayId = std::nullopt,
             std::optional<int32_t> expectedFlags = std::nullopt) {
         consumeMotionEvent(
                 testing::AllOf(WithMotionAction(AMOTION_EVENT_ACTION_DOWN),
                                testing::Conditional(expectedDisplayId.has_value(),
                                                     WithDisplayId(*expectedDisplayId), testing::_),
                                testing::Conditional(expectedFlags.has_value(),
                                                     WithFlags(*expectedFlags), testing::_)));
     }

     inline void consumeMotionPointerDown(
             int32_t pointerIdx,
             ui::LogicalDisplayId expectedDisplayId = ui::LogicalDisplayId::DEFAULT,
             int32_t expectedFlags = 0) {
         const int32_t action = AMOTION_EVENT_ACTION_POINTER_DOWN |
                 (pointerIdx << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT);
         consumeMotionEvent(testing::AllOf(WithMotionAction(action),
                                           WithDisplayId(expectedDisplayId),
                                           WithFlags(expectedFlags)));
     }

     inline void consumeMotionPointerDown(int32_t pointerIdx,
                                          const ::testing::Matcher<MotionEvent>& matcher) {
         const int32_t action = AMOTION_EVENT_ACTION_POINTER_DOWN |
                 (pointerIdx << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT);
         consumeMotionEvent(testing::AllOf(WithMotionAction(action), matcher));
     }

     inline void consumeMotionPointerUp(int32_t pointerIdx,
                                        const ::testing::Matcher<MotionEvent>& matcher) {
         const int32_t action = AMOTION_EVENT_ACTION_POINTER_UP |
                 (pointerIdx << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT);
         consumeMotionEvent(testing::AllOf(WithMotionAction(action), matcher));
     }

     inline void consumeMotionUp(
             ui::LogicalDisplayId expectedDisplayId = ui::LogicalDisplayId::DEFAULT,
             int32_t expectedFlags = 0) {
         consumeMotionEvent(testing::AllOf(WithMotionAction(AMOTION_EVENT_ACTION_UP),
                                           WithDisplayId(expectedDisplayId),
                                           WithFlags(expectedFlags)));
     }

     inline void consumeMotionOutside(
             ui::LogicalDisplayId expectedDisplayId = ui::LogicalDisplayId::DEFAULT,
             int32_t expectedFlags = 0) {
         consumeMotionEvent(testing::AllOf(WithMotionAction(AMOTION_EVENT_ACTION_OUTSIDE),
                                           WithDisplayId(expectedDisplayId),
                                           WithFlags(expectedFlags)));
     }

     inline void consumeMotionOutsideWithZeroedCoords() {
         consumeMotionEvent(testing::AllOf(WithMotionAction(AMOTION_EVENT_ACTION_OUTSIDE),
                                           WithRawCoords(0, 0)));
     }

     inline void consumeFocusEvent(bool hasFocus, bool inTouchMode = true) {
         ASSERT_NE(mInputReceiver, nullptr)
                 << "Cannot consume events from a window with no receiver";
         mInputReceiver->consumeFocusEvent(hasFocus, inTouchMode);
     }

     inline void consumeCaptureEvent(bool hasCapture) {
         ASSERT_NE(mInputReceiver, nullptr)
                 << "Cannot consume events from a window with no receiver";
         mInputReceiver->consumeCaptureEvent(hasCapture);
     }

     std::unique_ptr<MotionEvent> consumeMotionEvent(
             const ::testing::Matcher<MotionEvent>& matcher = testing::_);

     inline void consumeDragEvent(bool isExiting, float x, float y) {
         mInputReceiver->consumeDragEvent(isExiting, x, y);
     }

     inline void consumeTouchModeEvent(bool inTouchMode) {
         ASSERT_NE(mInputReceiver, nullptr)
                 << "Cannot consume events from a window with no receiver";
         mInputReceiver->consumeTouchModeEvent(inTouchMode);
     }

     inline std::pair<std::optional<uint32_t>, std::unique_ptr<InputEvent>> receiveEvent() {
         return receive();
     }

     inline void finishEvent(uint32_t sequenceNum) {
         ASSERT_NE(mInputReceiver, nullptr) << "Invalid receive event on window with no receiver";
         mInputReceiver->finishEvent(sequenceNum);
     }

     inline void sendTimeline(int32_t inputEventId,
                              std::array<nsecs_t, GraphicsTimeline::SIZE> timeline) {
         ASSERT_NE(mInputReceiver, nullptr) << "Invalid receive event on window with no receiver";
         mInputReceiver->sendTimeline(inputEventId, timeline);
     }

     void assertNoEvents(std::optional<std::chrono::milliseconds> timeout = {});

     inline sp<IBinder> getToken() { return mInfo.token; }

     inline const std::string& getName() { return mName; }

     inline void setOwnerInfo(gui::Pid ownerPid, gui::Uid ownerUid) {
         mInfo.ownerPid = ownerPid;
         mInfo.ownerUid = ownerUid;
     }

     inline gui::Pid getPid() const { return mInfo.ownerPid; }

     inline void destroyReceiver() { mInputReceiver = nullptr; }

     inline int getChannelFd() { return mInputReceiver->getChannelFd(); }

     // FakeWindowHandle uses this consume method to ensure received events are added to the trace.
     std::unique_ptr<InputEvent> consume(std::chrono::milliseconds timeout, bool handled = true);

 private:
     FakeWindowHandle(std::string name) : mName(name){};
     const std::string mName;
     std::shared_ptr<FakeInputReceiver> mInputReceiver;
     static std::atomic<int32_t> sId; // each window gets a unique id, like in surfaceflinger
     friend class sp<FakeWindowHandle>;

     // FakeWindowHandle uses this receive method to ensure received events are added to the trace.
     std::pair<std::optional<uint32_t /*seq*/>, std::unique_ptr<InputEvent>> receive();
 };

 } // namespace android
	/*
	* Copyright 2024 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.
	*/

	#pragma once

	#include "../dispatcher/InputDispatcher.h"
	#include "TestEventMatchers.h"

	#include <android-base/logging.h>
	#include <gtest/gtest.h>
	#include <input/Input.h>
	#include <input/InputConsumer.h>

	namespace android {

	/**
	* If we expect to receive the event, the timeout can be made very long. When the test are running
	* correctly, we will actually never wait until the end of the timeout because the wait will end
	* when the event comes in. Still, this value shouldn't be infinite. During development, a local
	* change may cause the test to fail. This timeout should be short enough to not annoy so that the
	* developer can see the failure quickly (on human scale).
	*/
	static constexpr std::chrono::duration CONSUME_TIMEOUT_EVENT_EXPECTED = 1000ms;

	/**
	* When no event is expected, we can have a very short timeout. A large value here would slow down
	* the tests. In the unlikely event of system being too slow, the event may still be present but the
	* timeout would complete before it is consumed. This would result in test flakiness. If this
	* occurs, the flakiness rate would be high. Since the flakes are treated with high priority, this
	* would get noticed and addressed quickly.
	*/
	static constexpr std::chrono::duration CONSUME_TIMEOUT_NO_EVENT_EXPECTED = 10ms;

	/**
	* The default pid and uid for windows created on the primary display by the test.
	*/
	static constexpr gui::Pid WINDOW_PID{999};
	static constexpr gui::Uid WINDOW_UID{1001};

	/**
	* Default input dispatching timeout if there is no focused application or paused window
	* from which to determine an appropriate dispatching timeout.
	*/
	static const std::chrono::duration DISPATCHING_TIMEOUT = std::chrono::milliseconds(
	android::os::IInputConstants::UNMULTIPLIED_DEFAULT_DISPATCHING_TIMEOUT_MILLIS *
	android::base::HwTimeoutMultiplier());

	// --- FakeInputReceiver ---

	class FakeInputReceiver {
	public:
	explicit FakeInputReceiver(std::unique_ptr<InputChannel> clientChannel, const std::string name);

	std::unique_ptr<InputEvent> consume(std::chrono::milliseconds timeout, bool handled = false);
	/**
	* Receive an event without acknowledging it.
	* Return the sequence number that could later be used to send finished signal.
	*/
	std::pair<std::optional<uint32_t>, std::unique_ptr<InputEvent>> receiveEvent(
	std::chrono::milliseconds timeout);
	/**
	* To be used together with "receiveEvent" to complete the consumption of an event.
	*/
	void finishEvent(uint32_t consumeSeq, bool handled = true);

	void sendTimeline(int32_t inputEventId, std::array<nsecs_t, GraphicsTimeline::SIZE> timeline);

	void consumeEvent(android::InputEventType expectedEventType, int32_t expectedAction,
	std::optional<ui::LogicalDisplayId> expectedDisplayId,
	std::optional<int32_t> expectedFlags);

	std::unique_ptr<MotionEvent> consumeMotion();
	void consumeMotionEvent(const ::testing::Matcher<MotionEvent>& matcher);

	void consumeFocusEvent(bool hasFocus, bool inTouchMode);
	void consumeCaptureEvent(bool hasCapture);
	void consumeDragEvent(bool isExiting, float x, float y);
	void consumeTouchModeEvent(bool inTouchMode);

	void assertNoEvents(std::chrono::milliseconds timeout);

	sp<IBinder> getToken();
	int getChannelFd();

	private:
	InputConsumer mConsumer;
	DynamicInputEventFactory mEventFactory;
	std::string mName;
	};

	// --- FakeWindowHandle ---

	class FakeWindowHandle : public gui::WindowInfoHandle {
	public:
	static const int32_t WIDTH = 600;
	static const int32_t HEIGHT = 800;
	using InputConfig = gui::WindowInfo::InputConfig;

	// This is a callback that is fired when an event is received by the window.
	// It is static to avoid having to pass it individually into all of the FakeWindowHandles
	// created by tests.
	// TODO(b/210460522): Update the tests to use a factory pattern so that we can avoid
	// the need to make this static.
	static std::function<void(const std::unique_ptr<InputEvent>&, const gui::WindowInfo&)>
	sOnEventReceivedCallback;

	FakeWindowHandle(const std::shared_ptr<InputApplicationHandle>& inputApplicationHandle,
	const std::unique_ptr<inputdispatcher::InputDispatcher>& dispatcher,
	const std::string name, ui::LogicalDisplayId displayId,
	bool createInputChannel = true);

	sp<FakeWindowHandle> clone(ui::LogicalDisplayId displayId);

	inline void setTouchable(bool touchable) {
	mInfo.setInputConfig(InputConfig::NOT_TOUCHABLE, !touchable);
	}

	inline void setFocusable(bool focusable) {
	mInfo.setInputConfig(InputConfig::NOT_FOCUSABLE, !focusable);
	}

	inline void setVisible(bool visible) {
	mInfo.setInputConfig(InputConfig::NOT_VISIBLE, !visible);
	}

	inline void setDispatchingTimeout(std::chrono::nanoseconds timeout) {
	mInfo.dispatchingTimeout = timeout;
	}

	inline void setPaused(bool paused) {
	mInfo.setInputConfig(InputConfig::PAUSE_DISPATCHING, paused);
	}

	inline void setPreventSplitting(bool preventSplitting) {
	mInfo.setInputConfig(InputConfig::PREVENT_SPLITTING, preventSplitting);
	}

	inline void setSlippery(bool slippery) {
	mInfo.setInputConfig(InputConfig::SLIPPERY, slippery);
	}

	inline void setWatchOutsideTouch(bool watchOutside) {
	mInfo.setInputConfig(InputConfig::WATCH_OUTSIDE_TOUCH, watchOutside);
	}

	inline void setSpy(bool spy) { mInfo.setInputConfig(InputConfig::SPY, spy); }

	inline void setSecure(bool secure) {
	if (secure) {
	mInfo.layoutParamsFlags \|= gui::WindowInfo::Flag::SECURE;
	} else {
	using namespace ftl::flag_operators;
	mInfo.layoutParamsFlags &= ~gui::WindowInfo::Flag::SECURE;
	}
	mInfo.setInputConfig(InputConfig::SENSITIVE_FOR_PRIVACY, secure);
	}

	inline void setInterceptsStylus(bool interceptsStylus) {
	mInfo.setInputConfig(InputConfig::INTERCEPTS_STYLUS, interceptsStylus);
	}

	inline void setDropInput(bool dropInput) {
	mInfo.setInputConfig(InputConfig::DROP_INPUT, dropInput);
	}

	inline void setDropInputIfObscured(bool dropInputIfObscured) {
	mInfo.setInputConfig(InputConfig::DROP_INPUT_IF_OBSCURED, dropInputIfObscured);
	}

	inline void setNoInputChannel(bool noInputChannel) {
	mInfo.setInputConfig(InputConfig::NO_INPUT_CHANNEL, noInputChannel);
	}

	inline void setDisableUserActivity(bool disableUserActivity) {
	mInfo.setInputConfig(InputConfig::DISABLE_USER_ACTIVITY, disableUserActivity);
	}

	inline void setGlobalStylusBlocksTouch(bool shouldGlobalStylusBlockTouch) {
	mInfo.setInputConfig(InputConfig::GLOBAL_STYLUS_BLOCKS_TOUCH, shouldGlobalStylusBlockTouch);
	}

	inline void setAlpha(float alpha) { mInfo.alpha = alpha; }

	inline void setTouchOcclusionMode(gui::TouchOcclusionMode mode) {
	mInfo.touchOcclusionMode = mode;
	}

	inline void setApplicationToken(sp<IBinder> token) { mInfo.applicationInfo.token = token; }

	inline void setFrame(const Rect& frame,
	const ui::Transform& displayTransform = ui::Transform()) {
	mInfo.frame = frame;
	mInfo.touchableRegion.clear();
	mInfo.addTouchableRegion(frame);

	const Rect logicalDisplayFrame = displayTransform.transform(frame);
	ui::Transform translate;
	translate.set(-logicalDisplayFrame.left, -logicalDisplayFrame.top);
	mInfo.transform = translate * displayTransform;
	}

	inline void setTouchableRegion(const Region& region) { mInfo.touchableRegion = region; }

	inline void setIsWallpaper(bool isWallpaper) {
	mInfo.setInputConfig(InputConfig::IS_WALLPAPER, isWallpaper);
	}

	inline void setDupTouchToWallpaper(bool hasWallpaper) {
	mInfo.setInputConfig(InputConfig::DUPLICATE_TOUCH_TO_WALLPAPER, hasWallpaper);
	}

	inline void setTrustedOverlay(bool trustedOverlay) {
	mInfo.setInputConfig(InputConfig::TRUSTED_OVERLAY, trustedOverlay);
	}

	inline void setWindowTransform(float dsdx, float dtdx, float dtdy, float dsdy) {
	mInfo.transform.set(dsdx, dtdx, dtdy, dsdy);
	}

	inline void setWindowScale(float xScale, float yScale) {
	setWindowTransform(xScale, 0, 0, yScale);
	}

	inline void setWindowOffset(float offsetX, float offsetY) {
	mInfo.transform.set(offsetX, offsetY);
	}

	std::unique_ptr<KeyEvent> consumeKey(bool handled = true);

	inline std::unique_ptr<KeyEvent> consumeKeyEvent(const ::testing::Matcher<KeyEvent>& matcher) {
	std::unique_ptr<KeyEvent> keyEvent = consumeKey();
	EXPECT_NE(nullptr, keyEvent);
	if (!keyEvent) {
	return nullptr;
	}
	EXPECT_THAT(*keyEvent, matcher);
	return keyEvent;
	}

	inline void consumeKeyDown(ui::LogicalDisplayId expectedDisplayId, int32_t expectedFlags = 0) {
	consumeKeyEvent(testing::AllOf(WithKeyAction(AKEY_EVENT_ACTION_DOWN),
	WithDisplayId(expectedDisplayId), WithFlags(expectedFlags)));
	}

	inline void consumeKeyUp(ui::LogicalDisplayId expectedDisplayId, int32_t expectedFlags = 0) {
	consumeKeyEvent(testing::AllOf(WithKeyAction(AKEY_EVENT_ACTION_UP),
	WithDisplayId(expectedDisplayId), WithFlags(expectedFlags)));
	}

	inline void consumeMotionCancel(
	ui::LogicalDisplayId expectedDisplayId = ui::LogicalDisplayId::DEFAULT,
	int32_t expectedFlags = 0) {
	consumeMotionEvent(testing::AllOf(WithMotionAction(AMOTION_EVENT_ACTION_CANCEL),
	WithDisplayId(expectedDisplayId),
	WithFlags(expectedFlags \| AMOTION_EVENT_FLAG_CANCELED)));
	}

	inline void consumeMotionMove(
	ui::LogicalDisplayId expectedDisplayId = ui::LogicalDisplayId::DEFAULT,
	int32_t expectedFlags = 0) {
	consumeMotionEvent(testing::AllOf(WithMotionAction(AMOTION_EVENT_ACTION_MOVE),
	WithDisplayId(expectedDisplayId),
	WithFlags(expectedFlags)));
	}

	inline void consumeMotionDown(
	ui::LogicalDisplayId expectedDisplayId = ui::LogicalDisplayId::DEFAULT,
	int32_t expectedFlags = 0) {
	consumeAnyMotionDown(expectedDisplayId, expectedFlags);
	}

	inline void consumeAnyMotionDown(
	std::optional<ui::LogicalDisplayId> expectedDisplayId = std::nullopt,
	std::optional<int32_t> expectedFlags = std::nullopt) {
	consumeMotionEvent(
	testing::AllOf(WithMotionAction(AMOTION_EVENT_ACTION_DOWN),
	testing::Conditional(expectedDisplayId.has_value(),
	WithDisplayId(*expectedDisplayId), testing::_),
	testing::Conditional(expectedFlags.has_value(),
	WithFlags(*expectedFlags), testing::_)));
	}

	inline void consumeMotionPointerDown(
	int32_t pointerIdx,
	ui::LogicalDisplayId expectedDisplayId = ui::LogicalDisplayId::DEFAULT,
	int32_t expectedFlags = 0) {
	const int32_t action = AMOTION_EVENT_ACTION_POINTER_DOWN \|
	(pointerIdx << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT);
	consumeMotionEvent(testing::AllOf(WithMotionAction(action),
	WithDisplayId(expectedDisplayId),
	WithFlags(expectedFlags)));
	}

	inline void consumeMotionPointerDown(int32_t pointerIdx,
	const ::testing::Matcher<MotionEvent>& matcher) {
	const int32_t action = AMOTION_EVENT_ACTION_POINTER_DOWN \|
	(pointerIdx << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT);
	consumeMotionEvent(testing::AllOf(WithMotionAction(action), matcher));
	}

	inline void consumeMotionPointerUp(int32_t pointerIdx,
	const ::testing::Matcher<MotionEvent>& matcher) {
	const int32_t action = AMOTION_EVENT_ACTION_POINTER_UP \|
	(pointerIdx << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT);
	consumeMotionEvent(testing::AllOf(WithMotionAction(action), matcher));
	}

	inline void consumeMotionUp(
	ui::LogicalDisplayId expectedDisplayId = ui::LogicalDisplayId::DEFAULT,
	int32_t expectedFlags = 0) {
	consumeMotionEvent(testing::AllOf(WithMotionAction(AMOTION_EVENT_ACTION_UP),
	WithDisplayId(expectedDisplayId),
	WithFlags(expectedFlags)));
	}

	inline void consumeMotionOutside(
	ui::LogicalDisplayId expectedDisplayId = ui::LogicalDisplayId::DEFAULT,
	int32_t expectedFlags = 0) {
	consumeMotionEvent(testing::AllOf(WithMotionAction(AMOTION_EVENT_ACTION_OUTSIDE),
	WithDisplayId(expectedDisplayId),
	WithFlags(expectedFlags)));
	}

	inline void consumeMotionOutsideWithZeroedCoords() {
	consumeMotionEvent(testing::AllOf(WithMotionAction(AMOTION_EVENT_ACTION_OUTSIDE),
	WithRawCoords(0, 0)));
	}

	inline void consumeFocusEvent(bool hasFocus, bool inTouchMode = true) {
	ASSERT_NE(mInputReceiver, nullptr)
	<< "Cannot consume events from a window with no receiver";
	mInputReceiver->consumeFocusEvent(hasFocus, inTouchMode);
	}

	inline void consumeCaptureEvent(bool hasCapture) {
	ASSERT_NE(mInputReceiver, nullptr)
	<< "Cannot consume events from a window with no receiver";
	mInputReceiver->consumeCaptureEvent(hasCapture);
	}

	std::unique_ptr<MotionEvent> consumeMotionEvent(
	const ::testing::Matcher<MotionEvent>& matcher = testing::_);

	inline void consumeDragEvent(bool isExiting, float x, float y) {
	mInputReceiver->consumeDragEvent(isExiting, x, y);
	}

	inline void consumeTouchModeEvent(bool inTouchMode) {
	ASSERT_NE(mInputReceiver, nullptr)
	<< "Cannot consume events from a window with no receiver";
	mInputReceiver->consumeTouchModeEvent(inTouchMode);
	}

	inline std::pair<std::optional<uint32_t>, std::unique_ptr<InputEvent>> receiveEvent() {
	return receive();
	}

	inline void finishEvent(uint32_t sequenceNum) {
	ASSERT_NE(mInputReceiver, nullptr) << "Invalid receive event on window with no receiver";
	mInputReceiver->finishEvent(sequenceNum);
	}

	inline void sendTimeline(int32_t inputEventId,
	std::array<nsecs_t, GraphicsTimeline::SIZE> timeline) {
	ASSERT_NE(mInputReceiver, nullptr) << "Invalid receive event on window with no receiver";
	mInputReceiver->sendTimeline(inputEventId, timeline);
	}

	void assertNoEvents(std::optional<std::chrono::milliseconds> timeout = {});

	inline sp<IBinder> getToken() { return mInfo.token; }

	inline const std::string& getName() { return mName; }

	inline void setOwnerInfo(gui::Pid ownerPid, gui::Uid ownerUid) {
	mInfo.ownerPid = ownerPid;
	mInfo.ownerUid = ownerUid;
	}

	inline gui::Pid getPid() const { return mInfo.ownerPid; }

	inline void destroyReceiver() { mInputReceiver = nullptr; }

	inline int getChannelFd() { return mInputReceiver->getChannelFd(); }

	// FakeWindowHandle uses this consume method to ensure received events are added to the trace.
	std::unique_ptr<InputEvent> consume(std::chrono::milliseconds timeout, bool handled = true);

	private:
	FakeWindowHandle(std::string name) : mName(name){};
	const std::string mName;
	std::shared_ptr<FakeInputReceiver> mInputReceiver;
	static std::atomic<int32_t> sId; // each window gets a unique id, like in surfaceflinger
	friend class sp<FakeWindowHandle>;

	// FakeWindowHandle uses this receive method to ensure received events are added to the trace.
	std::pair<std::optional<uint32_t /seq/>, std::unique_ptr<InputEvent>> receive();
	};

	} // namespace android