Files
Flexera-Launcher/quickstep/src/com/android/launcher3/taskbar/TaskbarNavButtonController.java
T
Graciela Wissen Putri b6488e052c Add displayId to back event
This will allow core to determine which display the back event was
started from.

Flag: com.android.window.flags.enable_independent_back_in_projected
Bug: 401530192
Test: atest TaskbarNavButtonControllerTest
Change-Id: I181aae3e9f5009f99e6ce21092dd45caeeae20cc
2025-04-08 13:28:02 +00:00

420 lines
17 KiB
Java

/*
* Copyright 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.view.KeyEvent.ACTION_DOWN;
import static android.view.KeyEvent.ACTION_UP;
import static com.android.internal.app.AssistUtils.INVOCATION_TYPE_HOME_BUTTON_LONG_PRESS;
import static com.android.internal.app.AssistUtils.INVOCATION_TYPE_KEY;
import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_TASKBAR_A11Y_BUTTON_LONGPRESS;
import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_TASKBAR_A11Y_BUTTON_TAP;
import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_TASKBAR_BACK_BUTTON_LONGPRESS;
import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_TASKBAR_BACK_BUTTON_TAP;
import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_TASKBAR_HOME_BUTTON_LONGPRESS;
import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_TASKBAR_HOME_BUTTON_TAP;
import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_TASKBAR_IME_SWITCHER_BUTTON_LONGPRESS;
import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_TASKBAR_IME_SWITCHER_BUTTON_TAP;
import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_TASKBAR_OVERVIEW_BUTTON_LONGPRESS;
import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_TASKBAR_OVERVIEW_BUTTON_TAP;
import static com.android.systemui.shared.system.ActivityManagerWrapper.CLOSE_SYSTEM_WINDOWS_REASON_HOME_KEY;
import static com.android.systemui.shared.system.ActivityManagerWrapper.CLOSE_SYSTEM_WINDOWS_REASON_RECENTS;
import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_SCREEN_PINNING;
import static com.android.window.flags.Flags.predictiveBackThreeButtonNav;
import android.content.Context;
import android.os.Bundle;
import android.os.Handler;
import android.os.SystemClock;
import android.util.Log;
import android.view.HapticFeedbackConstants;
import android.view.KeyEvent;
import android.view.View;
import android.view.inputmethod.Flags;
import androidx.annotation.IntDef;
import androidx.annotation.Nullable;
import androidx.annotation.StringRes;
import com.android.launcher3.R;
import com.android.launcher3.logging.StatsLogManager;
import com.android.launcher3.testing.TestLogging;
import com.android.launcher3.testing.shared.TestProtocol;
import com.android.quickstep.SystemUiProxy;
import com.android.quickstep.TaskUtils;
import com.android.quickstep.util.ContextualSearchInvoker;
import com.android.systemui.contextualeducation.GestureType;
import com.android.systemui.shared.system.QuickStepContract.SystemUiStateFlags;
import java.io.PrintWriter;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
/**
* Controller for 3 button mode in the taskbar.
* Handles all the functionality of the various buttons, making/routing the right calls into
* launcher or sysui/system.
*/
public class TaskbarNavButtonController implements TaskbarControllers.LoggableTaskbarController {
/** Allow some time in between the long press for back and recents. */
static final int SCREEN_PIN_LONG_PRESS_THRESHOLD = 200;
static final int SCREEN_PIN_LONG_PRESS_RESET = SCREEN_PIN_LONG_PRESS_THRESHOLD + 100;
private static final String TAG = "TaskbarNavButtonController";
private long mLastScreenPinLongPress;
private boolean mScreenPinned;
private boolean mAssistantLongPressEnabled;
private int mLastSentBackAction = ACTION_UP;
@Override
public void dumpLogs(String prefix, PrintWriter pw) {
pw.println(prefix + "TaskbarNavButtonController:");
pw.println(prefix + "\tmLastScreenPinLongPress=" + mLastScreenPinLongPress);
pw.println(prefix + "\tmScreenPinned=" + mScreenPinned);
pw.println(prefix + "\tmLastSentBackAction="
+ KeyEvent.actionToString(mLastSentBackAction));
}
@Retention(RetentionPolicy.SOURCE)
@IntDef(value = {
BUTTON_BACK,
BUTTON_HOME,
BUTTON_RECENTS,
BUTTON_IME_SWITCH,
BUTTON_A11Y,
BUTTON_QUICK_SETTINGS,
BUTTON_NOTIFICATIONS,
})
public @interface TaskbarButton {}
static final int BUTTON_BACK = 1;
static final int BUTTON_HOME = BUTTON_BACK << 1;
static final int BUTTON_RECENTS = BUTTON_HOME << 1;
static final int BUTTON_IME_SWITCH = BUTTON_RECENTS << 1;
static final int BUTTON_A11Y = BUTTON_IME_SWITCH << 1;
static final int BUTTON_QUICK_SETTINGS = BUTTON_A11Y << 1;
static final int BUTTON_NOTIFICATIONS = BUTTON_QUICK_SETTINGS << 1;
static final int BUTTON_SPACE = BUTTON_NOTIFICATIONS << 1;
private static final int SCREEN_UNPIN_COMBO = BUTTON_BACK | BUTTON_RECENTS;
private int mLongPressedButtons = 0;
private final Context mContext;
private final TaskbarNavButtonCallbacks mCallbacks;
private final SystemUiProxy mSystemUiProxy;
private final Handler mHandler;
private final ContextualSearchInvoker mContextualSearchInvoker;
private TaskbarControllers mControllers;
@Nullable private StatsLogManager mStatsLogManager;
private final Runnable mResetLongPress = this::resetScreenUnpin;
public TaskbarNavButtonController(
Context context,
TaskbarNavButtonCallbacks callbacks,
SystemUiProxy systemUiProxy,
Handler handler,
ContextualSearchInvoker contextualSearchInvoker) {
mContext = context;
mCallbacks = callbacks;
mSystemUiProxy = systemUiProxy;
mHandler = handler;
mContextualSearchInvoker = contextualSearchInvoker;
}
public void onButtonClick(@TaskbarButton int buttonType, View view) {
if (buttonType == BUTTON_SPACE) {
return;
}
if (predictiveBackThreeButtonNav() && mLastSentBackAction == ACTION_DOWN) {
Log.i(TAG, "Button click ignored while back button is pressed");
// prevent interactions with other buttons while back button is pressed
return;
}
switch (buttonType) {
case BUTTON_BACK:
executeBack(/* keyEvent */ null);
break;
case BUTTON_HOME:
logEvent(LAUNCHER_TASKBAR_HOME_BUTTON_TAP);
mSystemUiProxy.updateContextualEduStats(/* isTrackpadGesture= */ false,
GestureType.HOME);
navigateHome();
break;
case BUTTON_RECENTS:
logEvent(LAUNCHER_TASKBAR_OVERVIEW_BUTTON_TAP);
mSystemUiProxy.updateContextualEduStats(/* isTrackpadGesture= */ false,
GestureType.OVERVIEW);
navigateToOverview();
break;
case BUTTON_IME_SWITCH:
logEvent(LAUNCHER_TASKBAR_IME_SWITCHER_BUTTON_TAP);
onImeSwitcherPress();
break;
case BUTTON_A11Y:
logEvent(LAUNCHER_TASKBAR_A11Y_BUTTON_TAP);
notifyA11yClick(false /* longClick */);
break;
case BUTTON_QUICK_SETTINGS:
showQuickSettings();
break;
case BUTTON_NOTIFICATIONS:
showNotifications();
break;
}
}
public boolean onButtonLongClick(@TaskbarButton int buttonType, View view) {
if (buttonType == BUTTON_SPACE) {
return false;
}
if (predictiveBackThreeButtonNav() && mLastSentBackAction == ACTION_DOWN
&& buttonType != BUTTON_BACK && buttonType != BUTTON_RECENTS) {
// prevent interactions with other buttons while back button is pressed (except back
// and recents button for screen-unpin action).
Log.i(TAG, "Button long click ignored while back button is pressed");
return false;
}
// Provide the same haptic feedback that the system offers for long press.
// The haptic feedback from long pressing on the home button is handled by circle to search.
// There are no haptics for long pressing the back button if predictive back is enabled
if (buttonType != BUTTON_HOME
&& (!predictiveBackThreeButtonNav() || buttonType != BUTTON_BACK)) {
view.performHapticFeedback(HapticFeedbackConstants.LONG_PRESS);
}
switch (buttonType) {
case BUTTON_HOME:
logEvent(LAUNCHER_TASKBAR_HOME_BUTTON_LONGPRESS);
onLongPressHome();
return true;
case BUTTON_A11Y:
logEvent(LAUNCHER_TASKBAR_A11Y_BUTTON_LONGPRESS);
notifyA11yClick(true /* longClick */);
return true;
case BUTTON_BACK:
logEvent(LAUNCHER_TASKBAR_BACK_BUTTON_LONGPRESS);
backRecentsLongpress(buttonType);
return true;
case BUTTON_RECENTS:
logEvent(LAUNCHER_TASKBAR_OVERVIEW_BUTTON_LONGPRESS);
backRecentsLongpress(buttonType);
return true;
case BUTTON_IME_SWITCH:
if (Flags.imeSwitcherRevamp()) {
logEvent(LAUNCHER_TASKBAR_IME_SWITCHER_BUTTON_LONGPRESS);
onImeSwitcherLongPress();
return true;
}
return false;
default:
return false;
}
}
public @StringRes int getButtonContentDescription(@TaskbarButton int buttonType) {
switch (buttonType) {
case BUTTON_HOME:
return R.string.taskbar_button_home;
case BUTTON_A11Y:
return R.string.taskbar_button_a11y;
case BUTTON_BACK:
return R.string.taskbar_button_back;
case BUTTON_IME_SWITCH:
return R.string.taskbar_button_ime_switcher;
case BUTTON_RECENTS:
return R.string.taskbar_button_recents;
case BUTTON_NOTIFICATIONS:
return R.string.taskbar_button_notifications;
case BUTTON_QUICK_SETTINGS:
return R.string.taskbar_button_quick_settings;
default:
return 0;
}
}
private boolean backRecentsLongpress(@TaskbarButton int buttonType) {
mLongPressedButtons |= buttonType;
return determineScreenUnpin();
}
/**
* Checks if the user has long pressed back and recents buttons
* "together" (within {@link #SCREEN_PIN_LONG_PRESS_THRESHOLD})ms
* If so, then requests the system to turn off screen pinning.
*
* @return true if the long press is a valid user action in attempting to unpin an app
* Will always return {@code false} when screen pinning is not active.
* NOTE: Returning true does not mean that screen pinning has stopped
*/
private boolean determineScreenUnpin() {
long timeNow = System.currentTimeMillis();
if (!mScreenPinned) {
return false;
}
if (mLastScreenPinLongPress == 0) {
// First button long press registered, just mark time and wait for second button press
mLastScreenPinLongPress = System.currentTimeMillis();
mHandler.postDelayed(mResetLongPress, SCREEN_PIN_LONG_PRESS_RESET);
return true;
}
if ((timeNow - mLastScreenPinLongPress) > SCREEN_PIN_LONG_PRESS_THRESHOLD) {
// Too long in-between presses, reset the clock
resetScreenUnpin();
return false;
}
if ((mLongPressedButtons & SCREEN_UNPIN_COMBO) == SCREEN_UNPIN_COMBO) {
// Hooray! They did it (finally...)
mSystemUiProxy.stopScreenPinning();
mHandler.removeCallbacks(mResetLongPress);
resetScreenUnpin();
}
return true;
}
private void resetScreenUnpin() {
// if only back button was long pressed, navigate back like a single click back behavior.
if (mLongPressedButtons == BUTTON_BACK) {
executeBack(null);
}
mLongPressedButtons = 0;
mLastScreenPinLongPress = 0;
}
public void updateSysuiFlags(@SystemUiStateFlags long sysuiFlags) {
mScreenPinned = (sysuiFlags & SYSUI_STATE_SCREEN_PINNING) != 0;
}
public void init(TaskbarControllers taskbarControllers) {
mControllers = taskbarControllers;
mStatsLogManager = mControllers.getTaskbarActivityContext().getStatsLogManager();
}
public void onDestroy() {
mStatsLogManager = null;
}
public void setAssistantLongPressEnabled(boolean assistantLongPressEnabled) {
mAssistantLongPressEnabled = assistantLongPressEnabled;
}
private void logEvent(StatsLogManager.LauncherEvent event) {
if (mStatsLogManager == null) {
Log.w(TAG, "No stats log manager to log taskbar button event");
return;
}
mStatsLogManager.logger().log(event);
}
private void navigateHome() {
TaskUtils.closeSystemWindowsAsync(CLOSE_SYSTEM_WINDOWS_REASON_HOME_KEY);
mCallbacks.onNavigateHome(mContext.getDisplayId());
}
private void navigateToOverview() {
if (mScreenPinned) {
return;
}
TestLogging.recordEvent(TestProtocol.SEQUENCE_MAIN, "onOverviewToggle");
TaskUtils.closeSystemWindowsAsync(CLOSE_SYSTEM_WINDOWS_REASON_RECENTS);
mCallbacks.onToggleOverview(mContext.getDisplayId());
}
public void hideOverview() {
mCallbacks.onHideOverview(mContext.getDisplayId());
}
void sendBackKeyEvent(int action, boolean cancelled) {
if (action == mLastSentBackAction) {
// There must always be an alternating sequence of ACTION_DOWN and ACTION_UP events
return;
}
long time = SystemClock.uptimeMillis();
KeyEvent keyEvent = new KeyEvent(time, time, action, KeyEvent.KEYCODE_BACK, 0);
keyEvent.setDisplayId(mControllers.getTaskbarActivityContext().getDisplayId());
if (cancelled) {
keyEvent.cancel();
}
executeBack(keyEvent);
}
private void executeBack(@Nullable KeyEvent keyEvent) {
if (keyEvent == null || (keyEvent.getAction() == ACTION_UP && !keyEvent.isCanceled())) {
logEvent(LAUNCHER_TASKBAR_BACK_BUTTON_TAP);
mSystemUiProxy.updateContextualEduStats(/* isTrackpadGesture= */ false,
GestureType.BACK);
}
mSystemUiProxy.onBackEvent(keyEvent);
mLastSentBackAction = keyEvent != null ? keyEvent.getAction() : ACTION_UP;
}
private void onImeSwitcherPress() {
mSystemUiProxy.onImeSwitcherPressed();
}
private void onImeSwitcherLongPress() {
mSystemUiProxy.onImeSwitcherLongPress();
}
private void notifyA11yClick(boolean longClick) {
if (longClick) {
mSystemUiProxy.notifyAccessibilityButtonLongClicked();
} else {
mSystemUiProxy.notifyAccessibilityButtonClicked(mContext.getDisplayId());
}
}
private void onLongPressHome() {
if (mScreenPinned || !mAssistantLongPressEnabled) {
return;
}
// Attempt to start Contextual Search, otherwise fall back to SysUi's implementation.
if (!mContextualSearchInvoker.tryStartAssistOverride(
INVOCATION_TYPE_HOME_BUTTON_LONG_PRESS)) {
Bundle args = new Bundle();
args.putInt(INVOCATION_TYPE_KEY, INVOCATION_TYPE_HOME_BUTTON_LONG_PRESS);
mSystemUiProxy.startAssistant(args);
}
}
private void showQuickSettings() {
mSystemUiProxy.toggleNotificationPanel();
}
private void showNotifications() {
mSystemUiProxy.toggleNotificationPanel();
}
/** Callbacks for navigation buttons on Taskbar. */
public interface TaskbarNavButtonCallbacks {
/** Callback invoked when the home button is pressed. */
default void onNavigateHome(int displayId) {}
/** Callback invoked when the overview button is pressed. */
default void onToggleOverview(int displayId) {}
/** Callback invoken when a visible overview needs to be hidden. */
default void onHideOverview(int displayId) { }
}
}