The Tor Browser / file comparison

comparison: widget/gonk/libui/PointerController.cpp

widget/gonk/libui/PointerController.cpp

changeset 0
6474c204b198
equal deleted inserted replaced
-1:000000000000 0:d7760997ac62
1 /*
2 * Copyright (C) 2010 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 #define LOG_TAG "PointerController"
18
19 //#define LOG_NDEBUG 0
20
21 // Log debug messages about pointer updates
22 #define DEBUG_POINTER_UPDATES 0
23
24 #include "PointerController.h"
25
26 #include "cutils_log.h"
27
28 #include <SkBitmap.h>
29 #include <SkCanvas.h>
30 #include <SkColor.h>
31 #include <SkPaint.h>
32 #include <SkXfermode.h>
33
34 namespace android {
35
36 // --- PointerController ---
37
38 // Time to wait before starting the fade when the pointer is inactive.
39 static const nsecs_t INACTIVITY_TIMEOUT_DELAY_TIME_NORMAL = 15 * 1000 * 1000000LL; // 15 seconds
40 static const nsecs_t INACTIVITY_TIMEOUT_DELAY_TIME_SHORT = 3 * 1000 * 1000000LL; // 3 seconds
41
42 // Time to wait between animation frames.
43 static const nsecs_t ANIMATION_FRAME_INTERVAL = 1000000000LL / 60;
44
45 // Time to spend fading out the spot completely.
46 static const nsecs_t SPOT_FADE_DURATION = 200 * 1000000LL; // 200 ms
47
48 // Time to spend fading out the pointer completely.
49 static const nsecs_t POINTER_FADE_DURATION = 500 * 1000000LL; // 500 ms
50
51
52 // --- PointerController ---
53
54 PointerController::PointerController(const sp<PointerControllerPolicyInterface>& policy,
55 const sp<Looper>& looper, const sp<SpriteController>& spriteController) :
56 mPolicy(policy), mLooper(looper), mSpriteController(spriteController) {
57 mHandler = new WeakMessageHandler(this);
58
59 AutoMutex _l(mLock);
60
61 mLocked.animationPending = false;
62
63 mLocked.displayWidth = -1;
64 mLocked.displayHeight = -1;
65 mLocked.displayOrientation = DISPLAY_ORIENTATION_0;
66
67 mLocked.presentation = PRESENTATION_POINTER;
68 mLocked.presentationChanged = false;
69
70 mLocked.inactivityTimeout = INACTIVITY_TIMEOUT_NORMAL;
71
72 mLocked.pointerFadeDirection = 0;
73 mLocked.pointerX = 0;
74 mLocked.pointerY = 0;
75 mLocked.pointerAlpha = 0.0f; // pointer is initially faded
76 mLocked.pointerSprite = mSpriteController->createSprite();
77 mLocked.pointerIconChanged = false;
78
79 mLocked.buttonState = 0;
80
81 loadResources();
82 }
83
84 PointerController::~PointerController() {
85 mLooper->removeMessages(mHandler);
86
87 AutoMutex _l(mLock);
88
89 mLocked.pointerSprite.clear();
90
91 for (size_t i = 0; i < mLocked.spots.size(); i++) {
92 delete mLocked.spots.itemAt(i);
93 }
94 mLocked.spots.clear();
95 mLocked.recycledSprites.clear();
96 }
97
98 bool PointerController::getBounds(float* outMinX, float* outMinY,
99 float* outMaxX, float* outMaxY) const {
100 AutoMutex _l(mLock);
101
102 return getBoundsLocked(outMinX, outMinY, outMaxX, outMaxY);
103 }
104
105 bool PointerController::getBoundsLocked(float* outMinX, float* outMinY,
106 float* outMaxX, float* outMaxY) const {
107 if (mLocked.displayWidth <= 0 || mLocked.displayHeight <= 0) {
108 return false;
109 }
110
111 *outMinX = 0;
112 *outMinY = 0;
113 switch (mLocked.displayOrientation) {
114 case DISPLAY_ORIENTATION_90:
115 case DISPLAY_ORIENTATION_270:
116 *outMaxX = mLocked.displayHeight - 1;
117 *outMaxY = mLocked.displayWidth - 1;
118 break;
119 default:
120 *outMaxX = mLocked.displayWidth - 1;
121 *outMaxY = mLocked.displayHeight - 1;
122 break;
123 }
124 return true;
125 }
126
127 void PointerController::move(float deltaX, float deltaY) {
128 #if DEBUG_POINTER_UPDATES
129 ALOGD("Move pointer by deltaX=%0.3f, deltaY=%0.3f", deltaX, deltaY);
130 #endif
131 if (deltaX == 0.0f && deltaY == 0.0f) {
132 return;
133 }
134
135 AutoMutex _l(mLock);
136
137 setPositionLocked(mLocked.pointerX + deltaX, mLocked.pointerY + deltaY);
138 }
139
140 void PointerController::setButtonState(int32_t buttonState) {
141 #if DEBUG_POINTER_UPDATES
142 ALOGD("Set button state 0x%08x", buttonState);
143 #endif
144 AutoMutex _l(mLock);
145
146 if (mLocked.buttonState != buttonState) {
147 mLocked.buttonState = buttonState;
148 }
149 }
150
151 int32_t PointerController::getButtonState() const {
152 AutoMutex _l(mLock);
153
154 return mLocked.buttonState;
155 }
156
157 void PointerController::setPosition(float x, float y) {
158 #if DEBUG_POINTER_UPDATES
159 ALOGD("Set pointer position to x=%0.3f, y=%0.3f", x, y);
160 #endif
161 AutoMutex _l(mLock);
162
163 setPositionLocked(x, y);
164 }
165
166 void PointerController::setPositionLocked(float x, float y) {
167 float minX, minY, maxX, maxY;
168 if (getBoundsLocked(&minX, &minY, &maxX, &maxY)) {
169 if (x <= minX) {
170 mLocked.pointerX = minX;
171 } else if (x >= maxX) {
172 mLocked.pointerX = maxX;
173 } else {
174 mLocked.pointerX = x;
175 }
176 if (y <= minY) {
177 mLocked.pointerY = minY;
178 } else if (y >= maxY) {
179 mLocked.pointerY = maxY;
180 } else {
181 mLocked.pointerY = y;
182 }
183 updatePointerLocked();
184 }
185 }
186
187 void PointerController::getPosition(float* outX, float* outY) const {
188 AutoMutex _l(mLock);
189
190 *outX = mLocked.pointerX;
191 *outY = mLocked.pointerY;
192 }
193
194 void PointerController::fade(Transition transition) {
195 AutoMutex _l(mLock);
196
197 // Remove the inactivity timeout, since we are fading now.
198 removeInactivityTimeoutLocked();
199
200 // Start fading.
201 if (transition == TRANSITION_IMMEDIATE) {
202 mLocked.pointerFadeDirection = 0;
203 mLocked.pointerAlpha = 0.0f;
204 updatePointerLocked();
205 } else {
206 mLocked.pointerFadeDirection = -1;
207 startAnimationLocked();
208 }
209 }
210
211 void PointerController::unfade(Transition transition) {
212 AutoMutex _l(mLock);
213
214 // Always reset the inactivity timer.
215 resetInactivityTimeoutLocked();
216
217 // Start unfading.
218 if (transition == TRANSITION_IMMEDIATE) {
219 mLocked.pointerFadeDirection = 0;
220 mLocked.pointerAlpha = 1.0f;
221 updatePointerLocked();
222 } else {
223 mLocked.pointerFadeDirection = 1;
224 startAnimationLocked();
225 }
226 }
227
228 void PointerController::setPresentation(Presentation presentation) {
229 AutoMutex _l(mLock);
230
231 if (mLocked.presentation != presentation) {
232 mLocked.presentation = presentation;
233 mLocked.presentationChanged = true;
234
235 if (presentation != PRESENTATION_SPOT) {
236 fadeOutAndReleaseAllSpotsLocked();
237 }
238
239 updatePointerLocked();
240 }
241 }
242
243 void PointerController::setSpots(const PointerCoords* spotCoords,
244 const uint32_t* spotIdToIndex, BitSet32 spotIdBits) {
245 #if DEBUG_POINTER_UPDATES
246 ALOGD("setSpots: idBits=%08x", spotIdBits.value);
247 for (BitSet32 idBits(spotIdBits); !idBits.isEmpty(); ) {
248 uint32_t id = idBits.firstMarkedBit();
249 idBits.clearBit(id);
250 const PointerCoords& c = spotCoords[spotIdToIndex[id]];
251 ALOGD(" spot %d: position=(%0.3f, %0.3f), pressure=%0.3f", id,
252 c.getAxisValue(AMOTION_EVENT_AXIS_X),
253 c.getAxisValue(AMOTION_EVENT_AXIS_Y),
254 c.getAxisValue(AMOTION_EVENT_AXIS_PRESSURE));
255 }
256 #endif
257
258 AutoMutex _l(mLock);
259
260 mSpriteController->openTransaction();
261
262 // Add or move spots for fingers that are down.
263 for (BitSet32 idBits(spotIdBits); !idBits.isEmpty(); ) {
264 uint32_t id = idBits.clearFirstMarkedBit();
265 const PointerCoords& c = spotCoords[spotIdToIndex[id]];
266 const SpriteIcon& icon = c.getAxisValue(AMOTION_EVENT_AXIS_PRESSURE) > 0
267 ? mResources.spotTouch : mResources.spotHover;
268 float x = c.getAxisValue(AMOTION_EVENT_AXIS_X);
269 float y = c.getAxisValue(AMOTION_EVENT_AXIS_Y);
270
271 Spot* spot = getSpotLocked(id);
272 if (!spot) {
273 spot = createAndAddSpotLocked(id);
274 }
275
276 spot->updateSprite(&icon, x, y);
277 }
278
279 // Remove spots for fingers that went up.
280 for (size_t i = 0; i < mLocked.spots.size(); i++) {
281 Spot* spot = mLocked.spots.itemAt(i);
282 if (spot->id != Spot::INVALID_ID
283 && !spotIdBits.hasBit(spot->id)) {
284 fadeOutAndReleaseSpotLocked(spot);
285 }
286 }
287
288 mSpriteController->closeTransaction();
289 }
290
291 void PointerController::clearSpots() {
292 #if DEBUG_POINTER_UPDATES
293 ALOGD("clearSpots");
294 #endif
295
296 AutoMutex _l(mLock);
297
298 fadeOutAndReleaseAllSpotsLocked();
299 }
300
301 void PointerController::setInactivityTimeout(InactivityTimeout inactivityTimeout) {
302 AutoMutex _l(mLock);
303
304 if (mLocked.inactivityTimeout != inactivityTimeout) {
305 mLocked.inactivityTimeout = inactivityTimeout;
306 resetInactivityTimeoutLocked();
307 }
308 }
309
310 void PointerController::setDisplayViewport(int32_t width, int32_t height, int32_t orientation) {
311 AutoMutex _l(mLock);
312
313 // Adjust to use the display's unrotated coordinate frame.
314 if (orientation == DISPLAY_ORIENTATION_90
315 || orientation == DISPLAY_ORIENTATION_270) {
316 int32_t temp = height;
317 height = width;
318 width = temp;
319 }
320
321 if (mLocked.displayWidth != width || mLocked.displayHeight != height) {
322 mLocked.displayWidth = width;
323 mLocked.displayHeight = height;
324
325 float minX, minY, maxX, maxY;
326 if (getBoundsLocked(&minX, &minY, &maxX, &maxY)) {
327 mLocked.pointerX = (minX + maxX) * 0.5f;
328 mLocked.pointerY = (minY + maxY) * 0.5f;
329 } else {
330 mLocked.pointerX = 0;
331 mLocked.pointerY = 0;
332 }
333
334 fadeOutAndReleaseAllSpotsLocked();
335 }
336
337 if (mLocked.displayOrientation != orientation) {
338 // Apply offsets to convert from the pixel top-left corner position to the pixel center.
339 // This creates an invariant frame of reference that we can easily rotate when
340 // taking into account that the pointer may be located at fractional pixel offsets.
341 float x = mLocked.pointerX + 0.5f;
342 float y = mLocked.pointerY + 0.5f;
343 float temp;
344
345 // Undo the previous rotation.
346 switch (mLocked.displayOrientation) {
347 case DISPLAY_ORIENTATION_90:
348 temp = x;
349 x = mLocked.displayWidth - y;
350 y = temp;
351 break;
352 case DISPLAY_ORIENTATION_180:
353 x = mLocked.displayWidth - x;
354 y = mLocked.displayHeight - y;
355 break;
356 case DISPLAY_ORIENTATION_270:
357 temp = x;
358 x = y;
359 y = mLocked.displayHeight - temp;
360 break;
361 }
362
363 // Perform the new rotation.
364 switch (orientation) {
365 case DISPLAY_ORIENTATION_90:
366 temp = x;
367 x = y;
368 y = mLocked.displayWidth - temp;
369 break;
370 case DISPLAY_ORIENTATION_180:
371 x = mLocked.displayWidth - x;
372 y = mLocked.displayHeight - y;
373 break;
374 case DISPLAY_ORIENTATION_270:
375 temp = x;
376 x = mLocked.displayHeight - y;
377 y = temp;
378 break;
379 }
380
381 // Apply offsets to convert from the pixel center to the pixel top-left corner position
382 // and save the results.
383 mLocked.pointerX = x - 0.5f;
384 mLocked.pointerY = y - 0.5f;
385 mLocked.displayOrientation = orientation;
386 }
387
388 updatePointerLocked();
389 }
390
391 void PointerController::setPointerIcon(const SpriteIcon& icon) {
392 AutoMutex _l(mLock);
393
394 mLocked.pointerIcon = icon.copy();
395 mLocked.pointerIconChanged = true;
396
397 updatePointerLocked();
398 }
399
400 void PointerController::handleMessage(const Message& message) {
401 switch (message.what) {
402 case MSG_ANIMATE:
403 doAnimate();
404 break;
405 case MSG_INACTIVITY_TIMEOUT:
406 doInactivityTimeout();
407 break;
408 }
409 }
410
411 void PointerController::doAnimate() {
412 AutoMutex _l(mLock);
413
414 bool keepAnimating = false;
415 mLocked.animationPending = false;
416 nsecs_t frameDelay = systemTime(SYSTEM_TIME_MONOTONIC) - mLocked.animationTime;
417
418 // Animate pointer fade.
419 if (mLocked.pointerFadeDirection < 0) {
420 mLocked.pointerAlpha -= float(frameDelay) / POINTER_FADE_DURATION;
421 if (mLocked.pointerAlpha <= 0.0f) {
422 mLocked.pointerAlpha = 0.0f;
423 mLocked.pointerFadeDirection = 0;
424 } else {
425 keepAnimating = true;
426 }
427 updatePointerLocked();
428 } else if (mLocked.pointerFadeDirection > 0) {
429 mLocked.pointerAlpha += float(frameDelay) / POINTER_FADE_DURATION;
430 if (mLocked.pointerAlpha >= 1.0f) {
431 mLocked.pointerAlpha = 1.0f;
432 mLocked.pointerFadeDirection = 0;
433 } else {
434 keepAnimating = true;
435 }
436 updatePointerLocked();
437 }
438
439 // Animate spots that are fading out and being removed.
440 for (size_t i = 0; i < mLocked.spots.size(); i++) {
441 Spot* spot = mLocked.spots.itemAt(i);
442 if (spot->id == Spot::INVALID_ID) {
443 spot->alpha -= float(frameDelay) / SPOT_FADE_DURATION;
444 if (spot->alpha <= 0) {
445 mLocked.spots.removeAt(i--);
446 releaseSpotLocked(spot);
447 } else {
448 spot->sprite->setAlpha(spot->alpha);
449 keepAnimating = true;
450 }
451 }
452 }
453
454 if (keepAnimating) {
455 startAnimationLocked();
456 }
457 }
458
459 void PointerController::doInactivityTimeout() {
460 fade(TRANSITION_GRADUAL);
461 }
462
463 void PointerController::startAnimationLocked() {
464 if (!mLocked.animationPending) {
465 mLocked.animationPending = true;
466 mLocked.animationTime = systemTime(SYSTEM_TIME_MONOTONIC);
467 mLooper->sendMessageDelayed(ANIMATION_FRAME_INTERVAL, mHandler, Message(MSG_ANIMATE));
468 }
469 }
470
471 void PointerController::resetInactivityTimeoutLocked() {
472 mLooper->removeMessages(mHandler, MSG_INACTIVITY_TIMEOUT);
473
474 nsecs_t timeout = mLocked.inactivityTimeout == INACTIVITY_TIMEOUT_SHORT
475 ? INACTIVITY_TIMEOUT_DELAY_TIME_SHORT : INACTIVITY_TIMEOUT_DELAY_TIME_NORMAL;
476 mLooper->sendMessageDelayed(timeout, mHandler, MSG_INACTIVITY_TIMEOUT);
477 }
478
479 void PointerController::removeInactivityTimeoutLocked() {
480 mLooper->removeMessages(mHandler, MSG_INACTIVITY_TIMEOUT);
481 }
482
483 void PointerController::updatePointerLocked() {
484 mSpriteController->openTransaction();
485
486 mLocked.pointerSprite->setLayer(Sprite::BASE_LAYER_POINTER);
487 mLocked.pointerSprite->setPosition(mLocked.pointerX, mLocked.pointerY);
488
489 if (mLocked.pointerAlpha > 0) {
490 mLocked.pointerSprite->setAlpha(mLocked.pointerAlpha);
491 mLocked.pointerSprite->setVisible(true);
492 } else {
493 mLocked.pointerSprite->setVisible(false);
494 }
495
496 if (mLocked.pointerIconChanged || mLocked.presentationChanged) {
497 mLocked.pointerSprite->setIcon(mLocked.presentation == PRESENTATION_POINTER
498 ? mLocked.pointerIcon : mResources.spotAnchor);
499 mLocked.pointerIconChanged = false;
500 mLocked.presentationChanged = false;
501 }
502
503 mSpriteController->closeTransaction();
504 }
505
506 PointerController::Spot* PointerController::getSpotLocked(uint32_t id) {
507 for (size_t i = 0; i < mLocked.spots.size(); i++) {
508 Spot* spot = mLocked.spots.itemAt(i);
509 if (spot->id == id) {
510 return spot;
511 }
512 }
513 return NULL;
514 }
515
516 PointerController::Spot* PointerController::createAndAddSpotLocked(uint32_t id) {
517 // Remove spots until we have fewer than MAX_SPOTS remaining.
518 while (mLocked.spots.size() >= MAX_SPOTS) {
519 Spot* spot = removeFirstFadingSpotLocked();
520 if (!spot) {
521 spot = mLocked.spots.itemAt(0);
522 mLocked.spots.removeAt(0);
523 }
524 releaseSpotLocked(spot);
525 }
526
527 // Obtain a sprite from the recycled pool.
528 sp<Sprite> sprite;
529 if (! mLocked.recycledSprites.isEmpty()) {
530 sprite = mLocked.recycledSprites.top();
531 mLocked.recycledSprites.pop();
532 } else {
533 sprite = mSpriteController->createSprite();
534 }
535
536 // Return the new spot.
537 Spot* spot = new Spot(id, sprite);
538 mLocked.spots.push(spot);
539 return spot;
540 }
541
542 PointerController::Spot* PointerController::removeFirstFadingSpotLocked() {
543 for (size_t i = 0; i < mLocked.spots.size(); i++) {
544 Spot* spot = mLocked.spots.itemAt(i);
545 if (spot->id == Spot::INVALID_ID) {
546 mLocked.spots.removeAt(i);
547 return spot;
548 }
549 }
550 return NULL;
551 }
552
553 void PointerController::releaseSpotLocked(Spot* spot) {
554 spot->sprite->clearIcon();
555
556 if (mLocked.recycledSprites.size() < MAX_RECYCLED_SPRITES) {
557 mLocked.recycledSprites.push(spot->sprite);
558 }
559
560 delete spot;
561 }
562
563 void PointerController::fadeOutAndReleaseSpotLocked(Spot* spot) {
564 if (spot->id != Spot::INVALID_ID) {
565 spot->id = Spot::INVALID_ID;
566 startAnimationLocked();
567 }
568 }
569
570 void PointerController::fadeOutAndReleaseAllSpotsLocked() {
571 for (size_t i = 0; i < mLocked.spots.size(); i++) {
572 Spot* spot = mLocked.spots.itemAt(i);
573 fadeOutAndReleaseSpotLocked(spot);
574 }
575 }
576
577 void PointerController::loadResources() {
578 mPolicy->loadPointerResources(&mResources);
579 }
580
581
582 // --- PointerController::Spot ---
583
584 void PointerController::Spot::updateSprite(const SpriteIcon* icon, float x, float y) {
585 sprite->setLayer(Sprite::BASE_LAYER_SPOT + id);
586 sprite->setAlpha(alpha);
587 sprite->setTransformationMatrix(SpriteTransformationMatrix(scale, 0.0f, 0.0f, scale));
588 sprite->setPosition(x, y);
589
590 this->x = x;
591 this->y = y;
592
593 if (icon != lastIcon) {
594 lastIcon = icon;
595 if (icon) {
596 sprite->setIcon(*icon);
597 sprite->setVisible(true);
598 } else {
599 sprite->setVisible(false);
600 }
601 }
602 }
603
604 } // namespace android

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial