首页 文章 精选 留言 我的

Android笔记:触摸事件的分析与总结----多点触控

2017-11-07 688

一、多点触控

    当多点同时触摸屏幕时，系统将会产生如下的触摸事件：

    1.ACTION_DOWN：触摸屏幕的第一个点。此时手势开始。该点的数据通常在MotionEvent事件队列索引位置0处。

    2.ACTION_POINTER_DOWN：除了第一个点的其他触摸点数据。该点的数据的索引位置由getActionIndex（）方法返回。

    3.ACTION_MOVE：在手势过程中发生的一次变化。

    4.ACTION_POINTER_UP：当不是第一个点的其他点UP后触发。

    5.ACTION_UP：当手势中的最后一个点离开屏幕。


简单测试范例


布局xml代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<RelativeLayout xmlns:android= "http://schemas.android.com/apk/res/android"
     xmlns:tools= "http://schemas.android.com/tools"
     android:id= "@+id/layout1"
     android:layout_width= "match_parent"
     android:layout_height= "match_parent"
     android:tag= "true布局"
     tools:context= ".MainActivity"  >
 
     <TextView
         android:id= "@+id/message"
         android:layout_width= "wrap_content"
         android:layout_height= "wrap_content"
         android:tag= "true控件"
         android:text= "@string/hello_world"  />
 
</RelativeLayout>


java代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
package  com.lonshine.d_touchduodian;
 
import  android.os.Bundle;
import  android.app.Activity;
import  android.util.Log;
import  android.view.MotionEvent;
import  android.view.View;
import  android.view.View.OnTouchListener;
import  android.widget.RelativeLayout;
 
public  class  MainActivity  extends  Activity  implements  OnTouchListener  
{
     
     @Override
     protected  void  onCreate(Bundle savedInstanceState)
     {
         super .onCreate(savedInstanceState);
         setContentView(R.layout.activity_main);
         
         RelativeLayout layout = (RelativeLayout) findViewById(R.id.layout1);
         layout.setOnTouchListener( this );
         
     }
 
     @Override
     public  boolean  onTouch(View v, MotionEvent event)
     {
         String tag = v.getTag().toString();
         Log.e(tag,  "**********************************************" );
         Log.e(tag,  "**********************************************" );
         Log.e(tag,  "触摸的是:"  + tag);
         Log.e(tag, describeEvent(event));
         logAction(event);
         Log.e(tag,  "**********************************************" );
         Log.e(tag,  "**********************************************" );
         Log.e( "" ,  "                        " );
         Log.e( "" ,  "                        " );
         
         if ( "true" .equals(tag.substring( 0 ,  4 )))
         {
             return  true ;
         }
         else
         {
             return  false ;
         }
     }
 
     
     protected  static  String describeEvent(MotionEvent event)
     {
         StringBuilder sb =  new  StringBuilder( 500 );
         
         sb.append( "Action: " ).append(event.getAction()).append( "\n" ); // 获取触控动作比如ACTION_DOWN
         int  count = event.getPointerCount();
         sb.append( "触点个数: " ).append(count).append( "\n" );
         int  i =  0 ;
         while  (i < count)
         {
             sb.append( "-------------------------" ).append( "\n" );
             int  pointerId = event.getPointerId(i);
             sb.append( "触点序号: " ).append(i).append( "\n" );
             sb.append( "触点ID : " ).append(pointerId).append( "\n" );
             sb.append( "相对坐标: " ).append(event.getX(i)).append( "  *  " ).append(event.getY(i)).append( "\n" );
             sb.append( "压力       : " ).append(event.getPressure(i)).append( "\n" ); // 压力值,0-1之间,看情况,很可能始终返回1
             sb.append( "范围大小: " ).append(event.getSize(i)).append( "\n" ); // 指压范围
             
             i++;
             sb.append( "-------------------------" ).append( "\n" );
         }
         
         
         sb.append( "按下时间: " ).append(event.getDownTime()).append( "ms   " );
         sb.append( "结束时间: " ).append(event.getEventTime()).append( "ms   " );
         sb.append( "运行时间: " ).append(event.getEventTime() - event.getDownTime()).append( "ms\n" );
         
         return  sb.toString();
     }
     
     
     
