android的触摸事件

由于触摸（Touch）而触发的事件

Android的事件：onClick, onScroll, onFling等等，都是由许多个Touch组成的。其中Touch的第一个状态肯定是ACTION_DOWN, 表示按下了屏幕。之后，touch将会有后续事件，可能是：

• ACTION_MOVE //表示为移动手势

• ACTION_UP //表示为离开屏幕

• ACTION_CANCEL //表示取消手势，不会由用户产生，而是由程序产生的

一个Action_DOWN, n个ACTION_MOVE, 1个ACTION_UP，就构成了Android中众多的事件。

对于ViewGroup类的控件，有一个很重要的方法，就是onInterceptTouchEvent()，用于处理事件并改变事件的传递方向，它的返回值是一个布尔值，决定了Touch事件是否要向它包含的子View继续传递，这个方法是从父View向子View传递。

而方法onTouchEvent()，用于接收事件并处理，它的返回值也是一个布尔值，决定了事件及后续事件是否继续向上传递，这个方法是从子View向父View传递。

touch事件在 onInterceptTouchEvent()和onTouchEvent以及各个childView间的传递机制完全取决于onInterceptTouchEvent()和onTouchEvent()的返回值。返回值为true表示事件被正确接收和处理了，返回值为false表示事件没有被处理，将继续传递下去。

ACTION_DOWN事件会传到某个ViewGroup类的onInterceptTouchEvent，如果返回false，则DOWN事件继续向子ViewGroup类的onInterceptTouchEvent传递，如果子View不是ViewGroup类的控件，则传递给它的onTouchEvent。

如果onInterceptTouchEvent返回了true,则DOWN事件传递给它的onTouchEvent，不再继续传递，并且之后的后续事件也都传递给它的onTouchEvent。

如果某View的onTouchEvent返回了false，则DOWN事件继续向其父ViewGroup类的onTouchEvent传递；如果返回了true，则后续事件会直接传递给其onTouchEvent继续处理。（后续事件只会传递给对于必要事件ACTION_DOWN返回了true的onTouchEvent）

总结一下就是：onInterceptTouchEvent可以接受到所有的Touch事件，而onTouchEvent则不一定。

对于android 自定义控件的事件 android 提供了一个GestureDetector的类和GestureDetector.OnGestureListener的接口来判断用户在界面上做出怎么样的动作。

Android里有两个类
　　android.view.GestureDetector
　　android.view.GestureDetector.SimpleOnGestureListener
　　（另外android.widget.Gallery好像是更牛x的OnGestureListener ）
　　1）
　　新建一个类继承SimpleOnGestureListener，HahaGestureDetectorListener
　　可以实现以下event事件。
　　boolean onDoubleTap(MotionEvent e)
　　解释：双击的第二下Touch down时触发
　　boolean onDoubleTapEvent(MotionEvent e)
　　解释：双击的第二下Touch down和up都会触发，可用e.getAction()区分。
　　boolean onDown(MotionEvent e)
　　解释：Touch down时触发
　　boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY)
　　解释：Touch了滑动一点距离后，up时触发。
　　void onLongPress(MotionEvent e)
　　解释：Touch了不移动一直Touch down时触发
　　boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY)
　　解释：Touch了滑动时触发。
　　void onShowPress(MotionEvent e)
　　解释：Touch了还没有滑动时触发
　　（与onDown，onLongPress比较
　　onDown只要Touch down一定立刻触发。
　　而Touchdown后过一会没有滑动先触发onShowPress再是onLongPress。
　　所以Touchdown后一直不滑动，onDown->onShowPress->onLongPress这个顺序触发。
　　）
　　boolean onSingleTapConfirmed(MotionEvent e)
　　boolean onSingleTapUp(MotionEvent e)
　　解释：上面这两个函数都是在touch down后又没有滑动（onScroll），又没有长按（onLongPress），然后Touchup时触发。
　　点击一下非常快的（不滑动）Touchup：
　　onDown->onSingleTapUp->onSingleTapConfirmed
　　点击一下稍微慢点的（不滑动）Touchup：
　　onDown->onShowPress->onSingleTapUp->onSingleTapConfirmed

