Files
Flexera-Launcher/quickstep/src/com/android/quickstep/LauncherBackAnimationController.java
T
Andy Wickham 2b400db392 Fix back home animation blurring.
Particularly with predictive back in cases that the app doesn't
support peeking the home screen, there was a thrashing animation
due to a secondary blur animation being applied. So in some cases,
it would rapidly alternate between 0 blur and the correct animation
blur. This wasn't necessarily user-visible, but likely contributed
to some performance jank.

Also ensure the scaling workspace blur uses the correct starting
depth and duration.

Demo: https://drive.google.com/file/d/1AffSvzlXycg8Yl4ULpctKADO6IdvvO3m/view?usp=drive_link&resourcekey=0--zqQ341w7U3MhRBwSYrsyA

Bug: 407534544
Test: Manual (predictive back, back without predictive peek, home)
Flag: com.android.launcher3.predictive_back_to_home_blur
Flag: com.android.launcher3.all_apps_blur
Change-Id: I76ed59e99aaef5bd44e8f5b0290f01763a8d4b0f
2025-05-07 16:54:58 -07:00

674 lines
29 KiB
Java

/*
* Copyright (C) 2022 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.quickstep;
import static android.util.MathUtils.lerp;
import static android.view.RemoteAnimationTarget.MODE_CLOSING;
import static android.view.RemoteAnimationTarget.MODE_OPENING;
import static android.view.WindowInsetsController.APPEARANCE_LIGHT_STATUS_BARS;
import static com.android.launcher3.AbstractFloatingView.TYPE_REBIND_SAFE;
import static com.android.launcher3.BaseActivity.INVISIBLE_ALL;
import static com.android.launcher3.BaseActivity.INVISIBLE_BY_PENDING_FLAGS;
import static com.android.launcher3.BaseActivity.PENDING_INVISIBLE_BY_WALLPAPER_ANIMATION;
import static com.android.launcher3.Flags.enableOverviewBackgroundWallpaperBlur;
import static com.android.window.flags.Flags.predictiveBackThreeButtonNav;
import static com.android.window.flags.Flags.removeDepartTargetFromMotion;
import android.animation.Animator;
import android.animation.AnimatorListenerAdapter;
import android.animation.ValueAnimator;
import android.content.ComponentCallbacks;
import android.content.res.Configuration;
import android.graphics.Matrix;
import android.graphics.PointF;
import android.graphics.Rect;
import android.graphics.RectF;
import android.os.Handler;
import android.os.RemoteException;
import android.util.Log;
import android.view.Choreographer;
import android.view.IRemoteAnimationFinishedCallback;
import android.view.IRemoteAnimationRunner;
import android.view.RemoteAnimationTarget;
import android.view.SurfaceControl;
import android.view.View;
import android.view.animation.DecelerateInterpolator;
import android.view.animation.Interpolator;
import android.window.BackEvent;
import android.window.BackMotionEvent;
import android.window.BackProgressAnimator;
import android.window.IBackAnimationHandoffHandler;
import android.window.IOnBackInvokedCallback;
import com.android.app.animation.Animations;
import com.android.app.animation.Interpolators;
import com.android.internal.policy.SystemBarUtils;
import com.android.internal.view.AppearanceRegion;
import com.android.launcher3.AbstractFloatingView;
import com.android.launcher3.BubbleTextView;
import com.android.launcher3.Flags;
import com.android.launcher3.LauncherState;
import com.android.launcher3.QuickstepTransitionManager;
import com.android.launcher3.R;
import com.android.launcher3.Utilities;
import com.android.launcher3.taskbar.LauncherTaskbarUIController;
import com.android.launcher3.uioverrides.QuickstepLauncher;
import com.android.launcher3.util.DisplayController;
import com.android.launcher3.util.NavigationMode;
import com.android.launcher3.widget.LauncherAppWidgetHostView;
import com.android.quickstep.util.BackAnimState;
import com.android.quickstep.util.ScalingWorkspaceRevealAnim;
import com.android.systemui.shared.system.QuickStepContract;
import java.lang.ref.WeakReference;
/**
* Controls the animation of swiping back and returning to launcher.
*
* This is a two part animation. The first part is an animation that tracks gesture location to
* scale and move the leaving app window. Once the gesture is committed, the second part takes over
* the app window and plays the rest of app close transitions in one go.
*
* This animation is used only for apps that enable back dispatching via
* {@link android.window.OnBackInvokedDispatcher}. The controller registers
* an {@link IOnBackInvokedCallback} with WM Shell and receives back dispatches when a back
* navigation to launcher starts.
*
* Apps using the legacy back dispatching will keep triggering the WALLPAPER_OPEN remote
* transition registered in {@link QuickstepTransitionManager}.
*
*/
public class LauncherBackAnimationController {
private static final int SCRIM_FADE_DURATION = 233;
private static final float MIN_WINDOW_SCALE =
Flags.predictiveBackToHomePolish() ? 0.75f : 0.85f;
private static final float MAX_SCRIM_ALPHA_DARK = 0.8f;
private static final float MAX_SCRIM_ALPHA_LIGHT = 0.2f;
private static final int MIN_BLUR_RADIUS_PRE_COMMIT = 10;
private final QuickstepTransitionManager mQuickstepTransitionManager;
private final Matrix mTransformMatrix = new Matrix();
/** The window position at the beginning of the back animation. */
private final Rect mStartRect = new Rect();
/** The current window position. */
private final RectF mCurrentRect = new RectF();
private final QuickstepLauncher mLauncher;
private final int mWindowScaleMarginX;
private float mWindowScaleEndCornerRadius;
private float mWindowScaleStartCornerRadius;
private int mStatusBarHeight;
private final Interpolator mProgressInterpolator = Interpolators.BACK_GESTURE;
private final Interpolator mVerticalMoveInterpolator = new DecelerateInterpolator();
private final PointF mInitialTouchPos = new PointF();
private RemoteAnimationTarget mBackTarget;
private RemoteAnimationTarget mLauncherTarget;
private View mLauncherTargetView;
private final SurfaceControl.Transaction mTransaction = new SurfaceControl.Transaction();
private float mBackProgress = 0;
private boolean mBackInProgress = false;
private boolean mWaitStartTransition = false;
private OnBackInvokedCallbackStub mBackCallback;
private IRemoteAnimationFinishedCallback mAnimationFinishedCallback;
private final BackProgressAnimator mProgressAnimator = new BackProgressAnimator();
private SurfaceControl mScrimLayer;
private ValueAnimator mScrimAlphaAnimator;
private float mScrimAlpha;
private boolean mOverridingStatusBarFlags;
private int mMaxBlurRadius;
private int mLastBlurRadius = 0;
private final ComponentCallbacks mComponentCallbacks = new ComponentCallbacks() {
@Override
public void onConfigurationChanged(Configuration newConfig) {
loadResources();
}
@Override
public void onLowMemory() {}
};
public LauncherBackAnimationController(
QuickstepLauncher launcher,
QuickstepTransitionManager quickstepTransitionManager) {
mLauncher = launcher;
mQuickstepTransitionManager = quickstepTransitionManager;
loadResources();
mWindowScaleMarginX = mLauncher.getResources().getDimensionPixelSize(
R.dimen.swipe_back_window_scale_x_margin);
}
/**
* Registers {@link IOnBackInvokedCallback} to receive back dispatches from shell.
* @param handler Handler to the thread to run the animations on.
*/
public void registerBackCallbacks(Handler handler) {
mBackCallback = new OnBackInvokedCallbackStub(handler, mProgressAnimator,
mProgressInterpolator, this);
SystemUiProxy.INSTANCE.get(mLauncher).setBackToLauncherCallback(mBackCallback,
new RemoteAnimationRunnerStub(this,
removeDepartTargetFromMotion() ? handler : null));
}
private static class OnBackInvokedCallbackStub extends IOnBackInvokedCallback.Stub {
private Handler mHandler;
private BackProgressAnimator mProgressAnimator;
private final Interpolator mProgressInterpolator;
// LauncherBackAnimationController has strong reference to Launcher activity, the binder
// callback should not hold strong reference to it to avoid memory leak.
private WeakReference<LauncherBackAnimationController> mControllerRef;
private OnBackInvokedCallbackStub(
Handler handler,
BackProgressAnimator progressAnimator,
Interpolator progressInterpolator,
LauncherBackAnimationController controller) {
mHandler = handler;
mProgressAnimator = progressAnimator;
mProgressInterpolator = progressInterpolator;
mControllerRef = new WeakReference<>(controller);
}
@Override
public void onBackCancelled() {
mHandler.post(() -> {
LauncherBackAnimationController controller = mControllerRef.get();
if (controller != null) {
mProgressAnimator.onBackCancelled(controller::onCancelFinished);
}
});
}
@Override
public void onBackInvoked() {
mHandler.post(() -> {
LauncherBackAnimationController controller = mControllerRef.get();
if (controller != null) {
if (!removeDepartTargetFromMotion()) {
controller.startTransition();
} else {
controller.mWaitStartTransition = true;
if (controller.mBackTarget != null && controller.mBackInProgress) {
controller.startTransition();
}
}
}
mProgressAnimator.reset();
});
}
@Override
public void onBackProgressed(BackMotionEvent backMotionEvent) {
mHandler.post(() -> {
LauncherBackAnimationController controller = mControllerRef.get();
if (controller == null
|| controller.mLauncher == null
|| !controller.mLauncher.isStarted()) {
// Skip animating back progress if Launcher isn't visible yet.
return;
}
mProgressAnimator.onBackProgressed(backMotionEvent);
});
}
@Override
public void onBackStarted(BackMotionEvent backEvent) {
mHandler.post(() -> {
LauncherBackAnimationController controller = mControllerRef.get();
if (controller != null) {
controller.initBackMotion(backEvent);
controller.tryStartBackAnimation();
mProgressAnimator.onBackStarted(backEvent, event -> {
float backProgress = event.getProgress();
controller.mBackProgress =
mProgressInterpolator.getInterpolation(backProgress);
controller.updateBackProgress(controller.mBackProgress, event);
});
}
});
}
@Override
public void setTriggerBack(boolean triggerBack) {
// TODO(b/261654570): track touch from the Launcher process.
}
@Override
public void setHandoffHandler(IBackAnimationHandoffHandler unused) {
// For now, Launcher handles this internally so it doesn't need to hand off the
// animation.
}
}
private static class RemoteAnimationRunnerStub extends IRemoteAnimationRunner.Stub {
// LauncherBackAnimationController has strong reference to Launcher activity, the binder
// callback should not hold strong reference to it to avoid memory leak.
private WeakReference<LauncherBackAnimationController> mControllerRef;
private final Handler mHandler;
private RemoteAnimationRunnerStub(LauncherBackAnimationController controller,
Handler handler) {
mControllerRef = new WeakReference<>(controller);
mHandler = handler;
}
@Override
public void onAnimationStart(int transit, RemoteAnimationTarget[] apps,
RemoteAnimationTarget[] wallpapers, RemoteAnimationTarget[] nonApps,
IRemoteAnimationFinishedCallback finishedCallback) {
LauncherBackAnimationController controller = mControllerRef.get();
if (controller == null) {
return;
}
final Runnable r = () -> {
for (final RemoteAnimationTarget target : apps) {
if (MODE_CLOSING == target.mode) {
controller.mBackTarget = target;
}
if (MODE_OPENING == target.mode) {
controller.mLauncherTarget = target;
}
}
controller.mAnimationFinishedCallback = finishedCallback;
if (!removeDepartTargetFromMotion()) {
return;
}
controller.tryStartBackAnimation();
if (controller.mWaitStartTransition) {
controller.startTransition();
}
};
if (mHandler != null) {
mHandler.post(r);
} else {
r.run();
}
}
@Override
public void onAnimationCancelled() {}
}
private void onCancelFinished() {
customizeStatusBarAppearance(false);
if (Flags.predictiveBackToHomePolish() && !mLauncher.getWorkspace().isOverlayShown()
&& !mLauncher.isInState(LauncherState.ALL_APPS)) {
setLauncherScale(ScalingWorkspaceRevealAnim.MAX_SIZE);
}
finishAnimation();
}
/** Unregisters the back to launcher callback in shell. */
public void unregisterBackCallbacks() {
if (mBackCallback != null) {
SystemUiProxy.INSTANCE.get(mLauncher).clearBackToLauncherCallback(mBackCallback);
}
mProgressAnimator.reset();
mBackCallback = null;
}
private void initBackMotion(BackMotionEvent backEvent) {
// in case we're still animating an onBackCancelled event, let's remove the finish-
// callback from the progress animator to prevent calling finishAnimation() before
// restarting a new animation
// Side note: initBackMotion is never called during the post-commit phase if the back
// gesture was committed (not cancelled). BackAnimationController prevents that. Therefore
// we don't have to handle that case.
mProgressAnimator.removeOnBackCancelledFinishCallback();
if (!removeDepartTargetFromMotion()) {
RemoteAnimationTarget appTarget = backEvent.getDepartingAnimationTarget();
if (appTarget == null || appTarget.leash == null || !appTarget.leash.isValid()) {
return;
}
mBackTarget = appTarget;
}
mBackInProgress = true;
mInitialTouchPos.set(backEvent.getTouchX(), backEvent.getTouchY());
}
private void tryStartBackAnimation() {
if (mBackTarget == null || (removeDepartTargetFromMotion() && !mBackInProgress)) {
return;
}
mTransaction
.show(mBackTarget.leash)
.setAnimationTransaction();
mStartRect.set(mBackTarget.windowConfiguration.getMaxBounds());
// inset bottom in case of taskbar being present
if (!predictiveBackThreeButtonNav() || mLauncher.getDeviceProfile().isTaskbarPresent
|| DisplayController.getNavigationMode(mLauncher) == NavigationMode.NO_BUTTON) {
mStartRect.inset(0, 0, 0, mBackTarget.contentInsets.bottom);
}
mLauncherTargetView = mQuickstepTransitionManager.findLauncherView(
new RemoteAnimationTarget[]{ mBackTarget });
setLauncherTargetViewVisible(false);
mCurrentRect.set(mStartRect);
if (Flags.predictiveBackToHomePolish() && !mLauncher.getWorkspace().isOverlayShown()
&& !mLauncher.isInState(LauncherState.ALL_APPS)) {
Animations.cancelOngoingAnimation(mLauncher.getWorkspace());
Animations.cancelOngoingAnimation(mLauncher.getHotseat());
if (Flags.predictiveBackToHomeBlur()) {
mLauncher.getDepthController().pauseBlursOnWindows(true);
}
mLauncher.getDepthController().stateDepth.setValue(
LauncherState.BACKGROUND_APP.getDepth(mLauncher));
setLauncherScale(ScalingWorkspaceRevealAnim.MIN_SIZE);
}
if (mScrimLayer == null) {
addScrimLayer();
}
applyTransaction();
}
private void setLauncherTargetViewVisible(boolean isVisible) {
if (mLauncherTargetView instanceof BubbleTextView) {
((BubbleTextView) mLauncherTargetView).setIconVisible(isVisible);
} else if (mLauncherTargetView instanceof LauncherAppWidgetHostView) {
mLauncherTargetView.setAlpha(isVisible ? 1f : 0f);
}
}
private void setLauncherScale(float scale) {
mLauncher.getWorkspace().setScaleX(scale);
mLauncher.getWorkspace().setScaleY(scale);
mLauncher.getHotseat().setScaleX(scale);
mLauncher.getHotseat().setScaleY(scale);
}
void addScrimLayer() {
SurfaceControl parent = mLauncherTarget != null ? mLauncherTarget.leash : null;
if (parent == null || !parent.isValid()) {
// Parent surface is not ready at the moment. Retry later.
return;
}
boolean isDarkTheme = Utilities.isDarkTheme(mLauncher);
mScrimLayer = new SurfaceControl.Builder()
.setName("Back to launcher background scrim")
.setCallsite("LauncherBackAnimationController")
.setColorLayer()
.setParent(parent)
.setOpaque(false)
.setHidden(false)
.build();
final float[] colorComponents = new float[] { 0f, 0f, 0f };
mScrimAlpha = (isDarkTheme)
? MAX_SCRIM_ALPHA_DARK : MAX_SCRIM_ALPHA_LIGHT;
setBlur(mMaxBlurRadius);
mTransaction
.setColor(mScrimLayer, colorComponents)
.setAlpha(mScrimLayer, mScrimAlpha)
.show(mScrimLayer)
// Ensure the scrim layer occludes opening task & wallpaper
.setLayer(mScrimLayer, 1000);
}
void removeScrimLayer() {
if (mScrimLayer == null) {
return;
}
if (mScrimLayer.isValid()) {
mTransaction.remove(mScrimLayer);
applyTransaction();
}
mScrimLayer = null;
}
private void updateBackProgress(float progress, BackEvent event) {
if (!mBackInProgress || mBackTarget == null) {
return;
}
if (mScrimLayer == null) {
// Scrim hasn't been attached yet. Let's attach it.
addScrimLayer();
} else {
mLastBlurRadius = (int) lerp(mMaxBlurRadius, MIN_BLUR_RADIUS_PRE_COMMIT, progress);
setBlur(mLastBlurRadius);
}
float screenWidth = mStartRect.width();
float screenHeight = mStartRect.height();
float width = Utilities.mapRange(progress, 1, MIN_WINDOW_SCALE) * screenWidth;
float height = screenHeight / screenWidth * width;
// Base the window movement in the Y axis on the touch movement in the Y axis.
float rawYDelta = event.getTouchY() - mInitialTouchPos.y;
float yDirection = rawYDelta < 0 ? -1 : 1;
// limit yDelta interpretation to 1/2 of screen height in either direction
float deltaYRatio = Math.min(screenHeight / 2f, Math.abs(rawYDelta)) / (screenHeight / 2f);
float interpolatedYRatio = mVerticalMoveInterpolator.getInterpolation(deltaYRatio);
// limit y-shift so surface never passes 8dp screen margin
float deltaY = yDirection * interpolatedYRatio * Math.max(0f, (screenHeight - height)
/ 2f - mWindowScaleMarginX);
// Move the window along the Y axis.
float top = (screenHeight - height) * 0.5f + deltaY;
// Move the window along the X axis.
float left = switch (event.getSwipeEdge()) {
case BackEvent.EDGE_RIGHT -> progress * mWindowScaleMarginX;
case BackEvent.EDGE_LEFT -> screenWidth - progress * mWindowScaleMarginX - width;
default -> (screenWidth - width) / 2;
};
mCurrentRect.set(left, top, left + width, top + height);
float cornerRadius = Utilities.mapRange(
progress, mWindowScaleStartCornerRadius, mWindowScaleEndCornerRadius);
applyTransform(mCurrentRect, cornerRadius);
customizeStatusBarAppearance(top > mStatusBarHeight / 2);
}
private void setBlur(int blurRadius) {
if (Flags.predictiveBackToHomeBlur()) {
mTransaction.setBackgroundBlurRadius(mScrimLayer, blurRadius);
}
}
/** Transform the target window to match the target rect. */
private void applyTransform(RectF targetRect, float cornerRadius) {
final float scale = targetRect.width() / mStartRect.width();
mTransformMatrix.reset();
mTransformMatrix.setScale(scale, scale);
mTransformMatrix.postTranslate(targetRect.left, targetRect.top);
if (mBackTarget.leash.isValid()) {
mTransaction.setMatrix(mBackTarget.leash, mTransformMatrix, new float[9]);
mTransaction.setWindowCrop(mBackTarget.leash, mStartRect);
mTransaction.setCornerRadius(mBackTarget.leash, cornerRadius);
}
applyTransaction();
}
private void applyTransaction() {
mTransaction.setFrameTimelineVsync(Choreographer.getInstance().getVsyncId());
mTransaction.apply();
}
private void startTransition() {
if (!removeDepartTargetFromMotion()) {
if (mBackTarget == null) {
// Trigger transition system instead of custom transition animation.
finishAnimation();
return;
}
} else {
mWaitStartTransition = false;
}
if (mLauncher.isDestroyed()) {
return;
}
mLauncher.setPredictiveBackToHomeInProgress(true);
LauncherTaskbarUIController taskbarUIController = mLauncher.getTaskbarUIController();
if (taskbarUIController != null) {
taskbarUIController.onLauncherVisibilityChanged(true);
}
// TODO: Catch the moment when launcher becomes visible after the top app un-occludes
// launcher and start animating afterwards. Currently we occasionally get a flicker from
// animating when launcher is still invisible.
if (mLauncher.hasSomeInvisibleFlag(PENDING_INVISIBLE_BY_WALLPAPER_ANIMATION)) {
mLauncher.addForceInvisibleFlag(INVISIBLE_BY_PENDING_FLAGS);
mLauncher.getStateManager().moveToRestState();
}
setLauncherTargetViewVisible(true);
// Explicitly close opened floating views (which is typically called from
// Launcher#onResumed, but in the predictive back flow launcher is not resumed until
// the transition is fully finished.)
AbstractFloatingView.closeAllOpenViewsExcept(mLauncher, false, TYPE_REBIND_SAFE);
float cornerRadius = Utilities.mapRange(
mBackProgress, mWindowScaleStartCornerRadius, mWindowScaleEndCornerRadius);
final RectF resolveRectF = new RectF();
mQuickstepTransitionManager.transferRectToTargetCoordinate(
mBackTarget, mCurrentRect, true, resolveRectF);
BackAnimState backAnim =
mQuickstepTransitionManager.createWallpaperOpenAnimations(
new RemoteAnimationTarget[]{mBackTarget},
new RemoteAnimationTarget[0],
new RemoteAnimationTarget[0],
resolveRectF,
cornerRadius,
mBackInProgress /* fromPredictiveBack */);
startTransitionAnimations(backAnim);
mLauncher.clearForceInvisibleFlag(INVISIBLE_ALL);
customizeStatusBarAppearance(true);
}
private void finishAnimation() {
mLauncher.setPredictiveBackToHomeInProgress(false);
if (mBackTarget != null && mBackTarget.leash.isValid()) {
mBackTarget.leash.release();
}
mBackTarget = null;
if (mLauncherTarget != null && mLauncherTarget.leash.isValid()) {
mLauncherTarget.leash.release();
}
mLauncherTarget = null;
mBackInProgress = false;
mBackProgress = 0;
mTransformMatrix.reset();
mCurrentRect.setEmpty();
mStartRect.setEmpty();
mInitialTouchPos.set(0, 0);
setLauncherTargetViewVisible(true);
mLauncherTargetView = null;
// We don't call customizeStatusBarAppearance here to prevent the status bar update with
// the legacy appearance. It should be refreshed after the transition done.
mOverridingStatusBarFlags = false;
if (mAnimationFinishedCallback != null) {
try {
mAnimationFinishedCallback.onAnimationFinished();
} catch (RemoteException e) {
Log.w("ShellBackPreview", "Failed call onBackAnimationFinished", e);
}
mAnimationFinishedCallback = null;
}
if (mScrimAlphaAnimator != null && mScrimAlphaAnimator.isRunning()) {
mScrimAlphaAnimator.cancel();
mScrimAlphaAnimator = null;
}
if (mScrimLayer != null) {
removeScrimLayer();
}
if (Flags.predictiveBackToHomePolish() && Flags.predictiveBackToHomeBlur()
&& !mLauncher.getWorkspace().isOverlayShown()
&& !mLauncher.isInState(LauncherState.ALL_APPS)) {
mLauncher.getDepthController().pauseBlursOnWindows(false);
}
mLastBlurRadius = 0;
}
private void startTransitionAnimations(BackAnimState backAnim) {
backAnim.addOnAnimCompleteCallback(this::finishAnimation);
if (mScrimLayer == null) {
// Scrim hasn't been attached yet. Let's attach it.
addScrimLayer();
}
mScrimAlphaAnimator = ValueAnimator.ofFloat(1, 0);
mScrimAlphaAnimator.addUpdateListener(animation -> {
float value = (Float) animation.getAnimatedValue();
if (mScrimLayer != null && mScrimLayer.isValid()) {
mTransaction.setAlpha(mScrimLayer, value * mScrimAlpha);
setBlur((int) lerp(mLastBlurRadius, 0, 1f - value));
applyTransaction();
}
});
mScrimAlphaAnimator.addListener(new AnimatorListenerAdapter() {
@Override
public void onAnimationEnd(Animator animation) {
resetScrim();
}
});
mScrimAlphaAnimator.setDuration(SCRIM_FADE_DURATION).start();
backAnim.start(mLauncher.getStateManager());
}
private void loadResources() {
mWindowScaleEndCornerRadius = QuickStepContract.supportsRoundedCornersOnWindows(
mLauncher.getResources())
? mLauncher.getResources().getDimensionPixelSize(
R.dimen.swipe_back_window_corner_radius)
: 0;
mWindowScaleStartCornerRadius = QuickStepContract.getWindowCornerRadius(mLauncher);
mStatusBarHeight = SystemBarUtils.getStatusBarHeight(mLauncher);
if (Flags.allAppsBlur() || enableOverviewBackgroundWallpaperBlur()) {
mMaxBlurRadius = mLauncher.getResources().getDimensionPixelSize(
R.dimen.max_depth_blur_radius_enhanced);
} else {
mMaxBlurRadius = mLauncher.getResources().getInteger(R.integer.max_depth_blur_radius);
}
}
/**
* Called when launcher is destroyed. Unregisters component callbacks to avoid memory leaks.
*/
public void unregisterComponentCallbacks() {
mLauncher.unregisterComponentCallbacks(mComponentCallbacks);
}
/**
* Registers component callbacks with the launcher to receive configuration change events.
*/
public void registerComponentCallbacks() {
mLauncher.registerComponentCallbacks(mComponentCallbacks);
}
private void resetScrim() {
removeScrimLayer();
mScrimAlpha = 0;
}
private void customizeStatusBarAppearance(boolean overridingStatusBarFlags) {
if (mOverridingStatusBarFlags == overridingStatusBarFlags) {
return;
}
mOverridingStatusBarFlags = overridingStatusBarFlags;
final boolean isBackgroundDark =
(mLauncher.getWindow().getDecorView().getSystemUiVisibility()
& View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR) == 0;
final AppearanceRegion region = mOverridingStatusBarFlags
? new AppearanceRegion(!isBackgroundDark ? APPEARANCE_LIGHT_STATUS_BARS : 0,
mBackTarget.windowConfiguration.getBounds())
: null;
SystemUiProxy.INSTANCE.get(mLauncher).customizeStatusBarAppearance(region);
}
}