PawletOS/Lawnchair
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Snap for 9137459 from 6a84ebc7ab to tm-qpr2-release

Browse Source 
Change-Id: I26f76d5288970828711c73672ce7b2a39faa2bc2
This commit is contained in:
Android Build Coastguard Worker
2022-10-04 23:26:12 +00:00
parent c219457001 6a84ebc7ab
commit 2a6466976a
10 changed files with 163 additions and 214 deletions
Download Patch File Download Diff File Expand all files Collapse all files
quickstep/res/values/dimens.xml
+1 -1
View File
@@ -258,7 +258,7 @@
<dimen name="taskbar_contextual_button_padding">16dp</dimen>
<dimen name="taskbar_contextual_padding_top">8dp</dimen>
<dimen name="taskbar_nav_buttons_size">44dp</dimen>
<dimen name="taskbar_contextual_button_margin">47dp</dimen>
<dimen name="taskbar_contextual_button_margin">48dp</dimen>
<dimen name="taskbar_hotseat_nav_spacing">24dp</dimen>
<dimen name="taskbar_contextual_buttons_size">35dp</dimen>
<dimen name="taskbar_stashed_size">24dp</dimen>
quickstep/src/com/android/launcher3/taskbar/NavbarButtonsViewController.java
+9 -2
View File
@@ -126,7 +126,8 @@ public class NavbarButtonsViewController implements TaskbarControllers.LoggableT
public static final int ALPHA_INDEX_IMMERSIVE_MODE = 0;
public static final int ALPHA_INDEX_KEYGUARD_OR_DISABLE = 1;
private static final int NUM_ALPHA_CHANNELS = 2;
public static final int ALPHA_INDEX_SUW = 2;
private static final int NUM_ALPHA_CHANNELS = 3;
private final ArrayList<StatePropertyHolder> mPropertyHolders = new ArrayList<>();
private final ArrayList<ImageView> mAllButtons = new ArrayList<>();
@@ -270,11 +271,17 @@ public class NavbarButtonsViewController implements TaskbarControllers.LoggableT
// end-aligned, so start-align instead.
FrameLayout.LayoutParams navButtonsLayoutParams = (FrameLayout.LayoutParams)
mNavButtonContainer.getLayoutParams();
navButtonsLayoutParams.setMarginStart(navButtonsLayoutParams.getMarginEnd());
navButtonsLayoutParams.setMarginStart(
resources.getDimensionPixelSize(R.dimen.taskbar_contextual_button_margin));
navButtonsLayoutParams.setMarginEnd(0);
navButtonsLayoutParams.gravity = Gravity.START;
mNavButtonContainer.requestLayout();
// Hide back button in SUW if keyboard is showing (IME draws its own back).
mPropertyHolders.add(new StatePropertyHolder(
mBackButtonAlpha.getProperty(ALPHA_INDEX_SUW),
flags -> (flags & FLAG_IME_VISIBLE) == 0));
// TODO(b/210906568) Dark intensity is currently not propagated during setup, so set
// it based on dark theme for now.
int mode = resources.getConfiguration().uiMode
quickstep/src/com/android/launcher3/taskbar/TaskbarLauncherStateController.java
+106 -186
View File
@@ -50,7 +50,6 @@ import java.io.PrintWriter;
import java.util.HashMap;
import java.util.StringJoiner;
import java.util.function.Consumer;
import java.util.function.Supplier;
/**
* Track LauncherState, RecentsAnimation, resumed state for task bar in one place here and animate
@@ -65,15 +64,12 @@ import java.util.function.Supplier;
public static final int FLAG_RECENTS_ANIMATION_RUNNING = 1 << 1;
public static final int FLAG_TRANSITION_STATE_RUNNING = 1 << 2;
private static final int FLAGS_LAUNCHER = FLAG_RESUMED | FLAG_RECENTS_ANIMATION_RUNNING;
/** Equivalent to an int with all 1s for binary operation purposes */
private static final int FLAGS_ALL = ~0;
private final AnimatedFloat mIconAlignmentForResumedState =
new AnimatedFloat(this::onIconAlignmentRatioChangedForAppAndHomeTransition);
private final AnimatedFloat mIconAlignmentForGestureState =
new AnimatedFloat(this::onIconAlignmentRatioChangedForAppAndHomeTransition);
private final AnimatedFloat mIconAlignmentForLauncherState =
new AnimatedFloat(this::onIconAlignmentRatioChangedForStateTransition);
private final AnimatedFloat mIconAlignment =
new AnimatedFloat(this::onIconAlignmentRatioChanged);
private TaskbarControllers mControllers;
private AnimatedFloat mTaskbarBackgroundAlpha;
@@ -86,8 +82,7 @@ import java.util.function.Supplier;
private @Nullable TaskBarRecentsAnimationListener mTaskBarRecentsAnimationListener;
private boolean mIsAnimatingToLauncherViaGesture;
private boolean mIsAnimatingToLauncherViaResume;
private boolean mIsAnimatingToLauncher;
private boolean mShouldDelayLauncherStateAnim;
@@ -148,8 +143,8 @@ import java.util.function.Supplier;
mIconAlphaForHome = taskbarIconAlpha.getProperty(ALPHA_INDEX_HOME);
mIconAlphaForHome.setConsumer(mIconAlphaForHomeConsumer);
mIconAlignmentForResumedState.finishAnimation();
onIconAlignmentRatioChangedForAppAndHomeTransition();
mIconAlignment.finishAnimation();
onIconAlignmentRatioChanged();
mLauncher.getStateManager().addStateListener(mStateListener);
@@ -165,9 +160,7 @@ import java.util.function.Supplier;
public void onDestroy() {
mCanSyncViews = false;
mIconAlignmentForResumedState.finishAnimation();
mIconAlignmentForGestureState.finishAnimation();
mIconAlignmentForLauncherState.finishAnimation();
mIconAlignment.finishAnimation();
mIconAlphaForHome.setConsumer(null);
mLauncher.getHotseat().setIconsAlpha(1f);
@@ -187,6 +180,9 @@ import java.util.function.Supplier;
TaskbarStashController stashController = mControllers.taskbarStashController;
stashController.updateStateForFlag(FLAG_IN_STASHED_LAUNCHER_STATE,
toState.isTaskbarStashed(mLauncher));
if (DEBUG) {
Log.d(TAG, "createAnimToLauncher - FLAG_IN_APP: " + false);
}
stashController.updateStateForFlag(FLAG_IN_APP, false);
updateStateForFlag(FLAG_RECENTS_ANIMATION_RUNNING, true);
@@ -201,7 +197,7 @@ import java.util.function.Supplier;
}
public boolean isAnimatingToLauncher() {
return mIsAnimatingToLauncherViaResume || mIsAnimatingToLauncherViaGesture;
return mIsAnimatingToLauncher;
}
public void setShouldDelayLauncherStateAnim(boolean shouldDelayLauncherStateAnim) {
@@ -261,11 +257,29 @@ import java.util.function.Supplier;
}
private Animator onStateChangeApplied(int changedFlags, long duration, boolean start) {
boolean goingToLauncher = isInLauncher();
final float toAlignment;
if (goingToLauncher) {
boolean isInStashedState = mLauncherState.isTaskbarStashed(mLauncher);
boolean willStashVisually = isInStashedState
&& mControllers.taskbarStashController.supportsVisualStashing();
boolean isTaskbarAlignedWithHotseat =
mLauncherState.isTaskbarAlignedWithHotseat(mLauncher);
toAlignment = isTaskbarAlignedWithHotseat && !willStashVisually ? 1 : 0;
} else {
toAlignment = 0;
}
if (DEBUG) {
Log.d(TAG, "onStateChangeApplied - mState: " + getStateString(mState)
+ ", changedFlags: " + getStateString(changedFlags)
+ ", goingToLauncher: " + goingToLauncher
+ ", mLauncherState: " + mLauncherState
+ ", toAlignment: " + toAlignment);
}
AnimatorSet animatorSet = new AnimatorSet();
// Add the state animation first to ensure FLAG_IN_STASHED_LAUNCHER_STATE is set and we can
// determine whether goingToUnstashedLauncherStateChanged.
boolean wasGoingToUnstashedLauncherState = goingToUnstashedLauncherState();
if (hasAnyFlag(changedFlags, FLAG_TRANSITION_STATE_RUNNING)) {
boolean committed = !hasAnyFlag(FLAG_TRANSITION_STATE_RUNNING);
playStateTransitionAnim(animatorSet, duration, committed);
@@ -276,95 +290,69 @@ import java.util.function.Supplier;
applyState(0 /* duration */);
}
}
boolean goingToUnstashedLauncherStateChanged = wasGoingToUnstashedLauncherState
!= goingToUnstashedLauncherState();
boolean launcherStateChangedDuringAnimToResumeAlignment =
mIconAlignmentForResumedState.isAnimating() && goingToUnstashedLauncherStateChanged;
if (hasAnyFlag(changedFlags, FLAG_RESUMED)
|| launcherStateChangedDuringAnimToResumeAlignment) {
boolean isResumed = isResumed();
// If launcher is resumed, we show the icons when going to an unstashed launcher state
// or launcher state is not changed (e.g. in overview, launcher is paused and resumed).
float toAlignmentForResumedState = isResumed && (goingToUnstashedLauncherState()
|| !goingToUnstashedLauncherStateChanged) ? 1 : 0;
// If we're already animating to the value, just leave it be instead of restarting it.
if (!mIconAlignmentForResumedState.isAnimatingToValue(toAlignmentForResumedState)) {
ObjectAnimator resumeAlignAnim = mIconAlignmentForResumedState
.animateToValue(toAlignmentForResumedState)
.setDuration(duration);
if (DEBUG) {
Log.d(TAG, "mIconAlignmentForResumedState - "
+ mIconAlignmentForResumedState.value
+ " -> " + toAlignmentForResumedState + ": " + duration);
if (hasAnyFlag(changedFlags, FLAGS_LAUNCHER)) {
animatorSet.addListener(new AnimatorListenerAdapter() {
@Override
public void onAnimationEnd(Animator animation) {
mIsAnimatingToLauncher = false;
}
resumeAlignAnim.addListener(new AnimatorListenerAdapter() {
@Override
public void onAnimationEnd(Animator animation) {
mIsAnimatingToLauncherViaResume = false;
@Override
public void onAnimationStart(Animator animation) {
mIsAnimatingToLauncher = goingToLauncher;
TaskbarStashController stashController =
mControllers.taskbarStashController;
if (DEBUG) {
Log.d(TAG, "onAnimationStart - FLAG_IN_APP: " + !goingToLauncher);
}
@Override
public void onAnimationStart(Animator animation) {
mIsAnimatingToLauncherViaResume = isResumed;
TaskbarStashController stashController =
mControllers.taskbarStashController;
stashController.updateStateForFlag(FLAG_IN_APP, !isResumed);
stashController.applyState(duration);
}
});
animatorSet.play(resumeAlignAnim);
}
}
boolean launcherStateChangedDuringAnimToGestureAlignment =
mIconAlignmentForGestureState.isAnimating() && goingToUnstashedLauncherStateChanged;
if (hasAnyFlag(changedFlags, FLAG_RECENTS_ANIMATION_RUNNING)
|| launcherStateChangedDuringAnimToGestureAlignment) {
boolean isRecentsAnimationRunning = isRecentsAnimationRunning();
float toAlignmentForGestureState = isRecentsAnimationRunning
&& goingToUnstashedLauncherState() ? 1 : 0;
// If we're already animating to the value, just leave it be instead of restarting it.
if (!mIconAlignmentForGestureState.isAnimatingToValue(toAlignmentForGestureState)) {
Animator gestureAlignAnim = mIconAlignmentForGestureState
.animateToValue(toAlignmentForGestureState);
if (isRecentsAnimationRunning) {
gestureAlignAnim.setDuration(duration);
stashController.updateStateForFlag(FLAG_IN_APP, !goingToLauncher);
stashController.applyState(duration);
}
if (DEBUG) {
Log.d(TAG, "mIconAlignmentForGestureState - "
+ mIconAlignmentForGestureState.value
+ " -> " + toAlignmentForGestureState + ": " + duration);
}
gestureAlignAnim.addListener(new AnimatorListenerAdapter() {
@Override
public void onAnimationEnd(Animator animation) {
mIsAnimatingToLauncherViaGesture = false;
}
});
@Override
public void onAnimationStart(Animator animation) {
mIsAnimatingToLauncherViaGesture = isRecentsAnimationRunning();
}
});
animatorSet.play(gestureAlignAnim);
}
}
if (hasAnyFlag(changedFlags, FLAG_RESUMED | FLAG_RECENTS_ANIMATION_RUNNING)) {
boolean goingToLauncher = hasAnyFlag(FLAG_RESUMED | FLAG_RECENTS_ANIMATION_RUNNING);
if (goingToLauncher) {
// Handle closing open popups when going home/overview
AbstractFloatingView.closeAllOpenViews(mControllers.taskbarActivityContext);
}
animatorSet.play(mTaskbarBackgroundAlpha.animateToValue(goingToLauncher ? 0 : 1)
}
float backgroundAlpha =
goingToLauncher && mLauncherState.isTaskbarAlignedWithHotseat(mLauncher)
? 0 : 1;
// Don't animate if background has reached desired value.
if (mTaskbarBackgroundAlpha.isAnimating()
|| mTaskbarBackgroundAlpha.value != backgroundAlpha) {
mTaskbarBackgroundAlpha.cancelAnimation();
if (DEBUG) {
Log.d(TAG, "onStateChangeApplied - taskbarBackgroundAlpha - "
+ mTaskbarBackgroundAlpha.value
+ " -> " + backgroundAlpha + ": " + duration);
}
animatorSet.play(mTaskbarBackgroundAlpha.animateToValue(backgroundAlpha)
.setDuration(duration));
}
if (mIconAlignment.isAnimatingToValue(toAlignment)
|| mIconAlignment.isSettledOnValue(toAlignment)) {
// Already at desired value, but make sure we run the callback at the end.
animatorSet.addListener(AnimatorListeners.forEndCallback(
this::onIconAlignmentRatioChanged));
} else {
mIconAlignment.cancelAnimation();
ObjectAnimator iconAlignAnim = mIconAlignment
.animateToValue(toAlignment)
.setDuration(duration);
if (DEBUG) {
Log.d(TAG, "onStateChangeApplied - iconAlignment - "
+ mIconAlignment.value
+ " -> " + toAlignment + ": " + duration);
}
animatorSet.play(iconAlignAnim);
}
animatorSet.setInterpolator(EMPHASIZED);
if (start) {
animatorSet.start();
}
@@ -372,18 +360,13 @@ import java.util.function.Supplier;
}
/** Returns whether we're going to a state where taskbar icons should align with launcher. */
private boolean goingToUnstashedLauncherState() {
return !mControllers.taskbarStashController.isInStashedLauncherState();
public boolean goingToAlignedLauncherState() {
return mLauncherState.isTaskbarAlignedWithHotseat(mLauncher);
}
private void playStateTransitionAnim(AnimatorSet animatorSet, long duration,
boolean committed) {
boolean isInStashedState = mLauncherState.isTaskbarStashed(mLauncher);
boolean willStashVisually =
isInStashedState && mControllers.taskbarStashController.supportsVisualStashing();
float toAlignment =
mLauncherState.isTaskbarAlignedWithHotseat(mLauncher) && !willStashVisually ? 1 : 0;
TaskbarStashController stashController = mControllers.taskbarStashController;
stashController.updateStateForFlag(FLAG_IN_STASHED_LAUNCHER_STATE, isInStashedState);
Animator stashAnimator = stashController.applyStateWithoutStart(duration);
@@ -406,55 +389,23 @@ import java.util.function.Supplier;
});
animatorSet.play(stashAnimator);
}
if (mIconAlignmentForLauncherState.value == toAlignment) {
// Already at expected value, but make sure we run the callback at the end.
animatorSet.addListener(AnimatorListeners.forEndCallback(
this::onIconAlignmentRatioChangedForStateTransition));
}
if (!mIconAlignmentForLauncherState.isAnimatingToValue(toAlignment)) {
// If we're already animating to the value, just leave it be instead of restarting it.
mIconAlignmentForLauncherState.finishAnimation();
animatorSet.play(mIconAlignmentForLauncherState.animateToValue(toAlignment)
.setDuration(duration));
if (DEBUG) {
Log.d(TAG, "mIconAlignmentForLauncherState - "
+ mIconAlignmentForLauncherState.value
+ " -> " + toAlignment + ": " + duration);
}
animatorSet.setInterpolator(EMPHASIZED);
}
}
private boolean isResumed() {
return (mState & FLAG_RESUMED) != 0;
private boolean isInLauncher() {
return (mState & FLAGS_LAUNCHER) != 0;
}
private boolean isRecentsAnimationRunning() {
return (mState & FLAG_RECENTS_ANIMATION_RUNNING) != 0;
}
private void onIconAlignmentRatioChangedForStateTransition() {
if (!isResumed() && mTaskBarRecentsAnimationListener == null) {
return;
}
onIconAlignmentRatioChanged(this::getCurrentIconAlignmentRatioForLauncherState);
}
private void onIconAlignmentRatioChangedForAppAndHomeTransition() {
onIconAlignmentRatioChanged(this::getCurrentIconAlignmentRatioBetweenAppAndHome);
}
private void onIconAlignmentRatioChanged(Supplier<AnimatedFloat> alignmentSupplier) {
if (mControllers == null) {
return;
}
AnimatedFloat animatedFloat = alignmentSupplier.get();
private void onIconAlignmentRatioChanged() {
float currentValue = mIconAlphaForHome.getValue();
boolean taskbarWillBeVisible = animatedFloat.value < 1;
boolean taskbarWillBeVisible = mIconAlignment.value < 1;
boolean firstFrameVisChanged = (taskbarWillBeVisible && Float.compare(currentValue, 1) != 0)
|| (!taskbarWillBeVisible && Float.compare(currentValue, 0) != 0);
updateIconAlignment(animatedFloat.value, animatedFloat.getEndValue());
mControllers.taskbarViewController.setLauncherIconAlignment(
mIconAlignment.value, mIconAlignment.getEndValue(), mLauncher.getDeviceProfile());
mControllers.navbarButtonsViewController.updateTaskbarAlignment(mIconAlignment.value);
// Switch taskbar and hotseat in last frame
mIconAlphaForHome.setValue(taskbarWillBeVisible ? 1 : 0);
// Sync the first frame where we swap taskbar and hotseat.
if (firstFrameVisChanged && mCanSyncViews && !Utilities.IS_RUNNING_IN_TEST_HARNESS) {
@@ -464,28 +415,6 @@ import java.util.function.Supplier;
}
}
private void updateIconAlignment(float alignment, Float endAlignment) {
mControllers.taskbarViewController.setLauncherIconAlignment(
alignment, endAlignment, mLauncher.getDeviceProfile());
// Switch taskbar and hotseat in last frame
setTaskbarViewVisible(alignment < 1);
mControllers.navbarButtonsViewController.updateTaskbarAlignment(alignment);
}
private AnimatedFloat getCurrentIconAlignmentRatioBetweenAppAndHome() {
return mIconAlignmentForResumedState.value > mIconAlignmentForGestureState.value
? mIconAlignmentForResumedState : mIconAlignmentForGestureState;
}
private AnimatedFloat getCurrentIconAlignmentRatioForLauncherState() {
return mIconAlignmentForLauncherState;
}
private void setTaskbarViewVisible(boolean isVisible) {
mIconAlphaForHome.setValue(isVisible ? 1 : 0);
}
private final class TaskBarRecentsAnimationListener implements
RecentsAnimationCallbacks.RecentsAnimationListener {
private final RecentsAnimationCallbacks mCallbacks;
@@ -515,11 +444,11 @@ import java.util.function.Supplier;
updateStateForFlag(FLAG_RECENTS_ANIMATION_RUNNING, false);
updateStateForFlag(FLAG_RESUMED, launcherResumed);
applyState();
// Set this last because applyState() might also animate it.
mIconAlignmentForResumedState.cancelAnimation();
mIconAlignmentForResumedState.updateValue(launcherResumed ? 1 : 0);
TaskbarStashController controller = mControllers.taskbarStashController;
if (DEBUG) {
Log.d(TAG, "endGestureStateOverride - FLAG_IN_APP: " + finishedToApp);
}
controller.updateStateForFlag(FLAG_IN_APP, finishedToApp);
controller.applyState();
}
@@ -527,29 +456,24 @@ import java.util.function.Supplier;
private static String getStateString(int flags) {
StringJoiner str = new StringJoiner("|");
str.add((flags & FLAG_RESUMED) != 0 ? "FLAG_RESUMED" : "");
str.add((flags & FLAG_RECENTS_ANIMATION_RUNNING) != 0
? "FLAG_RECENTS_ANIMATION_RUNNING" : "");
str.add((flags & FLAG_TRANSITION_STATE_RUNNING) != 0
? "FLAG_TRANSITION_STATE_RUNNING" : "");
if ((flags & FLAG_RESUMED) != 0) {
str.add("FLAG_RESUMED");
}
if ((flags & FLAG_RECENTS_ANIMATION_RUNNING) != 0) {
str.add("FLAG_RECENTS_ANIMATION_RUNNING");
}
if ((flags & FLAG_TRANSITION_STATE_RUNNING) != 0) {
str.add("FLAG_TRANSITION_STATE_RUNNING");
}
return str.toString();
}
protected void dumpLogs(String prefix, PrintWriter pw) {
pw.println(prefix + "TaskbarLauncherStateController:");
pw.println(String.format(
"%s\tmIconAlignmentForResumedState=%.2f",
"%s\tmIconAlignment=%.2f",
prefix,
mIconAlignmentForResumedState.value));
pw.println(String.format(
"%s\tmIconAlignmentForGestureState=%.2f",
prefix,
mIconAlignmentForGestureState.value));
pw.println(String.format(
"%s\tmIconAlignmentForLauncherState=%.2f",
prefix,
mIconAlignmentForLauncherState.value));
mIconAlignment.value));
pw.println(String.format(
"%s\tmTaskbarBackgroundAlpha=%.2f", prefix, mTaskbarBackgroundAlpha.value));
pw.println(String.format(
@@ -558,13 +482,9 @@ import java.util.function.Supplier;
pw.println(String.format("%s\tmState=%s", prefix, getStateString(mState)));
pw.println(String.format("%s\tmLauncherState=%s", prefix, mLauncherState));
pw.println(String.format(
"%s\tmIsAnimatingToLauncherViaGesture=%b",
"%s\tmIsAnimatingToLauncher=%b",
prefix,
mIsAnimatingToLauncherViaGesture));
pw.println(String.format(
"%s\tmIsAnimatingToLauncherViaResume=%b",
prefix,
mIsAnimatingToLauncherViaResume));
mIsAnimatingToLauncher));
pw.println(String.format(
"%s\tmShouldDelayLauncherStateAnim=%b", prefix, mShouldDelayLauncherStateAnim));
}
quickstep/src/com/android/launcher3/taskbar/TaskbarViewController.java
+6
View File
@@ -102,6 +102,9 @@ public class TaskbarViewController implements TaskbarControllers.LoggableTaskbar
private int mThemeIconsColor;
private final DeviceProfile.OnDeviceProfileChangeListener mDeviceProfileChangeListener =
dp -> commitRunningAppsToUI();
public TaskbarViewController(TaskbarActivityContext activity, TaskbarView taskbarView) {
mActivity = activity;
mTaskbarView = taskbarView;
@@ -129,10 +132,13 @@ public class TaskbarViewController implements TaskbarControllers.LoggableTaskbar
controllers.navbarButtonsViewController.getTaskbarNavButtonTranslationY();
mTaskbarNavButtonTranslationYForInAppDisplay = controllers.navbarButtonsViewController
.getTaskbarNavButtonTranslationYForInAppDisplay();
mActivity.addOnDeviceProfileChangeListener(mDeviceProfileChangeListener);
}
public void onDestroy() {
LauncherAppState.getInstance(mActivity).getModel().removeCallbacks(mModelCallbacks);
mActivity.removeOnDeviceProfileChangeListener(mDeviceProfileChangeListener);
mModelCallbacks.unregisterListeners();
}
quickstep/src/com/android/launcher3/uioverrides/states/QuickstepAtomicAnimationFactory.java
+2 -1
View File
@@ -197,7 +197,8 @@ public class QuickstepAtomicAnimationFactory extends
config.setInterpolator(ANIM_OVERVIEW_ACTIONS_FADE, clampToProgress(LINEAR,
timings.getActionsFadeStartOffset(),
timings.getActionsFadeEndOffset()));
} else if (fromState == NORMAL && toState == OVERVIEW_SPLIT_SELECT) {
} else if ((fromState == NORMAL || fromState == ALL_APPS)
&& toState == OVERVIEW_SPLIT_SELECT) {
// Splitting from Home is currently only available on tablets
SplitAnimationTimings timings = SplitAnimationTimings.TABLET_HOME_TO_SPLIT;
config.setInterpolator(ANIM_SCRIM_FADE, clampToProgress(LINEAR,
quickstep/src/com/android/quickstep/AbsSwipeUpHandler.java
+2 -2
View File
@@ -1010,8 +1010,8 @@ public abstract class AbsSwipeUpHandler<T extends StatefulActivity<S>,
switch (endTarget) {
case HOME:
mStateCallback.setState(STATE_SCALED_CONTROLLER_HOME | STATE_CAPTURE_SCREENSHOT);
// Notify swipe-to-home (recents animation) is finished
SystemUiProxy.INSTANCE.get(mContext).notifySwipeToHomeFinished();
// Notify the SysUI to use fade-in animation when entering PiP
SystemUiProxy.INSTANCE.get(mContext).setPipAnimationTypeToAlpha();
break;
case RECENTS:
mStateCallback.setState(STATE_SCALED_CONTROLLER_RECENTS | STATE_CAPTURE_SCREENSHOT
quickstep/src/com/android/quickstep/AnimatedFloat.java
+7
View File
@@ -134,6 +134,13 @@ public class AnimatedFloat {
return isAnimating() && mEndValue != null && mEndValue == endValue;
}
/**
* Returns whether we are currently not animating, and the animation's value matches the given.
*/
public boolean isSettledOnValue(float endValue) {
return !isAnimating() && value == endValue;
}
/**
* Returns the value we are animating to, or {@code null} if we are not currently animating.
*/
quickstep/src/com/android/quickstep/LauncherSwipeHandlerV2.java
+2 -1
View File
@@ -84,7 +84,8 @@ public class LauncherSwipeHandlerV2 extends
final View workspaceView = findWorkspaceView(launchCookies,
mRecentsView.getRunningTaskView());
boolean canUseWorkspaceView = workspaceView != null && workspaceView.isAttachedToWindow();
boolean canUseWorkspaceView = workspaceView != null && workspaceView.isAttachedToWindow()
&& workspaceView.getHeight() > 0;
mActivity.getRootView().setForceHideBackArrow(true);
if (!TaskAnimationManager.ENABLE_SHELL_TRANSITIONS) {
quickstep/src/com/android/quickstep/SystemUiProxy.java
+17 -18
View File
@@ -187,7 +187,7 @@ public class SystemUiProxy implements ISystemUiProxy {
linkToDeath();
// re-attach the listeners once missing due to setProxy has not been initialized yet.
if (mPipAnimationListener != null && mPip != null) {
setPinnedStackAnimationListener(mPipAnimationListener);
setPipAnimationListener(mPipAnimationListener);
}
if (mSplitScreenListener != null && mSplitScreen != null) {
registerSplitScreenListener(mSplitScreenListener);
@@ -357,20 +357,6 @@ public class SystemUiProxy implements ISystemUiProxy {
}
}
/**
* Notifies that swipe-to-home action is finished.
*/
@Override
public void notifySwipeToHomeFinished() {
if (mSystemUiProxy != null) {
try {
mSystemUiProxy.notifySwipeToHomeFinished();
} catch (RemoteException e) {
Log.w(TAG, "Failed call notifySwipeToHomeFinished", e);
}
}
}
@Override
public void notifyPrioritizedRotation(int rotation) {
if (mSystemUiProxy != null) {
@@ -475,12 +461,12 @@ public class SystemUiProxy implements ISystemUiProxy {
}
/**
* Sets listener to get pinned stack animation callbacks.
* Sets listener to get pip animation callbacks.
*/
public void setPinnedStackAnimationListener(IPipAnimationListener listener) {
public void setPipAnimationListener(IPipAnimationListener listener) {
if (mPip != null) {
try {
mPip.setPinnedStackAnimationListener(listener);
mPip.setPipAnimationListener(listener);
} catch (RemoteException e) {
Log.w(TAG, "Failed call setPinnedStackAnimationListener", e);
}
@@ -522,6 +508,19 @@ public class SystemUiProxy implements ISystemUiProxy {
}
}
/**
* Sets the next pip animation type to be the alpha animation.
*/
public void setPipAnimationTypeToAlpha() {
if (mPip != null) {
try {
mPip.setPipAnimationTypeToAlpha();
} catch (RemoteException e) {
Log.w(TAG, "Failed call setPipAnimationTypeToAlpha", e);
}
}
}
//
// Splitscreen
//
quickstep/src/com/android/quickstep/views/RecentsView.java
+11 -3
View File
@@ -941,7 +941,7 @@ public abstract class RecentsView<ACTIVITY_TYPE extends StatefulActivity<STATE_T
.setSyncTransactionApplier(mSyncTransactionApplier));
RecentsModel.INSTANCE.get(getContext()).addThumbnailChangeListener(this);
mIPipAnimationListener.setActivityAndRecentsView(mActivity, this);
SystemUiProxy.INSTANCE.get(getContext()).setPinnedStackAnimationListener(
SystemUiProxy.INSTANCE.get(getContext()).setPipAnimationListener(
mIPipAnimationListener);
mOrientationState.initListeners();
SplitScreenBounds.INSTANCE.addOnChangeListener(this);
@@ -960,7 +960,7 @@ public abstract class RecentsView<ACTIVITY_TYPE extends StatefulActivity<STATE_T
.setSyncTransactionApplier(null));
executeSideTaskLaunchCallback();
RecentsModel.INSTANCE.get(getContext()).removeThumbnailChangeListener(this);
SystemUiProxy.INSTANCE.get(getContext()).setPinnedStackAnimationListener(null);
SystemUiProxy.INSTANCE.get(getContext()).setPipAnimationListener(null);
SplitScreenBounds.INSTANCE.removeOnChangeListener(this);
mIPipAnimationListener.setActivityAndRecentsView(null, null);
mOrientationState.destroyListeners();
@@ -1724,6 +1724,7 @@ public abstract class RecentsView<ACTIVITY_TYPE extends StatefulActivity<STATE_T
// Changed orientations, update controllers so they intercept accordingly.
mActivity.getDragLayer().recreateControllers();
onOrientationChanged();
resetTaskVisuals();
}
boolean isInLandscape = mOrientationState.getTouchRotation() != ROTATION_0
@@ -4157,6 +4158,9 @@ public abstract class RecentsView<ACTIVITY_TYPE extends StatefulActivity<STATE_T
}
}
/**
* Called when staging a split from Home/AllApps, using the icon long-press menu.
*/
public void initiateSplitSelect(QuickstepSystemShortcut.SplitSelectSource splitSelectSource) {
mSplitSelectSource = splitSelectSource;
mSplitSelectStateController.setInitialTaskSelect(splitSelectSource.intent,
@@ -4295,6 +4299,10 @@ public abstract class RecentsView<ACTIVITY_TYPE extends StatefulActivity<STATE_T
resetTaskVisuals();
mSplitHiddenTaskViewIndex = -1;
if (mSplitHiddenTaskView != null) {
mSplitHiddenTaskView.setThumbnailVisibility(VISIBLE);
mSplitHiddenTaskView = null;
}
}
private void safeRemoveDragLayerView(@Nullable View viewToRemove) {
@@ -4715,7 +4723,7 @@ public abstract class RecentsView<ACTIVITY_TYPE extends StatefulActivity<STATE_T
if (sendUserLeaveHint) {
// Notify the SysUI to use fade-in animation when entering PiP from live tile.
final SystemUiProxy systemUiProxy = SystemUiProxy.INSTANCE.get(getContext());
systemUiProxy.notifySwipeToHomeFinished();
systemUiProxy.setPipAnimationTypeToAlpha();
systemUiProxy.setShelfHeight(true, mActivity.getDeviceProfile().hotseatBarSizePx);
// Transaction to hide the task to avoid flicker for entering PiP from split-screen.
// See also {@link AbsSwipeUpHandler#maybeFinishSwipeToHome}.