Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

am 56a17690: Merge "TransformGestureDetector is now ScaleGestureDetector - scope reduced. N1 screen can\'t reliably handle translation and scaling at the same time." into eclair

Browse Source 
Merge commit '56a17690b0b9dc2a2e15ef38a37cc4c403c614fe' into eclair-plus-aosp

* commit '56a17690b0b9dc2a2e15ef38a37cc4c403c614fe':
  TransformGestureDetector is now ScaleGestureDetector - scope reduced.
This commit is contained in:
Adam Powell
2010-01-13 18:04:39 -08:00
committed by Android Git Automerger
parent cff6c8459c 56a17690b0
commit b5a5a39716
3 changed files with 407 additions and 345 deletions
Download Patch File Download Diff File Expand all files Collapse all files

360
core/java/android/view/ScaleGestureDetector.java Normal file
View File

@@ -0,0 +1,360 @@
/*
* Copyright (C) 2010 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 android.view;
import android.content.Context;
/**
* Detects transformation gestures involving more than one pointer ("multitouch")
* using the supplied {@link MotionEvent}s. The {@link OnScaleGestureListener}
* callback will notify users when a particular gesture event has occurred.
* This class should only be used with {@link MotionEvent}s reported via touch.
*
* To use this class:
* <ul>
* <li>Create an instance of the {@code ScaleGestureDetector} for your
* {@link View}
* <li>In the {@link View#onTouchEvent(MotionEvent)} method ensure you call
* {@link #onTouchEvent(MotionEvent)}. The methods defined in your
* callback will be executed when the events occur.
* </ul>
* @hide Pending API approval
*/
public class ScaleGestureDetector {
/**
* The listener for receiving notifications when gestures occur.
* If you want to listen for all the different gestures then implement
* this interface. If you only want to listen for a subset it might
* be easier to extend {@link SimpleOnScaleGestureListener}.
*
* An application will receive events in the following order:
* <ul>
* <li>One {@link OnScaleGestureListener#onScaleBegin()}
* <li>Zero or more {@link OnScaleGestureListener#onScale()}
* <li>One {@link OnScaleGestureListener#onTransformEnd()}
* </ul>
*/
public interface OnScaleGestureListener {
/**
* Responds to scaling events for a gesture in progress.
* Reported by pointer motion.
*
* @param detector The detector reporting the event - use this to
* retrieve extended info about event state.
* @return Whether or not the detector should consider this event
* as handled. If an event was not handled, the detector
* will continue to accumulate movement until an event is
* handled. This can be useful if an application, for example,
* only wants to update scaling factors if the change is
* greater than 0.01.
*/
public boolean onScale(ScaleGestureDetector detector);
/**
* Responds to the beginning of a scaling gesture. Reported by
* new pointers going down.
*
* @param detector The detector reporting the event - use this to
* retrieve extended info about event state.
* @return Whether or not the detector should continue recognizing
* this gesture. For example, if a gesture is beginning
* with a focal point outside of a region where it makes
* sense, onScaleBegin() may return false to ignore the
* rest of the gesture.
*/
public boolean onScaleBegin(ScaleGestureDetector detector);
/**
* Responds to the end of a scale gesture. Reported by existing
* pointers going up. If the end of a gesture would result in a fling,
* {@link onTransformFling()} is called instead.
*
* Once a scale has ended, {@link ScaleGestureDetector#getFocusX()}
* and {@link ScaleGestureDetector#getFocusY()} will return the location
* of the pointer remaining on the screen.
*
* @param detector The detector reporting the event - use this to
* retrieve extended info about event state.
*/
public void onScaleEnd(ScaleGestureDetector detector);
}
/**
* A convenience class to extend when you only want to listen for a subset
* of scaling-related events. This implements all methods in
* {@link OnScaleGestureListener} but does nothing.
* {@link OnScaleGestureListener#onScale(ScaleGestureDetector)} and
* {@link OnScaleGestureListener#onScaleBegin(ScaleGestureDetector)} return
* {@code true}.
*/
public class SimpleOnScaleGestureListener implements OnScaleGestureListener {
public boolean onScale(ScaleGestureDetector detector) {
return true;
}
public boolean onScaleBegin(ScaleGestureDetector detector) {
return true;
}
public void onScaleEnd(ScaleGestureDetector detector) {
// Intentionally empty
}
}
private static final float PRESSURE_THRESHOLD = 0.67f;
private Context mContext;
private OnScaleGestureListener mListener;
private boolean mGestureInProgress;
private MotionEvent mPrevEvent;
private MotionEvent mCurrEvent;
private float mFocusX;
private float mFocusY;
private float mPrevFingerDiffX;
private float mPrevFingerDiffY;
private float mCurrFingerDiffX;
private float mCurrFingerDiffY;
private float mCurrLen;
private float mPrevLen;
private float mScaleFactor;
private float mCurrPressure;
private float mPrevPressure;
private long mTimeDelta;
public ScaleGestureDetector(Context context, OnScaleGestureListener listener) {
mContext = context;
mListener = listener;
}
public boolean onTouchEvent(MotionEvent event) {
final int action = event.getAction();
boolean handled = true;
if (!mGestureInProgress) {
if ((action == MotionEvent.ACTION_POINTER_1_DOWN ||
action == MotionEvent.ACTION_POINTER_2_DOWN) &&
event.getPointerCount() >= 2) {
// We have a new multi-finger gesture
// Be paranoid in case we missed an event
reset();
mPrevEvent = MotionEvent.obtain(event);
mTimeDelta = 0;
setContext(event);
mGestureInProgress = mListener.onScaleBegin(this);
}
} else {
// Transform gesture in progress - attempt to handle it
switch (action) {
case MotionEvent.ACTION_POINTER_1_UP:
case MotionEvent.ACTION_POINTER_2_UP:
// Gesture ended
setContext(event);
// Set focus point to the remaining finger
int id = (((action & MotionEvent.ACTION_POINTER_ID_MASK)
>> MotionEvent.ACTION_POINTER_ID_SHIFT) == 0) ? 1 : 0;
mFocusX = event.getX(id);
mFocusY = event.getY(id);
mListener.onScaleEnd(this);
mGestureInProgress = false;
reset();
break;
case MotionEvent.ACTION_CANCEL:
mListener.onScaleEnd(this);
mGestureInProgress = false;
reset();
break;
case MotionEvent.ACTION_MOVE:
setContext(event);
// Only accept the event if our relative pressure is within
// a certain limit - this can help filter shaky data as a
// finger is lifted.
if (mCurrPressure / mPrevPressure > PRESSURE_THRESHOLD) {
final boolean updatePrevious = mListener.onScale(this);
if (updatePrevious) {
mPrevEvent.recycle();
mPrevEvent = MotionEvent.obtain(event);
}
}
break;
}
}
return handled;
}
private void setContext(MotionEvent curr) {
if (mCurrEvent != null) {
mCurrEvent.recycle();
}
mCurrEvent = MotionEvent.obtain(curr);
mCurrLen = -1;
mPrevLen = -1;
mScaleFactor = -1;
final MotionEvent prev = mPrevEvent;
final float px0 = prev.getX(0);
final float py0 = prev.getY(0);
final float px1 = prev.getX(1);
final float py1 = prev.getY(1);
final float cx0 = curr.getX(0);
final float cy0 = curr.getY(0);
final float cx1 = curr.getX(1);
final float cy1 = curr.getY(1);
final float pvx = px1 - px0;
final float pvy = py1 - py0;
final float cvx = cx1 - cx0;
final float cvy = cy1 - cy0;
mPrevFingerDiffX = pvx;
mPrevFingerDiffY = pvy;
mCurrFingerDiffX = cvx;
mCurrFingerDiffY = cvy;
mFocusX = cx0 + cvx * 0.5f;
mFocusY = cy0 + cvy * 0.5f;
mTimeDelta = curr.getEventTime() - prev.getEventTime();
mCurrPressure = curr.getPressure(0) + curr.getPressure(1);
mPrevPressure = prev.getPressure(0) + prev.getPressure(1);
}
private void reset() {
if (mPrevEvent != null) {
mPrevEvent.recycle();
mPrevEvent = null;
}
if (mCurrEvent != null) {
mCurrEvent.recycle();
mCurrEvent = null;
}
}
/**
* Returns {@code true} if a two-finger scale gesture is in progress.
* @return {@code true} if a scale gesture is in progress, {@code false} otherwise.
*/
public boolean isInProgress() {
return mGestureInProgress;
}
/**
* Get the X coordinate of the current gesture's focal point.
* If a gesture is in progress, the focal point is directly between
* the two pointers forming the gesture.
* If a gesture is ending, the focal point is the location of the
* remaining pointer on the screen.
* If {@link isInProgress()} would return false, the result of this
* function is undefined.
*
* @return X coordinate of the focal point in pixels.
*/
public float getFocusX() {
return mFocusX;
}
/**
* Get the Y coordinate of the current gesture's focal point.
* If a gesture is in progress, the focal point is directly between
* the two pointers forming the gesture.
* If a gesture is ending, the focal point is the location of the
* remaining pointer on the screen.
* If {@link isInProgress()} would return false, the result of this
* function is undefined.
*
* @return Y coordinate of the focal point in pixels.
*/
public float getFocusY() {
return mFocusY;
}
/**
* Return the current distance between the two pointers forming the
* gesture in progress.
*
* @return Distance between pointers in pixels.
*/
public float getCurrentSpan() {
if (mCurrLen == -1) {
final float cvx = mCurrFingerDiffX;
final float cvy = mCurrFingerDiffY;
mCurrLen = (float)Math.sqrt(cvx*cvx + cvy*cvy);
}
return mCurrLen;
}
/**
* Return the previous distance between the two pointers forming the
* gesture in progress.
*
* @return Previous distance between pointers in pixels.
*/
public float getPreviousSpan() {
if (mPrevLen == -1) {
final float pvx = mPrevFingerDiffX;
final float pvy = mPrevFingerDiffY;
mPrevLen = (float)Math.sqrt(pvx*pvx + pvy*pvy);
}
return mPrevLen;
}
/**
* Return the scaling factor from the previous scale event to the current
* event. This value is defined as
* ({@link getCurrentSpan()} / {@link getPreviousSpan()}).
*
* @return The current scaling factor.
*/
public float getScaleFactor() {
if (mScaleFactor == -1) {
mScaleFactor = getCurrentSpan() / getPreviousSpan();
}
return mScaleFactor;
}
/**
* Return the time difference in milliseconds between the previous
* accepted scaling event and the current scaling event.
*
* @return Time difference since the last scaling event in milliseconds.
*/
public long getTimeDelta() {
return mTimeDelta;
}
/**
* Return the event time of the current event being processed.
*
* @return Current event time in milliseconds.
*/
public long getEventTime() {
return mCurrEvent.getEventTime();
}
}

