Allow PointerController to be disabled on creation (3401d23a) · Commits · e / os / android_frameworks_base

libs/input/PointerController.cpp

+40 −6

Original line number	Original line	Diff line number	Diff line
	@@ -63,10 +63,10 @@ void PointerController::DisplayInfoListener::onPointerControllerDestroyed() {

	std::shared_ptr<PointerController> PointerController::create(		std::shared_ptr<PointerController> PointerController::create(
	const sp<PointerControllerPolicyInterface>& policy, const sp<Looper>& looper,		const sp<PointerControllerPolicyInterface>& policy, const sp<Looper>& looper,
	SpriteController& spriteController) {		SpriteController& spriteController, bool enabled) {
	// using 'new' to access non-public constructor		// using 'new' to access non-public constructor
	std::shared_ptr<PointerController> controller = std::shared_ptr<PointerController>(		std::shared_ptr<PointerController> controller = std::shared_ptr<PointerController>(
	new PointerController(policy, looper, spriteController));		new PointerController(policy, looper, spriteController, enabled));

	/*		/*
	* Now we need to hook up the constructed PointerController object to its callbacks.		* Now we need to hook up the constructed PointerController object to its callbacks.
	@@ -85,9 +85,10 @@ std::shared_ptr<PointerController> PointerController::create(
	}		}

	PointerController::PointerController(const sp<PointerControllerPolicyInterface>& policy,		PointerController::PointerController(const sp<PointerControllerPolicyInterface>& policy,
	const sp<Looper>& looper, SpriteController& spriteController)		const sp<Looper>& looper, SpriteController& spriteController,
			bool enabled)
	: PointerController(		: PointerController(
	policy, looper, spriteController,		policy, looper, spriteController, enabled,
	[](const sp<android::gui::WindowInfosListener>& listener) {		[](const sp<android::gui::WindowInfosListener>& listener) {
	SurfaceComposerClient::getDefault()->addWindowInfosListener(listener);		SurfaceComposerClient::getDefault()->addWindowInfosListener(listener);
	},		},
	@@ -97,9 +98,10 @@ PointerController::PointerController(const sp<PointerControllerPolicyInterface>&

	PointerController::PointerController(const sp<PointerControllerPolicyInterface>& policy,		PointerController::PointerController(const sp<PointerControllerPolicyInterface>& policy,
	const sp<Looper>& looper, SpriteController& spriteController,		const sp<Looper>& looper, SpriteController& spriteController,
	WindowListenerConsumer registerListener,		bool enabled, WindowListenerConsumer registerListener,
	WindowListenerConsumer unregisterListener)		WindowListenerConsumer unregisterListener)
	: mContext(policy, looper, spriteController, *this),		: mEnabled(enabled),
			mContext(policy, looper, spriteController, *this),
	mCursorController(mContext),		mCursorController(mContext),
	mDisplayInfoListener(sp<DisplayInfoListener>::make(this)),		mDisplayInfoListener(sp<DisplayInfoListener>::make(this)),
	mUnregisterWindowInfosListener(std::move(unregisterListener)) {		mUnregisterWindowInfosListener(std::move(unregisterListener)) {
	@@ -119,10 +121,14 @@ std::mutex& PointerController::getLock() const {
	}		}

	std::optional<FloatRect> PointerController::getBounds() const {		std::optional<FloatRect> PointerController::getBounds() const {
			if (!mEnabled) return {};

	return mCursorController.getBounds();		return mCursorController.getBounds();
	}		}

	void PointerController::move(float deltaX, float deltaY) {		void PointerController::move(float deltaX, float deltaY) {
			if (!mEnabled) return;

	const int32_t displayId = mCursorController.getDisplayId();		const int32_t displayId = mCursorController.getDisplayId();
	vec2 transformed;		vec2 transformed;
	{		{
	@@ -134,6 +140,8 @@ void PointerController::move(float deltaX, float deltaY) {
	}		}

	void PointerController::setPosition(float x, float y) {		void PointerController::setPosition(float x, float y) {
			if (!mEnabled) return;

	const int32_t displayId = mCursorController.getDisplayId();		const int32_t displayId = mCursorController.getDisplayId();
	vec2 transformed;		vec2 transformed;
	{		{
	@@ -145,6 +153,11 @@ void PointerController::setPosition(float x, float y) {
	}		}

	FloatPoint PointerController::getPosition() const {		FloatPoint PointerController::getPosition() const {
			if (!mEnabled) {
			return FloatPoint{AMOTION_EVENT_INVALID_CURSOR_POSITION,
			AMOTION_EVENT_INVALID_CURSOR_POSITION};
			}

	const int32_t displayId = mCursorController.getDisplayId();		const int32_t displayId = mCursorController.getDisplayId();
	const auto p = mCursorController.getPosition();		const auto p = mCursorController.getPosition();
	{		{
	@@ -155,20 +168,28 @@ FloatPoint PointerController::getPosition() const {
	}		}

	int32_t PointerController::getDisplayId() const {		int32_t PointerController::getDisplayId() const {
			if (!mEnabled) return ADISPLAY_ID_NONE;

	return mCursorController.getDisplayId();		return mCursorController.getDisplayId();
	}		}

	void PointerController::fade(Transition transition) {		void PointerController::fade(Transition transition) {
			if (!mEnabled) return;

	std::scoped_lock lock(getLock());		std::scoped_lock lock(getLock());
	mCursorController.fade(transition);		mCursorController.fade(transition);
	}		}

	void PointerController::unfade(Transition transition) {		void PointerController::unfade(Transition transition) {
			if (!mEnabled) return;

	std::scoped_lock lock(getLock());		std::scoped_lock lock(getLock());
	mCursorController.unfade(transition);		mCursorController.unfade(transition);
	}		}

	void PointerController::setPresentation(Presentation presentation) {		void PointerController::setPresentation(Presentation presentation) {
			if (!mEnabled) return;

	std::scoped_lock lock(getLock());		std::scoped_lock lock(getLock());

	if (mLocked.presentation == presentation) {		if (mLocked.presentation == presentation) {
	@@ -193,6 +214,8 @@ void PointerController::setPresentation(Presentation presentation) {

	void PointerController::setSpots(const PointerCoords* spotCoords, const uint32_t* spotIdToIndex,		void PointerController::setSpots(const PointerCoords* spotCoords, const uint32_t* spotIdToIndex,
	BitSet32 spotIdBits, int32_t displayId) {		BitSet32 spotIdBits, int32_t displayId) {
			if (!mEnabled) return;

	std::scoped_lock lock(getLock());		std::scoped_lock lock(getLock());
	std::array<PointerCoords, MAX_POINTERS> outSpotCoords{};		std::array<PointerCoords, MAX_POINTERS> outSpotCoords{};
	const ui::Transform& transform = getTransformForDisplayLocked(displayId);		const ui::Transform& transform = getTransformForDisplayLocked(displayId);
	@@ -216,6 +239,8 @@ void PointerController::setSpots(const PointerCoords* spotCoords, const uint32_t
	}		}

	void PointerController::clearSpots() {		void PointerController::clearSpots() {
			if (!mEnabled) return;

	std::scoped_lock lock(getLock());		std::scoped_lock lock(getLock());
	clearSpotsLocked();		clearSpotsLocked();
	}		}
	@@ -277,11 +302,15 @@ void PointerController::setDisplayViewport(const DisplayViewport& viewport) {
	}		}

	void PointerController::updatePointerIcon(PointerIconStyle iconId) {		void PointerController::updatePointerIcon(PointerIconStyle iconId) {
			if (!mEnabled) return;

	std::scoped_lock lock(getLock());		std::scoped_lock lock(getLock());
	mCursorController.updatePointerIcon(iconId);		mCursorController.updatePointerIcon(iconId);
	}		}

	void PointerController::setCustomPointerIcon(const SpriteIcon& icon) {		void PointerController::setCustomPointerIcon(const SpriteIcon& icon) {
			if (!mEnabled) return;

	std::scoped_lock lock(getLock());		std::scoped_lock lock(getLock());
	mCursorController.setCustomPointerIcon(icon);		mCursorController.setCustomPointerIcon(icon);
	}		}
	@@ -326,6 +355,11 @@ const ui::Transform& PointerController::getTransformForDisplayLocked(int display
	}		}

	void PointerController::dump(std::string& dump) {		void PointerController::dump(std::string& dump) {
			if (!mEnabled) {
			dump += INDENT "PointerController: DISABLED due to ongoing PointerChoreographer refactor\n";
			return;
			}

	dump += INDENT "PointerController:\n";		dump += INDENT "PointerController:\n";
	std::scoped_lock lock(getLock());		std::scoped_lock lock(getLock());
	dump += StringPrintf(INDENT2 "Presentation: %s\n",		dump += StringPrintf(INDENT2 "Presentation: %s\n",

libs/input/PointerController.h

+6 −3

Original line number	Original line	Diff line number	Diff line
	@@ -47,7 +47,7 @@ class PointerController : public PointerControllerInterface {
	public:		public:
	static std::shared_ptr<PointerController> create(		static std::shared_ptr<PointerController> create(
	const sp<PointerControllerPolicyInterface>& policy, const sp<Looper>& looper,		const sp<PointerControllerPolicyInterface>& policy, const sp<Looper>& looper,
	SpriteController& spriteController);		SpriteController& spriteController, bool enabled);

	~PointerController() override;		~PointerController() override;

	@@ -83,12 +83,13 @@ protected:

	// Constructor used to test WindowInfosListener registration.		// Constructor used to test WindowInfosListener registration.
	PointerController(const sp<PointerControllerPolicyInterface>& policy, const sp<Looper>& looper,		PointerController(const sp<PointerControllerPolicyInterface>& policy, const sp<Looper>& looper,
	SpriteController& spriteController, WindowListenerConsumer registerListener,		SpriteController& spriteController, bool enabled,
			WindowListenerConsumer registerListener,
	WindowListenerConsumer unregisterListener);		WindowListenerConsumer unregisterListener);

	private:		private:
	PointerController(const sp<PointerControllerPolicyInterface>& policy, const sp<Looper>& looper,		PointerController(const sp<PointerControllerPolicyInterface>& policy, const sp<Looper>& looper,
	SpriteController& spriteController);		SpriteController& spriteController, bool enabled);

	friend PointerControllerContext::LooperCallback;		friend PointerControllerContext::LooperCallback;
	friend PointerControllerContext::MessageHandler;		friend PointerControllerContext::MessageHandler;
	@@ -99,6 +100,8 @@ private:
	// we use the DisplayInfoListener's lock in PointerController.		// we use the DisplayInfoListener's lock in PointerController.
	std::mutex& getLock() const;		std::mutex& getLock() const;

			const bool mEnabled;

	PointerControllerContext mContext;		PointerControllerContext mContext;

	MouseCursorController mCursorController;		MouseCursorController mCursorController;

libs/input/tests/PointerController_test.cpp

+3 −1

Original line number	Original line	Diff line number	Diff line
	@@ -181,7 +181,8 @@ PointerControllerTest::PointerControllerTest() : mPointerSprite(new NiceMock<Moc
	EXPECT_CALL(*mSpriteController, createSprite())		EXPECT_CALL(*mSpriteController, createSprite())
	.WillOnce(Return(mPointerSprite));		.WillOnce(Return(mPointerSprite));

	mPointerController = PointerController::create(mPolicy, mLooper, *mSpriteController);		mPointerController =
			PointerController::create(mPolicy, mLooper, mSpriteController, /enabled=*/true);
	}		}

	PointerControllerTest::~PointerControllerTest() {		PointerControllerTest::~PointerControllerTest() {
	@@ -321,6 +322,7 @@ public:
	const sp<Looper>& looper, SpriteController& spriteController)		const sp<Looper>& looper, SpriteController& spriteController)
	: PointerController(		: PointerController(
	new MockPointerControllerPolicyInterface(), looper, spriteController,		new MockPointerControllerPolicyInterface(), looper, spriteController,
			/enabled=/true,
	[&registeredListener](const sp<android::gui::WindowInfosListener>& listener) {		[&registeredListener](const sp<android::gui::WindowInfosListener>& listener) {
	// Register listener		// Register listener
	registeredListener = listener;		registeredListener = listener;

services/core/jni/com_android_server_input_InputManagerService.cpp

+8 −2

Original line number	Original line	Diff line number	Diff line
	@@ -733,7 +733,13 @@ std::shared_ptr<PointerControllerInterface> NativeInputManager::obtainPointerCon
	if (controller == nullptr) {		if (controller == nullptr) {
	ensureSpriteControllerLocked();		ensureSpriteControllerLocked();

	controller = PointerController::create(this, mLooper, *mLocked.spriteController);		static const bool ENABLE_POINTER_CHOREOGRAPHER =
			sysprop::InputProperties::enable_pointer_choreographer().value_or(false);

			// Disable the functionality of the legacy PointerController if PointerChoreographer is
			// enabled.
			controller = PointerController::create(this, mLooper, *mLocked.spriteController,
			/enabled=/!ENABLE_POINTER_CHOREOGRAPHER);
	mLocked.legacyPointerController = controller;		mLocked.legacyPointerController = controller;
	updateInactivityTimeoutLocked();		updateInactivityTimeoutLocked();
	}		}
	@@ -745,7 +751,7 @@ std::shared_ptr<PointerControllerInterface> NativeInputManager::createPointerCon
	std::scoped_lock _l(mLock);		std::scoped_lock _l(mLock);
	ensureSpriteControllerLocked();		ensureSpriteControllerLocked();
	std::shared_ptr<PointerController> pc =		std::shared_ptr<PointerController> pc =
	PointerController::create(this, mLooper, *mLocked.spriteController);		PointerController::create(this, mLooper, mLocked.spriteController, /enabled=*/true);
	mLocked.pointerControllers.emplace_back(pc);		mLocked.pointerControllers.emplace_back(pc);
	return pc;		return pc;
	}		}