android - ग्रिड लेआउट पर इशारा पता लगाना




listener gesture-recognition (12)

ViewConfiguration का उपयोग करने के लिए वेब (और इस पृष्ठ) पर कुछ प्रस्ताव है। SWSE_MIN_DISTANCE के लिए डिवाइस-स्केल्ड मान प्राप्त करने के लिए getScaledTouchSlop () SWIPE_MIN_DISTANCE

getScaledTouchSlop() " स्क्रॉलिंग थ्रेसहोल्ड" दूरी के लिए है, स्वाइप नहीं है। स्क्रॉलिंग थ्रेसहोल्ड दूरी को "पृष्ठ के बीच स्विंग" थ्रेसहोल्ड दूरी से छोटा होना चाहिए। उदाहरण के लिए, यह फ़ंक्शन मेरे सैमसंग जीएस 2 पर 12 पिक्सेल लौटाता है, और इस पृष्ठ में उद्धृत उदाहरण लगभग 100 पिक्सेल हैं।

एपीआई लेवल 8 (एंड्रॉइड 2.2, getScaledPagingTouchSlop() ) के साथ, आपको पेज स्वाइप के लिए इच्छित getScaledPagingTouchSlop() मिल गया है। मेरे डिवाइस पर, यह 24 (पिक्सल) देता है। तो यदि आप एपीआई लेवल <8 पर हैं, तो मुझे लगता है कि "2 * getScaledTouchSlop() " "मानक" स्वाइप थ्रेसहोल्ड होना चाहिए। लेकिन छोटी स्क्रीन के साथ मेरे आवेदन के उपयोगकर्ताओं ने मुझे बताया कि यह बहुत कम था ... मेरे आवेदन के अनुसार, आप लंबवत स्क्रॉल कर सकते हैं, और क्षैतिज पृष्ठ बदल सकते हैं। प्रस्तावित मूल्य के साथ, वे कभी-कभी स्क्रॉलिंग के बजाय पृष्ठ बदलते हैं।

मैं अपने एंड्रॉइड एप्लिकेशन में काम कर रहे fling इशारा करना चाहता हूं।

मेरे पास एक GridLayout है जिसमें 9 ImageView । स्रोत यहां पाया जा सकता है: रोमैन दोस्तों का ग्रिड लेआउट

मैं जो फ़ाइल लेता हूं वह रोमैन गाय के फोटोस्ट्रीम एप्लिकेशन से है और इसे केवल थोड़ा अनुकूलित किया गया है।

सरल क्लिक स्थिति के लिए मुझे केवल प्रत्येक ImageView View.OnClickListener सेट करना होगा, जिसे मैं मुख्य activity View.OnClickListener जो View.OnClickListener लागू View.OnClickListener । यह किसी चीज को लागू करने के लिए असीम रूप से अधिक जटिल लगता है जो fling पहचानता है। मुझे लगता है कि ऐसा इसलिए है क्योंकि यह views विस्तार कर सकता है?

  • अगर मेरी गतिविधि OnGestureListener लागू OnGestureListener मुझे नहीं पता कि Grid या Image दृश्यों के लिए इशारा श्रोता के रूप में इसे कैसे सेट किया जाए।

    public class SelectFilterActivity extends Activity implements
       View.OnClickListener, OnGestureListener { ...
    
  • अगर मेरी गतिविधि OnTouchListener लागू OnTouchListener तो मेरे पास override करने के लिए कोई onFling विधि नहीं है (इसमें दो घटनाएं हैं जो पैरामीटर के रूप में मुझे यह निर्धारित करने की अनुमति देती हैं कि onFling उल्लेखनीय है या नहीं)।

    public class SelectFilterActivity extends Activity implements
        View.OnClickListener, OnTouchListener { ...
    
  • यदि मैं कस्टम View करता GestureImageView , जैसे GestureImageView जो GestureImageView को बढ़ाता है, मुझे नहीं पता कि गतिविधि से GestureImageView कितनी गतिविधि हुई है। किसी भी मामले में, मैंने कोशिश की और जब मैंने स्क्रीन को छुआ तो विधियों को नहीं बुलाया गया था।

मुझे वास्तव में विचारों के इस काम के एक ठोस उदाहरण की आवश्यकता है। मुझे इस listener को कब और कब संलग्न करना चाहिए? मुझे सिंगल क्लिक का पता लगाने में भी सक्षम होना चाहिए।

// 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;
        }
    }
});

क्या फ़्लिंग्स को कैप्चर करने के लिए मेरी स्क्रीन के शीर्ष पर एक पारदर्शी दृश्य रखना संभव है?

अगर मैं एक्सएमएल से अपने बच्चे के छवि दृश्यों को GestureDetector सकता हूं, तो क्या मैं इमेज व्यू के एक नए उप-वर्ग में एक निर्माता पैरामीटर के रूप में GestureDetector को पास कर सकता हूं?

यह एक बहुत ही सरल गतिविधि है जिसके लिए मैं काम करने के लिए फ़्लिंग पहचान प्राप्त करने की कोशिश कर रहा हूं: SelectFilterActivity (फोटोस्ट्रीम से अनुकूलित)

मैं इन स्रोतों को देख रहा हूं:

अब तक मेरे लिए कुछ भी काम नहीं किया है और मैं कुछ पॉइंटर्स की उम्मीद कर रहा था।


