Merge changes I5303a6a8,I1c90c74d (588ee9ff) · Commits · e / os / android_frameworks_base

packages/SystemUI/src/com/android/systemui/ScreenDecorations.java

+149 −44

Original line number	Diff line number	Diff line
		@@ -43,9 +43,12 @@ import android.graphics.PixelFormat;
		import android.graphics.Rect;
		import android.graphics.Region;
		import android.hardware.display.DisplayManager;
		import android.os.Handler;
		import android.os.HandlerThread;
		import android.os.SystemProperties;
		import android.provider.Settings.Secure;
		import android.util.DisplayMetrics;
		import android.util.Log;
		import android.view.DisplayCutout;
		import android.view.DisplayInfo;
		import android.view.Gravity;
		@@ -60,6 +63,7 @@ import android.view.WindowManager;
		import android.widget.FrameLayout;
		import android.widget.ImageView;

		import com.android.internal.util.Preconditions;
		import com.android.systemui.RegionInterceptingFrameLayout.RegionInterceptableView;
		import com.android.systemui.fragments.FragmentHostManager;
		import com.android.systemui.fragments.FragmentHostManager.FragmentListener;
		@@ -79,6 +83,9 @@ import androidx.annotation.VisibleForTesting;
		* for antialiasing and emulation purposes.
		*/
		public class ScreenDecorations extends SystemUI implements Tunable {
		private static final boolean DEBUG = false;
		private static final String TAG = "ScreenDecorations";

		public static final String SIZE = "sysui_rounded_size";
		public static final String PADDING = "sysui_rounded_content_padding";
		private static final boolean DEBUG_SCREENSHOT_ROUNDED_CORNERS =
		@@ -99,9 +106,23 @@ public class ScreenDecorations extends SystemUI implements Tunable {
		private DisplayCutoutView mCutoutBottom;
		private SecureSetting mColorInversionSetting;
		private boolean mPendingRotationChange;
		private Handler mHandler;

		@Override
		public void start() {
		mHandler = startHandlerThread();
		mHandler.post(this::startOnScreenDecorationsThread);
		setupStatusBarPaddingIfNeeded();
		}

		@VisibleForTesting
		Handler startHandlerThread() {
		HandlerThread thread = new HandlerThread("ScreenDecorations");
		thread.start();
		return thread.getThreadHandler();
		}

		private void startOnScreenDecorationsThread() {
		mWindowManager = mContext.getSystemService(WindowManager.class);
		mRoundedDefault = mContext.getResources().getDimensionPixelSize(
		R.dimen.rounded_corner_radius);
		@@ -113,12 +134,6 @@ public class ScreenDecorations extends SystemUI implements Tunable {
		setupDecorations();
		}

		int padding = mContext.getResources().getDimensionPixelSize(
		R.dimen.rounded_corner_content_padding);
		if (padding != 0) {
		setupPadding(padding);
		}

		mDisplayListener = new DisplayManager.DisplayListener() {
		@Override
		public void onDisplayAdded(int displayId) {
		@@ -132,8 +147,8 @@ public class ScreenDecorations extends SystemUI implements Tunable {

		@Override
		public void onDisplayChanged(int displayId) {
		if ((hasRoundedCorners() \|\| shouldDrawCutout()) &&
		mRotation != RotationUtils.getExactRotation(mContext)) {
		final int newRotation = RotationUtils.getExactRotation(mContext);
		if (mOverlay != null && mBottomOverlay != null && mRotation != newRotation) {
		// We cannot immediately update the orientation. Otherwise
		// WindowManager is still deferring layout until it has finished dispatching
		// the config changes, which may cause divergence between what we draw
		@@ -142,10 +157,15 @@ public class ScreenDecorations extends SystemUI implements Tunable {
		// - we are trying to redraw. This because WM resized our window and told us to.
		// - the config change has been dispatched, so WM is no longer deferring layout.
		mPendingRotationChange = true;
		if (DEBUG) {
		Log.i(TAG, "Rotation changed, deferring " + newRotation + ", staying at "
		+ mRotation);
		}

		mOverlay.getViewTreeObserver().addOnPreDrawListener(
		new RestartingPreDrawListener(mOverlay));
		new RestartingPreDrawListener(mOverlay, newRotation));
		mBottomOverlay.getViewTreeObserver().addOnPreDrawListener(
		new RestartingPreDrawListener(mBottomOverlay));
		new RestartingPreDrawListener(mBottomOverlay, newRotation));
		}
		updateOrientation();
		}
		@@ -154,7 +174,7 @@ public class ScreenDecorations extends SystemUI implements Tunable {
		mRotation = -1;
		mDisplayManager = (DisplayManager) mContext.getSystemService(
		Context.DISPLAY_SERVICE);
		mDisplayManager.registerDisplayListener(mDisplayListener, null);
		mDisplayManager.registerDisplayListener(mDisplayListener, mHandler);
		}

		private void setupDecorations() {
		@@ -184,10 +204,11 @@ public class ScreenDecorations extends SystemUI implements Tunable {
		mWindowManager.getDefaultDisplay().getMetrics(metrics);
		mDensity = metrics.density;

		Dependency.get(TunerService.class).addTunable(this, SIZE);
		Dependency.get(Dependency.MAIN_HANDLER).post(
		() -> Dependency.get(TunerService.class).addTunable(this, SIZE));

		// Watch color inversion and invert the overlay as needed.
		mColorInversionSetting = new SecureSetting(mContext, Dependency.get(Dependency.MAIN_HANDLER),
		mColorInversionSetting = new SecureSetting(mContext, mHandler,
		Secure.ACCESSIBILITY_DISPLAY_INVERSION_ENABLED) {
		@Override
		protected void handleValueChanged(int value, boolean observedChange) {
		@@ -199,7 +220,7 @@ public class ScreenDecorations extends SystemUI implements Tunable {

		IntentFilter filter = new IntentFilter();
		filter.addAction(Intent.ACTION_USER_SWITCHED);
		mContext.registerReceiver(mIntentReceiver, filter);
		mContext.registerReceiver(mIntentReceiver, filter, null /* permission */, mHandler);

		mOverlay.addOnLayoutChangeListener(new OnLayoutChangeListener() {
		@Override
		@@ -217,6 +238,11 @@ public class ScreenDecorations extends SystemUI implements Tunable {
		.start();
		}
		});

		mOverlay.getViewTreeObserver().addOnPreDrawListener(
		new ValidatingPreDrawListener(mOverlay));
		mBottomOverlay.getViewTreeObserver().addOnPreDrawListener(
		new ValidatingPreDrawListener(mBottomOverlay));
		}

		private final BroadcastReceiver mIntentReceiver = new BroadcastReceiver() {
		@@ -246,14 +272,28 @@ public class ScreenDecorations extends SystemUI implements Tunable {

		@Override
		protected void onConfigurationChanged(Configuration newConfig) {
		mHandler.post(() -> {
		int oldRotation = mRotation;
		mPendingRotationChange = false;
		updateOrientation();
		if (DEBUG) Log.i(TAG, "onConfigChanged from rot " + oldRotation + " to " + mRotation);
		if (shouldDrawCutout() && mOverlay == null) {
		setupDecorations();
		}
		if (mOverlay != null) {
		// Updating the layout params ensures that ViewRootImpl will call relayoutWindow(),
		// which ensures that the forced seamless rotation will end, even if we updated
		// the rotation before window manager was ready (and was still waiting for sending
		// the updated rotation).
		updateLayoutParams();
		}
		});
		}

		protected void updateOrientation() {
		private void updateOrientation() {
		Preconditions.checkState(mHandler.getLooper().getThread() == Thread.currentThread(),
		"must call on " + mHandler.getLooper().getThread()
		+ ", but was " + Thread.currentThread());
		if (mPendingRotationChange) {
		return;
		}
		@@ -333,7 +373,19 @@ public class ScreenDecorations extends SystemUI implements Tunable {
		com.android.internal.R.bool.config_fillMainBuiltInDisplayCutout);
		}

		private void setupPadding(int padding) {

		private void setupStatusBarPaddingIfNeeded() {
		// TODO: This should be moved to a more appropriate place, as it is not related to the
		// screen decorations overlay.
		int padding = mContext.getResources().getDimensionPixelSize(
		R.dimen.rounded_corner_content_padding);
		if (padding != 0) {
		setupStatusBarPadding(padding);
		}

		}

		private void setupStatusBarPadding(int padding) {
		// Add some padding to all the content near the edge of the screen.
		StatusBar sb = getComponent(StatusBar.class);
		View statusBar = (sb != null ? sb.getStatusBarWindow() : null);
		@@ -402,6 +454,7 @@ public class ScreenDecorations extends SystemUI implements Tunable {

		@Override
		public void onTuningChanged(String key, String newValue) {
		mHandler.post(() -> {
		if (mOverlay == null) return;
		if (SIZE.equals(key)) {
		int size = mRoundedDefault;
		@@ -426,6 +479,7 @@ public class ScreenDecorations extends SystemUI implements Tunable {
		setSize(mBottomOverlay.findViewById(R.id.left), sizeBottom);
		setSize(mBottomOverlay.findViewById(R.id.right), sizeBottom);
		}
		});
		}

		private void setSize(View view, int pixelSize) {
		@@ -484,6 +538,11 @@ public class ScreenDecorations extends SystemUI implements Tunable {
		mVisibilityChangedListener = visibilityChangedListener;
		mDecorations = decorations;
		setId(R.id.display_cutout);
		if (DEBUG) {
		getViewTreeObserver().addOnDrawListener(() -> Log.i(TAG,
		(mInitialStart ? "OverlayTop" : "OverlayBottom")
		+ " drawn in rot " + mRotation));
		}
		}

		public void setColor(int color) {
		@@ -719,20 +778,66 @@ public class ScreenDecorations extends SystemUI implements Tunable {
		private class RestartingPreDrawListener implements ViewTreeObserver.OnPreDrawListener {

		private final View mView;
		private final int mTargetRotation;

		private RestartingPreDrawListener(View view) {
		private RestartingPreDrawListener(View view, int targetRotation) {
		mView = view;
		mTargetRotation = targetRotation;
		}

		@Override
		public boolean onPreDraw() {
		mPendingRotationChange = false;
		mView.getViewTreeObserver().removeOnPreDrawListener(this);

		if (mTargetRotation == mRotation) {
		if (DEBUG) {
		Log.i(TAG, (mView == mOverlay ? "OverlayTop" : "OverlayBottom")
		+ " already in target rot "
		+ mTargetRotation + ", allow draw without restarting it");
		}
		return true;
		}

		mPendingRotationChange = false;
		// This changes the window attributes - we need to restart the traversal for them to
		// take effect.
		updateOrientation();
		if (DEBUG) {
		Log.i(TAG, (mView == mOverlay ? "OverlayTop" : "OverlayBottom")
		+ " restarting listener fired, restarting draw for rot " + mRotation);
		}
		mView.invalidate();
		return false;
		}
		}

		/**
		* A pre-draw listener, that validates that the rotation we draw in matches the displays
		* rotation before continuing the draw.
		*
		* This is to prevent a race condition, where we have not received the display changed event
		* yet, and would thus draw in an old orientation.
		*/
		private class ValidatingPreDrawListener implements ViewTreeObserver.OnPreDrawListener {

		private final View mView;

		public ValidatingPreDrawListener(View view) {
		mView = view;
		}

		@Override
		public boolean onPreDraw() {
		final int displayRotation = RotationUtils.getExactRotation(mContext);
		if (displayRotation != mRotation && !mPendingRotationChange) {
		if (DEBUG) {
		Log.i(TAG, "Drawing rot " + mRotation + ", but display is at rot "
		+ displayRotation + ". Restarting draw");
		}
		mView.invalidate();
		return false;
		}
		return true;
		}
		}
		}

packages/SystemUI/tests/src/com/android/systemui/ScreenDecorationsTest.java

+32 −1

Original line number	Diff line number	Diff line
		@@ -34,8 +34,10 @@ import static org.mockito.Mockito.when;

		import android.app.Fragment;
		import android.content.res.Configuration;
		import android.os.Handler;
		import android.support.test.filters.SmallTest;
		import android.testing.AndroidTestingRunner;
		import android.testing.TestableLooper;
		import android.testing.TestableLooper.RunWithLooper;
		import android.view.Display;
		import android.view.View;
		@@ -60,6 +62,7 @@ import org.junit.runner.RunWith;
		@SmallTest
		public class ScreenDecorationsTest extends SysuiTestCase {

		private TestableLooper mTestableLooper;
		private ScreenDecorations mScreenDecorations;
		private StatusBar mStatusBar;
		private WindowManager mWindowManager;
		@@ -71,6 +74,10 @@ public class ScreenDecorationsTest extends SysuiTestCase {

		@Before
		public void setup() {
		mTestableLooper = TestableLooper.get(this);
		mDependency.injectTestDependency(Dependency.MAIN_HANDLER,
		new Handler(mTestableLooper.getLooper()));

		mStatusBar = mock(StatusBar.class);
		mWindowManager = mock(WindowManager.class);
		mView = spy(new StatusBarWindowView(mContext, null));
		@@ -88,7 +95,31 @@ public class ScreenDecorationsTest extends SysuiTestCase {

		mTunerService = mDependency.injectMockDependency(TunerService.class);

		mScreenDecorations = new ScreenDecorations();

		mScreenDecorations = new ScreenDecorations() {
		@Override
		public void start() {
		super.start();
		mTestableLooper.processAllMessages();
		}

		@Override
		Handler startHandlerThread() {
		return new Handler(mTestableLooper.getLooper());
		}

		@Override
		protected void onConfigurationChanged(Configuration newConfig) {
		super.onConfigurationChanged(newConfig);
		mTestableLooper.processAllMessages();
		}

		@Override
		public void onTuningChanged(String key, String newValue) {
		super.onTuningChanged(key, newValue);
		mTestableLooper.processAllMessages();
		}
		};
		mScreenDecorations.mContext = mContext;
		mScreenDecorations.mComponents = mContext.getComponents();

services/core/java/com/android/server/wm/ForcedSeamlessRotator.java

+31 −0

Original line number	Diff line number	Diff line
		@@ -21,9 +21,13 @@ import static android.view.Surface.ROTATION_90;

		import android.graphics.Matrix;
		import android.view.DisplayInfo;
		import android.view.Surface.Rotation;

		import com.android.server.wm.utils.CoordinateTransforms;

		import java.io.PrintWriter;
		import java.io.StringWriter;

		/**
		* Helper class for forced seamless rotation.
		*
		@@ -37,8 +41,13 @@ public class ForcedSeamlessRotator {

		private final Matrix mTransform = new Matrix();
		private final float[] mFloat9 = new float[9];
		private final int mOldRotation;
		private final int mNewRotation;

		public ForcedSeamlessRotator(int oldRotation, int newRotation, DisplayInfo info) {
		mOldRotation = oldRotation;
		mNewRotation = newRotation;

		final boolean flipped = info.rotation == ROTATION_90 \|\| info.rotation == ROTATION_270;
		final int h = flipped ? info.logicalWidth : info.logicalHeight;
		final int w = flipped ? info.logicalHeight : info.logicalWidth;
		@@ -57,6 +66,16 @@ public class ForcedSeamlessRotator {
		token.getPendingTransaction().setMatrix(token.getSurfaceControl(), mTransform, mFloat9);
		}

		/**
		* Returns the rotation of the display before it started rotating.
		*
		* @return the old rotation of the display
		*/
		@Rotation
		public int getOldRotation() {
		return mOldRotation;
		}

		/**
		* Removes the transform to the window token's surface that undoes the effect of the global
		* display rotation.
		@@ -77,4 +96,16 @@ public class ForcedSeamlessRotator {
		win.getFrameNumber());
		}
		}

		public void dump(PrintWriter pw) {
		pw.print("{old="); pw.print(mOldRotation); pw.print(", new="); pw.print(mNewRotation);
		pw.print("}");
		}

		@Override
		public String toString() {
		StringWriter sw = new StringWriter();
		dump(new PrintWriter(sw));
		return "ForcedSeamlessRotator" + sw.toString();
		}
		}

services/core/java/com/android/server/wm/WindowManagerService.java

+1 −0

Original line number	Diff line number	Diff line
		@@ -1901,6 +1901,7 @@ public class WindowManagerService extends IWindowManager.Stub
		// TODO(b/111504081): Consolidate seamless rotation logic.
		if (win.mPendingForcedSeamlessRotate != null && !mWaitingForConfig) {
		win.mPendingForcedSeamlessRotate.finish(win.mToken, win);
		win.mFinishForcedSeamlessRotateFrameNumber = win.getFrameNumber();
		win.mPendingForcedSeamlessRotate = null;
		}

services/core/java/com/android/server/wm/WindowState.java

+22 −0

Original line number	Diff line number	Diff line
		@@ -122,6 +122,7 @@ import static com.android.server.wm.WindowStateProto.CHILD_WINDOWS;
		import static com.android.server.wm.WindowStateProto.CONTENT_INSETS;
		import static com.android.server.wm.WindowStateProto.DESTROYING;
		import static com.android.server.wm.WindowStateProto.DISPLAY_ID;
		import static com.android.server.wm.WindowStateProto.FINISHED_FORCED_SEAMLESS_ROTATION_FRAME;
		import static com.android.server.wm.WindowStateProto.GIVEN_CONTENT_INSETS;
		import static com.android.server.wm.WindowStateProto.HAS_SURFACE;
		import static com.android.server.wm.WindowStateProto.IDENTIFIER;
		@@ -130,6 +131,7 @@ import static com.android.server.wm.WindowStateProto.IS_READY_FOR_DISPLAY;
		import static com.android.server.wm.WindowStateProto.IS_VISIBLE;
		import static com.android.server.wm.WindowStateProto.OUTSETS;
		import static com.android.server.wm.WindowStateProto.OVERSCAN_INSETS;
		import static com.android.server.wm.WindowStateProto.PENDING_FORCED_SEAMLESS_ROTATION;
		import static com.android.server.wm.WindowStateProto.REMOVED;
		import static com.android.server.wm.WindowStateProto.REMOVE_ON_EXIT;
		import static com.android.server.wm.WindowStateProto.REQUESTED_HEIGHT;
		@@ -281,6 +283,7 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP
		*/
		final boolean mForceSeamlesslyRotate;
		ForcedSeamlessRotator mPendingForcedSeamlessRotate;
		long mFinishForcedSeamlessRotateFrameNumber;

		private RemoteCallbackList<IWindowFocusObserver> mFocusCallbacks;

		@@ -631,6 +634,10 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP

		void forceSeamlesslyRotateIfAllowed(int oldRotation, int rotation) {
		if (mForceSeamlesslyRotate) {
		if (mPendingForcedSeamlessRotate != null) {
		oldRotation = mPendingForcedSeamlessRotate.getOldRotation();
		}

		mPendingForcedSeamlessRotate = new ForcedSeamlessRotator(
		oldRotation, rotation, getDisplayInfo());
		mPendingForcedSeamlessRotate.unrotate(this.mToken);
		@@ -3294,6 +3301,11 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP
		proto.write(REMOVED, mRemoved);
		proto.write(IS_ON_SCREEN, isOnScreen());
		proto.write(IS_VISIBLE, isVisible());
		if (mForceSeamlesslyRotate) {
		proto.write(PENDING_FORCED_SEAMLESS_ROTATION, mPendingForcedSeamlessRotate != null);
		proto.write(FINISHED_FORCED_SEAMLESS_ROTATION_FRAME,
		mFinishForcedSeamlessRotateFrameNumber);
		}
		proto.end(token);
		}

		@@ -3449,6 +3461,16 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP
		pw.print(prefix); pw.print("mLastFreezeDuration=");
		TimeUtils.formatDuration(mLastFreezeDuration, pw); pw.println();
		}
		if (mForceSeamlesslyRotate) {
		pw.print(prefix); pw.print("forceSeamlesslyRotate: pending=");
		if (mPendingForcedSeamlessRotate != null) {
		mPendingForcedSeamlessRotate.dump(pw);
		} else {
		pw.print("null");
		}
		pw.print(" finishedFrameNumber="); pw.print(mFinishForcedSeamlessRotateFrameNumber);
		pw.println();
		}
		if (mHScale != 1 \|\| mVScale != 1) {
		pw.print(prefix); pw.print("mHScale="); pw.print(mHScale);
		pw.print(" mVScale="); pw.println(mVScale);