     private  void  logAction(MotionEvent event)
     {
         int  masked = event.getActionMasked();
         int  index = event.getActionIndex();
         int  pointerId = event.getPointerId(index);
         
         if (masked ==  5  || masked ==  6 )
         {
             masked = masked -  5 ;
         }
         
         Log.e( "Action" ,  "触点序号: "  + index);
         Log.e( "Action" ,  "触点ID ：  "  + pointerId);
         Log.e( "Action" ,  "ActionMasked :"  + masked);
     }
     
     
}


多点触控的日志打印出来太多，此处仅针对日志输出作简单分析：

A.按下第一根手指时，获得一个索引为0且指针ID为0的指针(ACTION_DOWN = 0);

B.接下去action输出为2(ACTION_MOVE)，此时仍然仅有一个指针，并且索引和ID都为0;

C.然后按下第二根手指，action值输出为261。此值由两部分组成：一个是指针索引，一个是指针正在执行何种操作;

D.将十进制261转换为十六进制数为0x00000105。其中01代表指针索引，05代表操作值(即ACTION_POINTER_DOWN的值，用于多点触摸场景);

E.依此类推，当按下第三根手指时action输出值为0x00000205(十进制517)，第四根则为0x000305(十进制773);

F.当第一根手指离开屏幕时，action值为0x00000006(十进制6)，即索引为0，操作值为6(即ACTION_POINTER_UP);

G.如果此时第二根手指离开时,action值应该为0x00000106(十进制262)，因为此时仍然拥有两根手指的信息;

H.而实际结果并没有得到262的action值，这是因为当第一根手指离开屏幕后，第二根手指的索引从1更改成了0，但是指针ID仍然为1.

I.对于每一次移动，action值将始终为2，因为ACTION_MOVE事件并没有包含哪根手指在移动的信息。


附：依次按下四根手指的日志

wKiom1RbP7iwz9OeAAZOMRV8Tik291.jpg





其他小结:

(1)getPointerCount() 获得触屏的点数，

   getActionIndex()获得触点的指针索引，

   getPointerId(index)获得指针索引对应的触点ID；


(2)getActionMasked()表示用于多点触控检测点。而在1.6和2.1中并没有event.getActionMasked()这个方法，其实他就是把event.getAction()& MotionEvent.ACTION_MASK封装了一下。






二、其他参考范例：

(一)单点触摸拖动图片与多点触摸缩放图片

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
package  com.lonshine.touchdemo;
 
 
 
import  android.app.Activity;
import  android.content.Context;
import  android.graphics.*;
import  android.graphics.drawable.BitmapDrawable;
import  android.os.Bundle;
import  android.view.MotionEvent;
import  android.widget.ImageView;
import  android.widget.ImageView.ScaleType;
 
/**
  * 多点触控来控制ImageView中图像的放大与缩小, 单点触控则用来拖动图片
  * 
  * @author zeng
  * 
  */
public  class  MainActivity  extends  Activity
{
     private  MyImageView imageView;
     private  Bitmap bitmap;
     
     // 两点触屏后之间的长度
     private  float  beforeLenght;
     private  float  afterLenght;
     
     // 单点移动的前后坐标值
     private  float  afterX, afterY;
     private  float  beforeX, beforeY;
     
     /** Called when the activity is first created. */
     @Override
     public  void  onCreate(Bundle savedInstanceState)
     {
         super .onCreate(savedInstanceState);
         findView();
         setContentView(imageView);
         config();
     }
     
     private  void  findView()
     {
         imageView =  new  MyImageView( this );
         // 获得图片
         bitmap = ((BitmapDrawable) getResources().getDrawable(R.drawable.xing)).getBitmap();
     }
     
     private  void  config()
     {
         // 设置imageView的显示图片
         imageView.setImageBitmap(bitmap);
         // 设置图片填充ImageView
         imageView.setScaleType(ScaleType.FIT_XY);
     }
     
     // 创建一个自己的ImageView类
     class  MyImageView  extends  ImageView
     {
         
         private  float  scale =  0 .1f;
         
         public  MyImageView(Context context)
         {
             super (context);
         }
         
         // 用来设置ImageView的位置
         private  void  setLocation( int  x,  int  y)
         {
             this .setFrame( this .getLeft() + x,  this .getTop() + y,  this .getRight() + x,  this .getBottom() + y);
         }
         
