Merge changes from topic "revert-10602670-XFOJAPBNWU" into rvc-dev am: 18cf5cd605 am: 8307736423

Change-Id: I6b5f4a22df58528681e63e8631b1e3f4d659a5ad

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

@@ -129,221 +129,217 @@ public class Divider extends SystemUI implements DividerView.DividerCallbacks,
                 }
             };
 
-    private class DividerImeController implements DisplayImeController.ImePositionProcessor {
+    private DisplayImeController.ImePositionProcessor mImePositionProcessor =
-        /**
+            new 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
-        private int mHiddenTop = 0;
+                 * IME itself.
-        private int mShownTop = 0;
+                 */
+                private int mHiddenTop = 0;
+                private int mShownTop = 0;
 
-        // The following are target states (what we are curretly animating towards).
+                // 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
+                 * {@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;
+                 */
-        /**
+                private boolean mTargetAdjusted = false;
-         * {@code true} if, at the end of the animation, the IME should be shown/visible
+                /**
-         * regardless of what has focus.
+                 * {@code true} if, at the end of the animation, the IME should be shown/visible
-         */
+                 * regardless of what has focus.
-        private boolean mTargetShown = false;
+                 */
-        private float mTargetPrimaryDim = 0.f;
+                private boolean mTargetShown = false;
-        private float mTargetSecondaryDim = 0.f;
 
-        // The following are the current (most recent) states set during animation
+                // The following are the current (most recent) states set during animation
-        /** {@code true} if the secondary split has IME focus. */
+                /**
-        private boolean mSecondaryHasFocus = false;
+                 * {@code true} if the secondary split has IME focus.
-        /** The dimming currently applied to the primary/secondary splits. */
+                 */
-        private float mLastPrimaryDim = 0.f;
+                private boolean mSecondaryHasFocus = false;
-        private float mLastSecondaryDim = 0.f;
+                /** The dimming currently applied to the primary/secondary splits. */
-        /** The most recent y position of the top of the IME surface */
+                private float mLastPrimaryDim = 0.f;
-        private int mLastAdjustTop = -1;
+                private float mLastSecondaryDim = 0.f;
+                /** The most recent y position of the top of the IME surface */
+                private int mLastAdjustTop = -1;
 
-        // The following are states reached last time an animation fully completed.
+                // The following are states reached last time an animation fully completed.
-        /** {@code true} if the IME was shown/visible by the last-completed animation. */
+                /** {@code true} if the IME was shown/visible by the last-completed animation. */
-        private boolean mImeWasShown = false;
+                private boolean mImeWasShown = false;
-        /** {@code true} if the split positions were adjusted by the last-completed animation. */
+                /**
-        private boolean mAdjusted = false;
+                 * {@code true} if the split positions were adjusted by the last-completed
+                 * animation.
+                 */
+                private boolean mAdjusted = false;
 
-        /**
+                /**
-         * When some aspect of split-screen needs to animate independent from the IME,
+                 * When some aspect of split-screen needs to animate independent from the IME,
-         * this will be non-null and control split animation.
+                 * this will be non-null and control split animation.
-         */
+                 */
-        @Nullable
+                @Nullable
-        private ValueAnimator mAnimation = null;
+                private ValueAnimator mAnimation = null;
 
-        private boolean getSecondaryHasFocus(int displayId) {
+                private boolean getSecondaryHasFocus(int displayId) {
-            try {
+                    try {
-                IWindowContainer imeSplit = ActivityTaskManager.getTaskOrganizerController()
+                        IWindowContainer imeSplit = ActivityTaskManager.getTaskOrganizerController()
-                        .getImeTarget(displayId);
+                                .getImeTarget(displayId);
-                return imeSplit != null
+                        return imeSplit != null
-                        && (imeSplit.asBinder() == mSplits.mSecondary.token.asBinder());
+                                && (imeSplit.asBinder() == mSplits.mSecondary.token.asBinder());
-            } catch (RemoteException e) {
+                    } catch (RemoteException e) {
-                Slog.w(TAG, "Failed to get IME target", e);
+                        Slog.w(TAG, "Failed to get IME target", e);
-            }
+                    }
-            return false;
+                    return false;
-        }
-
-        @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 = splitIsVisible && imeShouldShow && mSecondaryHasFocus
-                    && !mSplitLayout.mDisplayLayout.isLandscape();
-            mHiddenTop = hiddenTop;
-            mShownTop = shownTop;
-            mTargetShown = imeShouldShow;
-            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
-                // start our own animation to drive adjustment. This happens when a
-                // 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();
-            if (mTargetAdjusted) {
-                mSplitLayout.updateAdjustedBounds(mShownTop, mHiddenTop, mShownTop);
-                wct.setBounds(mSplits.mSecondary.token, mSplitLayout.mAdjustedSecondary);
-                // "Freeze" the configuration size so that the app doesn't get a config
-                // or relaunch. This is required because normally nav-bar contributes
-                // to configuration bounds (via nondecorframe).
-                Rect adjustAppBounds = new Rect(mSplits.mSecondary.configuration
-                        .windowConfiguration.getAppBounds());
-                adjustAppBounds.offset(0, mSplitLayout.mAdjustedSecondary.top
-                        - mSplitLayout.mSecondary.top);
-                wct.setAppBounds(mSplits.mSecondary.token, adjustAppBounds);
-                wct.setScreenSizeDp(mSplits.mSecondary.token,
-                        mSplits.mSecondary.configuration.screenWidthDp,
-                        mSplits.mSecondary.configuration.screenHeightDp);
-            } else {
-                wct.setBounds(mSplits.mSecondary.token, mSplitLayout.mSecondary);
-                wct.setAppBounds(mSplits.mSecondary.token, null);
-                wct.setScreenSizeDp(mSplits.mSecondary.token,
-                        SCREEN_WIDTH_DP_UNDEFINED, SCREEN_HEIGHT_DP_UNDEFINED);
-            }
-            try {
-                ActivityTaskManager.getTaskOrganizerController()
-                        .applyContainerTransaction(wct, null /* organizer */);
-            } catch (RemoteException e) {
-            }
-
-            // Update all the adjusted-for-ime states
-            mView.setAdjustedForIme(mTargetShown, mTargetShown
-                    ? DisplayImeController.ANIMATION_DURATION_SHOW_MS
-                    : DisplayImeController.ANIMATION_DURATION_HIDE_MS);
-            setAdjustedForIme(mTargetShown);
-        }
-
-        @Override
-        public void onImePositionChanged(int displayId, int imeTop,
-                SurfaceControl.Transaction t) {
-            if (mAnimation != null || !inSplitMode()) {
-                // Not synchronized with IME anymore, so return.
-                return;
-            }
-            final float fraction = ((float) imeTop - mHiddenTop) / (mShownTop - mHiddenTop);
-            final float progress = mTargetShown ? fraction : 1.f - fraction;
-            onProgress(progress, t);
-        }
-
-        @Override
-        public void onImeEndPositioning(int displayId, boolean cancelled,
-                SurfaceControl.Transaction t) {
-            if (mAnimation != null || !inSplitMode()) {
-                // Not synchronized with IME anymore, so return.
-                return;
-            }
-            onEnd(cancelled, t);
-        }
-
-        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);
-                mSplitLayout.updateAdjustedBounds(mLastAdjustTop, mHiddenTop, mShownTop);
-                mView.resizeSplitSurfaces(t, mSplitLayout.mAdjustedPrimary,
-                        mSplitLayout.mAdjustedSecondary);
-            }
-            final float invProg = 1.f - progress;
-            mView.setResizeDimLayer(t, true /* primary */,
-                    mLastPrimaryDim * invProg + progress * mTargetPrimaryDim);
-            mView.setResizeDimLayer(t, false /* primary */,
-                    mLastSecondaryDim * invProg + progress * mTargetSecondaryDim);
-        }
-
-        private void onEnd(boolean cancelled, SurfaceControl.Transaction t) {
-            if (!cancelled) {
-                onProgress(1.f, t);
-                mAdjusted = mTargetAdjusted;
-                mImeWasShown = mTargetShown;
-                mLastAdjustTop = mAdjusted ? mShownTop : mHiddenTop;
-                mLastPrimaryDim = mTargetPrimaryDim;
-                mLastSecondaryDim = mTargetSecondaryDim;
-            }
-        }
-
-        private void startAsyncAnimation() {
-            if (mAnimation != null) {
-                mAnimation.cancel();
-            }
-            mAnimation = ValueAnimator.ofFloat(0.f, 1.f);
-            mAnimation.setDuration(DisplayImeController.ANIMATION_DURATION_SHOW_MS);
-            if (mTargetAdjusted != mAdjusted) {
-                final float fraction =
-                        ((float) mLastAdjustTop - mHiddenTop) / (mShownTop - mHiddenTop);
-                final float progress = mTargetAdjusted ? fraction : 1.f - fraction;
-                mAnimation.setCurrentFraction(progress);
-            }
-
-            mAnimation.addUpdateListener(animation -> {
-                SurfaceControl.Transaction t = mTransactionPool.acquire();
-                float value = (float) animation.getAnimatedValue();
-                onProgress(value, t);
-                t.apply();
-                mTransactionPool.release(t);
-            });
-            mAnimation.setInterpolator(DisplayImeController.INTERPOLATOR);
-            mAnimation.addListener(new AnimatorListenerAdapter() {
-                private boolean mCancel = false;
-                @Override
-                public void onAnimationCancel(Animator animation) {
-                    mCancel = true;
                 }
+
                 @Override
-                public void onAnimationEnd(Animator animation) {
+                public void onImeStartPositioning(int displayId, int hiddenTop, int shownTop,
-                    SurfaceControl.Transaction t = mTransactionPool.acquire();
+                        boolean imeShouldShow, SurfaceControl.Transaction t) {
-                    onEnd(mCancel, t);
+                    mSecondaryHasFocus = getSecondaryHasFocus(displayId);
-                    t.apply();
+                    mTargetAdjusted = imeShouldShow && mSecondaryHasFocus
-                    mTransactionPool.release(t);
+                            && !mSplitLayout.mDisplayLayout.isLandscape();
-                    mAnimation = null;
+                    mHiddenTop = hiddenTop;
+                    mShownTop = shownTop;
+                    mTargetShown = imeShouldShow;
+                    if (mLastAdjustTop < 0) {
+                        mLastAdjustTop = imeShouldShow ? hiddenTop : shownTop;
+                    }
+                    if (mAnimation != null || (mImeWasShown && imeShouldShow
+                            && mTargetAdjusted != mAdjusted)) {
+                        // We need to animate adjustment independently of the IME position, so
+                        // start our own animation to drive adjustment. This happens when a
+                        // different split's editor has gained focus while the IME is still visible.
+                        startAsyncAnimation();
+                    }
+                    // Reposition the server's secondary split position so that it evaluates
+                    // insets properly.
+                    WindowContainerTransaction wct = new WindowContainerTransaction();
+                    if (mTargetAdjusted) {
+                        mSplitLayout.updateAdjustedBounds(mShownTop, mHiddenTop, mShownTop);
+                        wct.setBounds(mSplits.mSecondary.token, mSplitLayout.mAdjustedSecondary);
+                        // "Freeze" the configuration size so that the app doesn't get a config
+                        // or relaunch. This is required because normally nav-bar contributes
+                        // to configuration bounds (via nondecorframe).
+                        Rect adjustAppBounds = new Rect(mSplits.mSecondary.configuration
+                                .windowConfiguration.getAppBounds());
+                        adjustAppBounds.offset(0, mSplitLayout.mAdjustedSecondary.top
+                                - mSplitLayout.mSecondary.top);
+                        wct.setAppBounds(mSplits.mSecondary.token, adjustAppBounds);
+                        wct.setScreenSizeDp(mSplits.mSecondary.token,
+                                mSplits.mSecondary.configuration.screenWidthDp,
+                                mSplits.mSecondary.configuration.screenHeightDp);
+                    } else {
+                        wct.setBounds(mSplits.mSecondary.token, mSplitLayout.mSecondary);
+                        wct.setAppBounds(mSplits.mSecondary.token, null);
+                        wct.setScreenSizeDp(mSplits.mSecondary.token,
+                                SCREEN_WIDTH_DP_UNDEFINED, SCREEN_HEIGHT_DP_UNDEFINED);
+                    }
+                    try {
+                        ActivityTaskManager.getTaskOrganizerController()
+                                .applyContainerTransaction(wct, null /* organizer */);
+                    } catch (RemoteException e) {
+                    }
+
+                    // Update all the adjusted-for-ime states
+                    mView.setAdjustedForIme(mTargetShown, mTargetShown
+                            ? DisplayImeController.ANIMATION_DURATION_SHOW_MS
+                            : DisplayImeController.ANIMATION_DURATION_HIDE_MS);
+                    setAdjustedForIme(mTargetShown);
                 }
-            });
+
-            mAnimation.start();
+                @Override
-        }
+                public void onImePositionChanged(int displayId, int imeTop,
-    }
+                        SurfaceControl.Transaction t) {
-    private final DividerImeController mImePositionProcessor = new DividerImeController();
+                    if (mAnimation != null) {
+                        // Not synchronized with IME anymore, so return.
+                        return;
+                    }
+                    final float fraction = ((float) imeTop - mHiddenTop) / (mShownTop - mHiddenTop);
+                    final float progress = mTargetShown ? fraction : 1.f - fraction;
+                    onProgress(progress, t);
+                }
+
+                @Override
+                public void onImeEndPositioning(int displayId, boolean cancelled,
+                        SurfaceControl.Transaction t) {
+                    if (mAnimation != null) {
+                        // Not synchronized with IME anymore, so return.
+                        return;
+                    }
+                    onEnd(cancelled, t);
+                }
+
+                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);
+                        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);
+                    mView.setResizeDimLayer(t, false /* primary */,
+                            mLastSecondaryDim * invProg + progress * targetSecondaryDim);
+                }
+
+                private void onEnd(boolean cancelled, SurfaceControl.Transaction t) {
+                    if (!cancelled) {
+                        onProgress(1.f, t);
+                        mAdjusted = mTargetAdjusted;
+                        mImeWasShown = mTargetShown;
+                        mLastAdjustTop = mAdjusted ? mShownTop : mHiddenTop;
+                        mLastPrimaryDim =
+                                (mSecondaryHasFocus && mTargetShown) ? ADJUSTED_NONFOCUS_DIM : 0.f;
+                        mLastSecondaryDim =
+                                (!mSecondaryHasFocus && mTargetShown) ? ADJUSTED_NONFOCUS_DIM : 0.f;
+                    }
+                }
+
+                private void startAsyncAnimation() {
+                    if (mAnimation != null) {
+                        mAnimation.cancel();
+                    }
+                    mAnimation = ValueAnimator.ofFloat(0.f, 1.f);
+                    mAnimation.setDuration(DisplayImeController.ANIMATION_DURATION_SHOW_MS);
+                    if (mTargetAdjusted != mAdjusted) {
+                        final float fraction =
+                                ((float) mLastAdjustTop - mHiddenTop) / (mShownTop - mHiddenTop);
+                        final float progress = mTargetAdjusted ? fraction : 1.f - fraction;
+                        mAnimation.setCurrentFraction(progress);
+                    }
+
+                    mAnimation.addUpdateListener(animation -> {
+                        SurfaceControl.Transaction t = mTransactionPool.acquire();
+                        float value = (float) animation.getAnimatedValue();
+                        onProgress(value, t);
+                        t.apply();
+                        mTransactionPool.release(t);
+                    });
+                    mAnimation.setInterpolator(DisplayImeController.INTERPOLATOR);
+                    mAnimation.addListener(new AnimatorListenerAdapter() {
+                        private boolean mCancel = false;
+                        @Override
+                        public void onAnimationCancel(Animator animation) {
+                            mCancel = true;
+                        }
+                        @Override
+                        public void onAnimationEnd(Animator animation) {
+                            SurfaceControl.Transaction t = mTransactionPool.acquire();
+                            onEnd(mCancel, t);
+                            t.apply();
+                            mTransactionPool.release(t);
+                            mAnimation = null;
+                        }
+                    });
+                    mAnimation.start();
+                }
+            };
 
     public Divider(Context context, Optional<Lazy<Recents>> recentsOptionalLazy,
             DisplayController displayController, SystemWindows systemWindows,
@@ -517,43 +513,42 @@ public class Divider extends SystemUI implements DividerView.DividerCallbacks,
         }
     }
 
