Files
Flexera-Launcher/quickstep/src/com/android/launcher3/taskbar/TaskbarDragLayerController.java
T
Tony Wickham fdd34cb24a Don't report INSETS_ROUNDED_CORNER on phones
Flag: EXEMPT bugfix
Fixes: 406689798
Test: none (we can add one once we add TaskbarInsetsControllerTest)
Change-Id: I0bba8f39104b7b6d6dbbc4029981fea2988dae50
2025-04-02 18:54:47 +00:00

392 lines
15 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 com.android.app.animation.Interpolators.EMPHASIZED;
import static com.android.launcher3.taskbar.TaskbarPinningController.PINNING_PERSISTENT;
import static com.android.launcher3.taskbar.TaskbarPinningController.PINNING_TRANSIENT;
import android.animation.AnimatorSet;
import android.animation.ObjectAnimator;
import android.content.res.Resources;
import android.graphics.Canvas;
import android.graphics.Point;
import android.graphics.Rect;
import android.os.SystemProperties;
import android.view.MotionEvent;
import android.view.ViewTreeObserver;
import com.android.launcher3.DeviceProfile;
import com.android.launcher3.R;
import com.android.launcher3.anim.AnimatedFloat;
import com.android.launcher3.anim.AnimatorListeners;
import com.android.launcher3.util.DimensionUtils;
import com.android.launcher3.util.MultiPropertyFactory.MultiProperty;
import com.android.launcher3.util.TouchController;
import java.io.PrintWriter;
/**
* Handles properties/data collection, then passes the results to TaskbarDragLayer to render.
*/
public class TaskbarDragLayerController implements TaskbarControllers.LoggableTaskbarController,
TaskbarControllers.BackgroundRendererController {
private static final boolean DEBUG = SystemProperties.getBoolean(
"persist.debug.draw_taskbar_debug_ui", false);
private final TaskbarActivityContext mActivity;
private final TaskbarDragLayer mTaskbarDragLayer;
private final int mFolderMargin;
// Alpha properties for taskbar background.
private final AnimatedFloat mBgTaskbar = new AnimatedFloat(this::updateBackgroundAlpha);
private final AnimatedFloat mBgNavbar = new AnimatedFloat(this::updateBackgroundAlpha);
private final AnimatedFloat mKeyguardBgTaskbar = new AnimatedFloat(this::updateBackgroundAlpha);
private final AnimatedFloat mNotificationShadeBgTaskbar = new AnimatedFloat(
this::updateBackgroundAlpha);
private final AnimatedFloat mImeBgTaskbar = new AnimatedFloat(this::updateBackgroundAlpha);
private final AnimatedFloat mAssistantBgTaskbar = new AnimatedFloat(
this::updateBackgroundAlpha);
private final AnimatedFloat mBgTaskbarRecreate = new AnimatedFloat(
this::updateBackgroundAlpha);
// Used to hide our background color when someone else (e.g. ScrimView) is handling it.
private final AnimatedFloat mBgOverride = new AnimatedFloat(this::updateBackgroundAlpha);
// Translation property for taskbar background.
private final AnimatedFloat mBgOffset = new AnimatedFloat(this::updateBackgroundOffset);
// Used to fade in/out the entirety of the taskbar, for a smooth transition before/after sysui
// changes the inset visibility.
private final AnimatedFloat mTaskbarAlpha = new AnimatedFloat(this::updateTaskbarAlpha);
private final AnimatedFloat mTaskbarBackgroundProgress = new AnimatedFloat(
this::updateTaskbarBackgroundProgress);
// Initialized in init.
private TaskbarControllers mControllers;
private TaskbarStashViaTouchController mTaskbarStashViaTouchController;
private AnimatedFloat mOnBackgroundNavButtonColorIntensity;
private MultiProperty mBackgroundRendererAlpha;
private float mLastSetBackgroundAlpha;
public TaskbarDragLayerController(TaskbarActivityContext activity,
TaskbarDragLayer taskbarDragLayer) {
mActivity = activity;
mTaskbarDragLayer = taskbarDragLayer;
mBackgroundRendererAlpha = mTaskbarDragLayer.getBackgroundRendererAlpha();
final Resources resources = mTaskbarDragLayer.getResources();
mFolderMargin = resources.getDimensionPixelSize(R.dimen.taskbar_folder_margin);
}
/**
* Init of taskbar drag layer controller
*/
public void init(TaskbarControllers controllers, AnimatorSet startAnimation) {
mControllers = controllers;
mTaskbarStashViaTouchController = new TaskbarStashViaTouchController(mControllers);
mTaskbarDragLayer.init(new TaskbarDragLayerCallbacks());
mOnBackgroundNavButtonColorIntensity = mControllers.navbarButtonsViewController
.getOnTaskbarBackgroundNavButtonColorOverride();
if (startAnimation != null) {
// set taskbar background render animation boolean
if (mActivity.isTransientTaskbar()) {
mTaskbarDragLayer.setIsAnimatingTransientTaskbarBackground(true);
} else {
mTaskbarDragLayer.setIsAnimatingPersistentTaskbarBackground(true);
}
float desiredValue = mActivity.isTransientTaskbar()
? PINNING_TRANSIENT
: PINNING_PERSISTENT;
float nonDesiredvalue =
!mActivity.isTransientTaskbar() ? PINNING_TRANSIENT : PINNING_PERSISTENT;
ObjectAnimator objectAnimator = mTaskbarBackgroundProgress.animateToValue(
nonDesiredvalue, desiredValue);
objectAnimator.setInterpolator(EMPHASIZED);
startAnimation.play(objectAnimator);
startAnimation.addListener(AnimatorListeners.forEndCallback(()-> {
// reset taskbar background render animation boolean
mTaskbarDragLayer.setIsAnimatingPersistentTaskbarBackground(false);
mTaskbarDragLayer.setIsAnimatingTransientTaskbarBackground(false);
}));
} else {
mTaskbarBackgroundProgress.updateValue(
mActivity.isTransientTaskbar() ? PINNING_TRANSIENT : PINNING_PERSISTENT);
}
mBgTaskbar.value = 1;
mKeyguardBgTaskbar.value = 1;
mNotificationShadeBgTaskbar.value = 1;
mImeBgTaskbar.value = 1;
mAssistantBgTaskbar.value = 1;
mBgTaskbarRecreate.value = 1;
mBgOverride.value = 1;
updateBackgroundAlpha();
mTaskbarAlpha.value = 1;
updateTaskbarAlpha();
}
/**
* Called when destroying Taskbar with animation.
*/
public void onDestroyAnimation(AnimatorSet animatorSet) {
animatorSet.play(mBgTaskbarRecreate.animateToValue(0f));
}
public void onDestroy() {
mTaskbarDragLayer.onDestroy();
}
/**
* @return Bounds (in TaskbarDragLayer coordinates) where an opened Folder can display.
*/
public Rect getFolderBoundingBox() {
Rect boundingBox = new Rect(0, 0, mTaskbarDragLayer.getWidth(),
mTaskbarDragLayer.getHeight() - mActivity.getDeviceProfile().taskbarHeight
- mActivity.getDeviceProfile().taskbarBottomMargin);
boundingBox.inset(mFolderMargin, mFolderMargin);
return boundingBox;
}
public AnimatedFloat getTaskbarBackgroundAlpha() {
return mBgTaskbar;
}
public AnimatedFloat getNavbarBackgroundAlpha() {
return mBgNavbar;
}
public AnimatedFloat getKeyguardBgTaskbar() {
return mKeyguardBgTaskbar;
}
public AnimatedFloat getNotificationShadeBgTaskbar() {
return mNotificationShadeBgTaskbar;
}
public AnimatedFloat getImeBgTaskbar() {
return mImeBgTaskbar;
}
public AnimatedFloat getAssistantBgTaskbar() {
return mAssistantBgTaskbar;
}
public AnimatedFloat getTaskbarBackgroundOffset() {
return mBgOffset;
}
// AnimatedFloat is for animating between pinned and transient taskbar
public AnimatedFloat getTaskbarBackgroundProgress() {
return mTaskbarBackgroundProgress;
}
public AnimatedFloat getTaskbarAlpha() {
return mTaskbarAlpha;
}
/**
* Make updates when configuration changes.
*/
public void onConfigurationChanged() {
mTaskbarStashViaTouchController.updateGestureHeight();
}
private void updateBackgroundAlpha() {
if (!mActivity.drawsTaskbarBackground() || mActivity.isDestroyed()) {
return;
}
final float bgNavbar = mBgNavbar.value;
final float bgTaskbar = mBgTaskbar.value * mKeyguardBgTaskbar.value
* mNotificationShadeBgTaskbar.value * mImeBgTaskbar.value
* mAssistantBgTaskbar.value * mBgTaskbarRecreate.value;
mLastSetBackgroundAlpha = mBgOverride.value * Math.max(bgNavbar, bgTaskbar);
mBackgroundRendererAlpha.setValue(mLastSetBackgroundAlpha);
updateOnBackgroundNavButtonColorIntensity();
}
public MultiProperty getBackgroundRendererAlphaForStash() {
return mTaskbarDragLayer.getBackgroundRendererAlphaForStash();
}
/**
* Sets the translation of the background during the swipe up gesture.
*/
public void setTranslationYForSwipe(float transY) {
mTaskbarDragLayer.setBackgroundTranslationYForSwipe(transY);
}
/**
* Sets the translation of the background for the bubble bar.
*/
public void setTranslationXForBubbleBar(float transX) {
mTaskbarDragLayer.setBackgroundTranslationXForBubbleBar(transX);
}
/**
* Sets the translation of the background during the spring on stash animation.
*/
public void setTranslationYForStash(float transY) {
mTaskbarDragLayer.setBackgroundTranslationYForStash(transY);
}
private void updateBackgroundOffset() {
mTaskbarDragLayer.setTaskbarBackgroundOffset(mBgOffset.value);
updateOnBackgroundNavButtonColorIntensity();
}
private void updateTaskbarBackgroundProgress() {
mTaskbarDragLayer.setTaskbarBackgroundProgress(mTaskbarBackgroundProgress.value);
}
private void updateTaskbarAlpha() {
mTaskbarDragLayer.setAlpha(mTaskbarAlpha.value);
}
@Override
public void setCornerRoundness(float cornerRoundness) {
mTaskbarDragLayer.setCornerRoundness(cornerRoundness);
}
/**
* Set if another controller is temporarily handling background drawing. In this case we
* override our background alpha to be {@code 0}.
*/
public void setIsBackgroundDrawnElsewhere(boolean isBackgroundDrawnElsewhere) {
mBgOverride.updateValue(isBackgroundDrawnElsewhere ? 0 : 1);
}
private void updateOnBackgroundNavButtonColorIntensity() {
mOnBackgroundNavButtonColorIntensity.updateValue(
mLastSetBackgroundAlpha * (1 - mBgOffset.value));
}
/**
* Sets the width percentage to inset the transient taskbar's background from the left and from
* the right.
*/
public void setBackgroundHorizontalInsets(float insetPercentage) {
mTaskbarDragLayer.setBackgroundHorizontalInsets(insetPercentage);
}
@Override
public void dumpLogs(String prefix, PrintWriter pw) {
pw.println(prefix + "TaskbarDragLayerController:");
pw.println(prefix + "\tmBgOffset=" + mBgOffset.value);
pw.println(prefix + "\tmTaskbarAlpha=" + mTaskbarAlpha.value);
pw.println(prefix + "\tmFolderMargin=" + mFolderMargin);
pw.println(prefix + "\tmLastSetBackgroundAlpha=" + mLastSetBackgroundAlpha);
pw.println(prefix + "\t\tmBgOverride=" + mBgOverride.value);
pw.println(prefix + "\t\tmBgNavbar=" + mBgNavbar.value);
pw.println(prefix + "\t\tmBgTaskbar=" + mBgTaskbar.value);
pw.println(prefix + "\t\tmKeyguardBgTaskbar=" + mKeyguardBgTaskbar.value);
pw.println(prefix + "\t\tmNotificationShadeBgTaskbar=" + mNotificationShadeBgTaskbar.value);
pw.println(prefix + "\t\tmImeBgTaskbar=" + mImeBgTaskbar.value);
pw.println(prefix + "\t\tmAssistantBgTaskbar=" + mAssistantBgTaskbar.value);
pw.println(prefix + "\t\tmBgTaskbarRecreate=" + mBgTaskbarRecreate.value);
}
/**
* Callbacks for {@link TaskbarDragLayer} to interact with its controller.
*/
public class TaskbarDragLayerCallbacks {
/**
* Called to update the touchable insets.
* @see ViewTreeObserver.InternalInsetsInfo#setTouchableInsets(int)
*/
public void updateInsetsTouchability(ViewTreeObserver.InternalInsetsInfo insetsInfo) {
mControllers.taskbarInsetsController.updateInsetsTouchability(insetsInfo);
}
/**
* Called when an IME inset is changed.
*/
public void onImeInsetChanged() {
mControllers.taskbarStashController.onImeInsetChanged();
}
/**
* Called when a child is removed from TaskbarDragLayer.
*/
public void onDragLayerViewRemoved() {
mActivity.onDragEndOrViewRemoved();
}
/**
* Returns how tall the background should be drawn at the bottom of the screen.
*/
public int getTaskbarBackgroundHeight() {
DeviceProfile deviceProfile = mActivity.getDeviceProfile();
if (mActivity.isPhoneMode()) {
Resources resources = mActivity.getResources();
Point taskbarDimensions = DimensionUtils.getTaskbarPhoneDimensions(deviceProfile,
resources, true /* isPhoneMode */, mActivity.isGestureNav());
return taskbarDimensions.y == -1 ?
deviceProfile.getDisplayInfo().currentSize.y :
taskbarDimensions.y;
} else {
return deviceProfile.taskbarHeight;
}
}
/**
* Returns touch controllers.
*/
public TouchController[] getTouchControllers() {
return new TouchController[] {
mActivity.getDragController(),
mControllers.taskbarForceVisibleImmersiveController,
mControllers.navbarButtonsViewController.getTouchController(),
mTaskbarStashViaTouchController,
};
}
/**
* Draws debug UI on top of everything in TaskbarDragLayer.
*/
public void drawDebugUi(Canvas canvas) {
if (!DEBUG) {
return;
}
mControllers.taskbarInsetsController.drawDebugTouchableRegionBounds(canvas);
}
/** Handles any touch event before it is dispatched to the rest of TaskbarDragLayer. */
public void onDispatchTouchEvent(MotionEvent ev) {
if (mActivity.isThreeButtonNav() && ev.getAction() == MotionEvent.ACTION_OUTSIDE
&& mControllers.uiController.isAnimatingToHotseat()) {
// When touching during animation to home, jump to the end so Hotseat can handle
// the touch. (Gesture Navigation handles this in AbsSwipeUpHandler.)
mControllers.uiController.endAnimationToHotseat();
}
}
}
}