csdnceshi61
derek5.
采纳率100%
2009-06-01 23:35

网格布局中的投掷姿态检测

I want to get fling gesture detection working in my Android application.

What I have is a GridLayout that contains 9 ImageViews. The source can be found here: Romain Guys's Grid Layout.

That file I take is from Romain Guy's Photostream application and has only been slightly adapted.

For the simple click situation I need only set the onClickListener for each ImageView I add to be the main activity which implements View.OnClickListener. It seems infinitely more complicated to implement something that recognizes a fling. I presume this is because it may span views?

  • If my activity implements OnGestureListener I don't know how to set that as the gesture listener for the Grid or the Image views that I add.

    public class SelectFilterActivity extends Activity implements
       View.OnClickListener, OnGestureListener { ...
    
  • If my activity implements OnTouchListener then I have no onFling method to override (it has two events as parameters allowing me to determine if the fling was noteworthy).

    public class SelectFilterActivity extends Activity implements
        View.OnClickListener, OnTouchListener { ...
    
  • If I make a custom View, like GestureImageView that extends ImageView I don't know how to tell the activity that a fling has occurred from the view. In any case, I tried this and the methods weren't called when I touched the screen.

I really just need a concrete example of this working across views. What, when and how should I attach this listener? I need to be able to detect single clicks also.

// Gesture detection
mGestureDetector = new GestureDetector(this, new GestureDetector.SimpleOnGestureListener() {

    public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
        int dx = (int) (e2.getX() - e1.getX());
        // don't accept the fling if it's too short
        // as it may conflict with a button push
        if (Math.abs(dx) > MAJOR_MOVE && Math.abs(velocityX) > Math.absvelocityY)) {
            if (velocityX > 0) {
                moveRight();
            } else {
                moveLeft();
            }
            return true;
        } else {
            return false;
        }
    }
});

Is it possible to lay a transparent view over the top of my screen to capture flings?

If I choose not to inflate my child image views from XML can I pass the GestureDetector as a constructor parameter to a new subclass of ImageView that I create?

This is the very simple activity that I'm trying to get the fling detection to work for: SelectFilterActivity (Adapted from photostream).

I've been looking at these sources:

Nothing has worked for me so far and I was hoping for some pointers.

转载于:https://stackoverflow.com/questions/937313/fling-gesture-detection-on-grid-layout

  • 点赞
  • 写回答
  • 关注问题
  • 收藏
  • 复制链接分享
  • 邀请回答

