Files
Flexera-Launcher/quickstep/src/com/android/launcher3/taskbar/TaskbarTranslationController.java
T
mpodolian 484ff0fe9c Integrated new BubbleStashControllers into the existing code.
Integrated the PersistentTaskbarStashController and the
TransientTaskbarStashController into the launcher code. Made changes to
the TaskbarInsetsController to set appropriate touchable zones. Updated
the TaskbarUIController to not start the overview transition on clicks
for the collapsed bubble bar.

Bug: 346391377
Fixes: 350065038
Fixes: 355664783
Flag: com.android.wm.shell.enable_bubble_bar_in_persistent_task_bar
Test: com.android.launcher3.taskbar package tests

persistent taskbar and transient taskbar manual testing:
- on launcher home screen expand bubble bar, switch between bubbles,
remove bubble via bubble menu, add bubble, remove bubble with the drug
gesture, add bubble, collapse bubble bar
- repeat previous test on launcher overview screen and inside any
application
- after last test drag expanded bubble view to the opposite side of the
screen

Change-Id: I50f2c510854c4895fdfc9bd453a261c2103286fd
2024-07-30 18:36:05 -07:00

243 lines
8.2 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.launcher3.taskbar;
import static com.android.launcher3.anim.AnimatedFloat.VALUE;
import static com.android.launcher3.anim.AnimatorListeners.forEndCallback;
import android.animation.Animator;
import android.animation.AnimatorListenerAdapter;
import android.animation.ObjectAnimator;
import android.animation.ValueAnimator;
import androidx.annotation.Nullable;
import androidx.dynamicanimation.animation.SpringForce;
import com.android.app.animation.Interpolators;
import com.android.launcher3.anim.AnimatedFloat;
import com.android.launcher3.anim.SpringAnimationBuilder;
import com.android.launcher3.util.DisplayController;
import java.io.PrintWriter;
/**
* Class responsible for translating the transient taskbar UI during a swipe gesture.
*
* The translation is controlled, in priority order:
* - animation to home
* - a spring animation
* - controlled by user
*
* The spring animation will play start once the user lets go or when user pauses to go to overview.
* When the user goes home, the stash animation will play.
*/
public class TaskbarTranslationController implements TaskbarControllers.LoggableTaskbarController {
private final TaskbarActivityContext mContext;
private TaskbarControllers mControllers;
private final AnimatedFloat mTranslationYForSwipe = new AnimatedFloat(
this::updateTranslationYForSwipe);
private boolean mHasSprungOnceThisGesture;
private @Nullable ValueAnimator mSpringBounce;
private boolean mGestureInProgress;
private boolean mGestureEnded;
private boolean mAnimationToHomeRunning;
private final boolean mIsTransientTaskbar;
private final TransitionCallback mCallback;
public TaskbarTranslationController(TaskbarActivityContext context) {
mContext = context;
mIsTransientTaskbar = DisplayController.isTransientTaskbar(mContext);
mCallback = new TransitionCallback();
}
/**
* Initialization method.
*/
public void init(TaskbarControllers controllers) {
mControllers = controllers;
}
/**
* Called to cancel any existing animations.
*/
public void cancelSpringIfExists() {
if (mSpringBounce != null) {
mSpringBounce.cancel();
mSpringBounce = null;
}
}
private void updateTranslationYForSwipe() {
if (!mIsTransientTaskbar) {
return;
}
float transY = mTranslationYForSwipe.value;
mControllers.stashedHandleViewController.setTranslationYForSwipe(transY);
mControllers.taskbarViewController.setTranslationYForSwipe(transY);
mControllers.taskbarDragLayerController.setTranslationYForSwipe(transY);
mControllers.bubbleControllers.ifPresent(controllers -> {
controllers.bubbleBarViewController.setTranslationYForSwipe(transY);
controllers.bubbleStashedHandleViewController.ifPresent(
controller -> controller.setTranslationYForSwipe(transY));
});
}
/**
* Starts a spring aniamtion to set the views back to the resting state.
*/
public void startSpring() {
if (mHasSprungOnceThisGesture || mAnimationToHomeRunning) {
return;
}
mSpringBounce = new SpringAnimationBuilder(mContext)
.setStartValue(mTranslationYForSwipe.value)
.setEndValue(0)
.setDampingRatio(SpringForce.DAMPING_RATIO_MEDIUM_BOUNCY)
.setStiffness(SpringForce.STIFFNESS_LOW)
.build(mTranslationYForSwipe, VALUE);
mSpringBounce.addListener(forEndCallback(() -> {
if (!mGestureEnded) {
return;
}
reset();
if (mControllers.taskbarStashController.isInApp()
&& mControllers.taskbarStashController.isTaskbarVisibleAndNotStashing()) {
mControllers.taskbarEduTooltipController.maybeShowFeaturesEdu();
}
}));
mSpringBounce.start();
mHasSprungOnceThisGesture = true;
}
private void reset() {
mGestureEnded = false;
mHasSprungOnceThisGesture = false;
}
/**
* Returns a callback to help monitor the swipe gesture.
*/
public TransitionCallback getTransitionCallback() {
return mCallback;
}
/**
* Returns true if we will animate to zero before the input duration.
*/
public boolean willAnimateToZeroBefore(long duration) {
if (mSpringBounce != null && mSpringBounce.isRunning()) {
long springDuration = mSpringBounce.getDuration();
long current = mSpringBounce.getCurrentPlayTime();
return (springDuration - current < duration);
}
if (mTranslationYForSwipe.isAnimatingToValue(0)) {
return mTranslationYForSwipe.getRemainingTime() < duration;
}
return false;
}
/**
* Returns an animation to reset the taskbar translation to {@code 0}.
*/
public ValueAnimator createAnimToResetTranslation(long duration) {
if (mGestureInProgress) {
// Return an empty animator as the translation will reset itself after gesture ends.
return ValueAnimator.ofFloat(0).setDuration(duration);
}
ObjectAnimator animator = mTranslationYForSwipe.animateToValue(0);
animator.setInterpolator(Interpolators.LINEAR);
animator.setDuration(duration);
animator.addListener(new AnimatorListenerAdapter() {
@Override
public void onAnimationStart(Animator animation) {
cancelSpringIfExists();
reset();
mAnimationToHomeRunning = true;
}
@Override
public void onAnimationEnd(Animator animation) {
mAnimationToHomeRunning = false;
reset();
}
});
return animator;
}
/**
* Helper class to communicate to/from the input consumer.
*/
public class TransitionCallback {
/**
* Clears any existing animations so that user
* can take control over the movement of the taskbaer.
*/
public void onActionDown() {
if (mAnimationToHomeRunning) {
mTranslationYForSwipe.cancelAnimation();
}
mAnimationToHomeRunning = false;
cancelSpringIfExists();
reset();
mGestureInProgress = true;
}
/**
* Called when there is movement to move the taskbar.
*/
public void onActionMove(float dY) {
if (mAnimationToHomeRunning
|| (mHasSprungOnceThisGesture && !mGestureEnded)) {
return;
}
mTranslationYForSwipe.updateValue(dY);
}
/**
* Called when swipe gesture has ended.
*/
public void onActionEnd() {
if (mHasSprungOnceThisGesture) {
reset();
} else {
mGestureEnded = true;
startSpring();
}
mGestureInProgress = false;
}
}
@Override
public void dumpLogs(String prefix, PrintWriter pw) {
pw.println(prefix + "TaskbarTranslationController:");
pw.println(prefix + "\tmTranslationYForSwipe=" + mTranslationYForSwipe.value);
pw.println(prefix + "\tmHasSprungOnceThisGesture=" + mHasSprungOnceThisGesture);
pw.println(prefix + "\tmAnimationToHomeRunning=" + mAnimationToHomeRunning);
pw.println(prefix + "\tmGestureEnded=" + mGestureEnded);
pw.println(prefix + "\tmSpringBounce is running=" + (mSpringBounce != null
&& mSpringBounce.isRunning()));
}
}