Revert "SurfaceView: Synchronize all surface view changes with V..." (8dfd38ad) · Commits · e / os / android_frameworks_base

core/java/android/view/SurfaceView.java

+117 −86

Original line number	Original line	Diff line number	Diff line
	@@ -133,8 +133,9 @@ public class SurfaceView extends View implements ViewRootImpl.SurfaceChangedCall
	private boolean mDisableBackgroundLayer = false;		private boolean mDisableBackgroundLayer = false;

	/**		/**
	* We use this lock to protect access to mSurfaceControl. Both are accessed on the UI		* We use this lock to protect access to mSurfaceControl and
	* thread and the render thread via RenderNode.PositionUpdateListener#positionLost.		* SurfaceViewPositionUpdateListener#mPositionChangedTransaction. Both are accessed on the UI
			* thread and the render thread.
	*/		*/
	final Object mSurfaceControlLock = new Object();		final Object mSurfaceControlLock = new Object();
	final Rect mTmpRect = new Rect();		final Rect mTmpRect = new Rect();
	@@ -223,6 +224,12 @@ public class SurfaceView extends View implements ViewRootImpl.SurfaceChangedCall
	private final SurfaceControl.Transaction mFrameCallbackTransaction =		private final SurfaceControl.Transaction mFrameCallbackTransaction =
	new SurfaceControl.Transaction();		new SurfaceControl.Transaction();

			/**
			* A temporary transaction holder that should only be used when applying right away. There
			* should be no assumption about thread safety for this transaction.
			*/
			private final SurfaceControl.Transaction mTmpTransaction = new SurfaceControl.Transaction();

	private int mParentSurfaceSequenceId;		private int mParentSurfaceSequenceId;

	private RemoteAccessibilityController mRemoteAccessibilityController =		private RemoteAccessibilityController mRemoteAccessibilityController =
	@@ -753,7 +760,7 @@ public class SurfaceView extends View implements ViewRootImpl.SurfaceChangedCall
	mBlastBufferQueue = null;		mBlastBufferQueue = null;
	}		}

	final Transaction transaction = new Transaction();		Transaction transaction = new Transaction();
	if (mSurfaceControl != null) {		if (mSurfaceControl != null) {
	transaction.remove(mSurfaceControl);		transaction.remove(mSurfaceControl);
	mSurfaceControl = null;		mSurfaceControl = null;
	@@ -783,18 +790,22 @@ public class SurfaceView extends View implements ViewRootImpl.SurfaceChangedCall
	// synchronously otherwise we may see flickers.		// synchronously otherwise we may see flickers.
	// When the listener is updated, we will get at least a single position update call so we can		// When the listener is updated, we will get at least a single position update call so we can
	// guarantee any changes we post will be applied.		// guarantee any changes we post will be applied.
	private void replacePositionUpdateListener(int surfaceWidth, int surfaceHeight) {		private void replacePositionUpdateListener(int surfaceWidth, int surfaceHeight,
			Transaction geometryTransaction) {
	if (mPositionListener != null) {		if (mPositionListener != null) {
	mRenderNode.removePositionUpdateListener(mPositionListener);		mRenderNode.removePositionUpdateListener(mPositionListener);
			synchronized (mSurfaceControlLock) {
			geometryTransaction = mPositionListener.getTransaction().merge(geometryTransaction);
			}
	}		}
	mPositionListener = new SurfaceViewPositionUpdateListener(surfaceWidth, surfaceHeight,		mPositionListener = new SurfaceViewPositionUpdateListener(surfaceWidth, surfaceHeight,
	mSurfaceControl);		geometryTransaction);
	mRenderNode.addPositionUpdateListener(mPositionListener);		mRenderNode.addPositionUpdateListener(mPositionListener);
	}		}

	private boolean performSurfaceTransaction(ViewRootImpl viewRoot, Translator translator,		private boolean performSurfaceTransaction(ViewRootImpl viewRoot, Translator translator,
	boolean creating, boolean sizeChanged, boolean hintChanged,		boolean creating, boolean sizeChanged, boolean hintChanged,
	Transaction surfaceUpdateTransaction) {		Transaction geometryTransaction) {
	boolean realSizeChanged = false;		boolean realSizeChanged = false;

	mSurfaceLock.lock();		mSurfaceLock.lock();
	@@ -809,60 +820,59 @@ public class SurfaceView extends View implements ViewRootImpl.SurfaceChangedCall
	// SurfaceChangedCallback to update the relative z. This is needed so that		// SurfaceChangedCallback to update the relative z. This is needed so that
	// we do not change the relative z before the server is ready to swap the		// we do not change the relative z before the server is ready to swap the
	// parent surface.		// parent surface.
	if (creating) {		if (creating \|\| (mParentSurfaceSequenceId == viewRoot.getSurfaceSequenceId())) {
	updateRelativeZ(surfaceUpdateTransaction);		updateRelativeZ(mTmpTransaction);
	if (mSurfacePackage != null) {
	reparentSurfacePackage(surfaceUpdateTransaction, mSurfacePackage);
	}
	}		}
	mParentSurfaceSequenceId = viewRoot.getSurfaceSequenceId();		mParentSurfaceSequenceId = viewRoot.getSurfaceSequenceId();

	if (mViewVisibility) {		if (mViewVisibility) {
	surfaceUpdateTransaction.show(mSurfaceControl);		geometryTransaction.show(mSurfaceControl);
	} else {		} else {
	surfaceUpdateTransaction.hide(mSurfaceControl);		geometryTransaction.hide(mSurfaceControl);
	}		}

			if (mSurfacePackage != null) {
			reparentSurfacePackage(mTmpTransaction, mSurfacePackage);
			}

			updateBackgroundVisibility(mTmpTransaction);
	updateBackgroundVisibility(surfaceUpdateTransaction);		updateBackgroundColor(mTmpTransaction);
	updateBackgroundColor(surfaceUpdateTransaction);
	if (mUseAlpha) {		if (mUseAlpha) {
	float alpha = getFixedAlpha();		float alpha = getFixedAlpha();
	surfaceUpdateTransaction.setAlpha(mSurfaceControl, alpha);		mTmpTransaction.setAlpha(mSurfaceControl, alpha);
	mSurfaceAlpha = alpha;		mSurfaceAlpha = alpha;
	}		}

	surfaceUpdateTransaction.setCornerRadius(mSurfaceControl, mCornerRadius);		geometryTransaction.setCornerRadius(mSurfaceControl, mCornerRadius);
	if ((sizeChanged \|\| hintChanged) && !creating) {		if ((sizeChanged \|\| hintChanged) && !creating) {
	setBufferSize(surfaceUpdateTransaction);		setBufferSize(geometryTransaction);
	}		}
	if (sizeChanged \|\| creating \|\| !isHardwareAccelerated()) {		if (sizeChanged \|\| creating \|\| !isHardwareAccelerated()) {
			onSetSurfacePositionAndScaleRT(geometryTransaction, mSurfaceControl,
			mScreenRect.left, /positionLeft/
			mScreenRect.top /positionTop/ ,
			mScreenRect.width() / (float) mSurfaceWidth /postScaleX/,
			mScreenRect.height() / (float) mSurfaceHeight /postScaleY/);

	// Set a window crop when creating the surface or changing its size to		// Set a window crop when creating the surface or changing its size to
	// crop the buffer to the surface size since the buffer producer may		// crop the buffer to the surface size since the buffer producer may
	// use SCALING_MODE_SCALE and submit a larger size than the surface		// use SCALING_MODE_SCALE and submit a larger size than the surface
	// size.		// size.
	if (mClipSurfaceToBounds && mClipBounds != null) {		if (mClipSurfaceToBounds && mClipBounds != null) {
	surfaceUpdateTransaction.setWindowCrop(mSurfaceControl, mClipBounds);		geometryTransaction.setWindowCrop(mSurfaceControl, mClipBounds);
	} else {		} else {
	surfaceUpdateTransaction.setWindowCrop(mSurfaceControl, mSurfaceWidth,		geometryTransaction.setWindowCrop(mSurfaceControl, mSurfaceWidth,
	mSurfaceHeight);		mSurfaceHeight);
	}		}

	surfaceUpdateTransaction.setDesintationFrame(mBlastSurfaceControl, mSurfaceWidth,		geometryTransaction.setDesintationFrame(mBlastSurfaceControl, mSurfaceWidth,
	mSurfaceHeight);		mSurfaceHeight);

	if (isHardwareAccelerated()) {		if (isHardwareAccelerated()) {
	// This will consume the passed in transaction and the transaction will be		// This will consume the passed in transaction and the transaction will be
	// applied on a render worker thread.		// applied on a render worker thread.
	replacePositionUpdateListener(mSurfaceWidth, mSurfaceHeight);		replacePositionUpdateListener(mSurfaceWidth, mSurfaceHeight,
	} else {		geometryTransaction);
	onSetSurfacePositionAndScale(surfaceUpdateTransaction, mSurfaceControl,
	mScreenRect.left /positionLeft/,
	mScreenRect.top /positionTop/,
	mScreenRect.width() / (float) mSurfaceWidth /postScaleX/,
	mScreenRect.height() / (float) mSurfaceHeight /postScaleY/);
	}		}
	if (DEBUG_POSITION) {		if (DEBUG_POSITION) {
	Log.d(TAG, String.format(		Log.d(TAG, String.format(
	@@ -874,7 +884,8 @@ public class SurfaceView extends View implements ViewRootImpl.SurfaceChangedCall
	mScreenRect.bottom, mSurfaceWidth, mSurfaceHeight));		mScreenRect.bottom, mSurfaceWidth, mSurfaceHeight));
	}		}
	}		}
	applyTransactionOnVriDraw(surfaceUpdateTransaction);		mTmpTransaction.merge(geometryTransaction);
			mTmpTransaction.apply();
	updateEmbeddedAccessibilityMatrix();		updateEmbeddedAccessibilityMatrix();

	mSurfaceFrame.left = 0;		mSurfaceFrame.left = 0;
	@@ -982,17 +993,17 @@ public class SurfaceView extends View implements ViewRootImpl.SurfaceChangedCall
	mScreenRect.offset(surfaceInsets.left, surfaceInsets.top);		mScreenRect.offset(surfaceInsets.left, surfaceInsets.top);
	// Collect all geometry changes and apply these changes on the RenderThread worker		// Collect all geometry changes and apply these changes on the RenderThread worker
	// via the RenderNode.PositionUpdateListener.		// via the RenderNode.PositionUpdateListener.
	final Transaction surfaceUpdateTransaction = new Transaction();		final Transaction geometryTransaction = new Transaction();
	if (creating) {		if (creating) {
	updateOpaqueFlag();		updateOpaqueFlag();
	final String name = "SurfaceView[" + viewRoot.getTitle().toString() + "]";		final String name = "SurfaceView[" + viewRoot.getTitle().toString() + "]";
	createBlastSurfaceControls(viewRoot, name, surfaceUpdateTransaction);		createBlastSurfaceControls(viewRoot, name, geometryTransaction);
	} else if (mSurfaceControl == null) {		} else if (mSurfaceControl == null) {
	return;		return;
	}		}

	final boolean realSizeChanged = performSurfaceTransaction(viewRoot,		final boolean realSizeChanged = performSurfaceTransaction(viewRoot,
	translator, creating, sizeChanged, hintChanged, surfaceUpdateTransaction);		translator, creating, sizeChanged, hintChanged, geometryTransaction);
	final boolean redrawNeeded = sizeChanged \|\| creating \|\| hintChanged		final boolean redrawNeeded = sizeChanged \|\| creating \|\| hintChanged
	\|\| (mVisible && !mDrawFinished);		\|\| (mVisible && !mDrawFinished);

	@@ -1128,7 +1139,7 @@ public class SurfaceView extends View implements ViewRootImpl.SurfaceChangedCall
	*		*
	*/		*/
	private void createBlastSurfaceControls(ViewRootImpl viewRoot, String name,		private void createBlastSurfaceControls(ViewRootImpl viewRoot, String name,
	Transaction surfaceUpdateTransaction) {		Transaction geometryTransaction) {
	if (mSurfaceControl == null) {		if (mSurfaceControl == null) {
	mSurfaceControl = new SurfaceControl.Builder(mSurfaceSession)		mSurfaceControl = new SurfaceControl.Builder(mSurfaceSession)
	.setName(name)		.setName(name)
	@@ -1151,10 +1162,11 @@ public class SurfaceView extends View implements ViewRootImpl.SurfaceChangedCall
	.build();		.build();
	} else {		} else {
	// update blast layer		// update blast layer
	surfaceUpdateTransaction		mTmpTransaction
	.setOpaque(mBlastSurfaceControl, (mSurfaceFlags & SurfaceControl.OPAQUE) != 0)		.setOpaque(mBlastSurfaceControl, (mSurfaceFlags & SurfaceControl.OPAQUE) != 0)
	.setSecure(mBlastSurfaceControl, (mSurfaceFlags & SurfaceControl.SECURE) != 0)		.setSecure(mBlastSurfaceControl, (mSurfaceFlags & SurfaceControl.SECURE) != 0)
	.show(mBlastSurfaceControl);		.show(mBlastSurfaceControl)
			.apply();
	}		}

	if (mBackgroundControl == null) {		if (mBackgroundControl == null) {
	@@ -1201,7 +1213,7 @@ public class SurfaceView extends View implements ViewRootImpl.SurfaceChangedCall
	*		*
	* @hide		* @hide
	*/		*/
	protected void onSetSurfacePositionAndScale(@NonNull Transaction transaction,		protected void onSetSurfacePositionAndScaleRT(@NonNull Transaction transaction,
	@NonNull SurfaceControl surface, int positionLeft, int positionTop,		@NonNull SurfaceControl surface, int positionLeft, int positionTop,
	float postScaleX, float postScaleY) {		float postScaleX, float postScaleY) {
	transaction.setPosition(surface, positionLeft, positionTop);		transaction.setPosition(surface, positionLeft, positionTop);
	@@ -1214,14 +1226,12 @@ public class SurfaceView extends View implements ViewRootImpl.SurfaceChangedCall
	if (mSurfaceControl == null) {		if (mSurfaceControl == null) {
	return;		return;
	}		}
	final Transaction transaction = new Transaction();		onSetSurfacePositionAndScaleRT(mTmpTransaction, mSurfaceControl,
	onSetSurfacePositionAndScale(transaction, mSurfaceControl,
	mScreenRect.left, /positionLeft/		mScreenRect.left, /positionLeft/
	mScreenRect.top/positionTop/ ,		mScreenRect.top/positionTop/ ,
	mScreenRect.width() / (float) mSurfaceWidth /postScaleX/,		mScreenRect.width() / (float) mSurfaceWidth /postScaleX/,
	mScreenRect.height() / (float) mSurfaceHeight /postScaleY/);		mScreenRect.height() / (float) mSurfaceHeight /postScaleY/);
	applyTransactionOnVriDraw(transaction);		mTmpTransaction.apply();
	invalidate();
	}		}

	/**		/**
	@@ -1243,31 +1253,39 @@ public class SurfaceView extends View implements ViewRootImpl.SurfaceChangedCall
	}		}
	}		}

	private final Rect mRTLastReportedPosition = new Rect();		private Rect mRTLastReportedPosition = new Rect();
	private final Point mRTLastReportedSurfaceSize = new Point();		private Point mRTLastReportedSurfaceSize = new Point();

	private class SurfaceViewPositionUpdateListener implements RenderNode.PositionUpdateListener {		private class SurfaceViewPositionUpdateListener implements RenderNode.PositionUpdateListener {
	private final int mRtSurfaceWidth;		int mRtSurfaceWidth = -1;
	private final int mRtSurfaceHeight;		int mRtSurfaceHeight = -1;
	private final SurfaceControl.Transaction mPositionChangedTransaction =		private final SurfaceControl.Transaction mPositionChangedTransaction =
	new SurfaceControl.Transaction();		new SurfaceControl.Transaction();
	private final SurfaceControl mRtSurfaceControl = new SurfaceControl();		boolean mPendingTransaction = false;

	SurfaceViewPositionUpdateListener(int surfaceWidth, int surfaceHeight,		SurfaceViewPositionUpdateListener(int surfaceWidth, int surfaceHeight,
	SurfaceControl surfaceControl) {		@Nullable Transaction t) {
	mRtSurfaceWidth = surfaceWidth;		mRtSurfaceWidth = surfaceWidth;
	mRtSurfaceHeight = surfaceHeight;		mRtSurfaceHeight = surfaceHeight;
	mRtSurfaceControl.copyFrom(surfaceControl, "SurfaceViewPositionUpdateListener");		if (t != null) {
			mPositionChangedTransaction.merge(t);
			mPendingTransaction = true;
			}
	}		}

	@Override		@Override
	public void positionChanged(long frameNumber, int left, int top, int right, int bottom) {		public void positionChanged(long frameNumber, int left, int top, int right, int bottom) {
			synchronized(mSurfaceControlLock) {
			if (mSurfaceControl == null) {
			return;
			}
	if (mRTLastReportedPosition.left == left		if (mRTLastReportedPosition.left == left
	&& mRTLastReportedPosition.top == top		&& mRTLastReportedPosition.top == top
	&& mRTLastReportedPosition.right == right		&& mRTLastReportedPosition.right == right
	&& mRTLastReportedPosition.bottom == bottom		&& mRTLastReportedPosition.bottom == bottom
	&& mRTLastReportedSurfaceSize.x == mRtSurfaceWidth		&& mRTLastReportedSurfaceSize.x == mRtSurfaceWidth
	&& mRTLastReportedSurfaceSize.y == mRtSurfaceHeight) {		&& mRTLastReportedSurfaceSize.y == mRtSurfaceHeight
			&& !mPendingTransaction) {
	return;		return;
	}		}
	try {		try {
	@@ -1280,7 +1298,7 @@ public class SurfaceView extends View implements ViewRootImpl.SurfaceChangedCall
	}		}
	mRTLastReportedPosition.set(left, top, right, bottom);		mRTLastReportedPosition.set(left, top, right, bottom);
	mRTLastReportedSurfaceSize.set(mRtSurfaceWidth, mRtSurfaceHeight);		mRTLastReportedSurfaceSize.set(mRtSurfaceWidth, mRtSurfaceHeight);
	onSetSurfacePositionAndScale(mPositionChangedTransaction, mRtSurfaceControl,		onSetSurfacePositionAndScaleRT(mPositionChangedTransaction, mSurfaceControl,
	mRTLastReportedPosition.left /positionLeft/,		mRTLastReportedPosition.left /positionLeft/,
	mRTLastReportedPosition.top /positionTop/,		mRTLastReportedPosition.top /positionTop/,
	mRTLastReportedPosition.width()		mRTLastReportedPosition.width()
	@@ -1288,21 +1306,22 @@ public class SurfaceView extends View implements ViewRootImpl.SurfaceChangedCall
	mRTLastReportedPosition.height()		mRTLastReportedPosition.height()
	/ (float) mRtSurfaceHeight /postScaleY/);		/ (float) mRtSurfaceHeight /postScaleY/);
	if (mViewVisibility) {		if (mViewVisibility) {
	// b/131239825		mPositionChangedTransaction.show(mSurfaceControl);
	mPositionChangedTransaction.show(mRtSurfaceControl);
	}		}
	applyOrMergeTransaction(mPositionChangedTransaction, frameNumber);		applyOrMergeTransaction(mPositionChangedTransaction, frameNumber);
			mPendingTransaction = false;
	} catch (Exception ex) {		} catch (Exception ex) {
	Log.e(TAG, "Exception from repositionChild", ex);		Log.e(TAG, "Exception from repositionChild", ex);
	}		}
	}		}
			}

	@Override		@Override
	public void applyStretch(long frameNumber, float width, float height,		public void applyStretch(long frameNumber, float width, float height,
	float vecX, float vecY, float maxStretchX, float maxStretchY,		float vecX, float vecY, float maxStretchX, float maxStretchY,
	float childRelativeLeft, float childRelativeTop, float childRelativeRight,		float childRelativeLeft, float childRelativeTop, float childRelativeRight,
	float childRelativeBottom) {		float childRelativeBottom) {
	mRtTransaction.setStretchEffect(mRtSurfaceControl, width, height, vecX, vecY,		mRtTransaction.setStretchEffect(mSurfaceControl, width, height, vecX, vecY,
	maxStretchX, maxStretchY, childRelativeLeft, childRelativeTop,		maxStretchX, maxStretchY, childRelativeLeft, childRelativeTop,
	childRelativeRight, childRelativeBottom);		childRelativeRight, childRelativeBottom);
	applyOrMergeTransaction(mRtTransaction, frameNumber);		applyOrMergeTransaction(mRtTransaction, frameNumber);
	@@ -1317,14 +1336,28 @@ public class SurfaceView extends View implements ViewRootImpl.SurfaceChangedCall
	mRTLastReportedPosition.setEmpty();		mRTLastReportedPosition.setEmpty();
	mRTLastReportedSurfaceSize.set(-1, -1);		mRTLastReportedSurfaceSize.set(-1, -1);

	// positionLost can be called while UI thread is un-paused.		/**
			* positionLost can be called while UI thread is un-paused so we
			* need to hold the lock here.
			*/
	synchronized (mSurfaceControlLock) {		synchronized (mSurfaceControlLock) {
	if (mSurfaceControl == null) return;		if (mPendingTransaction) {
	// b/131239825		Log.w(TAG, System.identityHashCode(SurfaceView.this)
			+ "Pending transaction cleared.");
			mPositionChangedTransaction.clear();
			mPendingTransaction = false;
			}
			if (mSurfaceControl == null) {
			return;
			}
	mRtTransaction.hide(mSurfaceControl);		mRtTransaction.hide(mSurfaceControl);
	applyOrMergeTransaction(mRtTransaction, frameNumber);		applyOrMergeTransaction(mRtTransaction, frameNumber);
	}		}
	}		}

			public Transaction getTransaction() {
			return mPositionChangedTransaction;
			}
	}		}

	private SurfaceViewPositionUpdateListener mPositionListener = null;		private SurfaceViewPositionUpdateListener mPositionListener = null;
	@@ -1371,10 +1404,8 @@ public class SurfaceView extends View implements ViewRootImpl.SurfaceChangedCall
	* @hide		* @hide
	*/		*/
	public void setResizeBackgroundColor(int bgColor) {		public void setResizeBackgroundColor(int bgColor) {
	final SurfaceControl.Transaction transaction = new SurfaceControl.Transaction();		setResizeBackgroundColor(mTmpTransaction, bgColor);
	setResizeBackgroundColor(transaction, bgColor);		mTmpTransaction.apply();
	applyTransactionOnVriDraw(transaction);
	invalidate();
	}		}

	/**		/**

core/java/android/widget/inline/InlineContentView.java

+2 −3