packages/SystemUI/src/com/android/systemui/statusbar/phone/NavigationBarGestureHelper.java - platform/frameworks/base - Git at Google

 /*
  * Copyright (C) 2014 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 android.app.ActivityManager;
 import android.content.Context;
 import android.content.res.Resources;
 import android.graphics.Rect;
 import android.view.GestureDetector;
 import android.view.MotionEvent;
 import android.view.VelocityTracker;
 import android.view.View;
 import android.view.ViewConfiguration;

 import com.android.internal.logging.MetricsLogger;
 import com.android.internal.logging.MetricsProto.MetricsEvent;
 import com.android.internal.policy.DividerSnapAlgorithm.SnapTarget;
 import com.android.systemui.R;
 import com.android.systemui.RecentsComponent;
 import com.android.systemui.stackdivider.Divider;
 import com.android.systemui.tuner.TunerService;

 import static android.view.WindowManager.DOCKED_INVALID;
 import static android.view.WindowManager.DOCKED_LEFT;
 import static android.view.WindowManager.DOCKED_TOP;

 /**
  * Class to detect gestures on the navigation bar.
  */
 public class NavigationBarGestureHelper extends GestureDetector.SimpleOnGestureListener
         implements TunerService.Tunable {

     private static final String KEY_DOCK_WINDOW_GESTURE = "overview_nav_bar_gesture";
     /**
      * When dragging from the navigation bar, we drag in recents.
      */
     public static final int DRAG_MODE_NONE = -1;

     /**
      * When dragging from the navigation bar, we drag in recents.
      */
     public static final int DRAG_MODE_RECENTS = 0;

     /**
      * When dragging from the navigation bar, we drag the divider.
      */
     public static final int DRAG_MODE_DIVIDER = 1;

     private RecentsComponent mRecentsComponent;
     private Divider mDivider;
     private Context mContext;
     private NavigationBarView mNavigationBarView;
     private boolean mIsVertical;
     private boolean mIsRTL;

     private final GestureDetector mTaskSwitcherDetector;
     private final int mScrollTouchSlop;
     private final int mMinFlingVelocity;
     private int mTouchDownX;
     private int mTouchDownY;
     private boolean mDownOnRecents;
     private VelocityTracker mVelocityTracker;

     private boolean mDockWindowEnabled;
     private boolean mDockWindowTouchSlopExceeded;
     private int mDragMode;

     public NavigationBarGestureHelper(Context context) {
         mContext = context;
         ViewConfiguration configuration = ViewConfiguration.get(context);
         Resources r = context.getResources();
         mScrollTouchSlop = r.getDimensionPixelSize(R.dimen.navigation_bar_min_swipe_distance);
         mMinFlingVelocity = configuration.getScaledMinimumFlingVelocity();
         mTaskSwitcherDetector = new GestureDetector(context, this);
         TunerService.get(context).addTunable(this, KEY_DOCK_WINDOW_GESTURE);
     }

     public void setComponents(RecentsComponent recentsComponent, Divider divider,
             NavigationBarView navigationBarView) {
         mRecentsComponent = recentsComponent;
         mDivider = divider;
         mNavigationBarView = navigationBarView;
     }

     public void setBarState(boolean isVertical, boolean isRTL) {
         mIsVertical = isVertical;
         mIsRTL = isRTL;
     }

     public boolean onInterceptTouchEvent(MotionEvent event) {
         // If we move more than a fixed amount, then start capturing for the
         // task switcher detector
         mTaskSwitcherDetector.onTouchEvent(event);
         int action = event.getAction();
         switch (action & MotionEvent.ACTION_MASK) {
             case MotionEvent.ACTION_DOWN: {
                 mTouchDownX = (int) event.getX();
                 mTouchDownY = (int) event.getY();
                 break;
             }
             case MotionEvent.ACTION_MOVE: {
                 int x = (int) event.getX();
                 int y = (int) event.getY();
                 int xDiff = Math.abs(x - mTouchDownX);
                 int yDiff = Math.abs(y - mTouchDownY);
                 boolean exceededTouchSlop = !mIsVertical
                         ? xDiff > mScrollTouchSlop && xDiff > yDiff
                         : yDiff > mScrollTouchSlop && yDiff > xDiff;
                 if (exceededTouchSlop) {
                     return true;
                 }
                 break;
             }
             case MotionEvent.ACTION_CANCEL:
             case MotionEvent.ACTION_UP:
                 break;
         }
         return mDockWindowEnabled && interceptDockWindowEvent(event);
     }

     private boolean interceptDockWindowEvent(MotionEvent event) {
         switch (event.getActionMasked()) {
             case MotionEvent.ACTION_DOWN:
                 handleDragActionDownEvent(event);
                 break;
             case MotionEvent.ACTION_MOVE:
                 return handleDragActionMoveEvent(event);
             case MotionEvent.ACTION_UP:
             case MotionEvent.ACTION_CANCEL:
                 handleDragActionUpEvent(event);
                 break;
         }
         return false;
     }

     private boolean handleDockWindowEvent(MotionEvent event) {
         switch (event.getActionMasked()) {
             case MotionEvent.ACTION_DOWN:
                 handleDragActionDownEvent(event);
                 break;
             case MotionEvent.ACTION_MOVE:
                 handleDragActionMoveEvent(event);
                 break;
             case MotionEvent.ACTION_UP:
             case MotionEvent.ACTION_CANCEL:
                 handleDragActionUpEvent(event);
                 break;
         }
         return true;
     }

     private void handleDragActionDownEvent(MotionEvent event) {
         mVelocityTracker = VelocityTracker.obtain();
         mVelocityTracker.addMovement(event);
         mDockWindowTouchSlopExceeded = false;
         mTouchDownX = (int) event.getX();
         mTouchDownY = (int) event.getY();

         if (mNavigationBarView != null) {
             View recentsButton = mNavigationBarView.getRecentsButton().getCurrentView();
             if (recentsButton != null) {
                 mDownOnRecents = mTouchDownX >= recentsButton.getLeft()
                         && mTouchDownX <= recentsButton.getRight()
                         && mTouchDownY >= recentsButton.getTop()
                         && mTouchDownY <= recentsButton.getBottom();
             } else {
                 mDownOnRecents = false;
             }
         }
     }

     private boolean handleDragActionMoveEvent(MotionEvent event) {
         mVelocityTracker.addMovement(event);
         int x = (int) event.getX();
         int y = (int) event.getY();
         int xDiff = Math.abs(x - mTouchDownX);
         int yDiff = Math.abs(y - mTouchDownY);
         if (mDivider == null || mRecentsComponent == null) {
             return false;
         }
         if (!mDockWindowTouchSlopExceeded) {
             boolean touchSlopExceeded = !mIsVertical
                     ? yDiff > mScrollTouchSlop && yDiff > xDiff
                     : xDiff > mScrollTouchSlop && xDiff > yDiff;
             if (mDownOnRecents && touchSlopExceeded
                     && mDivider.getView().getWindowManagerProxy().getDockSide() == DOCKED_INVALID) {
                 Rect initialBounds = null;
                 int dragMode = calculateDragMode();
                 int createMode = ActivityManager.DOCKED_STACK_CREATE_MODE_TOP_OR_LEFT;
                 if (dragMode == DRAG_MODE_DIVIDER) {
                     initialBounds = new Rect();
                     mDivider.getView().calculateBoundsForPosition(mIsVertical
                                     ? (int) event.getRawX()
                                     : (int) event.getRawY(),
                             mDivider.getView().isHorizontalDivision()
                                     ? DOCKED_TOP
                                     : DOCKED_LEFT,
                             initialBounds);
                 } else if (dragMode == DRAG_MODE_RECENTS && mTouchDownX
                         < mContext.getResources().getDisplayMetrics().widthPixels / 2) {
                     createMode = ActivityManager.DOCKED_STACK_CREATE_MODE_BOTTOM_OR_RIGHT;
                 }
                 boolean docked = mRecentsComponent.dockTopTask(dragMode, createMode, initialBounds,
                         MetricsEvent.ACTION_WINDOW_DOCK_SWIPE);
                 if (docked) {
                     mDragMode = dragMode;
                     if (mDragMode == DRAG_MODE_DIVIDER) {
                         mDivider.getView().startDragging(false /* animate */, true /* touching*/);
                     }
                     mDockWindowTouchSlopExceeded = true;
                     return true;
                 }
             }
         } else {
             if (mDragMode == DRAG_MODE_DIVIDER) {
                 int position = !mIsVertical ? (int) event.getRawY() : (int) event.getRawX();
                 SnapTarget snapTarget = mDivider.getView().getSnapAlgorithm()
                         .calculateSnapTarget(position, 0f /* velocity */, false /* hardDismiss */);
                 mDivider.getView().resizeStack(position, snapTarget.position, snapTarget);
             } else if (mDragMode == DRAG_MODE_RECENTS) {
                 mRecentsComponent.onDraggingInRecents(event.getRawY());
             }
         }
         return false;
     }

     private void handleDragActionUpEvent(MotionEvent event) {
         mVelocityTracker.addMovement(event);
         mVelocityTracker.computeCurrentVelocity(1000);
         if (mDockWindowTouchSlopExceeded && mDivider != null && mRecentsComponent != null) {
             if (mDragMode == DRAG_MODE_DIVIDER) {
                 mDivider.getView().stopDragging(mIsVertical
                                 ? (int) event.getRawX()
                                 : (int) event.getRawY(),
                         mIsVertical
                                 ? mVelocityTracker.getXVelocity()
                                 : mVelocityTracker.getYVelocity(),
                         true /* avoidDismissStart */, false /* logMetrics */);
             } else if (mDragMode == DRAG_MODE_RECENTS) {
                 mRecentsComponent.onDraggingInRecentsEnded(mVelocityTracker.getYVelocity());
             }
         }
         mVelocityTracker.recycle();
         mVelocityTracker = null;
     }

     private int calculateDragMode() {
         if (mIsVertical && !mDivider.getView().isHorizontalDivision()) {
             return DRAG_MODE_DIVIDER;
         }
         if (!mIsVertical && mDivider.getView().isHorizontalDivision()) {
             return DRAG_MODE_DIVIDER;
         }
         return DRAG_MODE_RECENTS;
     }

     public boolean onTouchEvent(MotionEvent event) {
         boolean result = mTaskSwitcherDetector.onTouchEvent(event);
         if (mDockWindowEnabled) {
             result |= handleDockWindowEvent(event);
         }
         return result;
     }

     @Override
     public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
         float absVelX = Math.abs(velocityX);
         float absVelY = Math.abs(velocityY);
         boolean isValidFling = absVelX > mMinFlingVelocity &&
                 mIsVertical ? (absVelY > absVelX) : (absVelX > absVelY);
         if (isValidFling && mRecentsComponent != null) {
             boolean showNext;
             if (!mIsRTL) {
                 showNext = mIsVertical ? (velocityY < 0) : (velocityX < 0);
             } else {
                 // In RTL, vertical is still the same, but horizontal is flipped
                 showNext = mIsVertical ? (velocityY < 0) : (velocityX > 0);
             }
             if (showNext) {
                 mRecentsComponent.showNextAffiliatedTask();
             } else {
                 mRecentsComponent.showPrevAffiliatedTask();
             }
         }
         return true;
     }

     @Override
     public void onTuningChanged(String key, String newValue) {
         switch (key) {
             case KEY_DOCK_WINDOW_GESTURE:
                 mDockWindowEnabled = newValue != null && (Integer.parseInt(newValue) != 0);
                 break;
         }
     }
 }
	/*
	* Copyright (C) 2014 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 android.app.ActivityManager;
	import android.content.Context;
	import android.content.res.Resources;
	import android.graphics.Rect;
	import android.view.GestureDetector;
	import android.view.MotionEvent;
	import android.view.VelocityTracker;
	import android.view.View;
	import android.view.ViewConfiguration;

	import com.android.internal.logging.MetricsLogger;
	import com.android.internal.logging.MetricsProto.MetricsEvent;
	import com.android.internal.policy.DividerSnapAlgorithm.SnapTarget;
	import com.android.systemui.R;
	import com.android.systemui.RecentsComponent;
	import com.android.systemui.stackdivider.Divider;
	import com.android.systemui.tuner.TunerService;

	import static android.view.WindowManager.DOCKED_INVALID;
	import static android.view.WindowManager.DOCKED_LEFT;
	import static android.view.WindowManager.DOCKED_TOP;

	/**
	* Class to detect gestures on the navigation bar.
	*/
	public class NavigationBarGestureHelper extends GestureDetector.SimpleOnGestureListener
	implements TunerService.Tunable {

	private static final String KEY_DOCK_WINDOW_GESTURE = "overview_nav_bar_gesture";
	/**
	* When dragging from the navigation bar, we drag in recents.
	*/
	public static final int DRAG_MODE_NONE = -1;

	/**
	* When dragging from the navigation bar, we drag in recents.
	*/
	public static final int DRAG_MODE_RECENTS = 0;

	/**
	* When dragging from the navigation bar, we drag the divider.
	*/
	public static final int DRAG_MODE_DIVIDER = 1;

	private RecentsComponent mRecentsComponent;
	private Divider mDivider;
	private Context mContext;
	private NavigationBarView mNavigationBarView;
	private boolean mIsVertical;
	private boolean mIsRTL;

	private final GestureDetector mTaskSwitcherDetector;
	private final int mScrollTouchSlop;
	private final int mMinFlingVelocity;
	private int mTouchDownX;
	private int mTouchDownY;
	private boolean mDownOnRecents;
	private VelocityTracker mVelocityTracker;

	private boolean mDockWindowEnabled;
	private boolean mDockWindowTouchSlopExceeded;
	private int mDragMode;

	public NavigationBarGestureHelper(Context context) {
	mContext = context;
	ViewConfiguration configuration = ViewConfiguration.get(context);
	Resources r = context.getResources();
	mScrollTouchSlop = r.getDimensionPixelSize(R.dimen.navigation_bar_min_swipe_distance);
	mMinFlingVelocity = configuration.getScaledMinimumFlingVelocity();
	mTaskSwitcherDetector = new GestureDetector(context, this);
	TunerService.get(context).addTunable(this, KEY_DOCK_WINDOW_GESTURE);
	}

	public void setComponents(RecentsComponent recentsComponent, Divider divider,
	NavigationBarView navigationBarView) {
	mRecentsComponent = recentsComponent;
	mDivider = divider;
	mNavigationBarView = navigationBarView;
	}

	public void setBarState(boolean isVertical, boolean isRTL) {
	mIsVertical = isVertical;
	mIsRTL = isRTL;
	}

	public boolean onInterceptTouchEvent(MotionEvent event) {
	// If we move more than a fixed amount, then start capturing for the
	// task switcher detector
	mTaskSwitcherDetector.onTouchEvent(event);
	int action = event.getAction();
	switch (action & MotionEvent.ACTION_MASK) {
	case MotionEvent.ACTION_DOWN: {
	mTouchDownX = (int) event.getX();
	mTouchDownY = (int) event.getY();
	break;
	}
	case MotionEvent.ACTION_MOVE: {
	int x = (int) event.getX();
	int y = (int) event.getY();
	int xDiff = Math.abs(x - mTouchDownX);
	int yDiff = Math.abs(y - mTouchDownY);
	boolean exceededTouchSlop = !mIsVertical
	? xDiff > mScrollTouchSlop && xDiff > yDiff
	: yDiff > mScrollTouchSlop && yDiff > xDiff;
	if (exceededTouchSlop) {
	return true;
	}
	break;
	}
	case MotionEvent.ACTION_CANCEL:
	case MotionEvent.ACTION_UP:
	break;
	}
	return mDockWindowEnabled && interceptDockWindowEvent(event);
	}

	private boolean interceptDockWindowEvent(MotionEvent event) {
	switch (event.getActionMasked()) {
	case MotionEvent.ACTION_DOWN:
	handleDragActionDownEvent(event);
	break;
	case MotionEvent.ACTION_MOVE:
	return handleDragActionMoveEvent(event);
	case MotionEvent.ACTION_UP:
	case MotionEvent.ACTION_CANCEL:
	handleDragActionUpEvent(event);
	break;
	}
	return false;
	}

	private boolean handleDockWindowEvent(MotionEvent event) {
	switch (event.getActionMasked()) {
	case MotionEvent.ACTION_DOWN:
	handleDragActionDownEvent(event);
	break;
	case MotionEvent.ACTION_MOVE:
	handleDragActionMoveEvent(event);
	break;
	case MotionEvent.ACTION_UP:
	case MotionEvent.ACTION_CANCEL:
	handleDragActionUpEvent(event);
	break;
	}
	return true;
	}

	private void handleDragActionDownEvent(MotionEvent event) {
	mVelocityTracker = VelocityTracker.obtain();
	mVelocityTracker.addMovement(event);
	mDockWindowTouchSlopExceeded = false;
	mTouchDownX = (int) event.getX();
	mTouchDownY = (int) event.getY();

	if (mNavigationBarView != null) {
	View recentsButton = mNavigationBarView.getRecentsButton().getCurrentView();
	if (recentsButton != null) {
	mDownOnRecents = mTouchDownX >= recentsButton.getLeft()
	&& mTouchDownX <= recentsButton.getRight()
	&& mTouchDownY >= recentsButton.getTop()
	&& mTouchDownY <= recentsButton.getBottom();
	} else {
	mDownOnRecents = false;
	}
	}
	}

	private boolean handleDragActionMoveEvent(MotionEvent event) {
	mVelocityTracker.addMovement(event);
	int x = (int) event.getX();
	int y = (int) event.getY();
	int xDiff = Math.abs(x - mTouchDownX);
	int yDiff = Math.abs(y - mTouchDownY);
	if (mDivider == null \|\| mRecentsComponent == null) {
	return false;
	}
	if (!mDockWindowTouchSlopExceeded) {
	boolean touchSlopExceeded = !mIsVertical
	? yDiff > mScrollTouchSlop && yDiff > xDiff
	: xDiff > mScrollTouchSlop && xDiff > yDiff;
	if (mDownOnRecents && touchSlopExceeded
	&& mDivider.getView().getWindowManagerProxy().getDockSide() == DOCKED_INVALID) {
	Rect initialBounds = null;
	int dragMode = calculateDragMode();
	int createMode = ActivityManager.DOCKED_STACK_CREATE_MODE_TOP_OR_LEFT;
	if (dragMode == DRAG_MODE_DIVIDER) {
	initialBounds = new Rect();
	mDivider.getView().calculateBoundsForPosition(mIsVertical
	? (int) event.getRawX()
	: (int) event.getRawY(),
	mDivider.getView().isHorizontalDivision()
	? DOCKED_TOP
	: DOCKED_LEFT,
	initialBounds);
	} else if (dragMode == DRAG_MODE_RECENTS && mTouchDownX
	< mContext.getResources().getDisplayMetrics().widthPixels / 2) {
	createMode = ActivityManager.DOCKED_STACK_CREATE_MODE_BOTTOM_OR_RIGHT;
	}
	boolean docked = mRecentsComponent.dockTopTask(dragMode, createMode, initialBounds,
	MetricsEvent.ACTION_WINDOW_DOCK_SWIPE);
	if (docked) {
	mDragMode = dragMode;
	if (mDragMode == DRAG_MODE_DIVIDER) {
	mDivider.getView().startDragging(false /* animate /, true / touching*/);
	}
	mDockWindowTouchSlopExceeded = true;
	return true;
	}
	}
	} else {
	if (mDragMode == DRAG_MODE_DIVIDER) {
	int position = !mIsVertical ? (int) event.getRawY() : (int) event.getRawX();
	SnapTarget snapTarget = mDivider.getView().getSnapAlgorithm()
	.calculateSnapTarget(position, 0f /* velocity /, false / hardDismiss */);
	mDivider.getView().resizeStack(position, snapTarget.position, snapTarget);
	} else if (mDragMode == DRAG_MODE_RECENTS) {
	mRecentsComponent.onDraggingInRecents(event.getRawY());
	}
	}
	return false;
	}

	private void handleDragActionUpEvent(MotionEvent event) {
	mVelocityTracker.addMovement(event);
	mVelocityTracker.computeCurrentVelocity(1000);
	if (mDockWindowTouchSlopExceeded && mDivider != null && mRecentsComponent != null) {
	if (mDragMode == DRAG_MODE_DIVIDER) {
	mDivider.getView().stopDragging(mIsVertical
	? (int) event.getRawX()
	: (int) event.getRawY(),
	mIsVertical
	? mVelocityTracker.getXVelocity()
	: mVelocityTracker.getYVelocity(),
	true /* avoidDismissStart /, false / logMetrics */);
	} else if (mDragMode == DRAG_MODE_RECENTS) {
	mRecentsComponent.onDraggingInRecentsEnded(mVelocityTracker.getYVelocity());
	}
	}
	mVelocityTracker.recycle();
	mVelocityTracker = null;
	}

	private int calculateDragMode() {
	if (mIsVertical && !mDivider.getView().isHorizontalDivision()) {
	return DRAG_MODE_DIVIDER;
	}
	if (!mIsVertical && mDivider.getView().isHorizontalDivision()) {
	return DRAG_MODE_DIVIDER;
	}
	return DRAG_MODE_RECENTS;
	}

	public boolean onTouchEvent(MotionEvent event) {
	boolean result = mTaskSwitcherDetector.onTouchEvent(event);
	if (mDockWindowEnabled) {
	result \|= handleDockWindowEvent(event);
	}
	return result;
	}

	@Override
	public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
	float absVelX = Math.abs(velocityX);
	float absVelY = Math.abs(velocityY);
	boolean isValidFling = absVelX > mMinFlingVelocity &&
	mIsVertical ? (absVelY > absVelX) : (absVelX > absVelY);
	if (isValidFling && mRecentsComponent != null) {
	boolean showNext;
	if (!mIsRTL) {
	showNext = mIsVertical ? (velocityY < 0) : (velocityX < 0);
	} else {
	// In RTL, vertical is still the same, but horizontal is flipped
	showNext = mIsVertical ? (velocityY < 0) : (velocityX > 0);
	}
	if (showNext) {
	mRecentsComponent.showNextAffiliatedTask();
	} else {
	mRecentsComponent.showPrevAffiliatedTask();
	}
	}
	return true;
	}

	@Override
	public void onTuningChanged(String key, String newValue) {
	switch (key) {
	case KEY_DOCK_WINDOW_GESTURE:
	mDockWindowEnabled = newValue != null && (Integer.parseInt(newValue) != 0);
	break;
	}
	}
	}