WM is making changes which allows apps to maintain their orientation independent of the orientation of the foreground app. This allows recents to always start in portrait even when the app currently running is in landscape. This means we have to give the illusion of a landscape oriented overview when user swipes up in gesterual nav when launcher is started in portrait configuration. PagedOrientationHandler abstracts all coordinate specific logic from Paged/RecentsView primarily, but also all other dynamic calculations throughout launcher. PagedViewOrientationState is the single point of exposure to other classes that depend on those changes. The goal is to also minimize holding state to allow for default implementations of PagedOrientationHandler for all the 3p/Fallback classes. PagedViewOrientationState also holds other data around rotation that isn't specifically tied to view logic. The fake landscape overview can be toggled with: adb shell settings put global forced_rotation [0/1] Fixes: 146176182 Change-Id: I65d8d4e9f92b93931cbe0053ccaf0cda8d2ffd6c
285 lines
10 KiB
Java
285 lines
10 KiB
Java
/*
|
|
* Copyright (C) 2017 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.touch;
|
|
|
|
import static android.view.MotionEvent.INVALID_POINTER_ID;
|
|
|
|
import android.graphics.PointF;
|
|
import android.util.Log;
|
|
import android.view.MotionEvent;
|
|
import android.view.VelocityTracker;
|
|
import android.view.ViewConfiguration;
|
|
|
|
import androidx.annotation.NonNull;
|
|
import androidx.annotation.VisibleForTesting;
|
|
|
|
import java.util.LinkedList;
|
|
import java.util.Queue;
|
|
|
|
/**
|
|
* Scroll/drag/swipe gesture detector.
|
|
*
|
|
* Definition of swipe is different from android system in that this detector handles
|
|
* 'swipe to dismiss', 'swiping up/down a container' but also keeps scrolling state before
|
|
* swipe action happens.
|
|
*
|
|
* @see SingleAxisSwipeDetector
|
|
* @see BothAxesSwipeDetector
|
|
*/
|
|
public abstract class BaseSwipeDetector {
|
|
|
|
private static final boolean DBG = false;
|
|
private static final String TAG = "BaseSwipeDetector";
|
|
private static final float ANIMATION_DURATION = 1200;
|
|
/** The minimum release velocity in pixels per millisecond that triggers fling.*/
|
|
private static final float RELEASE_VELOCITY_PX_MS = 1.0f;
|
|
private static final PointF sTempPoint = new PointF();
|
|
|
|
private final PointF mDownPos = new PointF();
|
|
private final PointF mLastPos = new PointF();
|
|
protected final boolean mIsRtl;
|
|
protected final float mTouchSlop;
|
|
protected final float mMaxVelocity;
|
|
private final Queue<Runnable> mSetStateQueue = new LinkedList<>();
|
|
|
|
private int mActivePointerId = INVALID_POINTER_ID;
|
|
private VelocityTracker mVelocityTracker;
|
|
private PointF mLastDisplacement = new PointF();
|
|
private PointF mDisplacement = new PointF();
|
|
protected PointF mSubtractDisplacement = new PointF();
|
|
@VisibleForTesting ScrollState mState = ScrollState.IDLE;
|
|
private boolean mIsSettingState;
|
|
|
|
protected boolean mIgnoreSlopWhenSettling;
|
|
|
|
private enum ScrollState {
|
|
IDLE,
|
|
DRAGGING, // onDragStart, onDrag
|
|
SETTLING // onDragEnd
|
|
}
|
|
|
|
protected BaseSwipeDetector(@NonNull ViewConfiguration config, boolean isRtl) {
|
|
mTouchSlop = config.getScaledTouchSlop();
|
|
mMaxVelocity = config.getScaledMaximumFlingVelocity();
|
|
mIsRtl = isRtl;
|
|
}
|
|
|
|
public static long calculateDuration(float velocity, float progressNeeded) {
|
|
// TODO: make these values constants after tuning.
|
|
float velocityDivisor = Math.max(2f, Math.abs(0.5f * velocity));
|
|
float travelDistance = Math.max(0.2f, progressNeeded);
|
|
long duration = (long) Math.max(100, ANIMATION_DURATION / velocityDivisor * travelDistance);
|
|
if (DBG) {
|
|
Log.d(TAG, String.format(
|
|
"calculateDuration=%d, v=%f, d=%f", duration, velocity, progressNeeded));
|
|
}
|
|
return duration;
|
|
}
|
|
|
|
public int getDownX() {
|
|
return (int) mDownPos.x;
|
|
}
|
|
|
|
public int getDownY() {
|
|
return (int) mDownPos.y;
|
|
}
|
|
/**
|
|
* There's no touch and there's no animation.
|
|
*/
|
|
public boolean isIdleState() {
|
|
return mState == ScrollState.IDLE;
|
|
}
|
|
|
|
public boolean isSettlingState() {
|
|
return mState == ScrollState.SETTLING;
|
|
}
|
|
|
|
public boolean isDraggingState() {
|
|
return mState == ScrollState.DRAGGING;
|
|
}
|
|
|
|
public boolean isDraggingOrSettling() {
|
|
return mState == ScrollState.DRAGGING || mState == ScrollState.SETTLING;
|
|
}
|
|
|
|
public void finishedScrolling() {
|
|
setState(ScrollState.IDLE);
|
|
}
|
|
|
|
public boolean isFling(float velocity) {
|
|
return Math.abs(velocity) > RELEASE_VELOCITY_PX_MS;
|
|
}
|
|
|
|
public boolean onTouchEvent(MotionEvent ev) {
|
|
int actionMasked = ev.getActionMasked();
|
|
if (actionMasked == MotionEvent.ACTION_DOWN && mVelocityTracker != null) {
|
|
mVelocityTracker.clear();
|
|
}
|
|
if (mVelocityTracker == null) {
|
|
mVelocityTracker = VelocityTracker.obtain();
|
|
}
|
|
mVelocityTracker.addMovement(ev);
|
|
|
|
switch (actionMasked) {
|
|
case MotionEvent.ACTION_DOWN:
|
|
mActivePointerId = ev.getPointerId(0);
|
|
mDownPos.set(ev.getX(), ev.getY());
|
|
mLastPos.set(mDownPos);
|
|
mLastDisplacement.set(0, 0);
|
|
mDisplacement.set(0, 0);
|
|
|
|
if (mState == ScrollState.SETTLING && mIgnoreSlopWhenSettling) {
|
|
setState(ScrollState.DRAGGING);
|
|
}
|
|
break;
|
|
//case MotionEvent.ACTION_POINTER_DOWN:
|
|
case MotionEvent.ACTION_POINTER_UP:
|
|
int ptrIdx = ev.getActionIndex();
|
|
int ptrId = ev.getPointerId(ptrIdx);
|
|
if (ptrId == mActivePointerId) {
|
|
final int newPointerIdx = ptrIdx == 0 ? 1 : 0;
|
|
mDownPos.set(
|
|
ev.getX(newPointerIdx) - (mLastPos.x - mDownPos.x),
|
|
ev.getY(newPointerIdx) - (mLastPos.y - mDownPos.y));
|
|
mLastPos.set(ev.getX(newPointerIdx), ev.getY(newPointerIdx));
|
|
mActivePointerId = ev.getPointerId(newPointerIdx);
|
|
}
|
|
break;
|
|
case MotionEvent.ACTION_MOVE:
|
|
int pointerIndex = ev.findPointerIndex(mActivePointerId);
|
|
if (pointerIndex == INVALID_POINTER_ID) {
|
|
break;
|
|
}
|
|
mDisplacement.set(ev.getX(pointerIndex) - mDownPos.x,
|
|
ev.getY(pointerIndex) - mDownPos.y);
|
|
if (mIsRtl) {
|
|
mDisplacement.x = -mDisplacement.x;
|
|
}
|
|
|
|
// handle state and listener calls.
|
|
if (mState != ScrollState.DRAGGING && shouldScrollStart(mDisplacement)) {
|
|
setState(ScrollState.DRAGGING);
|
|
}
|
|
if (mState == ScrollState.DRAGGING) {
|
|
reportDragging(ev);
|
|
}
|
|
mLastPos.set(ev.getX(pointerIndex), ev.getY(pointerIndex));
|
|
break;
|
|
case MotionEvent.ACTION_CANCEL:
|
|
case MotionEvent.ACTION_UP:
|
|
// These are synthetic events and there is no need to update internal values.
|
|
if (mState == ScrollState.DRAGGING) {
|
|
setState(ScrollState.SETTLING);
|
|
}
|
|
mVelocityTracker.recycle();
|
|
mVelocityTracker = null;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//------------------- ScrollState transition diagram -----------------------------------
|
|
//
|
|
// IDLE -> (mDisplacement > mTouchSlop) -> DRAGGING
|
|
// DRAGGING -> (MotionEvent#ACTION_UP, MotionEvent#ACTION_CANCEL) -> SETTLING
|
|
// SETTLING -> (MotionEvent#ACTION_DOWN) -> DRAGGING
|
|
// SETTLING -> (View settled) -> IDLE
|
|
|
|
private void setState(ScrollState newState) {
|
|
if (mIsSettingState) {
|
|
mSetStateQueue.add(() -> setState(newState));
|
|
return;
|
|
}
|
|
mIsSettingState = true;
|
|
|
|
if (DBG) {
|
|
Log.d(TAG, "setState:" + mState + "->" + newState);
|
|
}
|
|
// onDragStart and onDragEnd is reported ONLY on state transition
|
|
if (newState == ScrollState.DRAGGING) {
|
|
initializeDragging();
|
|
if (mState == ScrollState.IDLE) {
|
|
reportDragStart(false /* recatch */);
|
|
} else if (mState == ScrollState.SETTLING) {
|
|
reportDragStart(true /* recatch */);
|
|
}
|
|
}
|
|
if (newState == ScrollState.SETTLING) {
|
|
reportDragEnd();
|
|
}
|
|
|
|
mState = newState;
|
|
mIsSettingState = false;
|
|
if (!mSetStateQueue.isEmpty()) {
|
|
mSetStateQueue.remove().run();
|
|
}
|
|
}
|
|
|
|
private void initializeDragging() {
|
|
if (mState == ScrollState.SETTLING && mIgnoreSlopWhenSettling) {
|
|
mSubtractDisplacement.set(0, 0);
|
|
} else {
|
|
mSubtractDisplacement.x = mDisplacement.x > 0 ? mTouchSlop : -mTouchSlop;
|
|
mSubtractDisplacement.y = mDisplacement.y > 0 ? mTouchSlop : -mTouchSlop;
|
|
}
|
|
}
|
|
|
|
protected abstract boolean shouldScrollStart(PointF displacement);
|
|
|
|
private void reportDragStart(boolean recatch) {
|
|
reportDragStartInternal(recatch);
|
|
if (DBG) {
|
|
Log.d(TAG, "onDragStart recatch:" + recatch);
|
|
}
|
|
}
|
|
|
|
protected abstract void reportDragStartInternal(boolean recatch);
|
|
|
|
private void reportDragging(MotionEvent event) {
|
|
if (mDisplacement != mLastDisplacement) {
|
|
if (DBG) {
|
|
Log.d(TAG, String.format("onDrag disp=%s", mDisplacement));
|
|
}
|
|
|
|
mLastDisplacement.set(mDisplacement);
|
|
sTempPoint.set(mDisplacement.x - mSubtractDisplacement.x,
|
|
mDisplacement.y - mSubtractDisplacement.y);
|
|
reportDraggingInternal(sTempPoint, event);
|
|
}
|
|
}
|
|
|
|
protected abstract void reportDraggingInternal(PointF displacement, MotionEvent event);
|
|
|
|
private void reportDragEnd() {
|
|
mVelocityTracker.computeCurrentVelocity(1000, mMaxVelocity);
|
|
PointF velocity = new PointF(mVelocityTracker.getXVelocity() / 1000,
|
|
mVelocityTracker.getYVelocity() / 1000);
|
|
if (mIsRtl) {
|
|
velocity.x = -velocity.x;
|
|
}
|
|
if (DBG) {
|
|
Log.d(TAG, String.format("onScrollEnd disp=%.1s, velocity=%.1s",
|
|
mDisplacement, velocity));
|
|
}
|
|
|
|
reportDragEndInternal(velocity);
|
|
}
|
|
|
|
protected abstract void reportDragEndInternal(PointF velocity);
|
|
}
|