Files
Flexera-Launcher/quickstep/src/com/android/launcher3/taskbar/LauncherTaskbarUIController.java
T
Jon Miranda 9bf65787e9 Prevent NPE when syncing app launch with taskbar stash.
This can happen because when callback is ran after onDestroy.
We call the runnable as part of the cleanup process to avoid
a leak.

Bug: 319162553
Fixes: 405316024
Test: Launch an app, note the two animations are synced
      Verified by locally introducing a startDelay (since otherwise it is hard to tell)
Flag: com.android.launcher3.sync_app_launch_with_taskbar_stash
Change-Id: I961b9a185b2751a8a908d1a7b2cbfdb8bfe0b8f9
2025-03-25 15:18:03 -07:00

637 lines
25 KiB
Java

/*
* Copyright (C) 2021 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.taskbar;
import static android.window.DesktopModeFlags.ENABLE_DESKTOP_WINDOWING_WALLPAPER_ACTIVITY;
import static com.android.launcher3.Flags.syncAppLaunchWithTaskbarStash;
import static com.android.launcher3.QuickstepTransitionManager.TASKBAR_TO_APP_DURATION;
import static com.android.launcher3.QuickstepTransitionManager.TRANSIENT_TASKBAR_TRANSITION_DURATION;
import static com.android.launcher3.QuickstepTransitionManager.getTaskbarToHomeDuration;
import static com.android.launcher3.statemanager.BaseState.FLAG_NON_INTERACTIVE;
import static com.android.launcher3.taskbar.TaskbarEduTooltipControllerKt.TOOLTIP_STEP_FEATURES;
import static com.android.launcher3.taskbar.TaskbarLauncherStateController.FLAG_VISIBLE;
import static com.android.launcher3.taskbar.TaskbarStashController.FLAG_IGNORE_IN_APP;
import android.animation.Animator;
import android.animation.AnimatorSet;
import android.window.RemoteTransition;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import com.android.launcher3.DeviceProfile;
import com.android.launcher3.Flags;
import com.android.launcher3.Hotseat;
import com.android.launcher3.LauncherState;
import com.android.launcher3.Utilities;
import com.android.launcher3.anim.AnimatedFloat;
import com.android.launcher3.logging.InstanceId;
import com.android.launcher3.logging.InstanceIdSequence;
import com.android.launcher3.model.data.ItemInfo;
import com.android.launcher3.taskbar.bubbles.BubbleBarController;
import com.android.launcher3.taskbar.bubbles.BubbleControllers;
import com.android.launcher3.uioverrides.QuickstepLauncher;
import com.android.launcher3.util.DisplayController;
import com.android.launcher3.util.MultiPropertyFactory;
import com.android.launcher3.util.OnboardingPrefs;
import com.android.quickstep.GestureState;
import com.android.quickstep.HomeVisibilityState;
import com.android.quickstep.LauncherActivityInterface;
import com.android.quickstep.RecentsAnimationCallbacks;
import com.android.quickstep.SystemUiProxy;
import com.android.quickstep.fallback.window.RecentsDisplayModel;
import com.android.quickstep.fallback.window.RecentsWindowFlags;
import com.android.quickstep.util.SplitTask;
import com.android.quickstep.views.RecentsView;
import com.android.quickstep.views.RecentsViewContainer;
import com.android.systemui.shared.system.QuickStepContract.SystemUiStateFlags;
import com.android.wm.shell.shared.bubbles.BubbleBarLocation;
import com.android.wm.shell.shared.desktopmode.DesktopModeStatus;
import java.io.PrintWriter;
import java.util.Arrays;
/**
* A data source which integrates with a Launcher instance
*/
public class LauncherTaskbarUIController extends TaskbarUIController {
private static final String TAG = "TaskbarUIController";
public static final int MINUS_ONE_PAGE_PROGRESS_INDEX = 0;
public static final int ALL_APPS_PAGE_PROGRESS_INDEX = 1;
public static final int WIDGETS_PAGE_PROGRESS_INDEX = 2;
public static final int SYSUI_SURFACE_PROGRESS_INDEX = 3;
public static final int LAUNCHER_PAUSE_PROGRESS_INDEX = 4;
public static final int DISPLAY_PROGRESS_COUNT = 5;
private final AnimatedFloat mTaskbarInAppDisplayProgress = new AnimatedFloat(
this::onInAppDisplayProgressChanged);
private final MultiPropertyFactory<AnimatedFloat> mTaskbarInAppDisplayProgressMultiProp =
new MultiPropertyFactory<>(mTaskbarInAppDisplayProgress,
AnimatedFloat.VALUE, DISPLAY_PROGRESS_COUNT, Float::max);
private final AnimatedFloat mLauncherPauseProgress = new AnimatedFloat(
this::onLauncherPauseProgressUpdate);
private final QuickstepLauncher mLauncher;
private final HomeVisibilityState mHomeState;
private final DeviceProfile.OnDeviceProfileChangeListener mOnDeviceProfileChangeListener =
dp -> {
onStashedInAppChanged(dp);
postAdjustHotseatForBubbleBar();
if (mControllers != null && mControllers.taskbarViewController != null) {
mControllers.taskbarViewController.onRotationChanged(dp);
}
};
private final HomeVisibilityState.VisibilityChangeListener mVisibilityChangeListener =
this::onLauncherVisibilityChanged;
// Initialized in init.
private final TaskbarLauncherStateController
mTaskbarLauncherStateController = new TaskbarLauncherStateController();
// When overview-in-a-window is enabled, that window is the container, else it is mLauncher.
private RecentsViewContainer mRecentsViewContainer;
public LauncherTaskbarUIController(QuickstepLauncher launcher) {
mLauncher = launcher;
mHomeState = SystemUiProxy.INSTANCE.get(mLauncher).getHomeVisibilityState();
}
@Override
protected void init(TaskbarControllers taskbarControllers) {
super.init(taskbarControllers);
mTaskbarLauncherStateController.init(mControllers, mLauncher,
mControllers.getSharedState().sysuiStateFlags);
final TaskbarActivityContext taskbarContext = mControllers.taskbarActivityContext;
if (RecentsWindowFlags.getEnableOverviewInWindow()) {
mRecentsViewContainer = RecentsDisplayModel.getINSTANCE()
.get(taskbarContext).getRecentsWindowManager(taskbarContext.getDisplayId());
}
if (mRecentsViewContainer == null) {
mRecentsViewContainer = mLauncher;
}
mLauncher.setTaskbarUIController(this);
if (mRecentsViewContainer != mLauncher) {
mRecentsViewContainer.setTaskbarUIController(this);
}
mHomeState.addListener(mVisibilityChangeListener);
onLauncherVisibilityChanged(
Flags.useActivityOverlay()
? mHomeState.isHomeVisible() : mLauncher.hasBeenResumed(),
true /* fromInit */);
onStashedInAppChanged(mLauncher.getDeviceProfile());
mLauncher.addOnDeviceProfileChangeListener(mOnDeviceProfileChangeListener);
// Restore the in-app display progress from before Taskbar was recreated.
float[] prevProgresses = mControllers.getSharedState().inAppDisplayProgressMultiPropValues;
// Make a copy of the previous progress to set since updating the multiprop will update
// the property which also calls onInAppDisplayProgressChanged() which writes the current
// values into the shared state
prevProgresses = Arrays.copyOf(prevProgresses, prevProgresses.length);
for (int i = 0; i < prevProgresses.length; i++) {
mTaskbarInAppDisplayProgressMultiProp.get(i).setValue(prevProgresses[i]);
}
}
@Override
protected void onDestroy() {
onLauncherVisibilityChanged(false /* isVisible */, true /* fromInitOrDestroy */);
mLauncher.removeOnDeviceProfileChangeListener(mOnDeviceProfileChangeListener);
super.onDestroy();
mTaskbarLauncherStateController.onDestroy();
mLauncher.setTaskbarUIController(null);
if (mRecentsViewContainer != mLauncher) {
mRecentsViewContainer.setTaskbarUIController(null);
}
mHomeState.removeListener(mVisibilityChangeListener);
}
private void onInAppDisplayProgressChanged() {
if (mControllers != null) {
// Update our shared state so we can restore it if taskbar gets recreated.
for (int i = 0; i < DISPLAY_PROGRESS_COUNT; i++) {
mControllers.getSharedState().inAppDisplayProgressMultiPropValues[i] =
mTaskbarInAppDisplayProgressMultiProp.get(i).getValue();
}
// Ensure nav buttons react to our latest state if necessary.
mControllers.navbarButtonsViewController.updateNavButtonTranslationY();
}
}
@Override
protected boolean isTaskbarTouchable() {
// Touching down during animation to Hotseat will end the transition and allow the touch to
// go through to the Hotseat directly.
return !isAnimatingToHotseat();
}
public void setShouldDelayLauncherStateAnim(boolean shouldDelayLauncherStateAnim) {
mTaskbarLauncherStateController.setShouldDelayLauncherStateAnim(
shouldDelayLauncherStateAnim);
}
@Override
public void stashHotseat(boolean stash) {
mTaskbarLauncherStateController.stashHotseat(stash);
}
@Override
public void unStashHotseatInstantly() {
mTaskbarLauncherStateController.unStashHotseatInstantly();
}
/**
* Adds the Launcher resume animator to the given animator set.
*
* This should be used to run a Launcher resume animation whose progress matches a
* swipe progress.
*
* @param placeholderDuration a placeholder duration to be used to ensure all full-length
* sub-animations are properly coordinated. This duration should not
* actually be used since this animation tracks a swipe progress.
*/
protected void addLauncherVisibilityChangedAnimation(AnimatorSet animation,
int placeholderDuration) {
animation.play(onLauncherVisibilityChanged(
/* isResumed= */ true,
/* fromInit= */ false,
/* startAnimation= */ false,
placeholderDuration));
}
/**
* Should be called from onResume() and onPause(), and animates the Taskbar accordingly.
*/
@Override
public void onLauncherVisibilityChanged(boolean isVisible) {
if (DesktopModeStatus.enterDesktopByDefaultOnFreeformDisplay(mLauncher)
&& mControllers.taskbarActivityContext.isPrimaryDisplay()) {
DisplayController.INSTANCE.get(mLauncher).notifyConfigChange();
}
onLauncherVisibilityChanged(isVisible, false /* fromInit */);
}
private void onLauncherVisibilityChanged(boolean isVisible, boolean fromInitOrDestroy) {
if (mControllers == null) {
return;
}
onLauncherVisibilityChanged(
isVisible,
fromInitOrDestroy,
/* startAnimation= */ true,
getTaskbarAnimationDuration(isVisible));
}
private int getTaskbarAnimationDuration(boolean isVisible) {
// fast animation duration since we will not be playing workspace reveal animation.
boolean shouldOverrideToFastAnimation = !isHotseatIconOnTopWhenAligned();
if (!Flags.predictiveBackToHomePolish()) {
shouldOverrideToFastAnimation |= mLauncher.getPredictiveBackToHomeInProgress();
}
boolean isPinned = mControllers.taskbarActivityContext.isPinnedTaskbar();
if (isVisible || isPinned) {
return getTaskbarToHomeDuration(shouldOverrideToFastAnimation, isPinned);
} else {
return (mControllers.taskbarActivityContext.isTransientTaskbar())
? TRANSIENT_TASKBAR_TRANSITION_DURATION : TASKBAR_TO_APP_DURATION;
}
}
@Nullable
private Animator onLauncherVisibilityChanged(
boolean isVisible, boolean fromInitOrDestroy, boolean startAnimation, int duration) {
// Launcher is resumed during the swipe-to-overview gesture under shell-transitions, so
// avoid updating taskbar state in that situation (when it's non-interactive -- or
// "background") to avoid premature animations.
LauncherState state = mTaskbarLauncherStateController.getLauncherState();
boolean nonInteractiveState = state.hasFlag(FLAG_NON_INTERACTIVE)
&& !state.isTaskbarAlignedWithHotseat(mLauncher);
if (isVisible && (nonInteractiveState || mSkipLauncherVisibilityChange)) {
return null;
}
if (!ENABLE_DESKTOP_WINDOWING_WALLPAPER_ACTIVITY.isTrue()
&& mControllers.taskbarDesktopModeController
.isInDesktopModeAndNotInOverview(mLauncher.getDisplayId())) {
// TODO: b/333533253 - Remove after flag rollout
isVisible = false;
}
mTaskbarLauncherStateController.updateStateForFlag(FLAG_VISIBLE, isVisible);
if (fromInitOrDestroy) {
duration = 0;
}
return mTaskbarLauncherStateController.applyState(duration, startAnimation);
}
@Override
public void onStateTransitionCompletedAfterSwipeToHome(LauncherState state) {
mTaskbarLauncherStateController.onStateTransitionCompletedAfterSwipeToHome(state);
}
@Override
public void refreshResumedState() {
onLauncherVisibilityChanged(Flags.useActivityOverlay()
? mHomeState.isHomeVisible() : mLauncher.hasBeenResumed());
}
@Override
public void adjustHotseatForBubbleBar(boolean isBubbleBarVisible) {
if (mLauncher.getHotseat() != null) {
mLauncher.getHotseat().adjustForBubbleBar(isBubbleBarVisible);
}
}
private void postAdjustHotseatForBubbleBar() {
Hotseat hotseat = mLauncher.getHotseat();
if (hotseat == null || !isBubbleBarVisible()) return;
hotseat.post(() -> {
if (mControllers == null) return;
adjustHotseatForBubbleBar(isBubbleBarVisible());
});
}
private boolean isBubbleBarVisible() {
BubbleControllers bubbleControllers = mControllers.bubbleControllers.orElse(null);
return bubbleControllers != null
&& bubbleControllers.bubbleBarViewController.isBubbleBarVisible();
}
/**
* Create Taskbar animation when going from an app to Launcher as part of recents transition.
* {@inheritDoc}
*/
@Override
public Animator getParallelAnimationToGestureEndTarget(
GestureState.GestureEndTarget gestureEndTarget, long duration,
RecentsAnimationCallbacks callbacks) {
return mTaskbarLauncherStateController.createAnimToLauncher(
LauncherActivityInterface.INSTANCE.stateFromGestureEndTarget(gestureEndTarget),
callbacks,
duration);
}
/**
* Create Taskbar animation to be played alongside the Launcher app launch animation.
*/
public @Nullable Animator createAnimToApp() {
if (!syncAppLaunchWithTaskbarStash()) {
return null;
}
TaskbarStashController stashController = mControllers.taskbarStashController;
stashController.updateStateForFlag(TaskbarStashController.FLAG_IN_APP, true);
return stashController.createApplyStateAnimator(stashController.getStashDuration());
}
/**
* Temporarily ignore FLAG_IN_APP for app launches to prevent premature taskbar stashing.
* This is needed because taskbar gets a signal to stash before we actually start the
* app launch animation.
*/
public void setIgnoreInAppFlagForSync(boolean enabled) {
if (syncAppLaunchWithTaskbarStash()
&& mControllers != null
&& mControllers.taskbarStashController != null) {
mControllers.taskbarStashController.updateStateForFlag(FLAG_IGNORE_IN_APP, enabled);
}
}
public void updateTaskbarLauncherStateGoingHome() {
mTaskbarLauncherStateController.updateStateForFlag(FLAG_VISIBLE, true);
mTaskbarLauncherStateController.applyState();
}
public boolean isDraggingItem() {
boolean bubblesDragging = false;
if (mControllers.bubbleControllers.isPresent()) {
bubblesDragging =
mControllers.bubbleControllers.get().bubbleDragController.isDragging();
}
return mControllers.taskbarDragController.isDragging() || bubblesDragging;
}
@Override
protected void onStashedInAppChanged() {
onStashedInAppChanged(mLauncher.getDeviceProfile());
}
private void onStashedInAppChanged(DeviceProfile deviceProfile) {
boolean taskbarStashedInApps = mControllers.taskbarStashController.isStashedInApp();
deviceProfile.isTaskbarPresentInApps = !taskbarStashedInApps;
}
/**
* Starts a Taskbar EDU flow, if the user should see one upon launching an application.
*/
public void showEduOnAppLaunch() {
if (!shouldShowEduOnAppLaunch()) {
// Called in case the edu finishes and search edu is still pending
mControllers.taskbarEduTooltipController.maybeShowSearchEdu();
return;
}
// Persistent features EDU tooltip.
if (!mControllers.taskbarActivityContext.isTransientTaskbar()) {
mControllers.taskbarEduTooltipController.maybeShowFeaturesEdu();
return;
}
// Transient swipe EDU tooltip.
mControllers.taskbarEduTooltipController.maybeShowSwipeEdu();
}
/** Will make the next onRecentsAnimationFinished() animation a no-op. */
public void setSkipNextRecentsAnimEnd() {
mTaskbarLauncherStateController.setSkipNextRecentsAnimEnd();
}
/**
* Returns {@code true} if a Taskbar education should be shown on application launch.
*/
public boolean shouldShowEduOnAppLaunch() {
if (Utilities.isRunningInTestHarness()) {
return false;
}
// Persistent features EDU tooltip.
if (!mControllers.taskbarActivityContext.isTransientTaskbar()) {
return !OnboardingPrefs.TASKBAR_EDU_TOOLTIP_STEP.hasReachedMax(mLauncher);
}
// Transient swipe EDU tooltip.
return mControllers.taskbarEduTooltipController.getTooltipStep() < TOOLTIP_STEP_FEATURES;
}
@Override
public void onTaskbarIconLaunched(ItemInfo item) {
super.onTaskbarIconLaunched(item);
InstanceId instanceId = new InstanceIdSequence().newInstanceId();
mLauncher.logAppLaunch(mControllers.taskbarActivityContext.getStatsLogManager(), item,
instanceId);
}
/**
* Animates Taskbar elements during a transition to a Launcher state that should use in-app
* layouts.
*
* @param progress [0, 1]
* 0 => use home layout
* 1 => use in-app layout
*/
public void onTaskbarInAppDisplayProgressUpdate(float progress, int progressIndex) {
mTaskbarInAppDisplayProgressMultiProp.get(progressIndex).setValue(progress);
if (mControllers == null) {
// This method can be called before init() is called.
return;
}
if (mControllers.uiController.isIconAlignedWithHotseat()) {
if (!mTaskbarLauncherStateController.isAnimatingToLauncher()) {
// Only animate the nav buttons while home and not animating home, otherwise let
// the TaskbarViewController handle it.
mControllers.navbarButtonsViewController
.getTaskbarNavButtonTranslationYForInAppDisplay()
.updateValue(mLauncher.getDeviceProfile().getTaskbarOffsetY()
* mTaskbarInAppDisplayProgress.value);
mControllers.navbarButtonsViewController
.getOnTaskbarBackgroundNavButtonColorOverride().updateValue(progress);
}
if (isBubbleBarEnabled()) {
mControllers.bubbleControllers.ifPresent(
c -> c.bubbleStashController.setInAppDisplayOverrideProgress(
mTaskbarInAppDisplayProgress.value));
}
}
}
/** Returns true iff any in-app display progress > 0. */
public boolean shouldUseInAppLayout() {
return mTaskbarInAppDisplayProgress.value > 0;
}
public boolean isBubbleBarEnabled() {
return BubbleBarController.isBubbleBarEnabled();
}
/** Whether the bubble bar has any bubbles. */
public boolean hasBubbles() {
if (mControllers == null) {
return false;
}
if (mControllers.bubbleControllers.isEmpty()) {
return false;
}
return mControllers.bubbleControllers.get().bubbleBarViewController.hasBubbles();
}
@Override
public void onExpandPip() {
super.onExpandPip();
mTaskbarLauncherStateController.updateStateForFlag(FLAG_VISIBLE, false);
mTaskbarLauncherStateController.applyState();
}
@Override
public void updateStateForSysuiFlags(@SystemUiStateFlags long sysuiFlags) {
mTaskbarLauncherStateController.updateStateForSysuiFlags(sysuiFlags);
}
@Override
public boolean isIconAlignedWithHotseat() {
return mTaskbarLauncherStateController.isIconAlignedWithHotseat();
}
@Override
public boolean isHotseatIconOnTopWhenAligned() {
return mTaskbarLauncherStateController.isInHotseatOnTopStates()
&& mTaskbarInAppDisplayProgressMultiProp.get(MINUS_ONE_PAGE_PROGRESS_INDEX)
.getValue() == 0;
}
@Override
public boolean isAnimatingToHotseat() {
return mTaskbarLauncherStateController.isAnimatingToLauncher()
&& isIconAlignedWithHotseat();
}
@Override
public void endAnimationToHotseat() {
mTaskbarLauncherStateController.resetIconAlignment();
}
@Override
protected boolean isInOverviewUi() {
return mTaskbarLauncherStateController.isInOverviewUi();
}
@Override
protected void toggleAllApps(boolean focusSearch) {
boolean canToggleHomeAllApps = mLauncher.isResumed()
&& !mTaskbarLauncherStateController.isInOverviewUi()
&& !mLauncher.areDesktopTasksVisible();
if (canToggleHomeAllApps) {
mLauncher.toggleAllApps(focusSearch);
return;
}
super.toggleAllApps(focusSearch);
}
@Override
public RecentsView getRecentsView() {
return mRecentsViewContainer.getOverviewPanel();
}
@Override
public void launchSplitTasks(
@NonNull SplitTask splitTask, @Nullable RemoteTransition remoteTransition) {
mLauncher.launchSplitTasks(splitTask, remoteTransition);
}
@Override
protected void onIconLayoutBoundsChanged() {
mTaskbarLauncherStateController.resetIconAlignment();
}
@Override
public void dumpLogs(String prefix, PrintWriter pw) {
super.dumpLogs(prefix, pw);
pw.println(String.format("%s\tTaskbar in-app display progress: %.2f", prefix,
mTaskbarInAppDisplayProgress.value));
mTaskbarInAppDisplayProgressMultiProp.dump(
prefix + "\t\t",
pw,
"mTaskbarInAppDisplayProgressMultiProp",
"MINUS_ONE_PAGE_PROGRESS_INDEX",
"ALL_APPS_PAGE_PROGRESS_INDEX",
"WIDGETS_PAGE_PROGRESS_INDEX",
"SYSUI_SURFACE_PROGRESS_INDEX",
"LAUNCHER_PAUSE_PROGRESS_INDEX");
pw.println(String.format("%s\tmRecentsWindowContainer=%s", prefix, mRecentsViewContainer));
mTaskbarLauncherStateController.dumpLogs(prefix + "\t", pw);
}
@Override
protected String getTaskbarUIControllerName() {
return "LauncherTaskbarUIController";
}
@Override
public void onBubbleBarLocationAnimated(BubbleBarLocation location) {
mTaskbarLauncherStateController.onBubbleBarLocationChanged(location, /* animate = */ true);
mLauncher.setBubbleBarLocation(location);
}
@Override
public void onBubbleBarLocationUpdated(BubbleBarLocation location) {
mTaskbarLauncherStateController.onBubbleBarLocationChanged(location, /* animate = */ false);
mLauncher.setBubbleBarLocation(location);
}
@Override
public void onSwipeToUnstashTaskbar() {
// Once taskbar is unstashed, the user cannot return back to the overlay. We can
// clear it here to set the expected state once the user goes home.
if (mLauncher.getWorkspace().isOverlayShown()) {
mLauncher.getWorkspace().onOverlayScrollChanged(0);
}
}
/**
* Called when Launcher Activity resumed while staying at home.
* <p>
* Shift nav buttons up to at-home position.
*/
public void onLauncherResume() {
mLauncherPauseProgress.animateToValue(0.0f).start();
}
/**
* Called when Launcher Activity paused while staying at home.
* <p>
* To avoid UI clash between taskbar & bottom sheet, shift nav buttons down to in-app position.
*/
public void onLauncherPause() {
mLauncherPauseProgress.animateToValue(1.0f).start();
}
/**
* On launcher stop, avoid animating taskbar & overriding pre-existing animations.
*/
public void onLauncherStop() {
mLauncherPauseProgress.cancelAnimation();
mLauncherPauseProgress.updateValue(0.0f);
}
private void onLauncherPauseProgressUpdate() {
// If we are not aligned with hotseat, setting this will clobber the 3 button nav position.
// So in that case, treat the progress as 0 instead.
float pauseProgress = isIconAlignedWithHotseat() ? mLauncherPauseProgress.value : 0;
onTaskbarInAppDisplayProgressUpdate(pauseProgress, LAUNCHER_PAUSE_PROGRESS_INDEX);
}
}