316
core/java/android/view/TransformGestureDetector.java
View File

@@ -1,316 +0,0 @@
/*
* Copyright (C) 2010 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 android.view;
import android.content.Context;
import android.util.Log;
import android.view.GestureDetector.SimpleOnGestureListener;
/**
* Detects transformation gestures involving more than one pointer ("multitouch")
* using the supplied {@link MotionEvent}s. The {@link OnGestureListener} callback
* will notify users when a particular gesture event has occurred. This class
* should only be used with {@link MotionEvent}s reported via touch.
*
* To use this class:
* <ul>
* <li>Create an instance of the {@code TransformGestureDetector} for your
* {@link View}
* <li>In the {@link View#onTouchEvent(MotionEvent)} method ensure you call
* {@link #onTouchEvent(MotionEvent)}. The methods defined in your
* callback will be executed when the events occur.
* </ul>
* @hide Pending API approval
*/
public class TransformGestureDetector {
/**
* The listener for receiving notifications when gestures occur.
* If you want to listen for all the different gestures then implement
* this interface. If you only want to listen for a subset it might
* be easier to extend {@link SimpleOnGestureListener}.
*
* An application will receive events in the following order:
* One onTransformBegin()
* Zero or more onTransform()
* One onTransformEnd() or onTransformFling()
*/
public interface OnTransformGestureListener {
/**
* Responds to transformation events for a gesture in progress.
* Reported by pointer motion.
*
* @param detector The detector reporting the event - use this to
* retrieve extended info about event state.
* @return true if the event was handled, false otherwise.
*/
public boolean onTransform(TransformGestureDetector detector);
/**
* Responds to the beginning of a transformation gesture. Reported by
* new pointers going down.
*
* @param detector The detector reporting the event - use this to
* retrieve extended info about event state.
* @return true if the event was handled, false otherwise.
*/
public boolean onTransformBegin(TransformGestureDetector detector);
/**
* Responds to the end of a transformation gesture. Reported by existing
* pointers going up. If the end of a gesture would result in a fling,
* onTransformFling is called instead.
*
* @param detector The detector reporting the event - use this to
* retrieve extended info about event state.
* @return true if the event was handled, false otherwise.
*/
public boolean onTransformEnd(TransformGestureDetector detector);
/**
* Responds to the end of a transformation gesture that begins a fling.
* Reported by existing pointers going up. If the end of a gesture
* would not result in a fling, onTransformEnd is called instead.
*
* @param detector The detector reporting the event - use this to
* retrieve extended info about event state.
* @return true if the event was handled, false otherwise.
*/
public boolean onTransformFling(TransformGestureDetector detector);
}
private static final boolean DEBUG = false;
private static final int INITIAL_EVENT_IGNORES = 2;
private Context mContext;
private float mTouchSizeScale;
private OnTransformGestureListener mListener;
private int mVelocityTimeUnits;
private MotionEvent mInitialEvent;
private MotionEvent mPrevEvent;
private MotionEvent mCurrEvent;
private VelocityTracker mVelocityTracker;
private float mCenterX;
private float mCenterY;
private float mTransX;
private float mTransY;
private float mPrevFingerDiffX;
private float mPrevFingerDiffY;
private float mCurrFingerDiffX;
private float mCurrFingerDiffY;
private float mRotateDegrees;
private float mCurrLen;
private float mPrevLen;
private float mScaleFactor;
// Units in pixels. Current value is pulled out of thin air for debugging only.
private float mPointerJumpLimit = 30;
private int mEventIgnoreCount;
public TransformGestureDetector(Context context, OnTransformGestureListener listener,
int velocityTimeUnits) {
mContext = context;
mListener = listener;
mTouchSizeScale = context.getResources().getDisplayMetrics().widthPixels/3;
mVelocityTimeUnits = velocityTimeUnits;
mEventIgnoreCount = INITIAL_EVENT_IGNORES;
}
public TransformGestureDetector(Context context, OnTransformGestureListener listener) {
this(context, listener, 1000);
}
public boolean onTouchEvent(MotionEvent event) {
final int action = event.getAction();
boolean handled = true;
if (mInitialEvent == null) {
// No transform gesture in progress
if ((action == MotionEvent.ACTION_POINTER_1_DOWN ||
action == MotionEvent.ACTION_POINTER_2_DOWN) &&
event.getPointerCount() >= 2) {
// We have a new multi-finger gesture
mInitialEvent = MotionEvent.obtain(event);
mPrevEvent = MotionEvent.obtain(event);
mVelocityTracker = VelocityTracker.obtain();
handled = mListener.onTransformBegin(this);
}
} else {
// Transform gesture in progress - attempt to handle it
switch (action) {
case MotionEvent.ACTION_POINTER_1_UP:
case MotionEvent.ACTION_POINTER_2_UP:
// Gesture ended
handled = mListener.onTransformEnd(this);
reset();
break;
case MotionEvent.ACTION_CANCEL:
handled = mListener.onTransformEnd(this);
reset();
break;
case MotionEvent.ACTION_MOVE:
setContext(event);
// Our first few events can be crazy from some touchscreens - drop them.
if (mEventIgnoreCount == 0) {
mVelocityTracker.addMovement(event);
handled = mListener.onTransform(this);
} else {
mEventIgnoreCount--;
}
mPrevEvent.recycle();
mPrevEvent = MotionEvent.obtain(event);
break;
}
}
return handled;
}
private void setContext(MotionEvent curr) {
mCurrEvent = MotionEvent.obtain(curr);
mRotateDegrees = -1;
mCurrLen = -1;
mPrevLen = -1;
mScaleFactor = -1;
final MotionEvent prev = mPrevEvent;
float px0 = prev.getX(0);
float py0 = prev.getY(0);
float px1 = prev.getX(1);
float py1 = prev.getY(1);
float cx0 = curr.getX(0);
float cy0 = curr.getY(0);
float cx1 = curr.getX(1);
float cy1 = curr.getY(1);
// Some touchscreens do weird things with pointer values where points are
// too close along one axis. Try to detect this here and smooth things out.
// The main indicator is that we get the X or Y value from the other pointer.
final float dx0 = cx0 - px0;
final float dy0 = cy0 - py0;
final float dx1 = cx1 - px1;
final float dy1 = cy1 - py1;
if (cx0 == cx1) {
if (Math.abs(dx0) > mPointerJumpLimit) {
cx0 = px0;
} else if (Math.abs(dx1) > mPointerJumpLimit) {
cx1 = px1;
}
} else if (cy0 == cy1) {
if (Math.abs(dy0) > mPointerJumpLimit) {
cy0 = py0;
} else if (Math.abs(dy1) > mPointerJumpLimit) {
cy1 = py1;
}
}
final float pvx = px1 - px0;
final float pvy = py1 - py0;
final float cvx = cx1 - cx0;
final float cvy = cy1 - cy0;
mPrevFingerDiffX = pvx;
mPrevFingerDiffY = pvy;
mCurrFingerDiffX = cvx;
mCurrFingerDiffY = cvy;
final float pmidx = px0 + pvx * 0.5f;
final float pmidy = py0 + pvy * 0.5f;
final float cmidx = cx0 + cvx * 0.5f;
final float cmidy = cy0 + cvy * 0.5f;
mCenterX = cmidx;
mCenterY = cmidy;
mTransX = cmidx - pmidx;
mTransY = cmidy - pmidy;
}
private void reset() {
if (mInitialEvent != null) {
mInitialEvent.recycle();
mInitialEvent = null;
}
if (mPrevEvent != null) {
mPrevEvent.recycle();
mPrevEvent = null;
}
if (mCurrEvent != null) {
mCurrEvent.recycle();
mCurrEvent = null;
}
if (mVelocityTracker != null) {
mVelocityTracker.recycle();
mVelocityTracker = null;
}
mEventIgnoreCount = INITIAL_EVENT_IGNORES;
}
public float getCenterX() {
return mCenterX;
}
public float getCenterY() {
return mCenterY;
}
public float getTranslateX() {
return mTransX;
}
public float getTranslateY() {
return mTransY;
}
public float getCurrentSpan() {
if (mCurrLen == -1) {
final float cvx = mCurrFingerDiffX;
final float cvy = mCurrFingerDiffY;
mCurrLen = (float)Math.sqrt(cvx*cvx + cvy*cvy);
}
return mCurrLen;
}
public float getPreviousSpan() {
if (mPrevLen == -1) {
final float pvx = mPrevFingerDiffX;
final float pvy = mPrevFingerDiffY;
mPrevLen = (float)Math.sqrt(pvx*pvx + pvy*pvy);
}
return mPrevLen;
}
public float getScaleFactor() {
if (mScaleFactor == -1) {
mScaleFactor = getCurrentSpan() / getPreviousSpan();
}
return mScaleFactor;
}
public float getRotation() {
throw new UnsupportedOperationException();
}
}