आप flings, क्लिक, लंबे क्लिक, और कस्टम घटनाओं को संभालने के लिए droidQuery लाइब्रेरी का उपयोग कर सकते हैं। कार्यान्वयन नीचे मेरे पिछले उत्तर पर बनाया गया है, लेकिन droidQuery एक चिकना, सरल वाक्यविन्यास प्रदान करता है:

//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];
        }
    }
});

मूल उत्तर

यह उत्तर यहां अन्य उत्तरों से घटकों के संयोजन का उपयोग करता है। इसमें SwipeDetector वर्ग होता है, जिसमें घटनाओं को सुनने के लिए आंतरिक इंटरफ़ेस होता है। मैं यह दिखाने के लिए एक RelativeLayout onTouch भी प्रदान करता हूं कि कैसे एक View की onTouch विधि को ओवरराइड करना है ताकि दोनों स्वाइप घटनाओं और अन्य पता चलने वाली घटनाओं (जैसे कि क्लिक या लंबे क्लिक) को अनुमति दें।

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 .com,
 * with adaptations by other authors (see link).
 * @author Phil Brown
 * @see <a href="http://.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);
    }
}

स्वाइप इंटरसेप्टर व्यू

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;
    }
}

ऊपर स्वाइप इशारा डिटेक्टर कोड बहुत उपयोगी है! हालांकि आप पूर्ण समाधान (REL_SWIPE) बजाय निम्नलिखित सापेक्ष मान (REL_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);

एक अंतर्निहित इंटरफ़ेस है जिसे आप सीधे सभी संकेतों के लिए उपयोग कर सकते हैं:
बुनियादी स्तर के उपयोगकर्ता के लिए यहां एक स्पष्टीकरण दिया गया है: चुनने में 2 आयात सावधान रहें कि दोनों अलग-अलग हैं


मैं थॉमस फंकहौसर से थोड़ा संशोधित और मरम्मत का समाधान करता हूं

पूरी प्रणाली में दो फाइलें हैं, स्वाइपइंटरफेस और गतिविधिस्वाइप डिटेक्टर

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);

}

डिटेक्टर

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;
    }

}

इसका उपयोग इस तरह किया जाता है:

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

और Activity को लागू करने में आपको स्वाइपइंटरफेस से विधियों को लागू करने की आवश्यकता है, और आप यह पता लगा सकते हैं कि स्वाइप इवेंट को किस प्रकार देखा गया था।

@Override
public void left2right(View v) {
    switch(v.getId()){
        case R.id.swipe_layout:
            // do your stuff here
        break;
    }       
}

मैं इसे थोड़ा अलग करता हूं, और एक अतिरिक्त डिटेक्टर वर्ग लिखा जो View.onTouchListener लागू करता है

onCreate बस इसे निम्नतम लेआउट में जोड़ता है:

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

जहां id.lowestLayout id.xxx है, लेआउट पदानुक्रम में निम्नतम दृश्य के लिए और सबसे कम लेआउट को रिलेटिवलायआउट के रूप में घोषित किया गया है

और फिर वास्तविक गतिविधि स्वाइप डिटेक्टर वर्ग है:

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;
}

}

मेरे लिए वास्तव में अच्छा काम करता है!


यह प्रश्न पुराना है और जुलाई 2011 में Google ने संगतता पैकेज, संशोधन 3 जारी किया ) जिसमें ViewPager शामिल है जो एंड्रॉइड 1.6 के साथ काम करता है। इस प्रश्न के लिए पोस्ट किए गए GestureListener उत्तर एंड्रॉइड पर बहुत ही सुंदर महसूस नहीं करते हैं। यदि आप एंड्रॉइड गैलरी में फ़ोटो के बीच स्विच करने या नए Play Market ऐप में दृश्यों को स्विच करने के लिए उपयोग किए जाने वाले कोड की तलाश में हैं तो यह निश्चित रूप से ViewPager

अधिक जानकारी के लिए यहां कुछ लिंक दिए गए हैं:


यहां बहुत सारी उत्कृष्ट जानकारी है। दुर्भाग्यवश इस फ़्लिंग-प्रोसेसिंग कोड में से कई सारे पूर्ण होने के विभिन्न राज्यों में विभिन्न साइटों पर बिखरे हुए हैं, भले ही कोई सोचता है कि यह कई अनुप्रयोगों के लिए आवश्यक है।

मैंने एक फ़्लिंग श्रोता बनाने के लिए समय निकाला है जो सत्यापित करता है कि उपयुक्त स्थितियां पूरी की जाती हैं। मैंने एक पेज फ़्लिंग श्रोता जोड़ा है जो यह सुनिश्चित करने के लिए अधिक चेक जोड़ता है कि फ़्लिंग्स पेज फ़्लिंग्स के लिए थ्रेसहोल्ड को पूरा करते हैं। इन दोनों श्रोताओं ने आपको क्षैतिज या ऊर्ध्वाधर अक्ष पर आसानी से फ़्लिंग को प्रतिबंधित करने की अनुमति दी है। आप छवियों को स्लाइड करने के दृश्य में इसका उपयोग कैसे कर सकते हैं। मैं स्वीकार करता हूं कि यहां लोगों ने अधिकांश शोध किए हैं --- मैंने इसे एक प्रयोग योग्य पुस्तकालय में रखा है।

ये पिछले कुछ दिनों एंड्रॉइड पर कोडिंग पर मेरे पहले स्टैब का प्रतिनिधित्व करते हैं; आने के लिए और अधिक उम्मीद है


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


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");
    }

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;
        }
    });
});

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







gesture-recognition