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
420 lines
17 KiB
Java
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) { }
|
|
}
|
|
}
|