com/android/systemui/statusbar/phone/EdgeBackGestureHandler.java - platform/prebuilts/fullsdk/sources/android-29 - Git at Google

 /**
  * Copyright (C) 2019 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.Display.INVALID_DISPLAY;

 import android.content.Context;
 import android.content.pm.ParceledListSlice;
 import android.content.res.Resources;
 import android.graphics.PixelFormat;
 import android.graphics.Point;
 import android.graphics.PointF;
 import android.graphics.Rect;
 import android.graphics.Region;
 import android.hardware.display.DisplayManager;
 import android.hardware.display.DisplayManager.DisplayListener;
 import android.hardware.input.InputManager;
 import android.os.Looper;
 import android.os.RemoteException;
 import android.os.SystemClock;
 import android.util.Log;
 import android.util.MathUtils;
 import android.view.Gravity;
 import android.view.IPinnedStackController;
 import android.view.IPinnedStackListener;
 import android.view.ISystemGestureExclusionListener;
 import android.view.InputChannel;
 import android.view.InputDevice;
 import android.view.InputEvent;
 import android.view.InputEventReceiver;
 import android.view.InputMonitor;
 import android.view.KeyCharacterMap;
 import android.view.KeyEvent;
 import android.view.MotionEvent;
 import android.view.View;
 import android.view.ViewConfiguration;
 import android.view.WindowManager;
 import android.view.WindowManagerGlobal;

 import com.android.systemui.Dependency;
 import com.android.systemui.R;
 import com.android.systemui.bubbles.BubbleController;
 import com.android.systemui.recents.OverviewProxyService;
 import com.android.systemui.shared.system.QuickStepContract;
 import com.android.systemui.shared.system.WindowManagerWrapper;

 import java.io.PrintWriter;
 import java.util.concurrent.Executor;

 /**
  * Utility class to handle edge swipes for back gesture
  */
 public class EdgeBackGestureHandler implements DisplayListener {

     private static final String TAG = "EdgeBackGestureHandler";
     private static final int MAX_LONG_PRESS_TIMEOUT = 250;

     private final IPinnedStackListener.Stub mImeChangedListener = new IPinnedStackListener.Stub() {
         @Override
         public void onListenerRegistered(IPinnedStackController controller) {
         }

         @Override
         public void onImeVisibilityChanged(boolean imeVisible, int imeHeight) {
             // No need to thread jump, assignments are atomic
             mImeHeight = imeVisible ? imeHeight : 0;
             // TODO: Probably cancel any existing gesture
         }

         @Override
         public void onShelfVisibilityChanged(boolean shelfVisible, int shelfHeight) {
         }

         @Override
         public void onMinimizedStateChanged(boolean isMinimized) {
         }

         @Override
         public void onMovementBoundsChanged(Rect insetBounds, Rect normalBounds,
                 Rect animatingBounds, boolean fromImeAdjustment, boolean fromShelfAdjustment,
                 int displayRotation) {
         }

         @Override
         public void onActionsChanged(ParceledListSlice actions) {
         }
     };

     private ISystemGestureExclusionListener mGestureExclusionListener =
             new ISystemGestureExclusionListener.Stub() {
                 @Override
                 public void onSystemGestureExclusionChanged(int displayId,
                         Region systemGestureExclusion) {
                     if (displayId == mDisplayId) {
                         mMainExecutor.execute(() -> mExcludeRegion.set(systemGestureExclusion));
                     }
                 }
             };

     private final Context mContext;
     private final OverviewProxyService mOverviewProxyService;

     private final Point mDisplaySize = new Point();
     private final int mDisplayId;

     private final Executor mMainExecutor;

     private final Region mExcludeRegion = new Region();
     // The edge width where touch down is allowed
     private int mEdgeWidth;
     // The slop to distinguish between horizontal and vertical motion
     private final float mTouchSlop;
     // Duration after which we consider the event as longpress.
     private final int mLongPressTimeout;
     // The threshold where the touch needs to be at most, such that the arrow is displayed above the
     // finger, otherwise it will be below
     private final int mMinArrowPosition;
     // The amount by which the arrow is shifted to avoid the finger
     private final int mFingerOffset;


     private final int mNavBarHeight;

     private final PointF mDownPoint = new PointF();
     private boolean mThresholdCrossed = false;
     private boolean mAllowGesture = false;
     private boolean mIsOnLeftEdge;

     private int mImeHeight = 0;

     private boolean mIsAttached;
     private boolean mIsGesturalModeEnabled;
     private boolean mIsEnabled;

     private InputMonitor mInputMonitor;
     private InputEventReceiver mInputEventReceiver;

     private final WindowManager mWm;

     private NavigationBarEdgePanel mEdgePanel;
     private WindowManager.LayoutParams mEdgePanelLp;
     private final Rect mSamplingRect = new Rect();
     private RegionSamplingHelper mRegionSamplingHelper;
     private int mLeftInset;
     private int mRightInset;

     public EdgeBackGestureHandler(Context context, OverviewProxyService overviewProxyService) {
         final Resources res = context.getResources();
         mContext = context;
         mDisplayId = context.getDisplayId();
         mMainExecutor = context.getMainExecutor();
         mWm = context.getSystemService(WindowManager.class);
         mOverviewProxyService = overviewProxyService;

         // Reduce the default touch slop to ensure that we can intercept the gesture
         // before the app starts to react to it.
         // TODO(b/130352502) Tune this value and extract into a constant
         mTouchSlop = ViewConfiguration.get(context).getScaledTouchSlop() * 0.75f;
         mLongPressTimeout = Math.min(MAX_LONG_PRESS_TIMEOUT,
                 ViewConfiguration.getLongPressTimeout());

         mNavBarHeight = res.getDimensionPixelSize(R.dimen.navigation_bar_frame_height);
         mMinArrowPosition = res.getDimensionPixelSize(R.dimen.navigation_edge_arrow_min_y);
         mFingerOffset = res.getDimensionPixelSize(R.dimen.navigation_edge_finger_offset);
         updateCurrentUserResources(res);
     }

     public void updateCurrentUserResources(Resources res) {
         mEdgeWidth = res.getDimensionPixelSize(
                 com.android.internal.R.dimen.config_backGestureInset);
     }

     /**
      * @see NavigationBarView#onAttachedToWindow()
      */
     public void onNavBarAttached() {
         mIsAttached = true;
         updateIsEnabled();
     }

     /**
      * @see NavigationBarView#onDetachedFromWindow()
      */
     public void onNavBarDetached() {
         mIsAttached = false;
         updateIsEnabled();
     }

     public void onNavigationModeChanged(int mode, Context currentUserContext) {
         mIsGesturalModeEnabled = QuickStepContract.isGesturalMode(mode);
         updateIsEnabled();
         updateCurrentUserResources(currentUserContext.getResources());
     }

     private void disposeInputChannel() {
         if (mInputEventReceiver != null) {
             mInputEventReceiver.dispose();
             mInputEventReceiver = null;
         }
         if (mInputMonitor != null) {
             mInputMonitor.dispose();
             mInputMonitor = null;
         }
     }

     private void updateIsEnabled() {
         boolean isEnabled = mIsAttached && mIsGesturalModeEnabled;
         if (isEnabled == mIsEnabled) {
             return;
         }
         mIsEnabled = isEnabled;
         disposeInputChannel();

         if (mEdgePanel != null) {
             mWm.removeView(mEdgePanel);
             mEdgePanel = null;
             mRegionSamplingHelper.stop();
             mRegionSamplingHelper = null;
         }

         if (!mIsEnabled) {
             WindowManagerWrapper.getInstance().removePinnedStackListener(mImeChangedListener);
             mContext.getSystemService(DisplayManager.class).unregisterDisplayListener(this);

             try {
                 WindowManagerGlobal.getWindowManagerService()
                         .unregisterSystemGestureExclusionListener(
                                 mGestureExclusionListener, mDisplayId);
             } catch (RemoteException e) {
                 Log.e(TAG, "Failed to unregister window manager callbacks", e);
             }

         } else {
             updateDisplaySize();
             mContext.getSystemService(DisplayManager.class).registerDisplayListener(this,
                     mContext.getMainThreadHandler());

             try {
                 WindowManagerWrapper.getInstance().addPinnedStackListener(mImeChangedListener);
                 WindowManagerGlobal.getWindowManagerService()
                         .registerSystemGestureExclusionListener(
                                 mGestureExclusionListener, mDisplayId);
             } catch (RemoteException e) {
                 Log.e(TAG, "Failed to register window manager callbacks", e);
             }

             // Register input event receiver
             mInputMonitor = InputManager.getInstance().monitorGestureInput(
                     "edge-swipe", mDisplayId);
             mInputEventReceiver = new SysUiInputEventReceiver(
                     mInputMonitor.getInputChannel(), Looper.getMainLooper());

             // Add a nav bar panel window
             mEdgePanel = new NavigationBarEdgePanel(mContext);
             mEdgePanelLp = new WindowManager.LayoutParams(
                     mContext.getResources()
                             .getDimensionPixelSize(R.dimen.navigation_edge_panel_width),
                     mContext.getResources()
                             .getDimensionPixelSize(R.dimen.navigation_edge_panel_height),
                     WindowManager.LayoutParams.TYPE_NAVIGATION_BAR_PANEL,
                     WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE
                             | WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL
                             | WindowManager.LayoutParams.FLAG_SPLIT_TOUCH
                             | WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN,
                     PixelFormat.TRANSLUCENT);
             mEdgePanelLp.privateFlags |=
                     WindowManager.LayoutParams.PRIVATE_FLAG_SHOW_FOR_ALL_USERS;
             mEdgePanelLp.setTitle(TAG + mDisplayId);
             mEdgePanelLp.accessibilityTitle = mContext.getString(R.string.nav_bar_edge_panel);
             mEdgePanelLp.windowAnimations = 0;
             mEdgePanel.setLayoutParams(mEdgePanelLp);
             mWm.addView(mEdgePanel, mEdgePanelLp);
             mRegionSamplingHelper = new RegionSamplingHelper(mEdgePanel,
                     new RegionSamplingHelper.SamplingCallback() {
                         @Override
                         public void onRegionDarknessChanged(boolean isRegionDark) {
                             mEdgePanel.setIsDark(!isRegionDark, true /* animate */);
                         }

                         @Override
                         public Rect getSampledRegion(View sampledView) {
                             return mSamplingRect;
                         }
                     });
         }
     }

     private void onInputEvent(InputEvent ev) {
         if (ev instanceof MotionEvent) {
             onMotionEvent((MotionEvent) ev);
         }
     }

     private boolean isWithinTouchRegion(int x, int y) {
         if (y > (mDisplaySize.y - Math.max(mImeHeight, mNavBarHeight))) {
             return false;
         }

         if (x > mEdgeWidth + mLeftInset && x < (mDisplaySize.x - mEdgeWidth - mRightInset)) {
             return false;
         }
         boolean isInExcludedRegion = mExcludeRegion.contains(x, y);
         if (isInExcludedRegion) {
             mOverviewProxyService.notifyBackAction(false /* completed */, -1, -1,
                     false /* isButton */, !mIsOnLeftEdge);
         }
         return !isInExcludedRegion;
     }

     private void cancelGesture(MotionEvent ev) {
         // Send action cancel to reset all the touch events
         mAllowGesture = false;
         MotionEvent cancelEv = MotionEvent.obtain(ev);
         cancelEv.setAction(MotionEvent.ACTION_CANCEL);
         mEdgePanel.handleTouch(cancelEv);
         cancelEv.recycle();
     }

     private void onMotionEvent(MotionEvent ev) {
         int action = ev.getActionMasked();
         if (action == MotionEvent.ACTION_DOWN) {
             // Verify if this is in within the touch region and we aren't in immersive mode, and
             // either the bouncer is showing or the notification panel is hidden
             int stateFlags = mOverviewProxyService.getSystemUiStateFlags();
             mIsOnLeftEdge = ev.getX() <= mEdgeWidth + mLeftInset;
             mAllowGesture = !QuickStepContract.isBackGestureDisabled(stateFlags)
                     && isWithinTouchRegion((int) ev.getX(), (int) ev.getY());
             if (mAllowGesture) {
                 mEdgePanelLp.gravity = mIsOnLeftEdge
                         ? (Gravity.LEFT | Gravity.TOP)
                         : (Gravity.RIGHT | Gravity.TOP);
                 mEdgePanel.setIsLeftPanel(mIsOnLeftEdge);
                 mEdgePanel.handleTouch(ev);
                 updateEdgePanelPosition(ev.getY());
                 mWm.updateViewLayout(mEdgePanel, mEdgePanelLp);
                 mRegionSamplingHelper.start(mSamplingRect);

                 mDownPoint.set(ev.getX(), ev.getY());
                 mThresholdCrossed = false;
             }
         } else if (mAllowGesture) {
             if (!mThresholdCrossed) {
                 if (action == MotionEvent.ACTION_POINTER_DOWN) {
                     // We do not support multi touch for back gesture
                     cancelGesture(ev);
                     return;
                 } else if (action == MotionEvent.ACTION_MOVE) {
                     if ((ev.getEventTime() - ev.getDownTime()) > mLongPressTimeout) {
                         cancelGesture(ev);
                         return;
                     }
                     float dx = Math.abs(ev.getX() - mDownPoint.x);
                     float dy = Math.abs(ev.getY() - mDownPoint.y);
                     if (dy > dx && dy > mTouchSlop) {
                         cancelGesture(ev);
                         return;

                     } else if (dx > dy && dx > mTouchSlop) {
                         mThresholdCrossed = true;
                         // Capture inputs
                         mInputMonitor.pilferPointers();
                     }
                 }

             }

             // forward touch
             mEdgePanel.handleTouch(ev);

             boolean isUp = action == MotionEvent.ACTION_UP;
             if (isUp) {
                 boolean performAction = mEdgePanel.shouldTriggerBack();
                 if (performAction) {
                     // Perform back
                     sendEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_BACK);
                     sendEvent(KeyEvent.ACTION_UP, KeyEvent.KEYCODE_BACK);
                 }
                 mOverviewProxyService.notifyBackAction(performAction, (int) mDownPoint.x,
                         (int) mDownPoint.y, false /* isButton */, !mIsOnLeftEdge);
             }
             if (isUp || action == MotionEvent.ACTION_CANCEL) {
                 mRegionSamplingHelper.stop();
             } else {
                 updateSamplingRect();
                 mRegionSamplingHelper.updateSamplingRect();
             }
         }
     }

     private void updateEdgePanelPosition(float touchY) {
         float position = touchY - mFingerOffset;
         position = Math.max(position, mMinArrowPosition);
         position = (position - mEdgePanelLp.height / 2.0f);
         mEdgePanelLp.y = MathUtils.constrain((int) position, 0, mDisplaySize.y);
         updateSamplingRect();
     }

     private void updateSamplingRect() {
         int top = mEdgePanelLp.y;
         int left = mIsOnLeftEdge ? mLeftInset : mDisplaySize.x - mRightInset - mEdgePanelLp.width;
         int right = left + mEdgePanelLp.width;
         int bottom = top + mEdgePanelLp.height;
         mSamplingRect.set(left, top, right, bottom);
         mEdgePanel.adjustRectToBoundingBox(mSamplingRect);
     }

     @Override
     public void onDisplayAdded(int displayId) { }

     @Override
     public void onDisplayRemoved(int displayId) { }

     @Override
     public void onDisplayChanged(int displayId) {
         if (displayId == mDisplayId) {
             updateDisplaySize();
         }
     }

     private void updateDisplaySize() {
         mContext.getSystemService(DisplayManager.class)
                 .getDisplay(mDisplayId)
                 .getRealSize(mDisplaySize);
     }

     private void sendEvent(int action, int code) {
         long when = SystemClock.uptimeMillis();
         final KeyEvent ev = new KeyEvent(when, when, action, code, 0 /* repeat */,
                 0 /* metaState */, KeyCharacterMap.VIRTUAL_KEYBOARD, 0 /* scancode */,
                 KeyEvent.FLAG_FROM_SYSTEM | KeyEvent.FLAG_VIRTUAL_HARD_KEY,
                 InputDevice.SOURCE_KEYBOARD);

         // Bubble controller will give us a valid display id if it should get the back event
         BubbleController bubbleController = Dependency.get(BubbleController.class);
         int bubbleDisplayId = bubbleController.getExpandedDisplayId(mContext);
         if (code == KeyEvent.KEYCODE_BACK && bubbleDisplayId != INVALID_DISPLAY) {
             ev.setDisplayId(bubbleDisplayId);
         }
         InputManager.getInstance().injectInputEvent(ev, InputManager.INJECT_INPUT_EVENT_MODE_ASYNC);
     }

     public void setInsets(int leftInset, int rightInset) {
         mLeftInset = leftInset;
         mRightInset = rightInset;
     }

     public void dump(PrintWriter pw) {
         pw.println("EdgeBackGestureHandler:");
         pw.println("  mIsEnabled=" + mIsEnabled);
         pw.println("  mAllowGesture=" + mAllowGesture);
         pw.println("  mExcludeRegion=" + mExcludeRegion);
         pw.println("  mImeHeight=" + mImeHeight);
         pw.println("  mIsAttached=" + mIsAttached);
         pw.println("  mEdgeWidth=" + mEdgeWidth);
     }

     class SysUiInputEventReceiver extends InputEventReceiver {
         SysUiInputEventReceiver(InputChannel channel, Looper looper) {
             super(channel, looper);
         }

         public void onInputEvent(InputEvent event) {
             EdgeBackGestureHandler.this.onInputEvent(event);
             finishInputEvent(event, true);
         }
     }
 }
	/**
	* Copyright (C) 2019 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.Display.INVALID_DISPLAY;

	import android.content.Context;
	import android.content.pm.ParceledListSlice;
	import android.content.res.Resources;
	import android.graphics.PixelFormat;
	import android.graphics.Point;
	import android.graphics.PointF;
	import android.graphics.Rect;
	import android.graphics.Region;
	import android.hardware.display.DisplayManager;
	import android.hardware.display.DisplayManager.DisplayListener;
	import android.hardware.input.InputManager;
	import android.os.Looper;
	import android.os.RemoteException;
	import android.os.SystemClock;
	import android.util.Log;
	import android.util.MathUtils;
	import android.view.Gravity;
	import android.view.IPinnedStackController;
	import android.view.IPinnedStackListener;
	import android.view.ISystemGestureExclusionListener;
	import android.view.InputChannel;
	import android.view.InputDevice;
	import android.view.InputEvent;
	import android.view.InputEventReceiver;
	import android.view.InputMonitor;
	import android.view.KeyCharacterMap;
	import android.view.KeyEvent;
	import android.view.MotionEvent;
	import android.view.View;
	import android.view.ViewConfiguration;
	import android.view.WindowManager;
	import android.view.WindowManagerGlobal;

	import com.android.systemui.Dependency;
	import com.android.systemui.R;
	import com.android.systemui.bubbles.BubbleController;
	import com.android.systemui.recents.OverviewProxyService;
	import com.android.systemui.shared.system.QuickStepContract;
	import com.android.systemui.shared.system.WindowManagerWrapper;

	import java.io.PrintWriter;
	import java.util.concurrent.Executor;

	/**
	* Utility class to handle edge swipes for back gesture
	*/
	public class EdgeBackGestureHandler implements DisplayListener {

	private static final String TAG = "EdgeBackGestureHandler";
	private static final int MAX_LONG_PRESS_TIMEOUT = 250;

	private final IPinnedStackListener.Stub mImeChangedListener = new IPinnedStackListener.Stub() {
	@Override
	public void onListenerRegistered(IPinnedStackController controller) {
	}

	@Override
	public void onImeVisibilityChanged(boolean imeVisible, int imeHeight) {
	// No need to thread jump, assignments are atomic
	mImeHeight = imeVisible ? imeHeight : 0;
	// TODO: Probably cancel any existing gesture
	}

	@Override
	public void onShelfVisibilityChanged(boolean shelfVisible, int shelfHeight) {
	}

	@Override
	public void onMinimizedStateChanged(boolean isMinimized) {
	}

	@Override
	public void onMovementBoundsChanged(Rect insetBounds, Rect normalBounds,
	Rect animatingBounds, boolean fromImeAdjustment, boolean fromShelfAdjustment,
	int displayRotation) {
	}

	@Override
	public void onActionsChanged(ParceledListSlice actions) {
	}
	};

	private ISystemGestureExclusionListener mGestureExclusionListener =
	new ISystemGestureExclusionListener.Stub() {
	@Override
	public void onSystemGestureExclusionChanged(int displayId,
	Region systemGestureExclusion) {
	if (displayId == mDisplayId) {
	mMainExecutor.execute(() -> mExcludeRegion.set(systemGestureExclusion));
	}
	}
	};

	private final Context mContext;
	private final OverviewProxyService mOverviewProxyService;

	private final Point mDisplaySize = new Point();
	private final int mDisplayId;

	private final Executor mMainExecutor;

	private final Region mExcludeRegion = new Region();
	// The edge width where touch down is allowed
	private int mEdgeWidth;
	// The slop to distinguish between horizontal and vertical motion
	private final float mTouchSlop;
	// Duration after which we consider the event as longpress.
	private final int mLongPressTimeout;
	// The threshold where the touch needs to be at most, such that the arrow is displayed above the
	// finger, otherwise it will be below
	private final int mMinArrowPosition;
	// The amount by which the arrow is shifted to avoid the finger
	private final int mFingerOffset;


	private final int mNavBarHeight;

	private final PointF mDownPoint = new PointF();
	private boolean mThresholdCrossed = false;
	private boolean mAllowGesture = false;
	private boolean mIsOnLeftEdge;

	private int mImeHeight = 0;

	private boolean mIsAttached;
	private boolean mIsGesturalModeEnabled;
	private boolean mIsEnabled;

	private InputMonitor mInputMonitor;
	private InputEventReceiver mInputEventReceiver;

	private final WindowManager mWm;

	private NavigationBarEdgePanel mEdgePanel;
	private WindowManager.LayoutParams mEdgePanelLp;
	private final Rect mSamplingRect = new Rect();
	private RegionSamplingHelper mRegionSamplingHelper;
	private int mLeftInset;
	private int mRightInset;

	public EdgeBackGestureHandler(Context context, OverviewProxyService overviewProxyService) {
	final Resources res = context.getResources();
	mContext = context;
	mDisplayId = context.getDisplayId();
	mMainExecutor = context.getMainExecutor();
	mWm = context.getSystemService(WindowManager.class);
	mOverviewProxyService = overviewProxyService;

	// Reduce the default touch slop to ensure that we can intercept the gesture
	// before the app starts to react to it.
	// TODO(b/130352502) Tune this value and extract into a constant
	mTouchSlop = ViewConfiguration.get(context).getScaledTouchSlop() * 0.75f;
	mLongPressTimeout = Math.min(MAX_LONG_PRESS_TIMEOUT,
	ViewConfiguration.getLongPressTimeout());

	mNavBarHeight = res.getDimensionPixelSize(R.dimen.navigation_bar_frame_height);
	mMinArrowPosition = res.getDimensionPixelSize(R.dimen.navigation_edge_arrow_min_y);
	mFingerOffset = res.getDimensionPixelSize(R.dimen.navigation_edge_finger_offset);
	updateCurrentUserResources(res);
	}

	public void updateCurrentUserResources(Resources res) {
	mEdgeWidth = res.getDimensionPixelSize(
	com.android.internal.R.dimen.config_backGestureInset);
	}

	/**
	* @see NavigationBarView#onAttachedToWindow()
	*/
	public void onNavBarAttached() {
	mIsAttached = true;
	updateIsEnabled();
	}

	/**
	* @see NavigationBarView#onDetachedFromWindow()
	*/
	public void onNavBarDetached() {
	mIsAttached = false;
	updateIsEnabled();
	}

	public void onNavigationModeChanged(int mode, Context currentUserContext) {
	mIsGesturalModeEnabled = QuickStepContract.isGesturalMode(mode);
	updateIsEnabled();
	updateCurrentUserResources(currentUserContext.getResources());
	}

	private void disposeInputChannel() {
	if (mInputEventReceiver != null) {
	mInputEventReceiver.dispose();
	mInputEventReceiver = null;
	}
	if (mInputMonitor != null) {
	mInputMonitor.dispose();
	mInputMonitor = null;
	}
	}

	private void updateIsEnabled() {
	boolean isEnabled = mIsAttached && mIsGesturalModeEnabled;
	if (isEnabled == mIsEnabled) {
	return;
	}
	mIsEnabled = isEnabled;
	disposeInputChannel();

	if (mEdgePanel != null) {
	mWm.removeView(mEdgePanel);
	mEdgePanel = null;
	mRegionSamplingHelper.stop();
	mRegionSamplingHelper = null;
	}

	if (!mIsEnabled) {
	WindowManagerWrapper.getInstance().removePinnedStackListener(mImeChangedListener);
	mContext.getSystemService(DisplayManager.class).unregisterDisplayListener(this);

	try {
	WindowManagerGlobal.getWindowManagerService()
	.unregisterSystemGestureExclusionListener(
	mGestureExclusionListener, mDisplayId);
	} catch (RemoteException e) {
	Log.e(TAG, "Failed to unregister window manager callbacks", e);
	}

	} else {
	updateDisplaySize();
	mContext.getSystemService(DisplayManager.class).registerDisplayListener(this,
	mContext.getMainThreadHandler());

	try {
	WindowManagerWrapper.getInstance().addPinnedStackListener(mImeChangedListener);
	WindowManagerGlobal.getWindowManagerService()
	.registerSystemGestureExclusionListener(
	mGestureExclusionListener, mDisplayId);
	} catch (RemoteException e) {
	Log.e(TAG, "Failed to register window manager callbacks", e);
	}

	// Register input event receiver
	mInputMonitor = InputManager.getInstance().monitorGestureInput(
	"edge-swipe", mDisplayId);
	mInputEventReceiver = new SysUiInputEventReceiver(
	mInputMonitor.getInputChannel(), Looper.getMainLooper());

	// Add a nav bar panel window
	mEdgePanel = new NavigationBarEdgePanel(mContext);
	mEdgePanelLp = new WindowManager.LayoutParams(
	mContext.getResources()
	.getDimensionPixelSize(R.dimen.navigation_edge_panel_width),
	mContext.getResources()
	.getDimensionPixelSize(R.dimen.navigation_edge_panel_height),
	WindowManager.LayoutParams.TYPE_NAVIGATION_BAR_PANEL,
	WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE
	\| WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL
	\| WindowManager.LayoutParams.FLAG_SPLIT_TOUCH
	\| WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN,
	PixelFormat.TRANSLUCENT);
	mEdgePanelLp.privateFlags \|=
	WindowManager.LayoutParams.PRIVATE_FLAG_SHOW_FOR_ALL_USERS;
	mEdgePanelLp.setTitle(TAG + mDisplayId);
	mEdgePanelLp.accessibilityTitle = mContext.getString(R.string.nav_bar_edge_panel);
	mEdgePanelLp.windowAnimations = 0;
	mEdgePanel.setLayoutParams(mEdgePanelLp);
	mWm.addView(mEdgePanel, mEdgePanelLp);
	mRegionSamplingHelper = new RegionSamplingHelper(mEdgePanel,
	new RegionSamplingHelper.SamplingCallback() {
	@Override
	public void onRegionDarknessChanged(boolean isRegionDark) {
	mEdgePanel.setIsDark(!isRegionDark, true /* animate */);
	}

	@Override
	public Rect getSampledRegion(View sampledView) {
	return mSamplingRect;
	}
	});
	}
	}

	private void onInputEvent(InputEvent ev) {
	if (ev instanceof MotionEvent) {
	onMotionEvent((MotionEvent) ev);
	}
	}

	private boolean isWithinTouchRegion(int x, int y) {
	if (y > (mDisplaySize.y - Math.max(mImeHeight, mNavBarHeight))) {
	return false;
	}

	if (x > mEdgeWidth + mLeftInset && x < (mDisplaySize.x - mEdgeWidth - mRightInset)) {
	return false;
	}
	boolean isInExcludedRegion = mExcludeRegion.contains(x, y);
	if (isInExcludedRegion) {
	mOverviewProxyService.notifyBackAction(false /* completed */, -1, -1,
	false /* isButton */, !mIsOnLeftEdge);
	}
	return !isInExcludedRegion;
	}

	private void cancelGesture(MotionEvent ev) {
	// Send action cancel to reset all the touch events
	mAllowGesture = false;
	MotionEvent cancelEv = MotionEvent.obtain(ev);
	cancelEv.setAction(MotionEvent.ACTION_CANCEL);
	mEdgePanel.handleTouch(cancelEv);
	cancelEv.recycle();
	}

	private void onMotionEvent(MotionEvent ev) {
	int action = ev.getActionMasked();
	if (action == MotionEvent.ACTION_DOWN) {
	// Verify if this is in within the touch region and we aren't in immersive mode, and
	// either the bouncer is showing or the notification panel is hidden
	int stateFlags = mOverviewProxyService.getSystemUiStateFlags();
	mIsOnLeftEdge = ev.getX() <= mEdgeWidth + mLeftInset;
	mAllowGesture = !QuickStepContract.isBackGestureDisabled(stateFlags)
	&& isWithinTouchRegion((int) ev.getX(), (int) ev.getY());
	if (mAllowGesture) {
	mEdgePanelLp.gravity = mIsOnLeftEdge
	? (Gravity.LEFT \| Gravity.TOP)
	: (Gravity.RIGHT \| Gravity.TOP);
	mEdgePanel.setIsLeftPanel(mIsOnLeftEdge);
	mEdgePanel.handleTouch(ev);
	updateEdgePanelPosition(ev.getY());
	mWm.updateViewLayout(mEdgePanel, mEdgePanelLp);
	mRegionSamplingHelper.start(mSamplingRect);

	mDownPoint.set(ev.getX(), ev.getY());
	mThresholdCrossed = false;
	}
	} else if (mAllowGesture) {
	if (!mThresholdCrossed) {
	if (action == MotionEvent.ACTION_POINTER_DOWN) {
	// We do not support multi touch for back gesture
	cancelGesture(ev);
	return;
	} else if (action == MotionEvent.ACTION_MOVE) {
	if ((ev.getEventTime() - ev.getDownTime()) > mLongPressTimeout) {
	cancelGesture(ev);
	return;
	}
	float dx = Math.abs(ev.getX() - mDownPoint.x);
	float dy = Math.abs(ev.getY() - mDownPoint.y);
	if (dy > dx && dy > mTouchSlop) {
	cancelGesture(ev);
	return;

	} else if (dx > dy && dx > mTouchSlop) {
	mThresholdCrossed = true;
	// Capture inputs
	mInputMonitor.pilferPointers();
	}
	}

	}

	// forward touch
	mEdgePanel.handleTouch(ev);

	boolean isUp = action == MotionEvent.ACTION_UP;
	if (isUp) {
	boolean performAction = mEdgePanel.shouldTriggerBack();
	if (performAction) {
	// Perform back
	sendEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_BACK);
	sendEvent(KeyEvent.ACTION_UP, KeyEvent.KEYCODE_BACK);
	}
	mOverviewProxyService.notifyBackAction(performAction, (int) mDownPoint.x,
	(int) mDownPoint.y, false /* isButton */, !mIsOnLeftEdge);
	}
	if (isUp \|\| action == MotionEvent.ACTION_CANCEL) {
	mRegionSamplingHelper.stop();
	} else {
	updateSamplingRect();
	mRegionSamplingHelper.updateSamplingRect();
	}
	}
	}

	private void updateEdgePanelPosition(float touchY) {
	float position = touchY - mFingerOffset;
	position = Math.max(position, mMinArrowPosition);
	position = (position - mEdgePanelLp.height / 2.0f);
	mEdgePanelLp.y = MathUtils.constrain((int) position, 0, mDisplaySize.y);
	updateSamplingRect();
	}

	private void updateSamplingRect() {
	int top = mEdgePanelLp.y;
	int left = mIsOnLeftEdge ? mLeftInset : mDisplaySize.x - mRightInset - mEdgePanelLp.width;
	int right = left + mEdgePanelLp.width;
	int bottom = top + mEdgePanelLp.height;
	mSamplingRect.set(left, top, right, bottom);
	mEdgePanel.adjustRectToBoundingBox(mSamplingRect);
	}

	@Override
	public void onDisplayAdded(int displayId) { }

	@Override
	public void onDisplayRemoved(int displayId) { }

	@Override
	public void onDisplayChanged(int displayId) {
	if (displayId == mDisplayId) {
	updateDisplaySize();
	}
	}

	private void updateDisplaySize() {
	mContext.getSystemService(DisplayManager.class)
	.getDisplay(mDisplayId)
	.getRealSize(mDisplaySize);
	}

	private void sendEvent(int action, int code) {
	long when = SystemClock.uptimeMillis();
	final KeyEvent ev = new KeyEvent(when, when, action, code, 0 /* repeat */,
	0 /* metaState /, KeyCharacterMap.VIRTUAL_KEYBOARD, 0 / scancode */,
	KeyEvent.FLAG_FROM_SYSTEM \| KeyEvent.FLAG_VIRTUAL_HARD_KEY,
	InputDevice.SOURCE_KEYBOARD);

	// Bubble controller will give us a valid display id if it should get the back event
	BubbleController bubbleController = Dependency.get(BubbleController.class);
	int bubbleDisplayId = bubbleController.getExpandedDisplayId(mContext);
	if (code == KeyEvent.KEYCODE_BACK && bubbleDisplayId != INVALID_DISPLAY) {
	ev.setDisplayId(bubbleDisplayId);
	}
	InputManager.getInstance().injectInputEvent(ev, InputManager.INJECT_INPUT_EVENT_MODE_ASYNC);
	}

	public void setInsets(int leftInset, int rightInset) {
	mLeftInset = leftInset;
	mRightInset = rightInset;
	}

	public void dump(PrintWriter pw) {
	pw.println("EdgeBackGestureHandler:");
	pw.println(" mIsEnabled=" + mIsEnabled);
	pw.println(" mAllowGesture=" + mAllowGesture);
	pw.println(" mExcludeRegion=" + mExcludeRegion);
	pw.println(" mImeHeight=" + mImeHeight);
	pw.println(" mIsAttached=" + mIsAttached);
	pw.println(" mEdgeWidth=" + mEdgeWidth);
	}

	class SysUiInputEventReceiver extends InputEventReceiver {
	SysUiInputEventReceiver(InputChannel channel, Looper looper) {
	super(channel, looper);
	}

	public void onInputEvent(InputEvent event) {
	EdgeBackGestureHandler.this.onInputEvent(event);
	finishInputEvent(event, true);
	}
	}
	}