18条回答

  • csdnceshi70 笑故挽风 7年前

    Thanks to Code Shogun, whose code I adapted to my situation.

    Let your activity implementOnClickListener as usual:

    public class SelectFilterActivity extends Activity implements OnClickListener {
    
      private static final int SWIPE_MIN_DISTANCE = 120;
      private static final int SWIPE_MAX_OFF_PATH = 250;
      private static final int SWIPE_THRESHOLD_VELOCITY = 200;
      private GestureDetector gestureDetector;
      View.OnTouchListener gestureListener;
    
      @Override
      protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
    
        /* ... */
    
        // Gesture detection
        gestureDetector = new GestureDetector(this, new MyGestureDetector());
        gestureListener = new View.OnTouchListener() {
          public boolean onTouch(View v, MotionEvent event) {
            return gestureDetector.onTouchEvent(event);
          }
        };
    
      }
    
      class MyGestureDetector extends SimpleOnGestureListener {
        @Override
        public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
          try {
            if (Math.abs(e1.getY() - e2.getY()) > SWIPE_MAX_OFF_PATH)
              return false;
            // right to left swipe
            if(e1.getX() - e2.getX() > SWIPE_MIN_DISTANCE && Math.abs(velocityX) > SWIPE_THRESHOLD_VELOCITY) {
              Toast.makeText(SelectFilterActivity.this, "Left Swipe", Toast.LENGTH_SHORT).show();
            } else if (e2.getX() - e1.getX() > SWIPE_MIN_DISTANCE && Math.abs(velocityX) > SWIPE_THRESHOLD_VELOCITY) {
              Toast.makeText(SelectFilterActivity.this, "Right Swipe", Toast.LENGTH_SHORT).show();
            }
          } catch (Exception e) {
             // nothing
          }
          return false;
        }
    
        @Override
        public boolean onDown(MotionEvent e) {
          return true;
        }
      }
    }
    

    Attach your gesture listener to all the views you add to the main layout;

    // Do this for each view added to the grid
    imageView.setOnClickListener(SelectFilterActivity.this); 
    imageView.setOnTouchListener(gestureListener);
    

    Watch in awe as your overridden methods are hit, both the onClick(View v) of the activity and the onFling of the gesture listener.

    public void onClick(View v) {
      Filter f = (Filter) v.getTag();
      FilterFullscreenActivity.show(this, input, f);
    }
    

    The post 'fling' dance is optional but encouraged.

    点赞 24 评论 复制链接分享
  • csdnceshi78 程序go 7年前

    I nedded a more generic Class , I took Tomas's class and added an Interface that send events to your Activity or Fragment. it will register the listener on the constructor so be sure you implement the interface or an ClassCastException will be thorwn. the interface returns one of the four final int defined in the class and will return the view on which it was activated upon.

    import android.app.Activity;
    import android.support.v4.app.Fragment;
    import android.util.Log;
    import android.view.MotionEvent;
    import android.view.View;
    
    public class SwipeDetector implements View.OnTouchListener{
    
        static final int MIN_DISTANCE = 100;
        private float downX, downY, upX, upY;
        public final static int RIGHT_TO_LEFT=1;
        public final static int LEFT_TO_RIGHT=2;
        public final static int TOP_TO_BOTTOM=3;
        public final static int BOTTOM_TO_TOP=4;
        private View v;
    
        private onSwipeEvent swipeEventListener;
    
    
        public SwipeDetector(Activity activity,View v){
            try{
                swipeEventListener=(onSwipeEvent)activity;
            }
            catch(ClassCastException e)
            {
                Log.e("ClassCastException",activity.toString()+" must implement SwipeDetector.onSwipeEvent");
            } 
            this.v=v;
        }
        public SwipeDetector(Fragment fragment,View v){
            try{
                swipeEventListener=(onSwipeEvent)fragment;
            }
            catch(ClassCastException e)
            {
                Log.e("ClassCastException",fragment.toString()+" must implement SwipeDetector.onSwipeEvent");
            } 
            this.v=v;
        }
    
    
        public void onRightToLeftSwipe(){   
            swipeEventListener.SwipeEventDetected(v,RIGHT_TO_LEFT);
        }
    
        public void onLeftToRightSwipe(){   
            swipeEventListener.SwipeEventDetected(v,LEFT_TO_RIGHT);
        }
    
        public void onTopToBottomSwipe(){   
            swipeEventListener.SwipeEventDetected(v,TOP_TO_BOTTOM);
        }
    
        public void onBottomToTopSwipe(){
            swipeEventListener.SwipeEventDetected(v,BOTTOM_TO_TOP);
        }
    
        public boolean onTouch(View v, MotionEvent event) {
            switch(event.getAction()){
            case MotionEvent.ACTION_DOWN: {
                downX = event.getX();
                downY = event.getY();
                return true;
            }
            case MotionEvent.ACTION_UP: {
                upX = event.getX();
                upY = event.getY();
    
                float deltaX = downX - upX;
                float deltaY = downY - upY;
    
                //HORIZONTAL SCROLL
                if(Math.abs(deltaX) > Math.abs(deltaY))
                {
                    if(Math.abs(deltaX) > MIN_DISTANCE){
                        // left or right
                        if(deltaX < 0) 
                        {
                            this.onLeftToRightSwipe();
                            return true;
                        }
                        if(deltaX > 0) {
                            this.onRightToLeftSwipe();
                            return true; 
                        }
                    }
                    else {
                        //not long enough swipe...
                        return false; 
                    }
                }
                //VERTICAL SCROLL
                else 
                {
                    if(Math.abs(deltaY) > MIN_DISTANCE){
                        // top or down
                        if(deltaY < 0) 
                        { this.onTopToBottomSwipe();
                        return true; 
                        }
                        if(deltaY > 0)
                        { this.onBottomToTopSwipe(); 
                        return true;
                        }
                    }
                    else {
                        //not long enough swipe...
                        return false;
                    }
                }
    
                return true;
            }
            }
            return false;
        }
        public interface onSwipeEvent
        {
            public void SwipeEventDetected(View v , int SwipeType);
        }
    
    }
    
    点赞 8 评论 复制链接分享
  • csdnceshi72 谁还没个明天 4年前

    If you dont like to create a separate class or make code complex,
    You can just create a GestureDetector variable inside OnTouchListener and make your code more easier

    namVyuVar can be any name of the View on which you need to set the listner

    namVyuVar.setOnTouchListener(new View.OnTouchListener()
    {
        @Override
        public boolean onTouch(View view, MotionEvent MsnEvtPsgVal)
        {
            flingActionVar.onTouchEvent(MsnEvtPsgVal);
            return true;
        }
    
        GestureDetector flingActionVar = new GestureDetector(getApplicationContext(), new GestureDetector.SimpleOnGestureListener()
        {
            private static final int flingActionMinDstVac = 120;
            private static final int flingActionMinSpdVac = 200;
    
            @Override
            public boolean onFling(MotionEvent fstMsnEvtPsgVal, MotionEvent lstMsnEvtPsgVal, float flingActionXcoSpdPsgVal, float flingActionYcoSpdPsgVal)
            {
                if(fstMsnEvtPsgVal.getX() - lstMsnEvtPsgVal.getX() > flingActionMinDstVac && Math.abs(flingActionXcoSpdPsgVal) > flingActionMinSpdVac)
                {
                    // TskTdo :=> On Right to Left fling
    
                    return false;
                }
                else if (lstMsnEvtPsgVal.getX() - fstMsnEvtPsgVal.getX() > flingActionMinDstVac && Math.abs(flingActionXcoSpdPsgVal) > flingActionMinSpdVac)
                {
                    // TskTdo :=> On Left to Right fling
    
                    return false;
                }
    
                if(fstMsnEvtPsgVal.getY() - lstMsnEvtPsgVal.getY() > flingActionMinDstVac && Math.abs(flingActionYcoSpdPsgVal) > flingActionMinSpdVac)
                {
                    // TskTdo :=> On Bottom to Top fling
    
                    return false;
                }
                else if (lstMsnEvtPsgVal.getY() - fstMsnEvtPsgVal.getY() > flingActionMinDstVac && Math.abs(flingActionYcoSpdPsgVal) > flingActionMinSpdVac)
                {
                    // TskTdo :=> On Top to Bottom fling
    
                    return false;
                }
                return false;
            }
        });
    });
    
    点赞 4 评论 复制链接分享
  • csdnceshi79 python小菜 6年前

    Gestures are those subtle motions to trigger interactions between the touch screen and the user. It lasts for the time between the first touch on the screen to the point when the last finger leaves the surface.

    Android provides us with a class called GestureDetector using which we can detect common gestures like tapping down and up, swiping vertically and horizontally (fling), long and short press, double taps, etc. and attach listeners to them.

    Make our Activity class implement GestureDetector.OnDoubleTapListener (for double tap gesture detection) and GestureDetector.OnGestureListener interfaces and implement all the abstract methods.For more info. you may visit https://developer.android.com/training/gestures/detector.html . Courtesy

    For Demo Test.GestureDetectorDemo

    点赞 7 评论 复制链接分享
  • weixin_41568174 from.. 8年前

    To all: don't forget about case MotionEvent.ACTION_CANCEL:

    it calls in 30% swipes without ACTION_UP

    and its equal to ACTION_UP in this case

    点赞 6 评论 复制链接分享
  • weixin_41568126 乱世@小熊 7年前

    I know its too late to answer but Still I am posting Swipe Detection for ListView that How to use Swipe Touch Listener in ListView Item.

    Refrence: Exterminator13(one of answer in this page)

    Make one ActivitySwipeDetector.class

    package com.example.wocketapp;
    
    import android.content.Context;
    import android.util.DisplayMetrics;
    import android.util.Log;
    import android.view.MotionEvent;
    import android.view.View;
    import android.view.ViewConfiguration;
    
    public class ActivitySwipeDetector implements View.OnTouchListener 
    {
        static final String logTag = "SwipeDetector";
        private SwipeInterface activity;
        private float downX, downY;
        private long timeDown;
        private final float MIN_DISTANCE;
        private final int VELOCITY;
        private final float MAX_OFF_PATH;
    
        public ActivitySwipeDetector(Context context, SwipeInterface activity)
        {
            this.activity = activity;
            final ViewConfiguration vc = ViewConfiguration.get(context);
            DisplayMetrics dm = context.getResources().getDisplayMetrics();
            MIN_DISTANCE = vc.getScaledPagingTouchSlop() * dm.density;
            VELOCITY = vc.getScaledMinimumFlingVelocity();
            MAX_OFF_PATH = MIN_DISTANCE * 2;
        }
    
        public void onRightToLeftSwipe(View v) 
        {
            Log.i(logTag, "RightToLeftSwipe!");
            activity.onRightToLeft(v);
        }
    
        public void onLeftToRightSwipe(View v) 
        {
            Log.i(logTag, "LeftToRightSwipe!");
            activity.onLeftToRight(v);
        }
    
        public boolean onTouch(View v, MotionEvent event) 
        {
            switch (event.getAction()) 
            {
                case MotionEvent.ACTION_DOWN:
                {
                    Log.d("onTouch", "ACTION_DOWN");
                    timeDown = System.currentTimeMillis();
                    downX = event.getX();
                    downY = event.getY();
                    v.getParent().requestDisallowInterceptTouchEvent(false);
                    return true;
                }
    
            case MotionEvent.ACTION_MOVE:
                {
                    float y_up = event.getY();
                    float deltaY = y_up - downY;
                    float absDeltaYMove = Math.abs(deltaY);
    
                    if (absDeltaYMove > 60) 
                    {
                        v.getParent().requestDisallowInterceptTouchEvent(false);
                    } 
                    else
                    {
                        v.getParent().requestDisallowInterceptTouchEvent(true);
                    }
                }
    
                break;
    
                case MotionEvent.ACTION_UP: 
                {
                    Log.d("onTouch", "ACTION_UP");
                    long timeUp = System.currentTimeMillis();
                    float upX = event.getX();
                    float upY = event.getY();
    
                    float deltaX = downX - upX;
                    float absDeltaX = Math.abs(deltaX);
                    float deltaY = downY - upY;
                    float absDeltaY = Math.abs(deltaY);
    
                    long time = timeUp - timeDown;
    
                    if (absDeltaY > MAX_OFF_PATH) 
                    {
                        Log.e(logTag, String.format(
                                "absDeltaY=%.2f, MAX_OFF_PATH=%.2f", absDeltaY,
                                MAX_OFF_PATH));
                        return v.performClick();
                    }
    
                    final long M_SEC = 1000;
                    if (absDeltaX > MIN_DISTANCE && absDeltaX > time * VELOCITY / M_SEC) 
                    {
                         v.getParent().requestDisallowInterceptTouchEvent(true);
                        if (deltaX < 0) 
                        {
                            this.onLeftToRightSwipe(v);
                            return true;
                        }
                        if (deltaX > 0) 
                        {
                            this.onRightToLeftSwipe(v);
                            return true;
                        }
                    }
                    else 
                    {
                        Log.i(logTag,
                                String.format(
                                        "absDeltaX=%.2f, MIN_DISTANCE=%.2f, absDeltaX > MIN_DISTANCE=%b",
                                        absDeltaX, MIN_DISTANCE,
                                        (absDeltaX > MIN_DISTANCE)));
                        Log.i(logTag,
                                String.format(
                                        "absDeltaX=%.2f, time=%d, VELOCITY=%d, time*VELOCITY/M_SEC=%d, absDeltaX > time * VELOCITY / M_SEC=%b",
                                        absDeltaX, time, VELOCITY, time * VELOCITY
                                                / M_SEC, (absDeltaX > time * VELOCITY
                                                / M_SEC)));
                    }
    
                     v.getParent().requestDisallowInterceptTouchEvent(false);
    
                }
            }
            return false;
        }
        public interface SwipeInterface 
        {
    
            public void onLeftToRight(View v);
    
            public void onRightToLeft(View v);
        }
    
    }
    

    Call it from your activity class like this:

    yourLayout.setOnTouchListener(new ActivitySwipeDetector(this, your_activity.this));
    

    And Don't forget to implement SwipeInterface which will give you two @override methods:

        @Override
        public void onLeftToRight(View v) 
        {
            Log.e("TAG", "L to R");
        }
    
        @Override
        public void onRightToLeft(View v) 
        {
            Log.e("TAG", "R to L");
        }
    
    点赞 9 评论 复制链接分享
  • csdnceshi75 衫裤跑路 8年前

    You can use the droidQuery library to handle flings, clicks, long clicks, and custom events. The implementation is built on my previous answer below, but droidQuery provides a slick, simple syntax:

    //global variables    private boolean isSwiping = false;
    private SwipeDetector.Direction swipeDirection = null;
    private View v;//must be instantiated before next call.
    
    //swipe-handling code
    $.with(v).swipe(new Function() {
        @Override
        public void invoke($ droidQuery, Object... params) {
            if (params[0] == SwipeDetector.Direction.START)
                isSwiping = true;
            else if (params[0] == SwipeDetector.Direction.STOP) {
                if (isSwiping) {                    isSwiping = false;
                    if (swipeDirection != null) {
                        switch(swipeDirection) {
                            case DOWN :                                //TODO: Down swipe complete, so do something
                                break;
                            case UP :
                                //TODO: Up swipe complete, so do something
                                break;
                            case LEFT :
                                //TODO: Left swipe complete, so do something
                                break;
                            case RIGHT :
                                //TODO: Right swipe complete, so do something
                                break;
                            default :                                break;
                        }
                    }                }
            }
            else {
                swipeDirection = (SwipeDetector.Direction) params[0];
            }
        }
    });
    

    Original Answer

    This answer uses a combination of components from the other answers here. It consists of the SwipeDetector class, which has an inner interface for listening for events. I also provide a RelativeLayout to show how to override a View's onTouch method to allow both swipe events and other detected events (such as clicks or long clicks).

    SwipeDetector

    package self.philbrown;
    
    import android.view.MotionEvent;
    import android.view.View;
    import android.view.ViewConfiguration;
    
    /**
     * Detect Swipes on a per-view basis. Based on original code by Thomas Fankhauser on StackOverflow.com,
     * with adaptations by other authors (see link).
     * @author Phil Brown
     * @see <a href="http://stackoverflow.com/questions/937313/android-basic-gesture-detection">android-basic-gesture-detection</a>
     */
    public class SwipeDetector implements View.OnTouchListener
    {
        /**
         * The minimum distance a finger must travel in order to register a swipe event.
         */
        private int minSwipeDistance;
    
        /** Maintains a reference to the first detected down touch event. */
        private float downX, downY;
    
        /** Maintains a reference to the first detected up touch event. */
        private float upX, upY;
    
        /** provides access to size and dimension contants */
        private ViewConfiguration config;
    
        /**
         * provides callbacks to a listener class for various swipe gestures.
         */
        private SwipeListener listener;
    
        public SwipeDetector(SwipeListener listener)
        {
            this.listener = listener;
        }
    
    
        /**
         * {@inheritDoc}
         */
        public boolean onTouch(View v, MotionEvent event)
        {
            if (config == null)
            {
                    config = ViewConfiguration.get(v.getContext());
                    minSwipeDistance = config.getScaledTouchSlop();
            }
    
            switch(event.getAction())
            {
            case MotionEvent.ACTION_DOWN:
                downX = event.getX();
                downY = event.getY();
                return true;
            case MotionEvent.ACTION_UP:
                upX = event.getX();
                upY = event.getY();
    
                float deltaX = downX - upX;
                float deltaY = downY - upY;
    
                // swipe horizontal?
                if(Math.abs(deltaX) > minSwipeDistance)
                {
                    // left or right
                    if (deltaX < 0)
                    {
                            if (listener != null)
                            {
                                    listener.onRightSwipe(v);
                                    return true;
                            }
                    }
                    if (deltaX > 0)
                    {
                            if (listener != null)
                            {
                                    listener.onLeftSwipe(v);
                                    return true;
                            }
                    }
                }
    
                // swipe vertical?
                if(Math.abs(deltaY) > minSwipeDistance)
                {
                    // top or down
                    if (deltaY < 0)
                    {
                            if (listener != null)
                            {
                                    listener.onDownSwipe(v);
                                    return true;
                            }
                    }
                    if (deltaY > 0)
                    {
                            if (listener != null)
                            {
                                    listener.onUpSwipe(v);
                                    return true;
                            }
                    }
                }
            }
            return false;
        }
    
        /**
         * Provides callbacks to a registered listener for swipe events in {@link SwipeDetector}
         * @author Phil Brown
         */
        public interface SwipeListener
        {
            /** Callback for registering a new swipe motion from the bottom of the view toward its top. */
            public void onUpSwipe(View v);
            /** Callback for registering a new swipe motion from the left of the view toward its right. */
            public void onRightSwipe(View v);
            /** Callback for registering a new swipe motion from the right of the view toward its left. */
            public void onLeftSwipe(View v);
            /** Callback for registering a new swipe motion from the top of the view toward its bottom. */
            public void onDownSwipe(View v);
        }
    }
    

    Swipe Interceptor View

    package self.philbrown;
    
    import android.content.Context;
    import android.util.AttributeSet;
    import android.view.MotionEvent;
    import android.widget.RelativeLayout;
    
    import com.npeinc.module_NPECore.model.SwipeDetector;
    import com.npeinc.module_NPECore.model.SwipeDetector.SwipeListener;
    
    /**
     * View subclass used for handling all touches (swipes and others)
     * @author Phil Brown
     */
    public class SwipeInterceptorView extends RelativeLayout
    {
        private SwipeDetector swiper = null;
    
        public void setSwipeListener(SwipeListener listener)
        {
            if (swiper == null)
                swiper = new SwipeDetector(listener);
        }
    
        public SwipeInterceptorView(Context context) {
            super(context);
        }
    
        public SwipeInterceptorView(Context context, AttributeSet attrs) {
            super(context, attrs);
        }
    
        public SwipeInterceptorView(Context context, AttributeSet attrs, int defStyle) {
            super(context, attrs, defStyle);
        }
    
        @Override
        public boolean onTouchEvent(MotionEvent e)
        {
            boolean swipe = false, touch = false;
            if (swiper != null)
                swipe = swiper.onTouch(this, e);
            touch = super.onTouchEvent(e);
            return swipe || touch;
        }
    }
    
    点赞 10 评论 复制链接分享
  • csdnceshi75 衫裤跑路 9年前

    There's some proposition over the web (and this page) to use ViewConfiguration.getScaledTouchSlop() to have a device-scaled value for SWIPE_MIN_DISTANCE.

    getScaledTouchSlop() is intended for the "scrolling threshold" distance, not swipe. The scrolling threshold distance has to be smaller than a "swing between page" threshold distance. For example, this function returns 12 pixels on my Samsung GS2, and the examples quoted in this page are around 100 pixels.

    With API Level 8 (Android 2.2, Froyo), you've got getScaledPagingTouchSlop(), intended for page swipe. On my device, it returns 24 (pixels). So if you're on API Level < 8, I think "2 * getScaledTouchSlop()" should be the "standard" swipe threshold. But users of my application with small screens told me that it was too few... As on my application, you can scroll vertically, and change page horizontally. With the proposed value, they sometimes change page instead of scrolling.

    点赞 1 评论 复制链接分享
  • csdnceshi59 ℙℕℤℝ 7年前

    This is a combined answer of the two answers at top, if anyone wants a working implementation.

    package com.yourapplication;
    
    import android.content.Context;
    import android.view.GestureDetector;
    import android.view.MotionEvent;
    import android.view.View;
    import android.view.ViewConfiguration;
    
    public abstract class OnSwipeListener implements View.OnTouchListener {
    
        private final GestureDetector gestureDetector;
    
        public OnSwipeListener(Context context){
            gestureDetector = new GestureDetector(context, new OnSwipeGestureListener(context));
            gestureDetector.setIsLongpressEnabled(false);
        }
    
        @Override
        public boolean onTouch(View view, MotionEvent event) {
            return gestureDetector.onTouchEvent(event);
        }
    
        private final class OnSwipeGestureListener extends GestureDetector.SimpleOnGestureListener {
    
            private final int minSwipeDelta;
            private final int minSwipeVelocity;
            private final int maxSwipeVelocity;
    
            private OnSwipeGestureListener(Context context) {
                ViewConfiguration configuration = ViewConfiguration.get(context);
                // We think a swipe scrolls a full page.
                //minSwipeDelta = configuration.getScaledTouchSlop();
                minSwipeDelta = configuration.getScaledPagingTouchSlop();
                minSwipeVelocity = configuration.getScaledMinimumFlingVelocity();
                maxSwipeVelocity = configuration.getScaledMaximumFlingVelocity();
            }
    
            @Override
            public boolean onDown(MotionEvent event) {
                // Return true because we want system to report subsequent events to us.
                return true;
            }
    
            // NOTE: see http://stackoverflow.com/questions/937313/android-basic-gesture-detection
            @Override
            public boolean onFling(MotionEvent event1, MotionEvent event2, float velocityX,
                                   float velocityY) {
    
                boolean result = false;
                try {
                    float deltaX = event2.getX() - event1.getX();
                    float deltaY = event2.getY() - event1.getY();
                    float absVelocityX = Math.abs(velocityX);
                    float absVelocityY = Math.abs(velocityY);
                    float absDeltaX = Math.abs(deltaX);
                    float absDeltaY = Math.abs(deltaY);
                    if (absDeltaX > absDeltaY) {
                        if (absDeltaX > minSwipeDelta && absVelocityX > minSwipeVelocity
                                && absVelocityX < maxSwipeVelocity) {
                            if (deltaX < 0) {
                                onSwipeLeft();
                            } else {
                                onSwipeRight();
                            }
                        }
                        result = true;
                    } else if (absDeltaY > minSwipeDelta && absVelocityY > minSwipeVelocity
                            && absVelocityY < maxSwipeVelocity) {
                        if (deltaY < 0) {
                            onSwipeTop();
                        } else {
                            onSwipeBottom();
                        }
                    }
                    result = true;
                } catch (Exception e) {
                    e.printStackTrace();
                }
                return result;
            }
        }
    
        public void onSwipeLeft() {}
    
        public void onSwipeRight() {}
    
        public void onSwipeTop() {}
    
        public void onSwipeBottom() {}
    }
    
    点赞 1 评论 复制链接分享
  • csdnceshi68 local-host 10年前

    There is a lot of excellent information here. Unfortunately a lot of this fling-processing code is scattered around on various sites in various states of completion, even though one would think this is essential to many applications.

    I've taken the time to create a fling listener that verifies that the appropriate conditions are met. I've added a page fling listener that adds more checks to ensure that flings meet the threshold for page flings. Both of these listeners allow you to easily restrict flings to the horizontal or vertical axis. You can see how it's used in a view for sliding images. I acknowledge that the people here have done most of the research---I've just put it together into a usable library.

    These last few days represent my first stab at coding on Android; expect much more to come.

    点赞 4 评论 复制链接分享
  • csdnceshi80 胖鸭 10年前

    Also as a minor enhancement.

    The main reason for the try/catch block is that e1 could be null for the initial movement. in addition to the try/catch, include a test for null and return. similar to the following

    if (e1 == null || e2 == null) return false;
    try {
    ...
    } catch (Exception e) {}
    return false;
    
    点赞 2 评论 复制链接分享
  • csdnceshi66 必承其重 | 欲带皇冠 8年前

    There's a built-in interface that you can use directly for all gestures:
    Here is an explanation for a basic level user: enter image description here There is 2 imports be careful in choosing that both are diferent enter image description hereenter image description here

    点赞 6 评论 复制链接分享
  • csdnceshi71 Memor.の 9年前

    This question is kind of old and in July 2011 Google released the Compatibility Package, revision 3) which includes the ViewPager that works with Android 1.6 upwards. The GestureListener answers posted for this question don't feel very elegant on Android. If you're looking for the code used in switching between photos in the Android Gallery or switching views in the new Play Market app then it's definitely ViewPager.

    Here's some links for more info:

    点赞 5 评论 复制链接分享
  • csdnceshi56 lrony* 9年前

    My version of solution proposed by Thomas Fankhauser and Marek Sebera (does not handle vertical swipes):

    SwipeInterface.java

    import android.view.View;
    
    public interface SwipeInterface {
    
        public void onLeftToRight(View v);
    
        public void onRightToLeft(View v);
    }
    

    ActivitySwipeDetector.java

    import android.content.Context;
    import android.util.DisplayMetrics;
    import android.util.Log;
    import android.view.MotionEvent;
    import android.view.View;
    import android.view.ViewConfiguration;
    
    public class ActivitySwipeDetector implements View.OnTouchListener {
    
        static final String logTag = "ActivitySwipeDetector";
        private SwipeInterface activity;
        private float downX, downY;
        private long timeDown;
        private final float MIN_DISTANCE;
        private final int VELOCITY;
        private final float MAX_OFF_PATH;
    
        public ActivitySwipeDetector(Context context, SwipeInterface activity){
            this.activity = activity;
            final ViewConfiguration vc = ViewConfiguration.get(context);
            DisplayMetrics dm = context.getResources().getDisplayMetrics();
            MIN_DISTANCE = vc.getScaledPagingTouchSlop() * dm.density;
            VELOCITY = vc.getScaledMinimumFlingVelocity();
            MAX_OFF_PATH = MIN_DISTANCE * 2;            
        }
    
        public void onRightToLeftSwipe(View v){
            Log.i(logTag, "RightToLeftSwipe!");
            activity.onRightToLeft(v);
        }
    
        public void onLeftToRightSwipe(View v){
            Log.i(logTag, "LeftToRightSwipe!");
            activity.onLeftToRight(v);
        }
    
        public boolean onTouch(View v, MotionEvent event) {
            switch(event.getAction()){
            case MotionEvent.ACTION_DOWN: {
                Log.d("onTouch", "ACTION_DOWN");
                timeDown = System.currentTimeMillis();
                downX = event.getX();
                downY = event.getY();
                return true;
            }
            case MotionEvent.ACTION_UP: {
                Log.d("onTouch", "ACTION_UP");
                long timeUp = System.currentTimeMillis();
                float upX = event.getX();
                float upY = event.getY();
    
                float deltaX = downX - upX;
                float absDeltaX = Math.abs(deltaX); 
                float deltaY = downY - upY;
                float absDeltaY = Math.abs(deltaY);
    
                long time = timeUp - timeDown;
    
                if (absDeltaY > MAX_OFF_PATH) {
                    Log.i(logTag, String.format("absDeltaY=%.2f, MAX_OFF_PATH=%.2f", absDeltaY, MAX_OFF_PATH));
                    return v.performClick();
                }
    
                final long M_SEC = 1000;
                if (absDeltaX > MIN_DISTANCE && absDeltaX > time * VELOCITY / M_SEC) {
                    if(deltaX < 0) { this.onLeftToRightSwipe(v); return true; }
                    if(deltaX > 0) { this.onRightToLeftSwipe(v); return true; }
                } else {
                    Log.i(logTag, String.format("absDeltaX=%.2f, MIN_DISTANCE=%.2f, absDeltaX > MIN_DISTANCE=%b", absDeltaX, MIN_DISTANCE, (absDeltaX > MIN_DISTANCE)));
                    Log.i(logTag, String.format("absDeltaX=%.2f, time=%d, VELOCITY=%d, time*VELOCITY/M_SEC=%d, absDeltaX > time * VELOCITY / M_SEC=%b", absDeltaX, time, VELOCITY, time * VELOCITY / M_SEC, (absDeltaX > time * VELOCITY / M_SEC)));
                }
    
            }
            }
            return false;
        }
    
    }
    
    点赞 6 评论 复制链接分享
  • csdnceshi75 衫裤跑路 10年前

    The swipe gesture detector code above is very useful! You may however wish to make this solution density agnostic by using the following relative values (REL_SWIPE) rather than the absolute values (SWIPE_)

    DisplayMetrics dm = getResources().getDisplayMetrics();
    
    int REL_SWIPE_MIN_DISTANCE = (int)(SWIPE_MIN_DISTANCE * dm.densityDpi / 160.0f);
    int REL_SWIPE_MAX_OFF_PATH = (int)(SWIPE_MAX_OFF_PATH * dm.densityDpi / 160.0f);
    int REL_SWIPE_THRESHOLD_VELOCITY = (int)(SWIPE_THRESHOLD_VELOCITY * dm.densityDpi / 160.0f);
    
    点赞 10 评论 复制链接分享
  • csdnceshi69 YaoRaoLov 9年前

    I slightly modified and repaired solution from Thomas Fankhauser

    Whole system consists from two files, SwipeInterface and ActivitySwipeDetector


    SwipeInterface.java

    import android.view.View;
    
    public interface SwipeInterface {
    
        public void bottom2top(View v);
    
        public void left2right(View v);
    
        public void right2left(View v);
    
        public void top2bottom(View v);
    
    }
    

    Detector

    import android.util.Log;
    import android.view.MotionEvent;
    import android.view.View;
    
    public class ActivitySwipeDetector implements View.OnTouchListener {
    
        static final String logTag = "ActivitySwipeDetector";
        private SwipeInterface activity;
        static final int MIN_DISTANCE = 100;
        private float downX, downY, upX, upY;
    
        public ActivitySwipeDetector(SwipeInterface activity){
            this.activity = activity;
        }
    
        public void onRightToLeftSwipe(View v){
            Log.i(logTag, "RightToLeftSwipe!");
            activity.right2left(v);
        }
    
        public void onLeftToRightSwipe(View v){
            Log.i(logTag, "LeftToRightSwipe!");
            activity.left2right(v);
        }
    
        public void onTopToBottomSwipe(View v){
            Log.i(logTag, "onTopToBottomSwipe!");
            activity.top2bottom(v);
        }
    
        public void onBottomToTopSwipe(View v){
            Log.i(logTag, "onBottomToTopSwipe!");
            activity.bottom2top(v);
        }
    
        public boolean onTouch(View v, MotionEvent event) {
            switch(event.getAction()){
            case MotionEvent.ACTION_DOWN: {
                downX = event.getX();
                downY = event.getY();
                return true;
            }
            case MotionEvent.ACTION_UP: {
                upX = event.getX();
                upY = event.getY();
    
                float deltaX = downX - upX;
                float deltaY = downY - upY;
    
                // swipe horizontal?
                if(Math.abs(deltaX) > MIN_DISTANCE){
                    // left or right
                    if(deltaX < 0) { this.onLeftToRightSwipe(v); return true; }
                    if(deltaX > 0) { this.onRightToLeftSwipe(v); return true; }
                }
                else {
                    Log.i(logTag, "Swipe was only " + Math.abs(deltaX) + " long, need at least " + MIN_DISTANCE);
                }
    
                // swipe vertical?
                if(Math.abs(deltaY) > MIN_DISTANCE){
                    // top or down
                    if(deltaY < 0) { this.onTopToBottomSwipe(v); return true; }
                    if(deltaY > 0) { this.onBottomToTopSwipe(v); return true; }
                }
                else {
                    Log.i(logTag, "Swipe was only " + Math.abs(deltaX) + " long, need at least " + MIN_DISTANCE);
                    v.performClick();
                }
            }
            }
            return false;
        }
    
    }
    

    it is used like this:

    ActivitySwipeDetector swipe = new ActivitySwipeDetector(this);
    LinearLayout swipe_layout = (LinearLayout) findViewById(R.id.swipe_layout);
    swipe_layout.setOnTouchListener(swipe);
    

    And in implementing Activity you need to implement methods from SwipeInterface, and you can find out on which View the Swipe Event was called.

    @Override
    public void left2right(View v) {
        switch(v.getId()){
            case R.id.swipe_layout:
                // do your stuff here
            break;
        }       
    }
    
    点赞 3 评论 复制链接分享
  • weixin_41568127 ?yb? 10年前

    I do it a little different, and wrote an extra detector class that implements the View.onTouchListener

    onCreateis simply add it to the lowest layout like this:

    ActivitySwipeDetector activitySwipeDetector = new ActivitySwipeDetector(this);
    lowestLayout = (RelativeLayout)this.findViewById(R.id.lowestLayout);
    lowestLayout.setOnTouchListener(activitySwipeDetector);
    

    where id.lowestLayout is the id.xxx for the view lowest in the layout hierarchy and lowestLayout is declared as a RelativeLayout

    And then there is the actual activity swipe detector class:

    public class ActivitySwipeDetector implements View.OnTouchListener {
    
    static final String logTag = "ActivitySwipeDetector";
    private Activity activity;
    static final int MIN_DISTANCE = 100;
    private float downX, downY, upX, upY;
    
    public ActivitySwipeDetector(Activity activity){
        this.activity = activity;
    }
    
    public void onRightSwipe(){
        Log.i(logTag, "RightToLeftSwipe!");
        activity.doSomething();
    }
    
    public void onLeftSwipe(){
        Log.i(logTag, "LeftToRightSwipe!");
        activity.doSomething();
    }
    
    public void onDownSwipe(){
        Log.i(logTag, "onTopToBottomSwipe!");
        activity.doSomething();
    }
    
    public void onUpSwipe(){
        Log.i(logTag, "onBottomToTopSwipe!");
        activity.doSomething();
    }
    
    public boolean onTouch(View v, MotionEvent event) {
        switch(event.getAction()){
            case MotionEvent.ACTION_DOWN: {
                downX = event.getX();
                downY = event.getY();
                return true;
            }
            case MotionEvent.ACTION_UP: {
                upX = event.getX();
                upY = event.getY();
    
                float deltaX = downX - upX;
                float deltaY = downY - upY;
    
           // swipe horizontal?
            if(Math.abs(deltaX) > Math.abs(deltaY))
            {
                if(Math.abs(deltaX) > MIN_DISTANCE){
                    // left or right
                    if(deltaX > 0) { this.onRightSwipe(); return true; }
                    if(deltaX < 0) { this.onLeftSwipe(); return true; }
                }
                else {
                        Log.i(logTag, "Horizontal Swipe was only " + Math.abs(deltaX) + " long, need at least " + MIN_DISTANCE);
                        return false; // We don't consume the event
                }
            }
            // swipe vertical?
            else 
            {
                if(Math.abs(deltaY) > MIN_DISTANCE){
                    // top or down
                    if(deltaY < 0) { this.onDownSwipe(); return true; }
                    if(deltaY > 0) { this.onUpSwipe(); return true; }
                }
                else {
                        Log.i(logTag, "Vertical Swipe was only " + Math.abs(deltaX) + " long, need at least " + MIN_DISTANCE);
                        return false; // We don't consume the event
                }
            }
    
                return true;
            }
        }
        return false;
    }
    
    }
    

    Works really good for me!

    点赞 26 评论 复制链接分享
  • csdnceshi55 ~Onlooker 10年前

    One of the answers above mentions handling different pixel density but suggests computing the swipe parameters by hand. It is worth noting that you can actually obtain scaled, reasonable values from the system using ViewConfiguration class:

    final ViewConfiguration vc = ViewConfiguration.get(getContext());
    final int swipeMinDistance = vc.getScaledPagingTouchSlop();
    final int swipeThresholdVelocity = vc.getScaledMinimumFlingVelocity();
    final int swipeMaxOffPath = vc.getScaledTouchSlop();
    // (there is also vc.getScaledMaximumFlingVelocity() one could check against)
    

    I noticed that using these values causes the "feel" of fling to be more consistent between the application and rest of system.

    点赞 22 评论 复制链接分享

为你推荐