Merge "SurfaceFlinger: Cache updateInputWindows call" into rvc-dev am: 1d2d8b0365 (91eba0ee) · Commits · e / os / android_frameworks_native

services/surfaceflinger/BufferLayer.cpp

+4 −0

Original line number	Original line	Diff line number	Diff line
	@@ -485,6 +485,10 @@ bool BufferLayer::latchBuffer(bool& recomputeVisibleRegions, nsecs_t latchTime,
	}		}
	}		}

			if (recomputeVisibleRegions == true) {
			maybeDirtyInput();
			}

	return true;		return true;
	}		}

services/surfaceflinger/Layer.cpp

+29 −0

Original line number	Original line	Diff line number	Diff line
	@@ -993,6 +993,9 @@ uint32_t Layer::doTransaction(uint32_t flags) {
	commitTransaction(c);		commitTransaction(c);
	mPendingStatesSnapshot = mPendingStates;		mPendingStatesSnapshot = mPendingStates;
	mCurrentState.callbackHandles = {};		mCurrentState.callbackHandles = {};

			maybeDirtyInput();

	return flags;		return flags;
	}		}

	@@ -2472,6 +2475,32 @@ Layer::FrameRateCompatibility Layer::FrameRate::convertCompatibility(int8_t comp
	}		}
	}		}

			bool Layer::maybeDirtyInput() {
			// No sense redirtying input.
			if (mFlinger->inputDirty()) return true;

			if (hasInput()) {
			mFlinger->dirtyInput();
			return true;
			}

			// If a child or relative dirties the input, no sense continuing to traverse
			// so we return early and halt the recursion. We traverse ourselves instead
			// of using traverse() so we can implement this early halt.
			for (const sp<Layer>& child : mDrawingChildren) {
			if (child->maybeDirtyInput()) {
			return true;
			}
			}
			for (const wp<Layer>& weakRelative : mDrawingState.zOrderRelatives) {
			sp<Layer> relative = weakRelative.promote();
			if (relative && relative->maybeDirtyInput()) {
			return true;
			}
			}
			return false;
			}

	// ---------------------------------------------------------------------------		// ---------------------------------------------------------------------------

	}; // namespace android		}; // namespace android

services/surfaceflinger/Layer.h

+4 −0

Original line number	Original line	Diff line number	Diff line
	@@ -997,6 +997,10 @@ protected:
	// Window types from WindowManager.LayoutParams		// Window types from WindowManager.LayoutParams
	const int mWindowType;		const int mWindowType;

			// Called when mDrawingState has changed. If we or one of our children/relatives hasInput()
			// then we will dirty the setInputWindows cache.
			bool maybeDirtyInput();

	private:		private:
	/**		/**
	* Returns an unsorted vector of all layers that are part of this tree.		* Returns an unsorted vector of all layers that are part of this tree.

services/surfaceflinger/SurfaceFlinger.cpp

+15 −0

Original line number	Original line	Diff line number	Diff line
	@@ -2779,6 +2779,19 @@ void SurfaceFlinger::updateInputFlinger() {
	void SurfaceFlinger::updateInputWindowInfo() {		void SurfaceFlinger::updateInputWindowInfo() {
	std::vector<InputWindowInfo> inputHandles;		std::vector<InputWindowInfo> inputHandles;

			// We use a simple caching algorithm here. mInputDirty begins as true,
			// after we call setInputWindows we set it to false, so
			// in the future we wont call it again.. We set input dirty to true again
			// when any layer that hasInput() has a transaction performed on it
			// or when any parent or relative parent of such a layer has a transaction
			// performed on it. Not all of these transactions will really result in
			// input changes but all input changes will spring from these transactions
			// so the cache is safe but not optimal. It seems like it might be annoyingly
			// costly to cache and comapre the actual InputWindowHandle vector though.
			if (!mInputDirty) {
			return;
			}

	mDrawingState.traverseInReverseZOrder([&](Layer* layer) {		mDrawingState.traverseInReverseZOrder([&](Layer* layer) {
	if (layer->hasInput()) {		if (layer->hasInput()) {
	// When calculating the screen bounds we ignore the transparent region since it may		// When calculating the screen bounds we ignore the transparent region since it may
	@@ -2790,6 +2803,8 @@ void SurfaceFlinger::updateInputWindowInfo() {
	mInputFlinger->setInputWindows(inputHandles,		mInputFlinger->setInputWindows(inputHandles,
	mInputWindowCommands.syncInputWindows ? mSetInputWindowsListener		mInputWindowCommands.syncInputWindows ? mSetInputWindowsListener
	: nullptr);		: nullptr);

			mInputDirty = false;
	}		}

	void SurfaceFlinger::commitInputWindowCommands() {		void SurfaceFlinger::commitInputWindowCommands() {

services/surfaceflinger/SurfaceFlinger.h

+5 −0

Original line number	Original line	Diff line number	Diff line
	@@ -1235,6 +1235,11 @@ private:
	// janky frames there are.		// janky frames there are.
	nsecs_t mMissedFrameJankStart = 0;		nsecs_t mMissedFrameJankStart = 0;
	int32_t mMissedFrameJankCount = 0;		int32_t mMissedFrameJankCount = 0;

			// See updateInputWindowInfo() for details
			std::atomic<bool> mInputDirty = true;
			void dirtyInput() { mInputDirty = true; }
			bool inputDirty() { return mInputDirty; }
	};		};

	} // namespace android		} // namespace android