Merge changes Ifcac72f0,I68f1b47e into rvc-dev am: dc8feb4065 (833a1ebb) · Commits · e / os / android_frameworks_base

packages/SystemUI/src/com/android/systemui/stackdivider/Divider.java

+247 −258

Original line number	Diff line number	Diff line
		@@ -129,12 +129,10 @@ public class Divider extends SystemUI implements DividerView.DividerCallbacks,
		}
		};

		private DisplayImeController.ImePositionProcessor mImePositionProcessor =
		new DisplayImeController.ImePositionProcessor() {
		private class DividerImeController implements DisplayImeController.ImePositionProcessor {
		/**
		* These are the y positions of the top of the IME surface when it is hidden and
		* when it is shown respectively. These are NOT necessarily the top of the visible
		* IME itself.
		* These are the y positions of the top of the IME surface when it is hidden and when it is
		* shown respectively. These are NOT necessarily the top of the visible IME itself.
		*/
		private int mHiddenTop = 0;
		private int mShownTop = 0;
		@@ -142,8 +140,7 @@ public class Divider extends SystemUI implements DividerView.DividerCallbacks,
		// The following are target states (what we are curretly animating towards).
		/**
		* {@code true} if, at the end of the animation, the split task positions should be
		* adjusted by height of the IME. This happens when the secondary split is the IME
		* target.
		* adjusted by height of the IME. This happens when the secondary split is the IME target.
		*/
		private boolean mTargetAdjusted = false;
		/**
		@@ -151,11 +148,11 @@ public class Divider extends SystemUI implements DividerView.DividerCallbacks,
		* regardless of what has focus.
		*/
		private boolean mTargetShown = false;
		private float mTargetPrimaryDim = 0.f;
		private float mTargetSecondaryDim = 0.f;

		// The following are the current (most recent) states set during animation
		/**
		* {@code true} if the secondary split has IME focus.
		*/
		/** {@code true} if the secondary split has IME focus. */
		private boolean mSecondaryHasFocus = false;
		/** The dimming currently applied to the primary/secondary splits. */
		private float mLastPrimaryDim = 0.f;
		@@ -166,10 +163,7 @@ public class Divider extends SystemUI implements DividerView.DividerCallbacks,
		// The following are states reached last time an animation fully completed.
		/** {@code true} if the IME was shown/visible by the last-completed animation. */
		private boolean mImeWasShown = false;
		/**
		* {@code true} if the split positions were adjusted by the last-completed
		* animation.
		*/
		/** {@code true} if the split positions were adjusted by the last-completed animation. */
		private boolean mAdjusted = false;

		/**
		@@ -194,8 +188,12 @@ public class Divider extends SystemUI implements DividerView.DividerCallbacks,
		@Override
		public void onImeStartPositioning(int displayId, int hiddenTop, int shownTop,
		boolean imeShouldShow, SurfaceControl.Transaction t) {
		if (!inSplitMode()) {
		return;
		}
		final boolean splitIsVisible = !mView.isHidden();
		mSecondaryHasFocus = getSecondaryHasFocus(displayId);
		mTargetAdjusted = imeShouldShow && mSecondaryHasFocus
		mTargetAdjusted = splitIsVisible && imeShouldShow && mSecondaryHasFocus
		&& !mSplitLayout.mDisplayLayout.isLandscape();
		mHiddenTop = hiddenTop;
		mShownTop = shownTop;
		@@ -203,6 +201,10 @@ public class Divider extends SystemUI implements DividerView.DividerCallbacks,
		if (mLastAdjustTop < 0) {
		mLastAdjustTop = imeShouldShow ? hiddenTop : shownTop;
		}
		mTargetPrimaryDim = (mSecondaryHasFocus && mTargetShown && splitIsVisible)
		? ADJUSTED_NONFOCUS_DIM : 0.f;
		mTargetSecondaryDim = (!mSecondaryHasFocus && mTargetShown && splitIsVisible)
		? ADJUSTED_NONFOCUS_DIM : 0.f;
		if (mAnimation != null \|\| (mImeWasShown && imeShouldShow
		&& mTargetAdjusted != mAdjusted)) {
		// We need to animate adjustment independently of the IME position, so
		@@ -210,6 +212,14 @@ public class Divider extends SystemUI implements DividerView.DividerCallbacks,
		// different split's editor has gained focus while the IME is still visible.
		startAsyncAnimation();
		}
		if (splitIsVisible) {
		// If split is hidden, we don't want to trigger any relayouts that would cause the
		// divider to show again.
		updateImeAdjustState();
		}
		}

		private void updateImeAdjustState() {
		// Reposition the server's secondary split position so that it evaluates
		// insets properly.
		WindowContainerTransaction wct = new WindowContainerTransaction();
		@@ -249,7 +259,7 @@ public class Divider extends SystemUI implements DividerView.DividerCallbacks,
		@Override
		public void onImePositionChanged(int displayId, int imeTop,
		SurfaceControl.Transaction t) {
		if (mAnimation != null) {
		if (mAnimation != null \|\| !inSplitMode()) {
		// Not synchronized with IME anymore, so return.
		return;
		}
		@@ -261,7 +271,7 @@ public class Divider extends SystemUI implements DividerView.DividerCallbacks,
		@Override
		public void onImeEndPositioning(int displayId, boolean cancelled,
		SurfaceControl.Transaction t) {
		if (mAnimation != null) {
		if (mAnimation != null \|\| !inSplitMode()) {
		// Not synchronized with IME anymore, so return.
		return;
		}
		@@ -271,21 +281,16 @@ public class Divider extends SystemUI implements DividerView.DividerCallbacks,
		private void onProgress(float progress, SurfaceControl.Transaction t) {
		if (mTargetAdjusted != mAdjusted) {
		final float fraction = mTargetAdjusted ? progress : 1.f - progress;
		mLastAdjustTop =
		(int) (fraction * mShownTop + (1.f - fraction) * mHiddenTop);
		mLastAdjustTop = (int) (fraction * mShownTop + (1.f - fraction) * mHiddenTop);
		mSplitLayout.updateAdjustedBounds(mLastAdjustTop, mHiddenTop, mShownTop);
		mView.resizeSplitSurfaces(t, mSplitLayout.mAdjustedPrimary,
		mSplitLayout.mAdjustedSecondary);
		}
		final float invProg = 1.f - progress;
		final float targetPrimaryDim = (mSecondaryHasFocus && mTargetShown)
		? ADJUSTED_NONFOCUS_DIM : 0.f;
		final float targetSecondaryDim = (!mSecondaryHasFocus && mTargetShown)
		? ADJUSTED_NONFOCUS_DIM : 0.f;
		mView.setResizeDimLayer(t, true /* primary */,
		mLastPrimaryDim * invProg + progress * targetPrimaryDim);
		mLastPrimaryDim * invProg + progress * mTargetPrimaryDim);
		mView.setResizeDimLayer(t, false /* primary */,
		mLastSecondaryDim * invProg + progress * targetSecondaryDim);
		mLastSecondaryDim * invProg + progress * mTargetSecondaryDim);
		}

		private void onEnd(boolean cancelled, SurfaceControl.Transaction t) {
		@@ -294,10 +299,8 @@ public class Divider extends SystemUI implements DividerView.DividerCallbacks,
		mAdjusted = mTargetAdjusted;
		mImeWasShown = mTargetShown;
		mLastAdjustTop = mAdjusted ? mShownTop : mHiddenTop;
		mLastPrimaryDim =
		(mSecondaryHasFocus && mTargetShown) ? ADJUSTED_NONFOCUS_DIM : 0.f;
		mLastSecondaryDim =
		(!mSecondaryHasFocus && mTargetShown) ? ADJUSTED_NONFOCUS_DIM : 0.f;
		mLastPrimaryDim = mTargetPrimaryDim;
		mLastSecondaryDim = mTargetSecondaryDim;
		}
		}

		@@ -339,7 +342,8 @@ public class Divider extends SystemUI implements DividerView.DividerCallbacks,
		});
		mAnimation.start();
		}
		};
		}
		private final DividerImeController mImePositionProcessor = new DividerImeController();

		public Divider(Context context, Optional<Lazy<Recents>> recentsOptionalLazy,
		DisplayController displayController, SystemWindows systemWindows,
		@@ -513,42 +517,43 @@ public class Divider extends SystemUI implements DividerView.DividerCallbacks,
		}
		}

		private void setHomeStackResizable(boolean resizable) {
		if (mHomeStackResizable == resizable) {
		return;
		/** Switch to minimized state if appropriate */
		public void setMinimized(final boolean minimized) {
		mHandler.post(() -> {
		WindowContainerTransaction wct = new WindowContainerTransaction();
		if (setHomeMinimized(minimized, mHomeStackResizable, wct)) {
		WindowManagerProxy.applyContainerTransaction(wct);
		}
		mHomeStackResizable = resizable;
		if (!inSplitMode()) {
		return;
		});
		}
		WindowManagerProxy.applyHomeTasksMinimized(mSplitLayout, mSplits.mSecondary.token);

		private boolean setHomeMinimized(final boolean minimized, boolean homeStackResizable,
		WindowContainerTransaction wct) {
		boolean transact = false;

		// Update minimized state
		if (mMinimized != minimized) {
		mMinimized = minimized;
		wct.setFocusable(mSplits.mPrimary.token, !mMinimized);
		transact = true;
		}

		private void updateMinimizedDockedStack(final boolean minimized, final long animDuration,
		final boolean isHomeStackResizable) {
		setHomeStackResizable(isHomeStackResizable);
		if (animDuration > 0) {
		mView.setMinimizedDockStack(minimized, animDuration, isHomeStackResizable);
		} else {
		mView.setMinimizedDockStack(minimized, isHomeStackResizable);
		// Update home-stack resizability
		if (mHomeStackResizable != homeStackResizable) {
		mHomeStackResizable = homeStackResizable;
		if (inSplitMode()) {
		WindowManagerProxy.applyHomeTasksMinimized(
		mSplitLayout, mSplits.mSecondary.token, wct);
		transact = true;
		}
		updateTouchable();
		}

		/** Switch to minimized state if appropriate */
		public void setMinimized(final boolean minimized) {
		mHandler.post(() -> {
		if (!inSplitMode()) {
		return;
		}
		if (mMinimized == minimized) {
		return;
		// Sync state to DividerView if it exists.
		if (mView != null) {
		mView.setMinimizedDockStack(minimized, getAnimDuration(), homeStackResizable);
		}
		mMinimized = minimized;
		WindowManagerProxy.applyPrimaryFocusable(mSplits, !mMinimized);
		mView.setMinimizedDockStack(minimized, getAnimDuration(), mHomeStackResizable);
		updateTouchable();
		});
		return transact;
		}

		void setAdjustedForIme(boolean adjustedForIme) {
		@@ -646,46 +651,30 @@ public class Divider extends SystemUI implements DividerView.DividerCallbacks,
		}

		void ensureMinimizedSplit() {
		final boolean wasMinimized = mMinimized;
		mMinimized = true;
		setHomeStackResizable(mSplits.mSecondary.isResizable());
		WindowManagerProxy.applyPrimaryFocusable(mSplits, false /* focusable */);
		WindowContainerTransaction wct = new WindowContainerTransaction();
		if (setHomeMinimized(true, mSplits.mSecondary.isResizable(), wct)) {
		WindowManagerProxy.applyContainerTransaction(wct);
		}
		if (!inSplitMode()) {
		// Wasn't in split-mode yet, so enter now.
		if (DEBUG) {
		Log.d(TAG, " entering split mode with minimized=true");
		}
		updateVisibility(true /* visible */);
		} else if (!wasMinimized) {
		if (DEBUG) {
		Log.d(TAG, " in split mode, but minimizing ");
		}
		// Was already in split-mode, update just minimized state.
		updateMinimizedDockedStack(mMinimized, getAnimDuration(),
		mHomeStackResizable);
		}
		}

		void ensureNormalSplit() {
		if (mMinimized) {
		WindowManagerProxy.applyPrimaryFocusable(mSplits, true /* focusable */);
		WindowContainerTransaction wct = new WindowContainerTransaction();
		if (setHomeMinimized(false /* minimized */, mHomeStackResizable, wct)) {
		WindowManagerProxy.applyContainerTransaction(wct);
		}
		if (!inSplitMode()) {
		// Wasn't in split-mode, so enter now.
		if (DEBUG) {
		Log.d(TAG, " enter split mode unminimized ");
		}
		mMinimized = false;
		updateVisibility(true /* visible */);
		}
		if (mMinimized) {
		// Was in minimized state, so leave that.
		if (DEBUG) {
		Log.d(TAG, " in split mode already, but unminimizing ");
		}
		mMinimized = false;
		updateMinimizedDockedStack(mMinimized, getAnimDuration(),
		mHomeStackResizable);
		}
		}
		}

packages/SystemUI/src/com/android/systemui/stackdivider/DividerView.java

+13 −1

Original line number	Diff line number	Diff line
		@@ -165,6 +165,10 @@ public class DividerView extends FrameLayout implements OnTouchListener,
		// The view is removed or in the process of been removed from the system.
		private boolean mRemoved;

		// Whether the surface for this view has been hidden regardless of actual visibility. This is
		// used interact with keyguard.
		private boolean mSurfaceHidden = false;

		private final Handler mHandler = new Handler() {
		@Override
		public void handleMessage(Message msg) {
		@@ -414,6 +418,10 @@ public class DividerView extends FrameLayout implements OnTouchListener,

		/** Unlike setVisible, this directly hides the surface without changing view visibility. */
		void setHidden(boolean hidden) {
		if (mSurfaceHidden == hidden) {
		return;
		}
		mSurfaceHidden = hidden;
		post(() -> {
		final SurfaceControl sc = getWindowSurfaceControl();
		if (sc == null) {
		@@ -430,6 +438,10 @@ public class DividerView extends FrameLayout implements OnTouchListener,
		});
		}

		boolean isHidden() {
		return mSurfaceHidden;
		}

		public boolean startDragging(boolean animate, boolean touching) {
		cancelFlingAnimation();
		if (touching) {
		@@ -1071,7 +1083,7 @@ public class DividerView extends FrameLayout implements OnTouchListener,

		void setResizeDimLayer(Transaction t, boolean primary, float alpha) {
		SurfaceControl dim = primary ? mTiles.mPrimaryDim : mTiles.mSecondaryDim;
		if (alpha <= 0.f) {
		if (alpha <= 0.001f) {
		t.hide(dim);
		} else {
		t.setAlpha(dim, alpha);

packages/SystemUI/src/com/android/systemui/stackdivider/DividerWindowManager.java

+3 −0

Original line number	Diff line number	Diff line
		@@ -88,6 +88,9 @@ public class DividerWindowManager {
		}

		public void setTouchable(boolean touchable) {
		if (mView == null) {
		return;
		}
		boolean changed = false;
		if (!touchable && (mLp.flags & FLAG_NOT_TOUCHABLE) == 0) {
		mLp.flags \|= FLAG_NOT_TOUCHABLE;

packages/SystemUI/src/com/android/systemui/stackdivider/WindowManagerProxy.java

+3 −18

Original line number	Diff line number	Diff line
		@@ -21,6 +21,7 @@ import static android.app.WindowConfiguration.ACTIVITY_TYPE_RECENTS;
		import static android.app.WindowConfiguration.WINDOWING_MODE_FULLSCREEN;
		import static android.view.Display.DEFAULT_DISPLAY;

		import android.annotation.NonNull;
		import android.app.ActivityManager;
		import android.app.ActivityTaskManager;
		import android.graphics.Rect;
		@@ -137,17 +138,13 @@ public class WindowManagerProxy {
		return resizable;
		}

		static void applyHomeTasksMinimized(SplitDisplayLayout layout, IWindowContainer parent) {
		applyHomeTasksMinimized(layout, parent, null /* transaction */);
		}

		/**
		* Assign a fixed override-bounds to home tasks that reflect their geometry while the primary
		* split is minimized. This actually "sticks out" of the secondary split area, but when in
		* minimized mode, the secondary split gets a 'negative' crop to expose it.
		*/
		static boolean applyHomeTasksMinimized(SplitDisplayLayout layout, IWindowContainer parent,
		WindowContainerTransaction t) {
		@NonNull WindowContainerTransaction wct) {
		// Resize the home/recents stacks to the larger minimized-state size
		final Rect homeBounds;
		final ArrayList<IWindowContainer> homeStacks = new ArrayList<>();
		@@ -158,19 +155,9 @@ public class WindowManagerProxy {
		homeBounds = new Rect(0, 0, layout.mDisplayLayout.width(),
		layout.mDisplayLayout.height());
		}
		WindowContainerTransaction wct = t != null ? t : new WindowContainerTransaction();
		for (int i = homeStacks.size() - 1; i >= 0; --i) {
		wct.setBounds(homeStacks.get(i), homeBounds);
		}
		if (t != null) {
		return isHomeResizable;
		}
		try {
		ActivityTaskManager.getTaskOrganizerController().applyContainerTransaction(wct,
		null /* organizer */);
		} catch (RemoteException e) {
		Log.e(TAG, "Failed to resize home stacks ", e);
		}
		return isHomeResizable;
		}

		@@ -301,10 +288,8 @@ public class WindowManagerProxy {
		}
		}

		static void applyPrimaryFocusable(SplitScreenTaskOrganizer splits, boolean focusable) {
		static void applyContainerTransaction(WindowContainerTransaction wct) {
		try {
		WindowContainerTransaction wct = new WindowContainerTransaction();
		wct.setFocusable(splits.mPrimary.token, focusable);
		ActivityTaskManager.getTaskOrganizerController().applyContainerTransaction(wct,
		null /* organizer */);
		} catch (RemoteException e) {