+    private void setHomeStackResizable(boolean resizable) {
+        if (mHomeStackResizable == resizable) {
+            return;
+        }
+        mHomeStackResizable = resizable;
+        if (!inSplitMode()) {
+            return;
+        }
+        WindowManagerProxy.applyHomeTasksMinimized(mSplitLayout, mSplits.mSecondary.token);
+    }
+
+    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);
+        }
+        updateTouchable();
+    }
+
     /** Switch to minimized state if appropriate */
     public void setMinimized(final boolean minimized) {
         mHandler.post(() -> {
-            WindowContainerTransaction wct = new WindowContainerTransaction();
+            if (!inSplitMode()) {
-            if (setHomeMinimized(minimized, mHomeStackResizable, wct)) {
+                return;
-                WindowManagerProxy.applyContainerTransaction(wct);
+            }
+            if (mMinimized == minimized) {
+                return;
             }
-        });
-    }
-
-    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);
+            WindowManagerProxy.applyPrimaryFocusable(mSplits, !mMinimized);
-            transact = true;
+            mView.setMinimizedDockStack(minimized, getAnimDuration(), mHomeStackResizable);
-        }
+            updateTouchable();
-
+        });
-        // Update home-stack resizability
-        if (mHomeStackResizable != homeStackResizable) {
-            mHomeStackResizable = homeStackResizable;
-            if (inSplitMode()) {
-                WindowManagerProxy.applyHomeTasksMinimized(
-                        mSplitLayout, mSplits.mSecondary.token, wct);
-                transact = true;
-            }
-        }
-
-        // Sync state to DividerView if it exists.
-        if (mView != null) {
-            mView.setMinimizedDockStack(minimized, getAnimDuration(), homeStackResizable);
-        }
-        updateTouchable();
-        return transact;
     }
 
     void setAdjustedForIme(boolean adjustedForIme) {
@@ -651,30 +646,46 @@ public class Divider extends SystemUI implements DividerView.DividerCallbacks,
     }
 
     void ensureMinimizedSplit() {
-        WindowContainerTransaction wct = new WindowContainerTransaction();
+        final boolean wasMinimized = mMinimized;
-        if (setHomeMinimized(true, mSplits.mSecondary.isResizable(), wct)) {
+        mMinimized = true;
-            WindowManagerProxy.applyContainerTransaction(wct);
+        setHomeStackResizable(mSplits.mSecondary.isResizable());
-        }
+        WindowManagerProxy.applyPrimaryFocusable(mSplits, false /* focusable */);
         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() {
-        WindowContainerTransaction wct = new WindowContainerTransaction();
+        if (mMinimized) {
-        if (setHomeMinimized(false /* minimized */, mHomeStackResizable, wct)) {
+            WindowManagerProxy.applyPrimaryFocusable(mSplits, true /* focusable */);
-            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

@@ -165,10 +165,6 @@ 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) {
@@ -418,10 +414,6 @@ 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) {
@@ -438,10 +430,6 @@ public class DividerView extends FrameLayout implements OnTouchListener,
         });
     }
 
-    boolean isHidden() {
-        return mSurfaceHidden;
-    }
-
     public boolean startDragging(boolean animate, boolean touching) {
         cancelFlingAnimation();
         if (touching) {
@@ -1083,7 +1071,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.001f) {
+        if (alpha <= 0.f) {
             t.hide(dim);
         } else {
             t.setAlpha(dim, alpha);

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

@@ -88,9 +88,6 @@ 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

@@ -21,7 +21,6 @@ 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;
@@ -138,13 +137,17 @@ 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,
-            @NonNull WindowContainerTransaction wct) {
+            WindowContainerTransaction t) {
         // Resize the home/recents stacks to the larger minimized-state size
         final Rect homeBounds;
         final ArrayList<IWindowContainer> homeStacks = new ArrayList<>();
@@ -155,9 +158,19 @@ 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;
     }
 
@@ -288,8 +301,10 @@ public class WindowManagerProxy {
         }
     }
 
-    static void applyContainerTransaction(WindowContainerTransaction wct) {
+    static void applyPrimaryFocusable(SplitScreenTaskOrganizer splits, boolean focusable) {
         try {
+            WindowContainerTransaction wct = new WindowContainerTransaction();
+            wct.setFocusable(splits.mPrimary.token, focusable);
             ActivityTaskManager.getTaskOrganizerController().applyContainerTransaction(wct,
                     null /* organizer */);
         } catch (RemoteException e) {