Merge "Fixing TaskView.launchTask.onEndCallback is not called" into sc-dev

2026-03-02 00:36:49 +00:00 · 2021-06-22 18:08:25 +00:00
parent c5c0e5e96e 696c612964
commit eb3367796a
9 changed files with 134 additions and 182 deletions
--- a/quickstep/src/com/android/launcher3/BaseQuickstepLauncher.java
+++ b/quickstep/src/com/android/launcher3/BaseQuickstepLauncher.java
@@ -430,7 +430,7 @@ public abstract class BaseQuickstepLauncher extends Launcher
    public ActivityOptionsWrapper getActivityLaunchOptions(View v, @Nullable ItemInfo item) {
        ActivityOptionsWrapper activityOptions =
                mAppTransitionManager.hasControlRemoteAppTransitionPermission()
-                        ? mAppTransitionManager.getActivityLaunchOptions(this, v)
+                        ? mAppTransitionManager.getActivityLaunchOptions(v)
                        : super.getActivityLaunchOptions(v, item);
        if (mLastTouchUpTime > 0) {
            ActivityOptionsCompat.setLauncherSourceInfo(
--- a/quickstep/src/com/android/launcher3/LauncherAnimationRunner.java
+++ b/quickstep/src/com/android/launcher3/LauncherAnimationRunner.java
@@ -36,26 +36,48 @@ import androidx.annotation.UiThread;
 import com.android.systemui.shared.system.RemoteAnimationRunnerCompat;
 import com.android.systemui.shared.system.RemoteAnimationTargetCompat;

+import java.lang.ref.WeakReference;
+
+/**
+ * This class is needed to wrap any animation runner that is a part of the
+ * RemoteAnimationDefinition:
+ * - Launcher creates a new instance of the LauncherAppTransitionManagerImpl whenever it is
+ *   created, which in turn registers a new definition
+ * - When the definition is registered, window manager retains a strong binder reference to the
+ *   runner passed in
+ * - If the Launcher activity is recreated, the new definition registered will replace the old
+ *   reference in the system's activity record, but until the system server is GC'd, the binder
+ *   reference will still exist, which references the runner in the Launcher process, which
+ *   references the (old) Launcher activity through this class
+ *
+ * Instead we make the runner provided to the definition static only holding a weak reference to
+ * the runner implementation.  When this animation manager is destroyed, we remove the Launcher
+ * reference to the runner, leaving only the weak ref from the runner.
+ */
@TargetApi(Build.VERSION_CODES.P)
-public abstract class LauncherAnimationRunner implements RemoteAnimationRunnerCompat {
+public class LauncherAnimationRunner implements RemoteAnimationRunnerCompat {
+
+    private static final RemoteAnimationFactory DEFAULT_FACTORY =
+            (transit, appTargets, wallpaperTargets, nonAppTargets, result) ->
+                    result.setAnimation(null, null);

    private final Handler mHandler;
    private final boolean mStartAtFrontOfQueue;
+    private final WeakReference<RemoteAnimationFactory> mFactory;
+
    private AnimationResult mAnimationResult;

    /**
     * @param startAtFrontOfQueue If true, the animation start will be posted at the front of the
     *                            queue to minimize latency.
     */
-    public LauncherAnimationRunner(Handler handler, boolean startAtFrontOfQueue) {
+    public LauncherAnimationRunner(Handler handler, RemoteAnimationFactory factory,
+            boolean startAtFrontOfQueue) {
        mHandler = handler;
+        mFactory = new WeakReference<>(factory);
        mStartAtFrontOfQueue = startAtFrontOfQueue;
    }

-    public Handler getHandler() {
-        return mHandler;
-    }
-
    // Called only in S+ platform
    @BinderThread
    public void onAnimationStart(
@@ -67,7 +89,7 @@ public abstract class LauncherAnimationRunner implements RemoteAnimationRunnerCo
        Runnable r = () -> {
            finishExistingAnimation();
            mAnimationResult = new AnimationResult(() -> mAnimationResult = null, runnable);
-            onCreateAnimation(transit, appTargets, wallpaperTargets, nonAppTargets,
+            getFactory().onCreateAnimation(transit, appTargets, wallpaperTargets, nonAppTargets,
                    mAnimationResult);
        };
        if (mStartAtFrontOfQueue) {
@@ -92,17 +114,11 @@ public abstract class LauncherAnimationRunner implements RemoteAnimationRunnerCo
        onAnimationStart(appTargets, new RemoteAnimationTargetCompat[0], runnable);
    }

-    /**
-     * Called on the UI thread when the animation targets are received. The implementation must
-     * call {@link AnimationResult#setAnimation} with the target animation to be run.
-     */
-    @UiThread
-    public abstract void onCreateAnimation(
-            int transit,
-            RemoteAnimationTargetCompat[] appTargets,
-            RemoteAnimationTargetCompat[] wallpaperTargets,
-            RemoteAnimationTargetCompat[] nonAppTargets,
-            AnimationResult result);
+
+    private RemoteAnimationFactory getFactory() {
+        RemoteAnimationFactory factory = mFactory.get();
+        return factory != null ? factory : DEFAULT_FACTORY;
+    }

    @UiThread
    private void finishExistingAnimation() {
@@ -118,7 +134,10 @@ public abstract class LauncherAnimationRunner implements RemoteAnimationRunnerCo
    @BinderThread
    @Override
    public void onAnimationCancelled() {
-        postAsyncCallback(mHandler, this::finishExistingAnimation);
+        postAsyncCallback(mHandler, () -> {
+            finishExistingAnimation();
+            getFactory().onAnimationCancelled();
+        });
    }

    public static final class AnimationResult {
@@ -153,7 +172,6 @@ public abstract class LauncherAnimationRunner implements RemoteAnimationRunnerCo
        @UiThread
        public void setAnimation(AnimatorSet animation, Context context) {
            setAnimation(animation, context, null, true);
-
        }

        /**
@@ -198,4 +216,28 @@ public abstract class LauncherAnimationRunner implements RemoteAnimationRunnerCo
            }
        }
    }
+
+    /**
+     * Used with LauncherAnimationRunner as an interface for the runner to call back to the
+     * implementation.
+     */
+    @FunctionalInterface
+    public interface RemoteAnimationFactory {
+
+        /**
+         * Called on the UI thread when the animation targets are received. The implementation must
+         * call {@link AnimationResult#setAnimation} with the target animation to be run.
+         */
+        void onCreateAnimation(int transit,
+                RemoteAnimationTargetCompat[] appTargets,
+                RemoteAnimationTargetCompat[] wallpaperTargets,
+                RemoteAnimationTargetCompat[] nonAppTargets,
+                LauncherAnimationRunner.AnimationResult result);
+
+        /**
+         * Called when the animation is cancelled. This can happen with or without
+         * the create being called.
+         */
+        default void onAnimationCancelled() { }
+    }
 }
--- a/quickstep/src/com/android/launcher3/QuickstepTransitionManager.java
+++ b/quickstep/src/com/android/launcher3/QuickstepTransitionManager.java
@@ -79,6 +79,7 @@ import androidx.annotation.Nullable;
 import androidx.core.graphics.ColorUtils;

 import com.android.launcher3.DeviceProfile.OnDeviceProfileChangeListener;
+import com.android.launcher3.LauncherAnimationRunner.RemoteAnimationFactory;
 import com.android.launcher3.anim.AnimationSuccessListener;
 import com.android.launcher3.dragndrop.DragLayer;
 import com.android.launcher3.icons.FastBitmapDrawable;
@@ -197,11 +198,11 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener

    private RemoteAnimationProvider mRemoteAnimationProvider;
    // Strong refs to runners which are cleared when the launcher activity is destroyed
-    private WrappedAnimationRunnerImpl mWallpaperOpenRunner;
-    private WrappedAnimationRunnerImpl mAppLaunchRunner;
-    private WrappedAnimationRunnerImpl mKeyguardGoingAwayRunner;
+    private RemoteAnimationFactory mWallpaperOpenRunner;
+    private RemoteAnimationFactory mAppLaunchRunner;
+    private RemoteAnimationFactory mKeyguardGoingAwayRunner;

-    private WrappedAnimationRunnerImpl mWallpaperOpenTransitionRunner;
+    private RemoteAnimationFactory mWallpaperOpenTransitionRunner;
    private RemoteTransitionCompat mLauncherOpenTransition;

    private final AnimatorListenerAdapter mForceInvisibleListener = new AnimatorListenerAdapter() {
@@ -257,11 +258,11 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
     * @return ActivityOptions with remote animations that controls how the window of the opening
     *         targets are displayed.
     */
-    public ActivityOptionsWrapper getActivityLaunchOptions(Launcher launcher, View v) {
+    public ActivityOptionsWrapper getActivityLaunchOptions(View v) {
        boolean fromRecents = isLaunchingFromRecents(v, null /* targets */);
        RunnableList onEndCallback = new RunnableList();
-        mAppLaunchRunner = new AppLaunchAnimationRunner(mHandler, v, onEndCallback);
-        RemoteAnimationRunnerCompat runner = new WrappedLauncherAnimationRunner<>(
+        mAppLaunchRunner = new AppLaunchAnimationRunner(v, onEndCallback);
+        RemoteAnimationRunnerCompat runner = new LauncherAnimationRunner(
                mHandler, mAppLaunchRunner, true /* startAtFrontOfQueue */);

        // Note that this duration is a guess as we do not know if the animation will be a
@@ -1006,7 +1007,7 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
            definition.addRemoteAnimation(WindowManagerWrapper.TRANSIT_WALLPAPER_OPEN,
                    WindowManagerWrapper.ACTIVITY_TYPE_STANDARD,
                    new RemoteAnimationAdapterCompat(
-                            new WrappedLauncherAnimationRunner<>(mHandler, mWallpaperOpenRunner,
+                            new LauncherAnimationRunner(mHandler, mWallpaperOpenRunner,
                                    false /* startAtFrontOfQueue */),
                            CLOSING_TRANSITION_DURATION_MS, 0 /* statusBarTransitionDelay */));

@@ -1015,7 +1016,7 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
                definition.addRemoteAnimation(
                        WindowManagerWrapper.TRANSIT_KEYGUARD_GOING_AWAY_ON_WALLPAPER,
                        new RemoteAnimationAdapterCompat(
-                                new WrappedLauncherAnimationRunner<>(
+                                new LauncherAnimationRunner(
                                        mHandler, mKeyguardGoingAwayRunner,
                                        true /* startAtFrontOfQueue */),
                                CLOSING_TRANSITION_DURATION_MS, 0 /* statusBarTransitionDelay */));
@@ -1035,7 +1036,7 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
        if (hasControlRemoteAppTransitionPermission()) {
            mWallpaperOpenTransitionRunner = createWallpaperOpenRunner(false /* fromUnlock */);
            mLauncherOpenTransition = RemoteAnimationAdapterCompat.buildRemoteTransition(
-                    new WrappedLauncherAnimationRunner<>(mHandler, mWallpaperOpenTransitionRunner,
+                    new LauncherAnimationRunner(mHandler, mWallpaperOpenTransitionRunner,
                            false /* startAtFrontOfQueue */));
            mLauncherOpenTransition.addHomeOpenCheck();
            SystemUiProxy.INSTANCE.getNoCreate().registerRemoteTransition(mLauncherOpenTransition);
@@ -1085,7 +1086,7 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
     * @return Runner that plays when user goes to Launcher
     *         ie. pressing home, swiping up from nav bar.
     */
-    WrappedAnimationRunnerImpl createWallpaperOpenRunner(boolean fromUnlock) {
+    RemoteAnimationFactory createWallpaperOpenRunner(boolean fromUnlock) {
        return new WallpaperOpenLauncherAnimationRunner(mHandler, fromUnlock);
    }

@@ -1235,7 +1236,7 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
    /**
     * Remote animation runner for animation from the app to Launcher, including recents.
     */
-    protected class WallpaperOpenLauncherAnimationRunner implements WrappedAnimationRunnerImpl {
+    protected class WallpaperOpenLauncherAnimationRunner implements RemoteAnimationFactory {

        private final Handler mHandler;
        private final boolean mFromUnlock;
@@ -1323,17 +1324,12 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
    /**
     * Remote animation runner for animation to launch an app.
     */
-    private class AppLaunchAnimationRunner implements WrappedAnimationRunnerImpl {
+    private class AppLaunchAnimationRunner implements RemoteAnimationFactory {

-        private static final String TRANSITION_LAUNCH_FROM_RECENTS = "transition:LaunchFromRecents";
-        private static final String TRANSITION_LAUNCH_FROM_ICON = "transition:LaunchFromIcon";
-
-        private final Handler mHandler;
        private final View mV;
        private final RunnableList mOnEndCallback;

-        AppLaunchAnimationRunner(Handler handler, View v, RunnableList onEndCallback) {
-            mHandler = handler;
+        AppLaunchAnimationRunner(View v, RunnableList onEndCallback) {
            mV = v;
            mOnEndCallback = onEndCallback;
        }
@@ -1377,6 +1373,11 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
            result.setAnimation(anim, mLauncher, mOnEndCallback::executeAllAndDestroy,
                    skipFirstFrame);
        }
+
+        @Override
+        public void onAnimationCancelled() {
+            mOnEndCallback.executeAllAndDestroy();
+        }
    }

    /**
--- a/quickstep/src/com/android/launcher3/WrappedAnimationRunnerImpl.java
+++ b/quickstep/src/com/android/launcher3/WrappedAnimationRunnerImpl.java
@@ -1,32 +0,0 @@
-/*
- * Copyright (C) 2020 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.android.launcher3;
-
-import com.android.systemui.shared.system.RemoteAnimationTargetCompat;
-
-/**
- * Used with WrappedLauncherAnimationRunner as an interface for the runner to call back to the
- * implementation.
- */
-public interface WrappedAnimationRunnerImpl {
-
-    void onCreateAnimation(int transit,
-            RemoteAnimationTargetCompat[] appTargets,
-            RemoteAnimationTargetCompat[] wallpaperTargets,
-            RemoteAnimationTargetCompat[] nonAppTargets,
-            LauncherAnimationRunner.AnimationResult result);
-}
--- a/quickstep/src/com/android/launcher3/WrappedLauncherAnimationRunner.java
+++ b/quickstep/src/com/android/launcher3/WrappedLauncherAnimationRunner.java
@@ -1,65 +0,0 @@
-/*
- * Copyright (C) 2020 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.android.launcher3;
-
-import android.os.Handler;
-
-import com.android.systemui.shared.system.RemoteAnimationTargetCompat;
-
-import java.lang.ref.WeakReference;
-
-/**
- * This class is needed to wrap any animation runner that is a part of the
- * RemoteAnimationDefinition:
- * - Launcher creates a new instance of the LauncherAppTransitionManagerImpl whenever it is
- *   created, which in turn registers a new definition
- * - When the definition is registered, window manager retains a strong binder reference to the
- *   runner passed in
- * - If the Launcher activity is recreated, the new definition registered will replace the old
- *   reference in the system's activity record, but until the system server is GC'd, the binder
- *   reference will still exist, which references the runner in the Launcher process, which
- *   references the (old) Launcher activity through this class
- *
- * Instead we make the runner provided to the definition static only holding a weak reference to
- * the runner implementation.  When this animation manager is destroyed, we remove the Launcher
- * reference to the runner, leaving only the weak ref from the runner.
- */
-public class WrappedLauncherAnimationRunner<R extends WrappedAnimationRunnerImpl>
-        extends LauncherAnimationRunner {
-    private WeakReference<R> mImpl;
-
-    public WrappedLauncherAnimationRunner(
-            Handler handler, R animationRunnerImpl, boolean startAtFrontOfQueue) {
-        super(handler, startAtFrontOfQueue);
-        mImpl = new WeakReference<>(animationRunnerImpl);
-    }
-
-    @Override
-    public void onCreateAnimation(int transit,
-            RemoteAnimationTargetCompat[] appTargets,
-            RemoteAnimationTargetCompat[] wallpaperTargets,
-            RemoteAnimationTargetCompat[] nonAppTargets,
-            AnimationResult result) {
-        R animationRunnerImpl = mImpl.get();
-        if (animationRunnerImpl != null) {
-            animationRunnerImpl.onCreateAnimation(transit, appTargets, wallpaperTargets,
-                    nonAppTargets, result);
-        } else {
-            result.setAnimation(null, null);
-        }
-    }
-}
--- a/quickstep/src/com/android/launcher3/uioverrides/QuickstepInteractionHandler.java
+++ b/quickstep/src/com/android/launcher3/uioverrides/QuickstepInteractionHandler.java
@@ -56,7 +56,7 @@ class QuickstepInteractionHandler implements RemoteViews.InteractionHandler {
        }
        Pair<Intent, ActivityOptions> options = remoteResponse.getLaunchOptions(view);
        ActivityOptionsWrapper activityOptions = mLauncher.getAppTransitionManager()
-                .getActivityLaunchOptions(mLauncher, hostView);
+                .getActivityLaunchOptions(hostView);
        if (Utilities.ATLEAST_S && !pendingIntent.isActivity()) {
            // In the event this pending intent eventually launches an activity, i.e. a trampoline,
            // use the Quickstep transition animation.
--- a/quickstep/src/com/android/quickstep/RecentsActivity.java
+++ b/quickstep/src/com/android/quickstep/RecentsActivity.java
@@ -49,9 +49,8 @@ import com.android.launcher3.DeviceProfile;
 import com.android.launcher3.InvariantDeviceProfile;
 import com.android.launcher3.LauncherAnimationRunner;
 import com.android.launcher3.LauncherAnimationRunner.AnimationResult;
+import com.android.launcher3.LauncherAnimationRunner.RemoteAnimationFactory;
 import com.android.launcher3.R;
-import com.android.launcher3.WrappedAnimationRunnerImpl;
-import com.android.launcher3.WrappedLauncherAnimationRunner;
 import com.android.launcher3.anim.AnimatorPlaybackController;
 import com.android.launcher3.anim.Interpolators;
 import com.android.launcher3.anim.PendingAnimation;
@@ -109,7 +108,7 @@ public final class RecentsActivity extends StatefulActivity<RecentsState> {
    private StateManager<RecentsState> mStateManager;

    // Strong refs to runners which are cleared when the activity is destroyed
-    private WrappedAnimationRunnerImpl mActivityLaunchAnimationRunner;
+    private RemoteAnimationFactory mActivityLaunchAnimationRunner;

    /**
     * Init drag layer and overview panel views.
@@ -206,19 +205,25 @@ public final class RecentsActivity extends StatefulActivity<RecentsState> {
        final TaskView taskView = (TaskView) v;
        RunnableList onEndCallback = new RunnableList();

-        mActivityLaunchAnimationRunner = (int transit,
-                    RemoteAnimationTargetCompat[] appTargets,
+        mActivityLaunchAnimationRunner = new RemoteAnimationFactory() {
+            @Override
+            public void onCreateAnimation(int transit, RemoteAnimationTargetCompat[] appTargets,
                    RemoteAnimationTargetCompat[] wallpaperTargets,
-                    RemoteAnimationTargetCompat[] nonAppTargets,
-                    AnimationResult result) -> {
-            AnimatorSet anim = composeRecentsLaunchAnimator(taskView, appTargets,
-                    wallpaperTargets, nonAppTargets);
-            anim.addListener(resetStateListener());
-            result.setAnimation(anim, RecentsActivity.this, onEndCallback::executeAllAndDestroy,
-                    true /* skipFirstFrame */);
+                    RemoteAnimationTargetCompat[] nonAppTargets, AnimationResult result) {
+                AnimatorSet anim = composeRecentsLaunchAnimator(taskView, appTargets,
+                        wallpaperTargets, nonAppTargets);
+                anim.addListener(resetStateListener());
+                result.setAnimation(anim, RecentsActivity.this, onEndCallback::executeAllAndDestroy,
+                        true /* skipFirstFrame */);
+            }
+
+            @Override
+            public void onAnimationCancelled() {
+                onEndCallback.executeAllAndDestroy();
+            }
        };

-        final LauncherAnimationRunner wrapper = new WrappedLauncherAnimationRunner<>(
+        final LauncherAnimationRunner wrapper = new LauncherAnimationRunner(
                mUiHandler, mActivityLaunchAnimationRunner, true /* startAtFrontOfQueue */);
        RemoteAnimationAdapterCompat adapterCompat = new RemoteAnimationAdapterCompat(
                wrapper, RECENTS_LAUNCH_DURATION,
@@ -362,34 +367,37 @@ public final class RecentsActivity extends StatefulActivity<RecentsState> {
    }

    private void startHomeInternal() {
-        WrappedLauncherAnimationRunner runner = new WrappedLauncherAnimationRunner(
-                getMainThreadHandler(), this::onCreateAnimationToHome, true);
+        LauncherAnimationRunner runner = new LauncherAnimationRunner(
+                getMainThreadHandler(), mAnimationToHomeFactory, true);
        RemoteAnimationAdapterCompat adapterCompat =
                new RemoteAnimationAdapterCompat(runner, HOME_APPEAR_DURATION, 0);
        startActivity(createHomeIntent(),
                ActivityOptionsCompat.makeRemoteAnimation(adapterCompat).toBundle());
    }

-    private void onCreateAnimationToHome(
-            int transit, RemoteAnimationTargetCompat[] appTargets,
-            RemoteAnimationTargetCompat[] wallpaperTargets,
-            RemoteAnimationTargetCompat[] nonAppTargets, AnimationResult result) {
-        AnimatorPlaybackController controller = getStateManager()
-                .createAnimationToNewWorkspace(RecentsState.BG_LAUNCHER, HOME_APPEAR_DURATION);
-        controller.dispatchOnStart();
+    private final RemoteAnimationFactory mAnimationToHomeFactory =
+            new RemoteAnimationFactory() {
+        @Override
+        public void onCreateAnimation(int transit, RemoteAnimationTargetCompat[] appTargets,
+                RemoteAnimationTargetCompat[] wallpaperTargets,
+                RemoteAnimationTargetCompat[] nonAppTargets, AnimationResult result) {
+            AnimatorPlaybackController controller = getStateManager()
+                    .createAnimationToNewWorkspace(RecentsState.BG_LAUNCHER, HOME_APPEAR_DURATION);
+            controller.dispatchOnStart();

-        RemoteAnimationTargets targets = new RemoteAnimationTargets(
-                appTargets, wallpaperTargets, nonAppTargets, MODE_OPENING);
-        for (RemoteAnimationTargetCompat app : targets.apps) {
-            new Transaction().setAlpha(app.leash.getSurfaceControl(), 1).apply();
+            RemoteAnimationTargets targets = new RemoteAnimationTargets(
+                    appTargets, wallpaperTargets, nonAppTargets, MODE_OPENING);
+            for (RemoteAnimationTargetCompat app : targets.apps) {
+                new Transaction().setAlpha(app.leash.getSurfaceControl(), 1).apply();
+            }
+            AnimatorSet anim = new AnimatorSet();
+            anim.play(controller.getAnimationPlayer());
+            anim.setDuration(HOME_APPEAR_DURATION);
+            result.setAnimation(anim, RecentsActivity.this,
+                    () -> getStateManager().goToState(RecentsState.HOME, false),
+                    true /* skipFirstFrame */);
        }
-        AnimatorSet anim = new AnimatorSet();
-        anim.play(controller.getAnimationPlayer());
-        anim.setDuration(HOME_APPEAR_DURATION);
-        result.setAnimation(anim, this,
-                () -> getStateManager().goToState(RecentsState.HOME, false),
-                true /* skipFirstFrame */);
-    }
+    };

    @Override
    protected void collectStateHandlers(List<StateHandler> out) {
--- a/quickstep/src/com/android/quickstep/util/RemoteAnimationProvider.java
+++ b/quickstep/src/com/android/quickstep/util/RemoteAnimationProvider.java
@@ -21,15 +21,14 @@ import android.content.Context;
 import android.os.Handler;

 import com.android.launcher3.LauncherAnimationRunner;
-import com.android.launcher3.WrappedAnimationRunnerImpl;
-import com.android.launcher3.WrappedLauncherAnimationRunner;
+import com.android.launcher3.LauncherAnimationRunner.RemoteAnimationFactory;
 import com.android.systemui.shared.system.ActivityOptionsCompat;
 import com.android.systemui.shared.system.RemoteAnimationAdapterCompat;
 import com.android.systemui.shared.system.RemoteAnimationTargetCompat;

 public abstract class RemoteAnimationProvider {

-    WrappedAnimationRunnerImpl mAnimationRunner;
+    RemoteAnimationFactory mAnimationRunner;

    public abstract AnimatorSet createWindowAnimation(RemoteAnimationTargetCompat[] appTargets,
            RemoteAnimationTargetCompat[] wallpaperTargets);
@@ -37,7 +36,7 @@ public abstract class RemoteAnimationProvider {
    ActivityOptions toActivityOptions(Handler handler, long duration, Context context) {
        mAnimationRunner = (transit, appTargets, wallpaperTargets, nonApps, result) ->
                result.setAnimation(createWindowAnimation(appTargets, wallpaperTargets), context);
-        final LauncherAnimationRunner wrapper = new WrappedLauncherAnimationRunner(
+        final LauncherAnimationRunner wrapper = new LauncherAnimationRunner(
                handler, mAnimationRunner, false /* startAtFrontOfQueue */);
        return ActivityOptionsCompat.makeRemoteAnimation(
                new RemoteAnimationAdapterCompat(wrapper, duration, 0));
--- a/quickstep/src/com/android/quickstep/util/SplitSelectStateController.java
+++ b/quickstep/src/com/android/quickstep/util/SplitSelectStateController.java
@@ -41,9 +41,8 @@ import com.android.launcher3.BaseQuickstepLauncher;
 import com.android.launcher3.DeviceProfile;
 import com.android.launcher3.InsettableFrameLayout;
 import com.android.launcher3.LauncherAnimationRunner;
+import com.android.launcher3.LauncherAnimationRunner.RemoteAnimationFactory;
 import com.android.launcher3.R;
-import com.android.launcher3.WrappedAnimationRunnerImpl;
-import com.android.launcher3.WrappedLauncherAnimationRunner;
 import com.android.launcher3.util.SplitConfigurationOptions.SplitPositionOption;
 import com.android.quickstep.SystemUiProxy;
 import com.android.quickstep.TaskAnimationManager;
@@ -101,14 +100,14 @@ public class SplitSelectStateController {
            return;
        }
        // Assume initial mInitialTaskId is for top/left part of screen
-        WrappedAnimationRunnerImpl initialSplitRunnerWrapped =  new SplitLaunchAnimationRunner(
+        RemoteAnimationFactory initialSplitRunnerWrapped =  new SplitLaunchAnimationRunner(
                mInitialTaskView, 0);
-        WrappedAnimationRunnerImpl secondarySplitRunnerWrapped =  new SplitLaunchAnimationRunner(
+        RemoteAnimationFactory secondarySplitRunnerWrapped =  new SplitLaunchAnimationRunner(
                taskView, 1);
-        RemoteAnimationRunnerCompat initialSplitRunner = new WrappedLauncherAnimationRunner(
+        RemoteAnimationRunnerCompat initialSplitRunner = new LauncherAnimationRunner(
                new Handler(Looper.getMainLooper()), initialSplitRunnerWrapped,
                true /* startAtFrontOfQueue */);
-        RemoteAnimationRunnerCompat secondarySplitRunner = new WrappedLauncherAnimationRunner(
+        RemoteAnimationRunnerCompat secondarySplitRunner = new LauncherAnimationRunner(
                new Handler(Looper.getMainLooper()), secondarySplitRunnerWrapped,
                true /* startAtFrontOfQueue */);
        ActivityOptions initialOptions = ActivityOptionsCompat.makeRemoteAnimation(
@@ -192,7 +191,7 @@ public class SplitSelectStateController {
     * LEGACY
     * Remote animation runner for animation to launch an app.
     */
-    private class SplitLaunchAnimationRunner implements WrappedAnimationRunnerImpl {
+    private class SplitLaunchAnimationRunner implements RemoteAnimationFactory {

        private final TaskView mV;
        private final int mTargetState;