public class GestureActivity extends Activity implements OnTouchListener,
        OnGestureListener {

    GestureDetector detector;

    public GestureActivity() {
        detector = new GestureDetector(this);
    }
   
    public void onCreate(Bundle savedInstanceState) { 
            super.onCreate(savedInstanceState); 
            setContentView(R.layout.main); 
            TextView tv = (TextView) findViewById(R.id.TextView001);
            //设置tv的监听器  
            tv.setOnTouchListener(this); 
            tv.setFocusable(true);
            //必须，view才能够处理不同于Tap（轻触）的hold
            tv.setClickable(true); 
            tv.setLongClickable(true); 
            detector.setIsLongpressEnabled(true); 
    } 
   
   
      
    public boolean onTouch(View v, MotionEvent event) { 
        return detector.onTouchEvent(event); 
    } 
 
    // 用户轻触触摸屏，由1个MotionEvent ACTION_DOWN触发  
    public boolean onDown(MotionEvent arg0) { 
        Log.i("MyGesture", "onDown"); 
        Toast.makeText(this, "onDown", Toast.LENGTH_SHORT).show(); 
        return true; 
    } 
     
     
    public void onShowPress(MotionEvent e) { 
        Log.i("MyGesture", "onShowPress"); 
        Toast.makeText(this, "onShowPress", Toast.LENGTH_SHORT).show(); 
    } 
     
    // 用户（轻触触摸屏后）松开，由一个1个MotionEvent ACTION_UP触发  
    public boolean onSingleTapUp(MotionEvent e) { 
        Log.i("MyGesture", "onSingleTapUp"); 
        Toast.makeText(this, "onSingleTapUp", Toast.LENGTH_SHORT).show(); 
        return true; 
    } 
     
    // 用户按下触摸屏、快速移动后松开，由1个MotionEvent ACTION_DOWN, 多个ACTION_MOVE, 1个ACTION_UP触发  
    public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) { 
        Log.i("MyGesture", "onFling"); 
       
        // 参数解释： 
        // e1：第1个ACTION_DOWN MotionEvent 
        // e2：最后一个ACTION_MOVE MotionEvent 
        // velocityX：X轴上的移动速度，像素/秒 
        // velocityY：Y轴上的移动速度，像素/秒 
     
        // 触发条件 ： 
        // X轴的坐标位移大于FLING_MIN_DISTANCE，且移动速度大于FLING_MIN_VELOCITY个像素/秒  
         
        final int FLING_MIN_DISTANCE = 100, FLING_MIN_VELOCITY = 200; 
        if (e1.getX() - e2.getX() > FLING_MIN_DISTANCE && Math.abs(velocityX) >FLING_MIN_VELOCITY) { 
            // Fling left  
            Log.i("MyGesture", "Fling left"); 
            Toast.makeText(this, "Fling Left", Toast.LENGTH_SHORT).show(); 
        } else if (e2.getX() - e1.getX() > FLING_MIN_DISTANCE && Math.abs(velocityX) >FLING_MIN_VELOCITY) { 
            // Fling right  
            Log.i("MyGesture", "Fling right"); 
            Toast.makeText(this, "Fling Right", Toast.LENGTH_SHORT).show(); 
        } else if(e2.getY()-e1.getY()>FLING_MIN_DISTANCE &&Math.abs(velocityY)>FLING_MIN_VELOCITY) {
            // Fling down  
            Log.i("MyGesture", "Fling down"); 
            Toast.makeText(this, "Fling down", Toast.LENGTH_SHORT).show();
        } else if(e1.getY()-e2.getY()>FLING_MIN_DISTANCE &&Math.abs(velocityY)>FLING_MIN_VELOCITY) {
            // Fling up  
            Log.i("MyGesture", "Fling up"); 
            Toast.makeText(this, "Fling up", Toast.LENGTH_SHORT).show();
        } 
       
       
        return false;
        
    } 
     
    // 用户按下触摸屏，并拖动，由1个MotionEvent ACTION_DOWN, 多个ACTION_MOVE触发  
    public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) { 
        Log.i("MyGesture", "onScroll"); 
        Toast.makeText(this, "onScroll", Toast.LENGTH_LONG).show(); 
        return true; 
    } 
     
    // 用户长按触摸屏，由多个MotionEvent ACTION_DOWN触发  
    public void onLongPress(MotionEvent e) { 
        Log.i("MyGesture", "onLongPress"); 
        Toast.makeText(this, "onLongPress", Toast.LENGTH_LONG).show(); 
    } 
   

}
　　2）在view的新建一个GestureDetector的对象。
　　构造函数里
　　gestureDetector = new GestureDetector(new HahaGestureDetectorListener());
　　然后在View的onTouchEvent里以下这样用，就可以在刚才1）弄的事件里写自己的代码了。
　　@Override
　　public boolean onTouchEvent(MotionEvent event) {
　　gestureDetector.onTouchEvent(event);
　　}
　　01.mTouchListener = new OnTouchListener() {
　　02. @Override
　　03. public boolean onTouch(View v, MotionEvent event) {
　　04. // TODO Auto-generated method stub
　　05. float x = event.getXPrecision()*event.getX()+event.getX();
　　06. float y = event.getYPrecision()*event.getY()+event.getY();
　　07. switch (event.getAction()) {
　　08. case MotionEvent.ACTION_DOWN:
　　09.
　　10. break;
　　11. case MotionEvent.ACTION_MOVE:
　　12. mTouchTimes++;
　　13. if (mTouchTimes > TOUCH_TIMES) {
　　14.// 根据方向计算角度
　　15. if (mCurrentOrientation==DeviceOrientation.Landscape) {
　　16. mAngle = Math.toDegrees(Math.atan2(y - 480 / 2, x))+90;
　　17. } else {
　　18. mAngle = -Math.toDegrees(Math.atan2(y - 480 / 2, 320-x))+90;
　　19. }
　　20.
　　21. Log.w("angle", "mangle:"+mAngle);
　　22. }
　　23. break;
　　24. case MotionEvent.ACTION_UP:
　　25. if (mTouchTimes > TOUCH_TIMES) {
　　26.
　　27. } else {
　　28.
　　29. }
　　30. mTouchTimes = 0;
　　31. break;
　　32. default:
　　33. break;
　　34. }
　　35. return true;
　　36. }
　　37. };
　　38.mView.setOnTouchListener(mTouchListener);
 

