I needed to have a simple way to see if a gesture of swipe up, down, right or left had been carried out so I created this little class to help me out. I know that Android has the built in gesture recognition but this just seemed so much easier. You can easily attach a function to be called when a gesture has been detected and the minimum travel distance and diagonal offset can all be configured easily. 

Example code

2. /*
3. Example code to show one way to work with gestures at Android devices.
4. Swipe left, right, up and down to call different functions that changes the background color. 
5. Swipe settings such as how much directional swipe is allowed and minimum swipe length can be set easily in the constructor of the gesture class.
6. 
   
7. Tested on 
8. osx
9. Processing 2.0a4
10. java version "1.6.0_29" 
11. Android SDK tools 16
12. Samsung Galaxy Tab 10.1 Honeycomb 3.1
13. 
    
14. made by
15. david sjunnesson
16. david@tellart.com
17. Tellart.com
18. 2012
19. */
20. 
    
21. Gestures g;      // create a gesture object
22. color backgroundColor;   
23. void setup() {
24.   backgroundColor=color(0);
25.   g=new Gestures(100,50,this);    // iniate the gesture object first value is minimum swipe length in pixel and second is the diagonal offset allowed
26.   g.setSwipeUp("swipeUp");    // attach the function called swipeUp to the gesture of swiping upwards
27.   g.setSwipeDown("swipeDown");    // attach the function called swipeDown to the gesture of swiping downwards
28.   g.setSwipeLeft("swipeLeft");  // attach the function called swipeLeft to the gesture of swiping left
29.   g.setSwipeRight("swipeRight");  // attach the function called swipeRight to the gesture of swiping right
30. }
31. 
    
32. void draw() {
33.   background(backgroundColor);    // draw the background with the color, this changes accordingly to what swipe is being carried out
34. }
35. 
    
36. // android touch event. 
37. public boolean surfaceTouchEvent(MotionEvent event) {
38.  // check what that was  triggered  
39.   switch(event.getAction()) {
40.   case MotionEvent.ACTION_DOWN:    // ACTION_DOWN means we put our finger down on the screen 
41.     g.setStartPos(new PVector(event.getX(), event.getY()));    // set our start position
42.     break;
43.   case MotionEvent.ACTION_UP:    // ACTION_UP means we pulled our finger away from the screen  
44.     g.setEndPos(new PVector(event.getX(), event.getY()));    // set our end position of the gesture and calculate if it was a valid one
45.     break;
46.   }
47.   return super.surfaceTouchEvent(event);
48. }
49. 
    
50. // function that is called when we are swiping upwards
51. void swipeUp() {
52.   println("a swipe up");    
53.   backgroundColor=color(100);
54. }
55. void swipeDown() {
56.   println("a swipe down");
57.   backgroundColor=color(150);
58. }
59. void swipeLeft() {
60.   println("a swipe left");
61.   backgroundColor=color(200);
62. }
63. void swipeRight() {
64.   println("a swipe right");
65.   backgroundColor=color(250);
66. }

 

Gesture class

2. import java.lang.reflect.Method;
3. class Gestures {
4.   int  maxOffset, minLength;
5.   String functionName;
6.   PVector startPos, endPos;
7.   PApplet pApp;
8.   Method[] m;
9.   Gestures(int minimum,int offSet,PApplet theApplet) {
10.     m=new Method[4];
11.     pApp = theApplet;
12.     maxOffset=offSet;    //number pixels you are allowed to travel off the axis and still being counted as a swipe
13.     minLength=minimum;    // number of pixels you need to move your finger to count as a swipe
14.   }
15.   // where did our motion start
16.   void setStartPos(PVector pos) {
17.     startPos=pos;
18.   }
19.   // where did it end and also call to check if it was a valid swipe
20.   void setEndPos(PVector pos) {
21.     endPos=pos;
22.     checkSwipe();
23.     endPos=new PVector();
24.     startPos=new PVector();
25.   }
26.   // check if it is a valid swipe that has been performed and if so perform the attached function
27.   void checkSwipe() {
28.     if (abs(startPos.x-endPos.x)>minLength&&abs(startPos.y-endPos.y)<maxOffset) {
29.       if (startPos.x<endPos.x) {
30.         performAction(2);    // a swipe right
31.       }
32.       else {
33.         performAction(0);    // a swipe left
34.       }
35.     }
36.     else {
37.       if (abs(startPos.y-endPos.y)>minLength&&abs(startPos.x-endPos.x)<maxOffset) {
38.         if (startPos.y<endPos.y) {
39.           performAction(3);  // a swipe downwards
40.         }
41.         else {
42.           performAction(1);  // a swipe upwards
43.         }
44.       }
45.     }
46.   }
47.   // call the function that we have defined with setAction
48.   void performAction(int direction) {
49.     if (m[direction] == null)
50.       return;
51.     try {
52.       m[direction].invoke(pApp);
53.     } 
54.     catch (Exception e) {
55.       e.printStackTrace();
56.     }
57.   }
58.   // define a function that should get called when the different swipes is done
59.   void setAction(int direction, String method) {
60.     if (method != null && !method.equals("")) {
61.       try {
62.         m[direction] = pApp.getClass().getMethod(method);
63.       } 
64.       catch (SecurityException e) {
65.         e.printStackTrace();
66.       } 
67.       catch (NoSuchMethodException e) {
68.         e.printStackTrace();
69.       }
70.     }
71.   }
72.   // attach a function to a left swipe
73.   void setSwipeLeft(String _funcName) {
74.     setAction(0, _funcName);
75.   }
76.   void setSwipeUp(String _funcName) {
77.     setAction(1, _funcName);
78.   }
79.   void setSwipeRight(String _funcName) {
80.     setAction(2, _funcName);
81.   }
82.   void setSwipeDown(String _funcName) {
83.     setAction(3, _funcName);
84.   }
85. }