参考地址:
http://jcodecraeer.com/a/anzhuokaifa/androidkaifa/2012/1020/448.html
http://www.jcodecraeer.com/a/anzhuokaifa/androidkaifa/2012/1117/574.html
一.Android的手势操作识别
1.在android应用当中每一次手势的交互都都会依照如下顺序去执行的
- 刚接触到手机屏幕的时候,要触发MotionEvent事件
- 该事件被OnTouchListener监听,在要复写的onTouch()方法里获得该MotionEvent对象
- 通过GestureDetector(手势识别器)转发次MotionEvent对象至OnGestureListener。
- OnGestureListener获取到对象之后,根据对应的手势做出回应
2.这个顺序可以说就是手势交互的原理,下面一同来了解一下MotionEvent、GestureDetector和OnGestureListener。
MotionEvent: 这个类用于封装手势、触摸笔、轨迹球等等的动作事件。其内部封装了两个重要的属性X和Y,这两个属性分别用于记录横轴和纵轴的坐标。
GestureDetector: 识别各种手势。
OnGestureListener: 这是一个手势交互的监听接口,其中提供了多个抽象方法,并根据GestureDetector的手势识别结果调用相对应的方法。
下面我再通过一个切换图片的代码示例,演示一下手势交互的实现,让大伙对上面的执行顺序,以及各手势动作的区分有一个更加深刻的了解和记忆。
首先,提供一个只有ImageView的布局文件——main.xml。
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical"
android:layout_width="fill_parent"
android:layout_height="fill_parent">
<ImageView android:id="@+id/image"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:layout_gravity="center"/>
</LinearLayout>
然后,完成我们的Activity,因为要监听触摸屏的触摸事件和手势事件,所以该Activity必须实现OnTouchListener和OnGestureListener两个接口,并重写其中的方法。具体代码如下:
public class MainActivity extends Activity implements OnTouchListener, OnGestureListener {
//创建一个用于识别收拾的GestureDetector对象waiyuwu.blogcn.com
private GestureDetector detector = new GestureDetector(this);
//定义一个数组,用于放漂亮的女孩
int[] girls = new int[]{R.drawable.girl1, R.drawable.girl2, R.drawable.girl3};
//定义数组下标,以方便观看各个女孩
private int index;
private ImageView image;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
image = (ImageView)findViewById(R.id.image);
//设置一个初始显示的girl吧
image.setImageResource(girls[index]);
//监听这个ImageView组件上的触摸屏时间
image.setOnTouchListener(this);
//下面两个要记得设哦,不然就没法处理轻触以外的事件了,例如抛掷动作。
image.setLongClickable(true);
detector.setIsLongpressEnabled(true);
}//用于呼喊下一个女孩的方法
public void goNext(){
index++;
index = Math.abs(index % girls.length);
image.setImageResource(girls[index]);
}
//重写OnTouchListener的onTouch方法
//此方法在触摸屏被触摸,即发生触摸事件(接触和抚摸两个事件,挺形象)的时候被调用。
@Override
public boolean onTouch(View v, MotionEvent event) {
detector.onTouchEvent(event);
return true;
}
//在按下动作时被调用
@Override
public boolean onDown(MotionEvent e) {
return false;
}
//在抛掷动作时被调用
@Override
public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX,
float velocityY) {
//velocityX表示横向的移动,根据手指移动的方向切换女孩
if(velocityX < 0){
goNext();
}else if(velocityX > 0){
goPrevious();
}
return false;
}
//用户呼唤上一个女孩的方法
public void goPrevious(){
index--;
index = Math.abs(index % girls.length);
image.setImageResource(girls[index]);
}
//在长按时被调用
@Override
public void onLongPress(MotionEvent e) {
}
//在滚动时调用
@Override
public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX,
float distanceY) {
return false;
}
//在按住时被调用
@Override
public void onShowPress(MotionEvent e) {
}
//在抬起时被调用
@Override
public boolean onSingleTapUp(MotionEvent e) {
return false;
}
}
GestureDetector.OnGestureListener监听手势的方法有如下这些:
aaarticlea/png;base64,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" alt="" width="812" height="300" />
对这些方法做一下解释:
按下(onDown): 刚刚手指接触到触摸屏的那一刹那,就是触的那一下。
抛掷(onFling): 手指在触摸屏上迅速移动,并松开的动作。
长按(onLongPress): 手指按在持续一段时间,并且没有松开。
滚动(onScroll): 手指在触摸屏上滑动。
按住(onShowPress): 手指按在触摸屏上,它的时间范围在按下起效,在长按之前。
抬起(onSingleTapUp):手指离开触摸屏的那一刹那。
除了这些定义之外,鄙人也总结了一点算是经验的经验吧,在这里和大家分享一下。
任何手势动作都会先执行一次按下(onDown)动作。
长按(onLongPress)动作前一定会执行一次按住(onShowPress)动作。
按住(onShowPress)动作和按下(onDown)动作之后都会执行一次抬起(onSingleTapUp)动作。
长按(onLongPress)、滚动(onScroll)和抛掷(onFling)动作之后都不会执行抬起(onSingleTapUp)动作。
二.手势事件:滑动动速度跟踪类VelocityTracker介绍
VelocityTracker顾名思义即速度跟踪,在android中主要应用于touchEvent, VelocityTracker通过跟踪一连串事件实时计算出当前的速度,这样的用法在android系统空间中随处可见,比如Gestures中的 Fling, Scrolling等。
android.view.VelocityTracker主要用跟踪触摸屏事件 (flinging事件和其他gestures手势事件)的速率。用addMovement(MotionEvent)函数将Motion event加入到VelocityTracker类实例中.你可以使用getXVelocity() 或getXVelocity()获得横向和竖向的速率到速率时,但是使用它们之前请先调用computeCurrentVelocity(int)来初始 化速率的单位 。
主要函数
Public Methods |
void |
addMovement(MotionEventevent)
Add a user's movement to the tracker.
|
void |
clear()
Reset the velocity tracker back to its initial state.
|
void |
computeCurrentVelocity(int units, float maxVelocity)
Compute the current velocity based on the points that have been collected.
intunitis表示速率的基本时间单位。unitis值为1的表示是,一毫秒时间单位内运动了多少个像素, unitis值为1000表示一秒(1000毫秒)时间单位内运动了多少个像素
floatVelocity表示速率的最大值
|
void |
computeCurrentVelocity(int units)
|
abstract T |
getNextPoolable() |
float |
getXVelocity()
Retrieve the last computed X velocity.
|
float |
getXVelocity(int id)
Retrieve the last computed X velocity.
|
float |
getYVelocity(int id)
Retrieve the last computed Y velocity.
|
float |
getYVelocity()
Retrieve the last computed Y velocity.
|
abstract boolean |
isPooled() |
static VelocityTracker |
obtain()
Retrieve a new VelocityTracker object to watch the velocity of a motion.
|
void |
recycle()
Return a VelocityTracker object back to be re-used by others.
|
abstract void |
setNextPoolable(T element) |
abstract void |
setPooled(boolean isPooled) |
示例:
private VelocityTracker mVelocityTracker;//生命变量
//在onTouchEvent(MotionEvent ev)中
if (mVelocityTracker == null) {
mVelocityTracker = VelocityTracker.obtain();//获得VelocityTracker类实例
}
mVelocityTracker.addMovement(ev);//将事件加入到VelocityTracker类实例中
//判断当ev事件是MotionEvent.ACTION_UP时:计算速率
final VelocityTracker velocityTracker = mVelocityTracker;
// 1000 provides pixels per second
velocityTracker.computeCurrentVelocity(1, (float)0.01);//设置maxVelocity值为0.1时,速率大于0.01时,显示的速率都是0.01,速率小于0.01时,显示正常
Log.i("test","velocityTraker"+velocityTracker.getXVelocity());
velocityTracker.computeCurrentVelocity(1000); //设置units的值为1000,意思为一秒时间内运动了多少个像素
Log.i("test","velocityTraker"+velocityTracker.getXVelocity());
大体的使用是这样的:
当你需要跟踪触摸屏事件的速度的时候,使用obtain()方法来获得VelocityTracker类的一个实例对象
在onTouchEvent回调函数中,使用addMovement(MotionEvent)函数将当前的移动事件传递给VelocityTracker对象
使用computeCurrentVelocity (int units)函数来计算当前的速度,使用getXVelocity ()、 getYVelocity ()函数来获得当前的速度
下面是我写的一个简单Demo:
package com.bxwu.demo.component.activity;
import android.app.Activity;
import android.graphics.Color;
import android.os.Bundle;
import android.view.MotionEvent;
import android.view.VelocityTracker;
import android.view.ViewConfiguration;
import android.view.ViewGroup.LayoutParams;
import android.widget.TextView;
public class VelocityTrackerTest extends Activity {
private TextView mInfo;
private VelocityTracker mVelocityTracker;
private int mMaxVelocity;
private int mPointerId;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
mInfo = new TextView(this);
mInfo.setLines(4);
mInfo.setLayoutParams(new LayoutParams(LayoutParams.FILL_PARENT, LayoutParams.FILL_PARENT));
mInfo.setTextColor(Color.WHITE);
setContentView(mInfo);
mMaxVelocity = ViewConfiguration.get(this).getMaximumFlingVelocity();
}
@Override
public boolean onTouchEvent(MotionEvent event) {
final int action = event.getAction();
acquireVelocityTracker(event);
final VelocityTracker verTracker = mVelocityTracker;
switch (action) {
case MotionEvent.ACTION_DOWN:
//求第一个触点的id, 此时可能有多个触点,但至少一个
mPointerId = event.getPointerId(0);
break;
case MotionEvent.ACTION_MOVE:
//求伪瞬时速度
verTracker.computeCurrentVelocity(1000, mMaxVelocity);
final float velocityX = verTracker.getXVelocity(mPointerId);
final float velocityY = verTracker.getYVelocity(mPointerId);
recodeInfo(velocityX, velocityY);
break;
case MotionEvent.ACTION_UP:
releaseVelocityTracker();
break;
case MotionEvent.ACTION_CANCEL:
releaseVelocityTracker();
break;
default:
break;
}
return super.onTouchEvent(event);
}
/**
*
* @param event 向VelocityTracker添加MotionEvent
*
* @see android.view.VelocityTracker#obtain()
* @see android.view.VelocityTracker#addMovement(MotionEvent)
*/
private void acquireVelocityTracker(final MotionEvent event) {
if(null == mVelocityTracker) {
mVelocityTracker = VelocityTracker.obtain();
}
mVelocityTracker.addMovement(event);
}
/**
* 释放VelocityTracker
*
* @see android.view.VelocityTracker#clear()
* @see android.view.VelocityTracker#recycle()
*/
private void releaseVelocityTracker() {
if(null != mVelocityTracker) {
mVelocityTracker.clear();
mVelocityTracker.recycle();
mVelocityTracker = null;
}
}
private static final String sFormatStr = "velocityX=%f\nvelocityY=%f";
/**
* 记录当前速度
*
* @param velocityX x轴速度
* @param velocityY y轴速度
*/
private void recodeInfo(final float velocityX, final float velocityY) {
final String info = String.format(sFormatStr, velocityX, velocityY);
mInfo.setText(info);
}
}
代码很简单,我们可以求出move过程中的伪瞬时速度, 这样在做很多控件的时候都是可以用到的,比如系统Launcher的分页,
ScrollView滑动等, 可根据此时的速度来计算ACTION_UP后的减速运动等。实现一些非常棒的效果。
android手势处理揭秘
- Android手势识别的发展
在播放器.与手势识别.所以,看看今天的我们Android手势识别. 首先,我们需要站在巨人的肩膀上.有些人举了个例子和说明. 第一章: http://www.2cto.com/kf/201110/10 ...
- 札记:android手势识别,MotionEvent
摘要 本文是手势识别输入事件处理的完整学习记录.内容包括输入事件InputEvent响应方式,触摸事件MotionEvent的概念和使用,触摸事件的动作分类.多点触摸.根据案例和API分析了触摸手势T ...
- 代码讲解Android Scroller、VelocityTracker
在编写自定义滑动控件时常常会用到Android触摸机制和Scroller及VelocityTracker.Android Touch系统简介(二):实例详解onInterceptTouchEvent与 ...
- Android手势识别(单击 双击 抬起 短按 长按 滚动 滑动)
对于触摸屏,其原生的消息无非按下.抬起.移动这几种,我们只需要简单重载onTouch或者设置触摸侦听器setOnTouchListener即可进行处理.不过,为了提高我们的APP的用户体验,有时候我们 ...
- Android手势识别总结
一:首先,在Android系统中,每一次手势交互都会依照以下顺序执行. 1. 接触接触屏一刹那,触发一个MotionEvent事件. 2. 该事件被OnTouchListener监听,在其onTouc ...
- android手势识别ViewFlipper触摸动画
使用ViewFlipper来将您要来回拖动的View装在一起,然 后与GestureDetector手势识别类来联动,确定要显示哪个View,加上一点点动画效果即可.比如当手指向左快速滑动时跳转到上一 ...
- Android 手势识别—缩放
上一篇讲解了手势识别中的点击和双击事件的识别,用到的是GestureDetector类和GestureDetectorCompat类,用于监听用户触摸屏幕中的简单动作. 缩放 基本用法如下,可以通过缩 ...
- Android 手势识别——单击/双击
为什么需要手势识别? 手势对于我们的app有很多的地方都在使用,比如右滑关闭界面等.手势控制分为触发动作(Touch Mechanics,用户手指在屏幕上如何动作)和触发行为(Touch Activi ...
- 代码解说Android Scroller、VelocityTracker
在编写自己定义滑动控件时经常会用到Android触摸机制和Scroller及VelocityTracker.Android Touch系统简单介绍(二):实例具体解释onInterceptTouchE ...
随机推荐
- AD芯片的基准参考电压问题
基准参考电压的精度一般非常高的! AD芯片 : AD9226的基准参考电压 误差一般是 千分之一! 我之前用万用表测量AD9226的参考电压大概是1.89V(这款AD的正确参考电压应该是2V),所 ...
- 静态实现AOP(翻译自MSDN)
在.net实现AOP 本文通过一个简单的例子实现静态AOP.改例子主要实现客户的增删改查,突然有一天你的老板需要在程序上跟踪每个方法操作的运行日志. 主要分为5个步骤. 第一步:创建接口IReposi ...
- pymysql简单链接示例
#!/usr/bin/env python # encoding: utf-8 # Date: 2018/6/24 import pymysql username = input('username ...
- 赋予oracle执行存储过程权限和创建表权限
grant create any table to username; grant create any procedure to username; grant execute any proced ...
- Oracle11gR2--删除数据库
1. 停止ORACLE数据库 [oracle@localhost oracle]$ ps -ef|grep smon oracle 72550 1 0 14:23 ? 00:00:00 ora_smo ...
- 0k6410定时器详细分析
看到一篇很好的博文,分析2410定时器中断的使用的,很详细,和大家分享一下 转载来源于http://www.cnblogs.com/Neddy/archive/2011/07/01/2095176.h ...
- CSS秘密花园:多边框
今天在查询CSS3动画相关资料时偶然发现这个,感觉有时还是挺方便的.原文链接:http://www.w3cplus.com/css3/css-secrets/multiple-borders.html ...
- Python基本数据类型之字符串、数字、布尔
一.数据类型种类 Python中基本数据类型主要有以下几类: Number(数字) String(字符串) Bool (布尔) List(列表) Tuple(元组) Sets(集合) Diction ...
- s=1+2*3+4*5*6+7*8*9*10+.... C语言求解
#include <stdio.h> /*类似斐波那契数列的计算方式 项 1 2 3 4 1 2*3 4*5*6 7*8*9*10 生成项的起始数字 1 2 4 7 和后一项的差值 1 2 ...
- 201671010127 2016—2017-2 通过一个小程序对Java的再认识。
学习了将近四周的Java语言,对于Java语言,我也有了更进一步的理解,出于对Java语言的喜爱,我总是喜欢没事的时候,自己敲一些很简单的代码,一边学习Java语言,一边对比C语言,往往可以帮助我们更 ...