         /**
          * 用来放大缩小ImageView 因为图片是填充ImageView的，所以也就有放大缩小图片的效果 flag为0是放大图片，为1是缩小图片
          */
         private  void  setScale( float  temp,  int  flag)
         {
             
             if  (flag ==  0 )
             {
                 this .setFrame( this .getLeft() - ( int ) (temp *  this .getWidth()),  this .getTop() - ( int ) (temp *  this .getHeight()),  this .getRight()
                         + ( int ) (temp *  this .getWidth()),  this .getBottom() + ( int ) (temp *  this .getHeight()));
             }
             else
             {
                 this .setFrame( this .getLeft() + ( int ) (temp *  this .getWidth()),  this .getTop() + ( int ) (temp *  this .getHeight()),  this .getRight()
                         - ( int ) (temp *  this .getWidth()),  this .getBottom() - ( int ) (temp *  this .getHeight()));
             }
         }
         
         // 绘制边框
         @Override
         protected  void  onDraw(Canvas canvas)
         {
             super .onDraw(canvas);
             Rect rec = canvas.getClipBounds();
             rec.bottom--;
             rec.right--;
             Paint paint =  new  Paint();
             paint.setColor(Color.RED);
             paint.setStyle(Paint.Style.STROKE);
             canvas.drawRect(rec, paint);
         }
         
         /**
          * 让图片跟随手指触屏的位置移动 beforeX、Y是用来保存前一位置的坐标 afterX、Y是用来保存当前位置的坐标
          * 它们的差值就是ImageView各坐标的增加或减少值
          */
         public  void  moveWithFinger(MotionEvent event)
         {
             
             switch  (event.getAction())
             {
             
                 case  MotionEvent.ACTION_DOWN:
                     beforeX = event.getX();
                     beforeY = event.getY();
                     break ;
                 case  MotionEvent.ACTION_MOVE:
                     afterX = event.getX();
                     afterY = event.getY();
                     
                     this .setLocation(( int ) (afterX - beforeX), ( int ) (afterY - beforeY));
                     
                     beforeX = afterX;
                     beforeY = afterY;
                     break ;
                 
                 case  MotionEvent.ACTION_UP:
                     break ;
             }
         }
         
         /**
          * 通过多点触屏放大或缩小图像 beforeLenght用来保存前一时间两点之间的距离 afterLenght用来保存当前时间两点之间的距离
          */
         public  void  scaleWithFinger(MotionEvent event)
         {
             float  moveX = event.getX( 1 ) - event.getX( 0 );
             float  moveY = event.getY( 1 ) - event.getY( 0 );
             
             switch  (event.getAction())
             {
                 case  MotionEvent.ACTION_DOWN:
                     beforeLenght = ( float ) Math.sqrt((moveX * moveX) + (moveY * moveY));
                     break ;
                 case  MotionEvent.ACTION_MOVE:
                     // 得到两个点之间的长度
                     afterLenght = ( float ) Math.sqrt((moveX * moveX) + (moveY * moveY));
                     
                     float  gapLenght = afterLenght - beforeLenght;
                     
                     if  (gapLenght ==  0 )
                     {
                         break ;
                     }
                     
                     // 如果当前时间两点距离大于前一时间两点距离，则传0，否则传1
                     if  (gapLenght >  0 )
                     {
                         this .setScale(scale,  0 );
                     }
                     else
                     {
                         this .setScale(scale,  1 );
                     }
                     
                     beforeLenght = afterLenght;
                     break ;
             }
         }
         
     }
     
     // 这里来监听屏幕触控时间
     @Override
     public  boolean  onTouchEvent(MotionEvent event)
     {
         
         /**
          * 判定用户是否触摸到了图片 如果是单点触摸则调用控制图片移动的方法 如果是2点触控则调用控制图片大小的方法
          */
         if  (event.getY() > imageView.getTop() && event.getY() < imageView.getBottom() && event.getX() > imageView.getLeft()
                 && event.getX() < imageView.getRight())
         {
             if  (event.getPointerCount() ==  2 )
             {
                 imageView.scaleWithFinger(event);
             }
             else  if  (event.getPointerCount() ==  1 )
             {
                 imageView.moveWithFinger(event);
             }
         }
         return  true ;
     }
     
}


范例参考自：http://blog.csdn.net/ldj299/article/details/6422547




(二)实现多点消息拦截，用于多个物体拖动等效果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
package  com.lonshine.d_touchdemo;
 
import  java.util.ArrayList;
import  java.util.List;
import  android.content.Context;
import  android.os.Handler;
import  android.os.Message;
import  android.view.MotionEvent;
import  android.view.VelocityTracker;
import  android.view.ViewConfiguration;
 
 
/**
  * 实现多点消息拦截，用于多个物体拖动等效果
  * @author zeng
  */
public  class  MultiTouchGestureDetector
{
     @SuppressWarnings ( "unused" )
     private  static  final  String MYTAG =  "Alan" ;
     public  static  final  String CLASS_NAME =  "MultiTouchGestureDetector" ;
     
     /**
      * 事件信息类 <br/>
      * 用来记录一个手势
      */
     private  class  EventInfo
     {
         private  MultiMotionEvent mCurrentDownEvent;  // 当前的down事件
         private  MultiMotionEvent mPreviousUpEvent;  // 上一次up事件
         private  boolean  mStillDown;  // 当前手指是否还在屏幕上
         private  boolean  mInLongPress;  // 当前事件是否属于长按手势
         private  boolean  mAlwaysInTapRegion;  // 是否当前手指仅在小范围内移动，当手指仅在小范围内移动时，视为手指未曾移动过，不会触发onScroll手势
         private  boolean  mAlwaysInBiggerTapRegion;  // 是否当前手指在较大范围内移动，仅当此值为true时，双击手势才能成立
         private  boolean  mIsDoubleTapping;  // 当前手势，是否为双击手势
         private  float  mLastMotionY;  // 最后一次事件的X坐标
         private  float  mLastMotionX;  // 最后一次事件的Y坐标
         
         private  EventInfo(MotionEvent e)
         {
             this ( new  MultiMotionEvent(e));
         }
         
         private  EventInfo(MultiMotionEvent me)
         {
             mCurrentDownEvent = me;
             mStillDown =  true ;
             mInLongPress =  false ;
             mAlwaysInTapRegion =  true ;
             mAlwaysInBiggerTapRegion =  true ;
             mIsDoubleTapping =  false ;
         }
         
         // 释放MotionEven对象，使系统能够继续使用它们
         public  void  recycle()
         {
             if  (mCurrentDownEvent !=  null )
             {
                 mCurrentDownEvent.recycle();
                 mCurrentDownEvent =  null ;
             }
             if  (mPreviousUpEvent !=  null )
             {
                 mPreviousUpEvent.recycle();
                 mPreviousUpEvent =  null ;
             }
         }
         
         @Override
         public  void  finalize()
         {
             this .recycle();
         }
     }
     
     /**
      * 多点事件类 <br/>
      * 将一个多点事件拆分为多个单点事件，并方便获得事件的绝对坐标 <br/>
      * 绝对坐标用以在界面中找到触点所在的控件
      * 
      * @author ray-ni
      */
     public  class  MultiMotionEvent
     {
         private  MotionEvent mEvent;
         private  int  mIndex;
         
         private  MultiMotionEvent(MotionEvent e)
         {
             mEvent = e;
             mIndex = (e.getAction() & MotionEvent.ACTION_POINTER_ID_MASK) >> MotionEvent.ACTION_POINTER_ID_SHIFT;  // 等效于
                                                                                                                   // mEvent.getActionIndex();
         }
         
         private  MultiMotionEvent(MotionEvent e,  int  idx)
         {
             mEvent = e;
             mIndex = idx;
         }
         
         // 行为
         public  int  getAction()
         {
             int  action = mEvent.getAction() & MotionEvent.ACTION_MASK;  // 等效于
                                                                        // mEvent.getActionMasked();
             switch  (action)
             {
                 case  MotionEvent.ACTION_POINTER_DOWN:
                     action = MotionEvent.ACTION_DOWN;
                     break ;
                 case  MotionEvent.ACTION_POINTER_UP:
                     action = MotionEvent.ACTION_UP;
                     break ;
             }
             return  action;
         }
         
         // 返回X的绝对坐标
         public  float  getX()
         {
             return  mEvent.getX(mIndex) + mEvent.getRawX() - mEvent.getX();
         }
         
         // 返回Y的绝对坐标
         public  float  getY()
         {
             return  mEvent.getY(mIndex) + mEvent.getRawY() - mEvent.getY();
         }
         
         // 事件发生的时间
         public  long  getEventTime()
         {
             return  mEvent.getEventTime();
         }
         
         // 事件序号
         public  int  getIndex()
         {
             return  mIndex;
         }
         
         // 事件ID
         public  int  getId()
         {
             return  mEvent.getPointerId(mIndex);
         }
         
         // 释放事件对象，使系统能够继续使用
         public  void  recycle()
         {
             if  (mEvent !=  null )
             {
                 mEvent.recycle();
                 mEvent =  null ;
             }
         }
     }
     
     // 多点手势监听器
     public  interface  MultiTouchGestureListener
     {
         // 手指触碰到屏幕，由一个 ACTION_DOWN触发
         boolean  onDown(MultiMotionEvent e);
         
         // 确定一个press事件，强调手指按下的一段时间（TAP_TIMEOUT）内，手指未曾移动或抬起
         void  onShowPress(MultiMotionEvent e);
         
         // 手指点击屏幕后离开，由 ACTION_UP引发，可以简单的理解为单击事件，即手指点击时间不长（未构成长按事件），也不曾移动过
         boolean  onSingleTapUp(MultiMotionEvent e);
         
         // 长按，手指点下后一段时间（DOUBLE_TAP_TIMEOUT）内，不曾抬起或移动
         void  onLongPress(MultiMotionEvent e);
         
         // 拖动，由ACTION_MOVE触发，手指地按下后，在屏幕上移动
         boolean  onScroll(MultiMotionEvent e1, MultiMotionEvent e2,  float  distanceX,  float  distanceY);
         
         // 滑动，由ACTION_UP触发，手指按下并移动一段距离后，抬起时触发
         boolean  onFling(MultiMotionEvent e1, MultiMotionEvent e2,  float  velocityX,  float  velocityY);
     }
     
     // 多点双击监听器
     public  interface  MultiTouchDoubleTapListener
     {
         // 单击事件确认，强调第一个单击事件发生后，一段时间内，未发生第二次单击事件，即确定不会触发双击事件
         boolean  onSingleTapConfirmed(MultiMotionEvent e);
         
         // 双击事件，
         // 由ACTION_DOWN触发，从第一次单击事件的DOWN事件开始的一段时间(DOUBLE_TAP_TIMEOUT)内结束（即手指），
         // 并且在第一次单击事件的UP时间开始后的一段时间内（DOUBLE_TAP_TIMEOUT）发生第二次单击事件，
         // 除此之外两者坐标间距小于定值（DOUBLE_TAP_SLAP）时，则触发双击事件
         boolean  onDoubleTap(MultiMotionEvent e);
         
         // 双击事件，与onDoubleTap事件不同之处在于，构成双击的第二次点击的ACTION_DOWN,ACTION_MOVE和ACTION_UP都会触发该事件
         boolean  onDoubleTapEvent(MultiMotionEvent e);
     }
     
     // 事件信息队列，队列的下标与MotionEvent的pointId对应
     private  static  List<EventInfo> sEventInfos =  new  ArrayList<EventInfo>( 10 );
     // 双击判断队列，这个队列中的元素等待双击超时的判断结果
     private  static  List<EventInfo> sEventForDoubleTap =  new  ArrayList<EventInfo>( 5 );
     // 指定大点击区域的大小（这个比较拗口），这个值主要用于帮助判断双击是否成立
     private  int  mBiggerTouchSlopSquare =  20  *  20 ;
     // 判断是否构成onScroll手势，当手指在这个范围内移动时，不触发onScroll手势
     private  int  mTouchSlopSquare;
     // 判断是否构成双击，只有两次点击的距离小于该值，才能构成双击手势
     private  int  mDoubleTapSlopSquare;
     // 最小滑动速度
     private  int  mMinimumFlingVelocity;
     // 最大滑动速度
     private  int  mMaximumFlingVelocity;
     
     // 长按阀值，当手指按下后，在该阀值的时间内，未移动超过mTouchSlopSquare的距离并未抬起，则长按手势触发
     private  static  final  int  LONGPRESS_TIMEOUT = ViewConfiguration.getLongPressTimeout();
     // showPress手势的触发阀值，当手指按下后，在该阀值的时间内，未移动超过mTouchSlopSquare的距离并未抬起，则showPress手势触发
     private  static  final  int  TAP_TIMEOUT = ViewConfiguration.getTapTimeout();
     // 双击超时阀值，仅在两次双击事件的间隔（第一次单击的UP事件和第二次单击的DOWN事件）小于此阀值，双击事件才能成立
     private  static  final  int  DOUBLE_TAP_TIMEOUT = ViewConfiguration.getDoubleTapTimeout();
     // 双击区域阀值，仅在两次双击事件的距离小于此阀值，双击事件才能成立
     private  static  final  int  DOUBLE_TAP_SLAP =  64 ;
     
     // GestureHandler所处理的Message的what属性可能为以下 常量：
     // showPress手势
     private  static  final  int  SHOW_PRESS =  1 ;
     // 长按手势
     private  static  final  int  LONG_PRESS =  2 ;
     // SingleTapConfirmed手势
     private  static  final  int  TAP_SINGLE =  3 ;
     // 双击手势
     private  static  final  int  TAP_DOUBLE =  4 ;
     
     // 手势处理器
     private  final  GestureHandler mHandler;
     // 手势监听器
     private  final  MultiTouchGestureListener mListener;
     // 双击监听器
     private  MultiTouchDoubleTapListener mDoubleTapListener;
     
     // 长按允许阀值
     private  boolean  mIsLongpressEnabled;
     // 速度追踪器
     private  VelocityTracker mVelocityTracker;
     
     private  class  GestureHandler  extends  Handler
     {
         GestureHandler()
         {
             super ();
         }
         
         GestureHandler(Handler handler)
         {
             super (handler.getLooper());
         }
         
         @Override
         public  void  handleMessage(Message msg)
         {
             int  idx = (Integer) msg.obj;
             switch  (msg.what)
             {
                 case  SHOW_PRESS:
                 {
                     if  (idx >= sEventInfos.size())
                     {
                         // Log.w(MYTAG, CLASS_NAME +
                         // ":handleMessage, msg.what = SHOW_PRESS, idx=" + idx +
                         // ", while sEventInfos.size()="
                         // + sEventInfos.size());
                         break ;
                     }
                     EventInfo info = sEventInfos.get(idx);
                     if  (info ==  null )
                     {
                         // Log.e(MYTAG, CLASS_NAME +
                         // ":handleMessage, msg.what = SHOW_PRESS, idx=" + idx +
                         // ", Info = null");
                         break ;
                     }
                     // 触发手势监听器的onShowPress事件
                     mListener.onShowPress(info.mCurrentDownEvent);
                     break ;
                 }
                 case  LONG_PRESS:
                 {
                     // Log.d(MYTAG, CLASS_NAME + ":trigger LONG_PRESS");
                     
                     if  (idx >= sEventInfos.size())
                     {
                         // Log.w(MYTAG, CLASS_NAME +
                         // ":handleMessage, msg.what = LONG_PRESS, idx=" + idx +
                         // ", while sEventInfos.size()="
                         // + sEventInfos.size());
                         break ;
                     }
                     EventInfo info = sEventInfos.get(idx);
                     if  (info ==  null )
                     {
                         // Log.e(MYTAG, CLASS_NAME +
                         // ":handleMessage, msg.what = LONG_PRESS, idx=" + idx +
                         // ", Info = null");
                         break ;
                     }
                     dispatchLongPress(info, idx);
                     break ;
                 }
                 case  TAP_SINGLE:
                 {
                     // Log.d(MYTAG, CLASS_NAME + ":trriger TAP_SINGLE");
                     // If the user's finger is still down, do not count it as a
                     // tap
                     if  (idx >= sEventInfos.size())
                     {
                         // Log.e(MYTAG, CLASS_NAME +
                         // ":handleMessage, msg.what = TAP_SINGLE, idx=" + idx +
                         // ", while sEventInfos.size()="
                         // + sEventInfos.size());
                         break ;
                     }
                     EventInfo info = sEventInfos.get(idx);
                     if  (info ==  null )
                     {
                         // Log.e(MYTAG, CLASS_NAME +
                         // ":handleMessage, msg.what = TAP_SINGLE, idx=" + idx +
                         // ", Info = null");
                         break ;
                     }
                     if  (mDoubleTapListener !=  null  && !info.mStillDown)
                     {  // 手指在双击超时的阀值内未离开屏幕进行第二次单击事件，则确定单击事件成立（不再触发双击事件）
                         mDoubleTapListener.onSingleTapConfirmed(info.mCurrentDownEvent);
                     }
                     break ;
                 }
                 case  TAP_DOUBLE:
                 {
                     if  (idx >= sEventForDoubleTap.size())
                     {
                         // Log.w(MYTAG, CLASS_NAME +
                         // ":handleMessage, msg.what = TAP_DOUBLE, idx=" + idx +
                         // ", while sEventForDoubleTap.size()="
                         // + sEventForDoubleTap.size());
                         break ;
                     }
                     EventInfo info = sEventForDoubleTap.get(idx);
                     if  (info ==  null )
                     {
                         // Log.w(MYTAG, CLASS_NAME +
                         // ":handleMessage, msg.what = TAP_DOUBLE, idx=" + idx +
                         // ", Info = null");
                         break ;
                     }
                     sEventForDoubleTap.set(idx,  null ); // 这个没什么好做的，就是把队列中对应的元素清除而已
                     break ;
上一篇 下一篇
优秀的个人博客,低调大师

微信关注我们

原文链接：https://yq.aliyun.com/articles/425288

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

Activity的四种加载模式

在多Activity开发中，有可能是自己应用之间的Activity跳转，或者夹带其他应用的可复用Activity。可能会希望跳转到原来某个Activity实例，而不是产生大量重复的Activity。 这需要为Activity配置特定的加载模式，而不是使用默认的加载模式。 加载模式分类及在哪里配置 Activity有四种加载模式： standard singleTop singleTask singleInstance 设置的位置在AndroidManifest.xml文件中activity元素的android:launchMode属性： <activity android:name="ActB" android:launchMode="singleTask"></activity> 也可以在Eclipse ADT中图形界面中编辑： 区分Activity的加载模式，通过示例一目了然。这里编写了一个Activity A（ActA）和Activity B（ActB）循环跳转的例子。对加载模式修改和代码做稍微改动，就可以说明四种模式的区别。 standard 首先说st...
2017-11-08
456
上一篇

Android笔记:AndroidManifest.xml属性详解(一)之sharedUserId

一、sharedUserId 1 android:sharedUserId= "com.rongqin" userid的特点： 1. 作为APK身份的标识 2. userid对应一个Linux用户，所以不同APK(用户)间互相访问数据默认是禁止的. 不同APK之间如何通过userid进行数据互访？ 在android系统中，apk之间可以相互读取数据的条件是：有同样的签名，并且AndroidManifest.xml文件中配置的android:sharedUserId属性值相同，那么两个apk运行在同一个进程中，可以互相访问任意数据。 通过userid访问其他apk资源的方法: 1.应用程序和插件(比如皮肤)程序的AndroidManifest.xml中配置相同的sharedUserId: 1 2 3 4 5 6 <?xmlversion= "1.0" encoding= "utf-8" ?> <manifestxmlns:android= "http://schemas.android.com/apk/res/android" package = "com.lons...
2017-11-08
666
下一篇

相关文章

发表评论

资源下载

更多资源
Mario

Mario

马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长，特征是大鼻子、头戴帽子、身穿背带裤，还留着胡子。与他的双胞胎兄弟路易基一起，长年担任任天堂的招牌角色。

时间: 2025-12-12 大小: 211.28KB 下载: 54次
腾讯云软件源

腾讯云软件源

为解决软件依赖安装时官方源访问速度慢的问题，腾讯云为一些软件搭建了缓存服务。您可以通过使用腾讯云软件源站来提升依赖包的安装速度。为了方便用户自由搭建服务架构，目前腾讯云软件源站支持公网访问和内网访问。

时间: 2026-01-27 大小: 1MB 下载: 5次
Nacos

Nacos

Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称，一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。

时间: 2025-12-21 大小: 189MB 下载: 2次
Sublime Text

Sublime Text

Sublime Text具有漂亮的用户界面和强大的功能，例如代码缩略图，Python的插件，代码段等。还可自定义键绑定，菜单和工具栏。Sublime Text 的主要功能包括：拼写检查，书签，完整的 Python API ， Goto 功能，即时项目切换，多选择，多窗口等等。Sublime Text 是一个跨平台的编辑器，同时支持Windows、Linux、Mac OS X等操作系统。

时间: 2025-12-03 大小: 9.84MB 下载: 39次
手机查看

扫码在手机上查看文章

扫描二维码，手机阅读更方便

热门标签
OpenAi HarmonyOS6 Nacos3 Rocky Service Mesh Gemini3 SpringCloud Redis Jdk25 DeepSeek Docker Kubernetes SpringBoot4

欢迎您来访！

登录后，您将获得更多功能！
热门文章
联系我们

有任何问题或合作意向欢迎联系我们

Email: 99873273@qq.com

QQ: 99873273

用户登录
用户注册