Links
Android Sites
Language
Results
Loading...
1
/*
2
* Copyright (C) 2013 The Android Open Source Project
3
*
4
* Licensed under the Apache License, Version 2.0 (the "License");
5
* you may not use this file except in compliance with the License.
6
* You may obtain a copy of the License at
7
*
8
* http://www.apache.org/licenses/LICENSE-2.0
9
*
10
* Unless required by applicable law or agreed to in writing, software
11
* distributed under the License is distributed on an "AS IS" BASIS,
12
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13
* See the License for the specific language governing permissions and
14
* limitations under the License.
15
*/
16
17
package com.example.android.basicmultitouch;
18
19
import android.content.Context;
20
import android.graphics.Canvas;
21
import android.graphics.Color;
22
import android.graphics.Paint;
23
import android.graphics.PointF;
24
import android.util.AttributeSet;
25
import android.util.SparseArray;
26
import android.view.MotionEvent;
27
import android.view.View;
28
29
import com.example.android.basicmultitouch.Pools.SimplePool;
30
31
/**
32
* View that shows touch events and their history. This view demonstrates the
33
* use of {@link #onTouchEvent(android.view.MotionEvent)} and {@link android.view.MotionEvent}s to keep
34
* track of touch pointers across events.
35
*/
36
public class TouchDisplayView extends View {
37
38
// Hold data for active touch pointer IDs
39
private SparseArray<TouchHistory> mTouches;
40
41
// Is there an active touch?
42
private boolean mHasTouch = false;
43
44
/**
45
* Holds data related to a touch pointer, including its current position,
46
* pressure and historical positions. Objects are allocated through an
47
* object pool using {@link #obtain()} and {@link #recycle()} to reuse
48
* existing objects.
49
*/
50
static final class TouchHistory {
51
52
// number of historical points to store
53
public static final int HISTORY_COUNT = 20;
54
55
public float x;
56
public float y;
57
public float pressure = 0f;
58
public String label = null;
59
60
// current position in history array
61
public int historyIndex = 0;
62
public int historyCount = 0;
63
64
// arrray of pointer position history
65
public PointF[] history = new PointF[HISTORY_COUNT];
66
67
private static final int MAX_POOL_SIZE = 10;
68
private static final SimplePool<TouchHistory> sPool =
69
new SimplePool<TouchHistory>(MAX_POOL_SIZE);
70
71
public static TouchHistory obtain(float x, float y, float pressure) {
72
TouchHistory data = sPool.acquire();
73
if (data == null) {
74
data = new TouchHistory();
75
}
76
77
data.setTouch(x, y, pressure);
78
79
return data;
80
}
81
82
public TouchHistory() {
83
84
// initialise history array
85
for (int i = 0; i < HISTORY_COUNT; i++) {
86
history[i] = new PointF();
87
}
88
}
89
90
public void setTouch(float x, float y, float pressure) {
91
this.x = x;
92
this.y = y;
93
this.pressure = pressure;
94
}
95
96
public void recycle() {
97
this.historyIndex = 0;
98
this.historyCount = 0;
99
sPool.release(this);
100
}
101
102
/**
103
* Add a point to its history. Overwrites oldest point if the maximum
104
* number of historical points is already stored.
105
*
106
* @param point
107
*/
108
public void addHistory(float x, float y) {
109
PointF p = history[historyIndex];
110
p.x = x;
111
p.y = y;
112
113
historyIndex = (historyIndex + 1) % history.length;
114
115
if (historyCount < HISTORY_COUNT) {
116
historyCount++;
117
}
118
}
119
120
}
121
122
public TouchDisplayView(Context context, AttributeSet attrs) {
123
super(context, attrs);
124
125
// SparseArray for touch events, indexed by touch id
126
mTouches = new SparseArray<TouchHistory>(10);
127
128
initialisePaint();
129
}
130
132
@Override
133
public boolean onTouchEvent(MotionEvent event) {
134
135
final int action = event.getAction();
136
137
/*
138
* Switch on the action. The action is extracted from the event by
139
* applying the MotionEvent.ACTION_MASK. Alternatively a call to
140
* event.getActionMasked() would yield in the action as well.
141
*/
142
switch (action & MotionEvent.ACTION_MASK) {
143
144
case MotionEvent.ACTION_DOWN: {
145
// first pressed gesture has started
146
147
/*
148
* Only one touch event is stored in the MotionEvent. Extract
149
* the pointer identifier of this touch from the first index
150
* within the MotionEvent object.
151
*/
152
int id = event.getPointerId(0);
153
154
TouchHistory data = TouchHistory.obtain(event.getX(0), event.getY(0),
155
event.getPressure(0));
156
data.label = "id: " + 0;
157
158
/*
159
* Store the data under its pointer identifier. The pointer
160
* number stays consistent for the duration of a gesture,
161
* accounting for other pointers going up or down.
162
*/
163
mTouches.put(id, data);
164
165
mHasTouch = true;
166
167
break;
168
}
169
170
case MotionEvent.ACTION_POINTER_DOWN: {
171
/*
172
* A non-primary pointer has gone down, after an event for the
173
* primary pointer (ACTION_DOWN) has already been received.
174
*/
175
176
/*
177
* The MotionEvent object contains multiple pointers. Need to
178
* extract the index at which the data for this particular event
179
* is stored.
180
*/
181
int index = event.getActionIndex();
182
int id = event.getPointerId(index);
183
184
TouchHistory data = TouchHistory.obtain(event.getX(index), event.getY(index),
185
event.getPressure(index));
186
data.label = "id: " + id;
187
188
/*
189
* Store the data under its pointer identifier. The index of
190
* this pointer can change over multiple events, but this
191
* pointer is always identified by the same identifier for this
192
* active gesture.
193
*/
194
mTouches.put(id, data);
195
196
break;
197
}
198
199
case MotionEvent.ACTION_UP: {
200
/*
201
* Final pointer has gone up and has ended the last pressed
202
* gesture.
203
*/
204
205
/*
206
* Extract the pointer identifier for the only event stored in
207
* the MotionEvent object and remove it from the list of active
208
* touches.
209
*/
210
int id = event.getPointerId(0);
211
TouchHistory data = mTouches.get(id);
212
mTouches.remove(id);
213
data.recycle();
214
215
mHasTouch = false;
216
217
break;
218
}
219
220
case MotionEvent.ACTION_POINTER_UP: {
221
/*
222
* A non-primary pointer has gone up and other pointers are
223
* still active.
224
*/
225
226
/*
227
* The MotionEvent object contains multiple pointers. Need to
228
* extract the index at which the data for this particular event
229
* is stored.
230
*/
231
int index = event.getActionIndex();
232
int id = event.getPointerId(index);
233
234
TouchHistory data = mTouches.get(id);
235
mTouches.remove(id);
236
data.recycle();
237
238
break;
239
}
240
241
case MotionEvent.ACTION_MOVE: {
242
/*
243
* A change event happened during a pressed gesture. (Between
244
* ACTION_DOWN and ACTION_UP or ACTION_POINTER_DOWN and
245
* ACTION_POINTER_UP)
246
*/
247
248
/*
249
* Loop through all active pointers contained within this event.
250
* Data for each pointer is stored in a MotionEvent at an index
251
* (starting from 0 up to the number of active pointers). This
252
* loop goes through each of these active pointers, extracts its
253
* data (position and pressure) and updates its stored data. A
254
* pointer is identified by its pointer number which stays
255
* constant across touch events as long as it remains active.
256
* This identifier is used to keep track of a pointer across
257
* events.
258
*/
259
for (int index = 0; index < event.getPointerCount(); index++) {
260
// get pointer id for data stored at this index
261
int id = event.getPointerId(index);
262
263
// get the data stored externally about this pointer.
264
TouchHistory data = mTouches.get(id);
265
266
// add previous position to history and add new values
267
data.addHistory(data.x, data.y);
268
data.setTouch(event.getX(index), event.getY(index),
269
event.getPressure(index));
270
271
}
272
273
break;
274
}
275
}
276
277
// trigger redraw on UI thread
278
this.postInvalidate();
279
280
return true;
281
}
282
284
285
@Override
286
protected void onDraw(Canvas canvas) {
287
super.onDraw(canvas);
288
289
// Canvas background color depends on whether there is an active touch
290
if (mHasTouch) {
291
canvas.drawColor(BACKGROUND_ACTIVE);
292
} else {
293
// draw inactive border
294
canvas.drawRect(mBorderWidth, mBorderWidth, getWidth() - mBorderWidth, getHeight()
295
- mBorderWidth, mBorderPaint);
296
}
297
298
// loop through all active touches and draw them
299
for (int i = 0; i < mTouches.size(); i++) {
300
301
// get the pointer id and associated data for this index
302
int id = mTouches.keyAt(i);
303
TouchHistory data = mTouches.valueAt(i);
304
305
// draw the data and its history to the canvas
306
drawCircle(canvas, id, data);
307
}
308
}
309
310
/*
311
* Below are only helper methods and variables required for drawing.
312
*/
313
314
// radius of active touch circle in dp
315
private static final float CIRCLE_RADIUS_DP = 75f;
316
// radius of historical circle in dp
317
private static final float CIRCLE_HISTORICAL_RADIUS_DP = 7f;
318
319
// calculated radiuses in px
320
private float mCircleRadius;
321
private float mCircleHistoricalRadius;
322
323
private Paint mCirclePaint = new Paint();
324
private Paint mTextPaint = new Paint();
325
326
private static final int BACKGROUND_ACTIVE = Color.WHITE;
327
328
// inactive border
329
private static final float INACTIVE_BORDER_DP = 15f;
330
private static final int INACTIVE_BORDER_COLOR = 0xFFffd060;
331
private Paint mBorderPaint = new Paint();
332
private float mBorderWidth;
333
334
public final int[] COLORS = {
335
0xFF33B5E5, 0xFFAA66CC, 0xFF99CC00, 0xFFFFBB33, 0xFFFF4444,
336
0xFF0099CC, 0xFF9933CC, 0xFF669900, 0xFFFF8800, 0xFFCC0000
337
};
338
339
/**
340
* Sets up the required {@link android.graphics.Paint} objects for the screen density of this
341
* device.
342
*/
343
private void initialisePaint() {
344
345
// Calculate radiuses in px from dp based on screen density
346
float density = getResources().getDisplayMetrics().density;
347
mCircleRadius = CIRCLE_RADIUS_DP * density;
348
mCircleHistoricalRadius = CIRCLE_HISTORICAL_RADIUS_DP * density;
349
350
// Setup text paint for circle label
351
mTextPaint.setTextSize(27f);
352
mTextPaint.setColor(Color.BLACK);
353
354
// Setup paint for inactive border
355
mBorderWidth = INACTIVE_BORDER_DP * density;
356
mBorderPaint.setStrokeWidth(mBorderWidth);
357
mBorderPaint.setColor(INACTIVE_BORDER_COLOR);
358
mBorderPaint.setStyle(Paint.Style.STROKE);
359
360
}
361
362
/**
363
* Draws the data encapsulated by a {@link TouchDisplayView.TouchHistory} object to a canvas.
364
* A large circle indicates the current position held by the
365
* {@link TouchDisplayView.TouchHistory} object, while a smaller circle is drawn for each
366
* entry in its history. The size of the large circle is scaled depending on
367
* its pressure, clamped to a maximum of <code>1.0</code>.
368
*
369
* @param canvas
370
* @param id
371
* @param data
372
*/
373
protected void drawCircle(Canvas canvas, int id, TouchHistory data) {
374
// select the color based on the id
375
int color = COLORS[id % COLORS.length];
376
mCirclePaint.setColor(color);
377
378
/*
379
* Draw the circle, size scaled to its pressure. Pressure is clamped to
380
* 1.0 max to ensure proper drawing. (Reported pressure values can
381
* exceed 1.0, depending on the calibration of the touch screen).
382
*/
383
float pressure = Math.min(data.pressure, 1f);
384
float radius = pressure * mCircleRadius;
385
386
canvas.drawCircle(data.x, (data.y) - (radius / 2f), radius,
387
mCirclePaint);
388
389
// draw all historical points with a lower alpha value
390
mCirclePaint.setAlpha(125);
391
for (int j = 0; j < data.history.length && j < data.historyCount; j++) {
392
PointF p = data.history[j];
393
canvas.drawCircle(p.x, p.y, mCircleHistoricalRadius, mCirclePaint);
394
}
395
396
// draw its label next to the main circle
397
canvas.drawText(data.label, data.x + radius, data.y
398
- radius, mTextPaint);
399
}
400
401
}