76
tests/TransformTest/src/com/google/android/test/transform/TransformTestActivity.java
View File

@@ -24,9 +24,8 @@ import android.graphics.drawable.Drawable;
import android.os.Bundle;
import android.util.DisplayMetrics;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.MotionEvent;
import android.view.TransformGestureDetector;
import android.view.ScaleGestureDetector;
import android.view.View;
import android.widget.LinearLayout;
@@ -48,9 +47,6 @@ public class TransformTestActivity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
final LayoutInflater li = (LayoutInflater)getSystemService(
LAYOUT_INFLATER_SERVICE);
this.setTitle(R.string.act_title);
LinearLayout root = new LinearLayout(this);
@@ -71,15 +67,19 @@ public class TransformTestActivity extends Activity {
private float mPosY;
private float mScale = 1.f;
private Matrix mMatrix;
private TransformGestureDetector mDetector;
private ScaleGestureDetector mDetector;
private class Listener implements TransformGestureDetector.OnTransformGestureListener {
private float mLastX;
private float mLastY;
private class Listener implements ScaleGestureDetector.OnScaleGestureListener {
public boolean onTransform(TransformGestureDetector detector) {
Log.d("ttest", "Translation: (" + detector.getTranslateX() +
", " + detector.getTranslateY() + ")");
public boolean onScale(ScaleGestureDetector detector) {
float scale = detector.getScaleFactor();
Log.d("ttest", "Scale: " + scale);
// Limit the scale so our object doesn't get too big or disappear
if (mScale * scale > 0.1f) {
if (mScale * scale < 10.f) {
mScale *= scale;
@@ -89,16 +89,13 @@ public class TransformTestActivity extends Activity {
} else {
mScale = 0.1f;
}
mPosX += detector.getTranslateX();
mPosY += detector.getTranslateY();
Log.d("ttest", "mScale: " + mScale + " mPos: (" + mPosX + ", " + mPosY + ")");
float sizeX = mDrawable.getIntrinsicWidth()/2;
float sizeY = mDrawable.getIntrinsicHeight()/2;
float centerX = detector.getCenterX();
float centerY = detector.getCenterY();
float centerX = detector.getFocusX();
float centerY = detector.getFocusY();
float diffX = centerX - mPosX;
float diffY = centerY - mPosY;
diffX = diffX*scale - diffX;
@@ -115,24 +112,20 @@ public class TransformTestActivity extends Activity {
return true;
}
public boolean onTransformBegin(TransformGestureDetector detector) {
public boolean onScaleBegin(ScaleGestureDetector detector) {
return true;
}
public boolean onTransformEnd(TransformGestureDetector detector) {
return true;
}
public boolean onTransformFling(TransformGestureDetector detector) {
return false;
}
public void onScaleEnd(ScaleGestureDetector detector) {
mLastX = detector.getFocusX();
mLastY = detector.getFocusY();
}
}
public TransformView(Context context) {
super(context);
mMatrix = new Matrix();
mDetector = new TransformGestureDetector(context, new Listener());
mDetector = new ScaleGestureDetector(context, new Listener());
DisplayMetrics metrics = context.getResources().getDisplayMetrics();
mPosX = metrics.widthPixels/2;
mPosY = metrics.heightPixels/2;
@@ -151,12 +144,37 @@ public class TransformTestActivity extends Activity {
@Override
public boolean onTouchEvent(MotionEvent event) {
boolean handled = mDetector.onTouchEvent(event);
mDetector.onTouchEvent(event);
int pointerCount = event.getPointerCount();
Log.d("ttest", "pointerCount: " + pointerCount);
// Handling single finger pan
if (!mDetector.isInProgress()) {
switch (event.getAction()) {
case MotionEvent.ACTION_DOWN:
mLastX = event.getX();
mLastY = event.getY();
break;
case MotionEvent.ACTION_MOVE:
final float x = event.getX();
final float y = event.getY();
mPosX += x - mLastX;
mPosY += y - mLastY;
mLastX = x;
mLastY = y;
float sizeX = mDrawable.getIntrinsicWidth()/2;
float sizeY = mDrawable.getIntrinsicHeight()/2;
mMatrix.reset();
mMatrix.postTranslate(-sizeX, -sizeY);
mMatrix.postScale(mScale, mScale);
mMatrix.postTranslate(mPosX, mPosY);
invalidate();
break;
}
}
return handled;
return true;
}
@Override