MotionEvent：（多点触摸）

int pointerCount = mMotionEvent.getPointerCount(); //获得多少点
switch (action) {
case MotionEvent.ACTION_DOWN: //判断是什么事件
mStartX1 = mMotionEvent.g……

 、、、、、、、、、、、、、、、、、、、、、、、、、、

1. void printSamples(MotionEvent ev) {  
2. final int historySize = ev.getHistorySize();
   　// 获取历史采样的集合大小  
3. final int pointerCount = ev.getPointerCount();
   　// 获取事件点数  
4. for (int h = 0; h < historySize; h++) {　// 对历史采样进行记录  
5. // 历史采样的时间点  
6. System.out.printf("At time %d:", ev.
   getHistoricalEventTime(h));  
7. for (int p = 0; p < pointerCount; p++) {　//   
8. System.out.printf("　pointer %d: (%f,%f)",  
9. ev.getPointerId(p), ev.
   getHistoricalX(p, h), ev.getHistoricalY(p, h));
   　// 打印每个点的坐标  
10. }  
11. }  
12. // 处理当前的点，输出时间以及每个点的坐标  
13. System.out.printf("At time %d:", ev.getEventTime());  
14. for (int p = 0; p < pointerCount; p++) {  
15. System.out.printf("　pointer %d: (%f,%f)",  
16. ev.getPointerId(p), ev.getX(p), ev.getY(p));  
17. }  
18.  }  

TouchEvent：

 

1. public boolean onTouchEvent(MotionEvent event) {  
2.   
3. //获得触摸的坐标  
4. float x = event.getX();  
5. float y = event.getY(); switch (event.getAction())   
6. {  
7. //触摸屏幕时刻  
8. case MotionEvent.ACTION_DOWN:  
9.   
10. break;  
11. //触摸并移动时刻  
12. case MotionEvent.ACTION_MOVE:  
13.   
14. break;  
15. //终止触摸时刻  
16. case MotionEvent.ACTION_UP:  
17. break;  
18. }  
19. return true;  
20. }  

关于public boolean onTouchEvent (MotionEvent event)方法：

参数event：参数event为手机屏幕触摸事件封装类的对象，其中封装了该事件的所有信息，例如触摸的位置、触摸的类型以及触摸的时间等。该对象会在用户触摸手机屏幕时被创建。

返回值：该方法的返回值机理与键盘响应事件的相同，同样是当已经完整地处理了该事件且不希望其他回调方法再次处理时返回true，否则返回false。

该方法并不像之前介绍过的方法只处理一种事件，一般情况下以下三种情况的事件全部由onTouchEvent方法处理，只是三种情况中的动作值不同。

屏幕被按下：当屏幕被按下时，会自动调用该方法来处理事件，此时MotionEvent.getAction()的值为MotionEvent.ACTION_DOWN，如果在应用程序中需要处理屏幕被按下的事件，只需重新该回调方法，然后在方法中进行动作的判断即可。

屏幕被抬起：当触控笔离开屏幕时触发的事件，该事件同样需要onTouchEvent方法来捕捉，然后在方法中进行动作判断。当MotionEvent.getAction()的值为MotionEvent.ACTION_UP时，表示是屏幕被抬起的事件。

在屏幕中拖动：该方法还负责处理触控笔在屏幕上滑动的事件，同样是调用MotionEvent.getAction()方法来判断动作值是否为MotionEvent.ACTION_MOVE再进行处理。

 android的拖放事件：

http://blog.csdn.net/fireofstar/article/details/7406656