Android开发：多点触控测试精华代码

最新推荐文章于 2024-03-15 15:47:11 发布
最新推荐文章于 2024-03-15 15:47:11 发布
阅读量2.1k 收藏 1
点赞数
分类专栏： Android

PointerLocationView.java:

/*
 * Copyright (C) 2010 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.ckl.PointerLocation;

import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.Paint.FontMetricsInt;
import android.util.Log;
import android.view.MotionEvent;
import android.view.VelocityTracker;
import android.view.View;
import android.view.ViewConfiguration;

import java.util.ArrayList;

public class PointerLocationView extends View {
	public static class PointerState {
		private final ArrayList<Float> mXs = new ArrayList<Float>();
		private final ArrayList<Float> mYs = new ArrayList<Float>();
		private boolean mCurDown;
		private int mCurX;
		private int mCurY;
		private float mCurPressure;
		private float mCurSize;
		private int mCurWidth;
		private VelocityTracker mVelocity;
	}

	private final ViewConfiguration mVC;
	private final Paint mTextPaint;
	private final Paint mTextBackgroundPaint;
	private final Paint mTextLevelPaint;
	private final Paint mPaint;
	private final Paint mTargetPaint;
	private final Paint mPathPaint;
	private final FontMetricsInt mTextMetrics = new FontMetricsInt();
	private int mHeaderBottom;
	private boolean mCurDown;
	private int mCurNumPointers;
	private int mMaxNumPointers;
	private final ArrayList<PointerState> mPointers = new ArrayList<PointerState>();

	private boolean mPrintCoords = true;

	public PointerLocationView(Context c) {
		super(c);
		setFocusable(true);
		mVC = ViewConfiguration.get(c);
		mTextPaint = new Paint();
		mTextPaint.setAntiAlias(true);
		mTextPaint.setTextSize(10 * getResources().getDisplayMetrics().density);
		mTextPaint.setARGB(255, 0, 0, 0);
		mTextBackgroundPaint = new Paint();
		mTextBackgroundPaint.setAntiAlias(false);
		mTextBackgroundPaint.setARGB(128, 255, 255, 255);
		mTextLevelPaint = new Paint();
		mTextLevelPaint.setAntiAlias(false);
		mTextLevelPaint.setARGB(192, 255, 0, 0);
		mPaint = new Paint();
		mPaint.setAntiAlias(true);
		mPaint.setARGB(255, 255, 255, 255);
		mPaint.setStyle(Paint.Style.STROKE);
		mPaint.setStrokeWidth(2);
		mTargetPaint = new Paint();
		mTargetPaint.setAntiAlias(false);
		mTargetPaint.setARGB(255, 0, 0, 192);
		mPathPaint = new Paint();
		mPathPaint.setAntiAlias(false);
		mPathPaint.setARGB(255, 0, 96, 255);
		mPaint.setStyle(Paint.Style.STROKE);
		mPaint.setStrokeWidth(1);

		PointerState ps = new PointerState();
		ps.mVelocity = VelocityTracker.obtain();
		mPointers.add(ps);
	}

	public void setPrintCoords(boolean state) {
		mPrintCoords = state;
	}

	@Override
	protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
		super.onMeasure(widthMeasureSpec, heightMeasureSpec);
		mTextPaint.getFontMetricsInt(mTextMetrics);
		mHeaderBottom = -mTextMetrics.ascent + mTextMetrics.descent + 2;
		if (false) {
			Log.i("foo", "Metrics: ascent=" + mTextMetrics.ascent + " descent="
					+ mTextMetrics.descent + " leading=" + mTextMetrics.leading
					+ " top=" + mTextMetrics.top + " bottom="
					+ mTextMetrics.bottom);
		}
	}

	@Override
	protected void onDraw(Canvas canvas) {
		synchronized (mPointers) {
			final int w = getWidth();
			final int itemW = w / 7;
			final int base = -mTextMetrics.ascent + 1;
			final int bottom = mHeaderBottom;
			final int NP = mPointers.size();

			if (NP > 0) {
				final PointerState ps = mPointers.get(0);
				canvas.drawRect(0, 0, itemW - 1, bottom, mTextBackgroundPaint);
				canvas.drawText("P: " + mCurNumPointers + " / "
						+ mMaxNumPointers, 1, base, mTextPaint);

				final int N = ps.mXs.size();
				if ((mCurDown && ps.mCurDown) || N == 0) {
					canvas.drawRect(itemW, 0, (itemW * 2) - 1, bottom,
							mTextBackgroundPaint);
					canvas.drawText("X: " + ps.mCurX, 1 + itemW, base,
							mTextPaint);
					canvas.drawRect(itemW * 2, 0, (itemW * 3) - 1, bottom,
							mTextBackgroundPaint);
					canvas.drawText("Y: " + ps.mCurY, 1 + itemW * 2, base,
							mTextPaint);
				} else {
					float dx = ps.mXs.get(N - 1) - ps.mXs.get(0);
					float dy = ps.mYs.get(N - 1) - ps.mYs.get(0);
					canvas.drawRect(
							itemW,
							0,
							(itemW * 2) - 1,
							bottom,
							Math.abs(dx) < mVC.getScaledTouchSlop() ? mTextBackgroundPaint
									: mTextLevelPaint);
					canvas.drawText("dX: " + String.format("%.1f", dx),
							1 + itemW, base, mTextPaint);
					canvas.drawRect(
							itemW * 2,
							0,
							(itemW * 3) - 1,
							bottom,
							Math.abs(dy) < mVC.getScaledTouchSlop() ? mTextBackgroundPaint
									: mTextLevelPaint);
					canvas.drawText("dY: " + String.format("%.1f", dy),
							1 + itemW * 2, base, mTextPaint);
				}

				canvas.drawRect(itemW * 3, 0, (itemW * 4) - 1, bottom,
						mTextBackgroundPaint);
				int velocity = ps.mVelocity == null ? 0 : (int) (ps.mVelocity
						.getXVelocity() * 1000);
				canvas.drawText("Xv: " + velocity, 1 + itemW * 3, base,
						mTextPaint);

				canvas.drawRect(itemW * 4, 0, (itemW * 5) - 1, bottom,
						mTextBackgroundPaint);
				velocity = ps.mVelocity == null ? 0 : (int) (ps.mVelocity
						.getYVelocity() * 1000);
				canvas.drawText("Yv: " + velocity, 1 + itemW * 4, base,
						mTextPaint);

				canvas.drawRect(itemW * 5, 0, (itemW * 6) - 1, bottom,
						mTextBackgroundPaint);
				canvas.drawRect(itemW * 5, 0, (itemW * 5)
						+ (ps.mCurPressure * itemW) - 1, bottom,
						mTextLevelPaint);
				canvas.drawText(
						"Prs: " + String.format("%.2f", ps.mCurPressure),
						1 + itemW * 5, base, mTextPaint);

				canvas.drawRect(itemW * 6, 0, w, bottom, mTextBackgroundPaint);
				canvas.drawRect(itemW * 6, 0, (itemW * 6)
						+ (ps.mCurSize * itemW) - 1, bottom, mTextLevelPaint);
				canvas.drawText("Size: " + String.format("%.2f", ps.mCurSize),
						1 + itemW * 6, base, mTextPaint);
			}

			for (int p = 0; p < NP; p++) {
				final PointerState ps = mPointers.get(p);

				if (mCurDown && ps.mCurDown) {
					canvas.drawLine(0, (int) ps.mCurY, getWidth(),
							(int) ps.mCurY, mTargetPaint);
					canvas.drawLine((int) ps.mCurX, 0, (int) ps.mCurX,
							getHeight(), mTargetPaint);
					int pressureLevel = (int) (ps.mCurPressure * 255);
					mPaint.setARGB(255, pressureLevel, 128, 255 - pressureLevel);
					canvas.drawPoint(ps.mCurX, ps.mCurY, mPaint);
					canvas.drawCircle(ps.mCurX, ps.mCurY, ps.mCurWidth, mPaint);
				}
			}

			for (int p = 0; p < NP; p++) {
				final PointerState ps = mPointers.get(p);

				final int N = ps.mXs.size();
				float lastX = 0, lastY = 0;
				boolean haveLast = false;
				boolean drawn = false;
				mPaint.setARGB(255, 128, 255, 255);
				for (int i = 0; i < N; i++) {
					float x = ps.mXs.get(i);
					float y = ps.mYs.get(i);
					if (Float.isNaN(x)) {
						haveLast = false;
						continue;
					}
					if (haveLast) {
						canvas.drawLine(lastX, lastY, x, y, mPathPaint);
						canvas.drawPoint(lastX, lastY, mPaint);
						drawn = true;
					}
					lastX = x;
					lastY = y;
					haveLast = true;
				}

				if (drawn) {
					if (ps.mVelocity != null) {
						mPaint.setARGB(255, 255, 64, 128);
						float xVel = ps.mVelocity.getXVelocity() * (1000 / 60);
						float yVel = ps.mVelocity.getYVelocity() * (1000 / 60);
						canvas.drawLine(lastX, lastY, lastX + xVel, lastY
								+ yVel, mPaint);
					} else {
						canvas.drawPoint(lastX, lastY, mPaint);
					}
				}
			}
		}
	}

	public void addTouchEvent(MotionEvent event) {
		synchronized (mPointers) {
			int action = event.getAction();

			// Log.i("Pointer", "Motion: action=0x" +
			// Integer.toHexString(action)
			// + " pointers=" + event.getPointerCount());

			int NP = mPointers.size();

			// mRect.set(0, 0, getWidth(), mHeaderBottom+1);
			// invalidate(mRect);
			// if (mCurDown) {
			// mRect.set(mCurX-mCurWidth-3, mCurY-mCurWidth-3,
			// mCurX+mCurWidth+3, mCurY+mCurWidth+3);
			// } else {
			// mRect.setEmpty();
			// }
			if (action == MotionEvent.ACTION_DOWN) {
				for (int p = 0; p < NP; p++) {
					final PointerState ps = mPointers.get(p);
					ps.mXs.clear();
					ps.mYs.clear();
					ps.mVelocity = VelocityTracker.obtain();
					ps.mCurDown = false;
				}
				mPointers.get(0).mCurDown = true;
				mMaxNumPointers = 0;
				if (mPrintCoords) {
					Log.i("Pointer", "Pointer 1: DOWN");
				}
			}

			if ((action & MotionEvent.ACTION_MASK) == MotionEvent.ACTION_POINTER_DOWN) {
				final int index = (action & MotionEvent.ACTION_POINTER_INDEX_MASK) >> MotionEvent.ACTION_POINTER_INDEX_SHIFT;
				final int id = event.getPointerId(index); // 对于每个触控的点的细节，我们可以通过一个循环执行getPointerId方法获取索引

				while (NP <= id) {
					PointerState ps = new PointerState();
					ps.mVelocity = VelocityTracker.obtain();
					mPointers.add(ps);
					NP++;
				}
				final PointerState ps = mPointers.get(id);
				ps.mVelocity = VelocityTracker.obtain();
				ps.mCurDown = true;
				if (mPrintCoords) {
					Log.i("Pointer", "Pointer " + (id + 1) + ": DOWN");
				}
			}

			final int NI = event.getPointerCount();// 获取触控点的数量，比如2则可能是两个手指同时按压屏幕

			mCurDown = action != MotionEvent.ACTION_UP
					&& action != MotionEvent.ACTION_CANCEL;
			mCurNumPointers = mCurDown ? NI : 0;
			if (mMaxNumPointers < mCurNumPointers) {
				mMaxNumPointers = mCurNumPointers;
			}

			for (int i = 0; i < NI; i++) {
				final int id = event.getPointerId(i);
				final PointerState ps = mPointers.get(id);
				ps.mVelocity.addMovement(event);
				ps.mVelocity.computeCurrentVelocity(1);
				final int N = event.getHistorySize();
				for (int j = 0; j < N; j++) {
					if (mPrintCoords) {
						Log.i("Pointer",
								"Pointer " + (id + 1) + ": ("
										+ event.getHistoricalX(i, j) + ", "
										+ event.getHistoricalY(i, j) + ")"
										+ " Prs="
										+ event.getHistoricalPressure(i, j)
										+ " Size="
										+ event.getHistoricalSize(i, j));
					}
					ps.mXs.add(event.getHistoricalX(i, j));
					ps.mYs.add(event.getHistoricalY(i, j));
				}
				if (mPrintCoords) {
					Log.i("Pointer",
							"Pointer " + (id + 1) + ": (" + event.getX(i)
									+ ", " + event.getY(i) + ")" + " Prs="
									+ event.getPressure(i) + " Size="
									+ event.getSize(i));
				}
				ps.mXs.add(event.getX(i));
				ps.mYs.add(event.getY(i));
				ps.mCurX = (int) event.getX(i);
				ps.mCurY = (int) event.getY(i);
				// Log.i("Pointer", "Pointer #" + p + ": (" + ps.mCurX
				// + "," + ps.mCurY + ")");
				ps.mCurPressure = event.getPressure(i);
				ps.mCurSize = event.getSize(i);
				ps.mCurWidth = (int) (ps.mCurSize * (getWidth() / 3));
			}

			if ((action & MotionEvent.ACTION_MASK) == MotionEvent.ACTION_POINTER_UP) {
				final int index = (action & MotionEvent.ACTION_POINTER_INDEX_MASK) >> MotionEvent.ACTION_POINTER_INDEX_SHIFT;
				final int id = event.getPointerId(index);
				final PointerState ps = mPointers.get(id);
				ps.mXs.add(Float.NaN);
				ps.mYs.add(Float.NaN);
				ps.mCurDown = false;
				if (mPrintCoords) {
					Log.i("Pointer", "Pointer " + (id + 1) + ": UP");
				}
			}

			if (action == MotionEvent.ACTION_UP) {
				for (int i = 0; i < NI; i++) {
					final int id = event.getPointerId(i);
					final PointerState ps = mPointers.get(id);
					if (ps.mCurDown) {
						ps.mCurDown = false;
						if (mPrintCoords) {
							Log.i("Pointer", "Pointer " + (id + 1) + ": UP");
						}
					}
				}
			}

			// if (mCurDown) {
			// mRect.union(mCurX-mCurWidth-3, mCurY-mCurWidth-3,
			// mCurX+mCurWidth+3, mCurY+mCurWidth+3);
			// }
			// invalidate(mRect);
			postInvalidate();
		}
	}

	@Override
	public boolean onTouchEvent(MotionEvent event) {
		addTouchEvent(event);
		return true;
	}

	@Override
	public boolean onTrackballEvent(MotionEvent event) {
		Log.i("Pointer", "Trackball: " + event);
		return super.onTrackballEvent(event);
	}

}


PointerLocation.java:

public class PointerLocation extends Activity {
	@Override
	protected void onCreate(Bundle icicle) {
		super.onCreate(icicle);
		setContentView(new PointerLocationView(this));

		// Make the screen full bright for this activity.
		WindowManager.LayoutParams lp = getWindow().getAttributes();
		lp.screenBrightness = 1.0f;
		getWindow().setAttributes(lp);
	}
}

 


demo地址：http://download.csdn.net/detail/weiyirong/4969590

效果图：

Ronys
关注
专栏目录
multitouchtest:多点触控测试
05-08
多点触控测试 多点触控测试
Android重写ViewPager修改滑动灵敏度
DMT专栏
05-22 7393
使用ViewPager作为一个页面进行切换，里面可以存放很多View，但有时在操作View时不小心滑动一下就有可能跳到下一页，这并不是我们想要的，这里就需要重写ViewPager修改它的滑动条件 效果图 程序目录结构 BTViewPager.java package com.example.viewpagerdemo; import android.content.Con
安卓开发-触控检测apk的实现
while(true)
07-15 468
安卓开发，屏幕测试，触控检测，cts测试，cit测试，多点触控显示坐标轨迹，多点触控相关，PointID，PointIndex，HistorySize。
Android自定义View的多点触控
u014582176的博客
12-29 2727
在Android游戏开发中，自定义View的多点触控技术必不可少，本文主要简单讲解下Android中多点触控技术的基础知识。 所谓多点触控技术，就是手机屏幕上支持同时处理多个触控点的触屏或移动事件。多点触控的关键点有以下三点：（1）需要LCD和应用程序同时支持；（2）通过重写View类中的onTouchEvent()方法来实现；（3）通过event.getActionMasked()来分类处理
Android游戏开发：SurfaceView多点触控之完美钢琴游戏Demo
hawkol的专栏
09-09 1065
一、我们在使用SurfaceView开发小游戏时，如果需要在窗体上自绘按钮和可交互对象，这时需要监听屏幕的多点触控，并且每次触控的改变都需要和游戏产生交互，如何实现呢？ CSDN博客 @MXout 有一篇博文：Android自定义View的多点触控有很详细的介绍，让我们共同学习下，其中最主要的知识点如下： Android中多点触控技术的基础知识回顾： 对于单点触控，MotionEvent的...
安卓android 多点触控实例源代码
09-29
本实例源代码着重于展示如何在Android应用中实现多点触控功能，使开发者能够理解和掌握相关技术。 首先，要实现多点触控，你需要在AndroidManifest.xml文件中为你的Activity添加`android:configChanges="screenSize...
Android实现多点触控，自由缩放图片的实例代码
01-05
Android多点触控涉及到的知识点 1、ScaleGestureDetector 2、OnScaleGestureListener 3、Matrix 4、OnTouchListener 四个知识点需要了解一下，需要注意的是Matrix在内存中是一个一维数组，操控图片的Matrxi是...
[多点触控测试]不用app，手机怎么测试屏幕触控点数
热门推荐
技术改变世界
09-01 1万+
For Android : 打开 设置/系统/开发人员选项/显示点按操作反馈。 这样在屏幕上点按时就会有一个白色圆点出现。 打开一张比较暗的图片（遮住摄像头就能拍一张全黑的），全屏查看。 这时在屏幕上点按就可以清楚的看到触控点了。一般屏幕都支持到10点触控。 十个手指用上，再加上一支电容笔，数一下有没有超过10点？？？ 测试结果跟专门的测试软件结果一致。  2018-09-01 华为V8 ...
Appium 移动端自动化测试 —— 触摸(TouchAction) 与多点触控(MultiAction)
myh919的博客
11-02 230
在所有的 Appium 客户端库里，TouchAction 触摸对象被创建并被赋予一连串的事件。规范里可用的事件有： * 短按() * 释放() * 移动到() * 点击() * 等待() * 长按() * 取消() * 执行(注意： action.press(x=10,y=100).wait(100).move_to(el=ele).release() 只是将动作存储在action 对象中，还没有执行，具体执行动作要使用 action.perform()。
检测手机多点触摸数
m0_38056609的博客
07-09 538
检测手机多点触摸数
android 模拟触摸
Grindstone_Fos的博客
06-02 1116
package android.car.server.input; import android.car.utils.InputIoctl; import android.car.utils.touch.TouchWriter; import android.os.SystemClock; import android.util.Log; import android.view.InputDev
Appium 移动端自动化测试，触摸(TouchAction) 与多点触控(MultiAction)
最新发布
m0_58026506的博客
03-15 677
一、触摸 TouchAction、在所有的 Appium 客户端库里，TouchAction 触摸对象被创建并被赋予一连串的事件。规范里可用的事件有： * 短按(press) * 释放(release) * 移动到(moveTo) * 点击(tap) * 等待(wait) * 长按(longPress) * 取消(cancel) * 执行(perform)
Android通过代码模拟物理、屏幕点击事件
dawuafang
07-25 7031
本文讲的是通过使用代码，可以控制手机的屏幕和物理按键，也就是说不只是在某一个APP里去操作，而是整个手机系统。 getevent/sendevent getevent&amp;sendevent 是android系统下的一个工具，可以模拟多种按键和触屏操作，产生的是raw event，raw event经过event hub处理产生最终的gesture事件。getevent用于获取...
Airtest多点触控测试
Sodnrn的博客
04-27 1855
通过airtest实现多点按压和检测按压位置的RGB数值来判断测试是否成功。 代码: from airtest.core.api import * from airtest.core.android.touch_methods.base_touch import * from os import getcwd from PIL import Image # 连接设备 auto_setup(__file__,logdir=True,devices=["android://127.0.0.1:503.
【Android】android系统多点触控源码
且歌且行
10-10 992
原文：http://www.linuxidc.com/Linux/2011-10/44305.htm PointerLocation多点触控代码在Android系统源码中的位置分别为： android\development\apps\Development\src\com\android\development\PointerLocation.java android\fr
多点触摸和手势检测
骑着蜗牛找马儿
07-04 966
多点触摸及手势
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值