| /* |
| * Copyright (C) 2018 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.systemui.statusbar.phone; |
| |
| import static android.view.WindowManagerPolicyConstants.NAV_BAR_LEFT; |
| import static android.view.WindowManagerPolicyConstants.NAV_BAR_RIGHT; |
| |
| import static com.android.systemui.shared.system.NavigationBarCompat.HIT_TARGET_NONE; |
| |
| import android.annotation.NonNull; |
| import android.content.Context; |
| import android.graphics.Canvas; |
| import android.provider.Settings; |
| import android.view.MotionEvent; |
| |
| import com.android.systemui.recents.OverviewProxyService; |
| |
| /** |
| * A gesture action that would be triggered and reassigned by {@link QuickStepController} |
| */ |
| public abstract class NavigationGestureAction { |
| private static final String ENABLE_TASK_STABILIZER_FLAG = "ENABLE_TASK_STABILIZER"; |
| |
| static private boolean sLastTaskStabilizationFlag; |
| |
| protected final NavigationBarView mNavigationBarView; |
| protected final OverviewProxyService mProxySender; |
| |
| protected int mNavigationBarPosition; |
| protected boolean mDragHorizontalPositive; |
| protected boolean mDragVerticalPositive; |
| private boolean mIsActive; |
| |
| public NavigationGestureAction(@NonNull NavigationBarView navigationBarView, |
| @NonNull OverviewProxyService service) { |
| mNavigationBarView = navigationBarView; |
| mProxySender = service; |
| sLastTaskStabilizationFlag = Settings.Global.getInt( |
| mNavigationBarView.getContext().getContentResolver(), |
| ENABLE_TASK_STABILIZER_FLAG, 0) != 0; |
| } |
| |
| /** |
| * Pass event that the state of the bar (such as rotation) has changed |
| * @param changed if rotation or drag positive direction (such as ltr) has changed |
| * @param navBarPos position of navigation bar |
| * @param dragHorPositive direction of positive horizontal drag, could change with ltr changes |
| * @param dragVerPositive direction of positive vertical drag, could change with ltr changes |
| */ |
| public void setBarState(boolean changed, int navBarPos, boolean dragHorPositive, |
| boolean dragVerPositive) { |
| mNavigationBarPosition = navBarPos; |
| mDragHorizontalPositive = dragHorPositive; |
| mDragVerticalPositive = dragVerPositive; |
| } |
| |
| /** |
| * Resets the state of the action. Called when touch down occurs over the Navigation Bar. |
| */ |
| public void reset() { |
| mIsActive = false; |
| } |
| |
| /** |
| * Start the gesture and the action will be active |
| * @param event the event that caused the gesture |
| */ |
| public void startGesture(MotionEvent event) { |
| mIsActive = true; |
| |
| // Tell launcher that this action requires a stable task list or not |
| boolean flag = requiresStableTaskList(); |
| if (flag != sLastTaskStabilizationFlag) { |
| Settings.Global.putInt(mNavigationBarView.getContext().getContentResolver(), |
| ENABLE_TASK_STABILIZER_FLAG, flag ? 1 : 0); |
| sLastTaskStabilizationFlag = flag; |
| } |
| |
| onGestureStart(event); |
| } |
| |
| /** |
| * Gesture has ended with action cancel or up and this action will not be active |
| */ |
| public void endGesture() { |
| mIsActive = false; |
| onGestureEnd(); |
| } |
| |
| /** |
| * If the action is currently active based on the gesture that triggered it. Only one action |
| * can occur at a time |
| * @return whether or not if this action has been triggered |
| */ |
| public boolean isActive() { |
| return mIsActive; |
| } |
| |
| /** |
| * @return whether or not this action can run if notification shade is shown |
| */ |
| public boolean canRunWhenNotificationsShowing() { |
| return true; |
| } |
| |
| /** |
| * @return whether or not this action triggers when starting a gesture from a certain hit target |
| * If {@link HIT_TARGET_NONE} is specified then action does not need to be triggered by button |
| */ |
| public int requiresTouchDownHitTarget() { |
| return HIT_TARGET_NONE; |
| } |
| |
| /** |
| * @return whether or not to move the button that started gesture over with user input drag |
| */ |
| public boolean allowHitTargetToMoveOverDrag() { |
| return false; |
| } |
| |
| /** |
| * Tell if the action is able to execute. Note that {@link #isEnabled()} must be true for this |
| * to be checked. The difference between this and {@link #isEnabled()} is that this dependent |
| * on the state of the navigation bar |
| * @return true if action can execute after gesture activates based on current states |
| */ |
| public boolean canPerformAction() { |
| return true; |
| } |
| |
| /** |
| * Decide if the controller should not send the current motion event to launcher via |
| * {@link OverviewProxyService} |
| * @return if controller should not proxy |
| */ |
| public boolean disableProxyEvents() { |
| return false; |
| } |
| |
| /** |
| * Tell if action is enabled. Compared to {@link #canPerformAction()} this is based on settings |
| * if the action is disabled for a particular gesture. For example a back action can be enabled |
| * however if there is nothing to back to then {@link #canPerformAction()} should return false. |
| * In this way if the action requires {@link #allowHitTargetToMoveOverDrag()} then if enabled, |
| * the button can be dragged with a large dampening factor during the gesture but will not |
| * activate the action. |
| * @return true if this action is enabled and can run |
| */ |
| public abstract boolean isEnabled(); |
| |
| /** |
| * @return action requires a stable task list from launcher |
| */ |
| protected boolean requiresStableTaskList() { |
| return false; |
| } |
| |
| protected void onDarkIntensityChange(float intensity) { |
| } |
| |
| protected void onDraw(Canvas canvas) { |
| } |
| |
| protected void onLayout(boolean changed, int left, int top, int right, int bottom) { |
| } |
| |
| /** |
| * When gesture starts, this will run to execute the action |
| * @param event the event that triggered the gesture |
| */ |
| protected abstract void onGestureStart(MotionEvent event); |
| |
| /** |
| * Channels motion move events to the action to track the user inputs |
| * @param x the x position |
| * @param y the y position |
| */ |
| public void onGestureMove(int x, int y) { |
| } |
| |
| /** |
| * When gesture ends, this will run from action up or cancel |
| */ |
| protected void onGestureEnd() { |
| } |
| |
| protected Context getContext() { |
| return mNavigationBarView.getContext(); |
| } |
| |
| protected boolean isNavBarVertical() { |
| return mNavigationBarPosition == NAV_BAR_LEFT || mNavigationBarPosition == NAV_BAR_RIGHT; |
| } |
| |
| protected boolean getGlobalBoolean(@NonNull String key) { |
| return QuickStepController.getBoolGlobalSetting(getContext(), key); |
| } |
| } |