PointerController.cpp revision 1afd5bab4e0eaba8b5bc2ab5c7b556cd602cf2e7 
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
34namespace android {
35
36// --- PointerController ---
37
38// Time to wait before starting the fade when the pointer is inactive.
39static const nsecs_t INACTIVITY_TIMEOUT_DELAY_TIME_NORMAL = 15 * 1000 * 1000000LL; // 15 seconds
40static const nsecs_t INACTIVITY_TIMEOUT_DELAY_TIME_SHORT = 3 * 1000 * 1000000LL; // 3 seconds
41
42// Time to wait between animation frames.
43static const nsecs_t ANIMATION_FRAME_INTERVAL = 1000000000LL / 60;
44
45// Time to spend fading out the spot completely.
46static const nsecs_t SPOT_FADE_DURATION = 200 * 1000000LL; // 200 ms
47
48// Time to spend fading out the pointer completely.
49static const nsecs_t POINTER_FADE_DURATION = 500 * 1000000LL; // 500 ms
50
51
52// --- PointerController ---
53
54PointerController::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
84PointerController::~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
98bool 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
105bool 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
127void 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
140void 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
151int32_t PointerController::getButtonState() const {
152    AutoMutex _l(mLock);
153
154    return mLocked.buttonState;
155}
156
157void 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
166void 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
187void PointerController::getPosition(float* outX, float* outY) const {
188    AutoMutex _l(mLock);
189
190    *outX = mLocked.pointerX;
191    *outY = mLocked.pointerY;
192}
193
194void 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
211void 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
228void 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
243void 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
291void PointerController::clearSpots() {
292#if DEBUG_POINTER_UPDATES
293    ALOGD("clearSpots");
294#endif
295
296    AutoMutex _l(mLock);
297
298    fadeOutAndReleaseAllSpotsLocked();
299}
300
301void PointerController::setInactivityTimeout(InactivityTimeout inactivityTimeout) {
302    AutoMutex _l(mLock);
303
304    if (mLocked.inactivityTimeout != inactivityTimeout) {
305        mLocked.inactivityTimeout = inactivityTimeout;
306        resetInactivityTimeoutLocked();
307    }
308}
309
310void PointerController::setDisplaySize(int32_t width, int32_t height) {
311    AutoMutex _l(mLock);
312
313    if (mLocked.displayWidth != width || mLocked.displayHeight != height) {
314        mLocked.displayWidth = width;
315        mLocked.displayHeight = height;
316
317        float minX, minY, maxX, maxY;
318        if (getBoundsLocked(&minX, &minY, &maxX, &maxY)) {
319            mLocked.pointerX = (minX + maxX) * 0.5f;
320            mLocked.pointerY = (minY + maxY) * 0.5f;
321        } else {
322            mLocked.pointerX = 0;
323            mLocked.pointerY = 0;
324        }
325
326        fadeOutAndReleaseAllSpotsLocked();
327        updatePointerLocked();
328    }
329}
330
331void PointerController::setDisplayOrientation(int32_t orientation) {
332    AutoMutex _l(mLock);
333
334    if (mLocked.displayOrientation != orientation) {
335        // Apply offsets to convert from the pixel top-left corner position to the pixel center.
336        // This creates an invariant frame of reference that we can easily rotate when
337        // taking into account that the pointer may be located at fractional pixel offsets.
338        float x = mLocked.pointerX + 0.5f;
339        float y = mLocked.pointerY + 0.5f;
340        float temp;
341
342        // Undo the previous rotation.
343        switch (mLocked.displayOrientation) {
344        case DISPLAY_ORIENTATION_90:
345            temp = x;
346            x = mLocked.displayWidth - y;
347            y = temp;
348            break;
349        case DISPLAY_ORIENTATION_180:
350            x = mLocked.displayWidth - x;
351            y = mLocked.displayHeight - y;
352            break;
353        case DISPLAY_ORIENTATION_270:
354            temp = x;
355            x = y;
356            y = mLocked.displayHeight - temp;
357            break;
358        }
359
360        // Perform the new rotation.
361        switch (orientation) {
362        case DISPLAY_ORIENTATION_90:
363            temp = x;
364            x = y;
365            y = mLocked.displayWidth - temp;
366            break;
367        case DISPLAY_ORIENTATION_180:
368            x = mLocked.displayWidth - x;
369            y = mLocked.displayHeight - y;
370            break;
371        case DISPLAY_ORIENTATION_270:
372            temp = x;
373            x = mLocked.displayHeight - y;
374            y = temp;
375            break;
376        }
377
378        // Apply offsets to convert from the pixel center to the pixel top-left corner position
379        // and save the results.
380        mLocked.pointerX = x - 0.5f;
381        mLocked.pointerY = y - 0.5f;
382        mLocked.displayOrientation = orientation;
383
384        updatePointerLocked();
385    }
386}
387
388void PointerController::setPointerIcon(const SpriteIcon& icon) {
389    AutoMutex _l(mLock);
390
391    mLocked.pointerIcon = icon.copy();
392    mLocked.pointerIconChanged = true;
393
394    updatePointerLocked();
395}
396
397void PointerController::handleMessage(const Message& message) {
398    switch (message.what) {
399    case MSG_ANIMATE:
400        doAnimate();
401        break;
402    case MSG_INACTIVITY_TIMEOUT:
403        doInactivityTimeout();
404        break;
405    }
406}
407
408void PointerController::doAnimate() {
409    AutoMutex _l(mLock);
410
411    bool keepAnimating = false;
412    mLocked.animationPending = false;
413    nsecs_t frameDelay = systemTime(SYSTEM_TIME_MONOTONIC) - mLocked.animationTime;
414
415    // Animate pointer fade.
416    if (mLocked.pointerFadeDirection < 0) {
417        mLocked.pointerAlpha -= float(frameDelay) / POINTER_FADE_DURATION;
418        if (mLocked.pointerAlpha <= 0.0f) {
419            mLocked.pointerAlpha = 0.0f;
420            mLocked.pointerFadeDirection = 0;
421        } else {
422            keepAnimating = true;
423        }
424        updatePointerLocked();
425    } else if (mLocked.pointerFadeDirection > 0) {
426        mLocked.pointerAlpha += float(frameDelay) / POINTER_FADE_DURATION;
427        if (mLocked.pointerAlpha >= 1.0f) {
428            mLocked.pointerAlpha = 1.0f;
429            mLocked.pointerFadeDirection = 0;
430        } else {
431            keepAnimating = true;
432        }
433        updatePointerLocked();
434    }
435
436    // Animate spots that are fading out and being removed.
437    for (size_t i = 0; i < mLocked.spots.size(); i++) {
438        Spot* spot = mLocked.spots.itemAt(i);
439        if (spot->id == Spot::INVALID_ID) {
440            spot->alpha -= float(frameDelay) / SPOT_FADE_DURATION;
441            if (spot->alpha <= 0) {
442                mLocked.spots.removeAt(i--);
443                releaseSpotLocked(spot);
444            } else {
445                spot->sprite->setAlpha(spot->alpha);
446                keepAnimating = true;
447            }
448        }
449    }
450
451    if (keepAnimating) {
452        startAnimationLocked();
453    }
454}
455
456void PointerController::doInactivityTimeout() {
457    fade(TRANSITION_GRADUAL);
458}
459
460void PointerController::startAnimationLocked() {
461    if (!mLocked.animationPending) {
462        mLocked.animationPending = true;
463        mLocked.animationTime = systemTime(SYSTEM_TIME_MONOTONIC);
464        mLooper->sendMessageDelayed(ANIMATION_FRAME_INTERVAL, mHandler, Message(MSG_ANIMATE));
465    }
466}
467
468void PointerController::resetInactivityTimeoutLocked() {
469    mLooper->removeMessages(mHandler, MSG_INACTIVITY_TIMEOUT);
470
471    nsecs_t timeout = mLocked.inactivityTimeout == INACTIVITY_TIMEOUT_SHORT
472            ? INACTIVITY_TIMEOUT_DELAY_TIME_SHORT : INACTIVITY_TIMEOUT_DELAY_TIME_NORMAL;
473    mLooper->sendMessageDelayed(timeout, mHandler, MSG_INACTIVITY_TIMEOUT);
474}
475
476void PointerController::removeInactivityTimeoutLocked() {
477    mLooper->removeMessages(mHandler, MSG_INACTIVITY_TIMEOUT);
478}
479
480void PointerController::updatePointerLocked() {
481    mSpriteController->openTransaction();
482
483    mLocked.pointerSprite->setLayer(Sprite::BASE_LAYER_POINTER);
484    mLocked.pointerSprite->setPosition(mLocked.pointerX, mLocked.pointerY);
485
486    if (mLocked.pointerAlpha > 0) {
487        mLocked.pointerSprite->setAlpha(mLocked.pointerAlpha);
488        mLocked.pointerSprite->setVisible(true);
489    } else {
490        mLocked.pointerSprite->setVisible(false);
491    }
492
493    if (mLocked.pointerIconChanged || mLocked.presentationChanged) {
494        mLocked.pointerSprite->setIcon(mLocked.presentation == PRESENTATION_POINTER
495                ? mLocked.pointerIcon : mResources.spotAnchor);
496        mLocked.pointerIconChanged = false;
497        mLocked.presentationChanged = false;
498    }
499
500    mSpriteController->closeTransaction();
501}
502
503PointerController::Spot* PointerController::getSpotLocked(uint32_t id) {
504    for (size_t i = 0; i < mLocked.spots.size(); i++) {
505        Spot* spot = mLocked.spots.itemAt(i);
506        if (spot->id == id) {
507            return spot;
508        }
509    }
510    return NULL;
511}
512
513PointerController::Spot* PointerController::createAndAddSpotLocked(uint32_t id) {
514    // Remove spots until we have fewer than MAX_SPOTS remaining.
515    while (mLocked.spots.size() >= MAX_SPOTS) {
516        Spot* spot = removeFirstFadingSpotLocked();
517        if (!spot) {
518            spot = mLocked.spots.itemAt(0);
519            mLocked.spots.removeAt(0);
520        }
521        releaseSpotLocked(spot);
522    }
523
524    // Obtain a sprite from the recycled pool.
525    sp<Sprite> sprite;
526    if (! mLocked.recycledSprites.isEmpty()) {
527        sprite = mLocked.recycledSprites.top();
528        mLocked.recycledSprites.pop();
529    } else {
530        sprite = mSpriteController->createSprite();
531    }
532
533    // Return the new spot.
534    Spot* spot = new Spot(id, sprite);
535    mLocked.spots.push(spot);
536    return spot;
537}
538
539PointerController::Spot* PointerController::removeFirstFadingSpotLocked() {
540    for (size_t i = 0; i < mLocked.spots.size(); i++) {
541        Spot* spot = mLocked.spots.itemAt(i);
542        if (spot->id == Spot::INVALID_ID) {
543            mLocked.spots.removeAt(i);
544            return spot;
545        }
546    }
547    return NULL;
548}
549
550void PointerController::releaseSpotLocked(Spot* spot) {
551    spot->sprite->clearIcon();
552
553    if (mLocked.recycledSprites.size() < MAX_RECYCLED_SPRITES) {
554        mLocked.recycledSprites.push(spot->sprite);
555    }
556
557    delete spot;
558}
559
560void PointerController::fadeOutAndReleaseSpotLocked(Spot* spot) {
561    if (spot->id != Spot::INVALID_ID) {
562        spot->id = Spot::INVALID_ID;
563        startAnimationLocked();
564    }
565}
566
567void PointerController::fadeOutAndReleaseAllSpotsLocked() {
568    for (size_t i = 0; i < mLocked.spots.size(); i++) {
569        Spot* spot = mLocked.spots.itemAt(i);
570        fadeOutAndReleaseSpotLocked(spot);
571    }
572}
573
574void PointerController::loadResources() {
575    mPolicy->loadPointerResources(&mResources);
576}
577
578
579// --- PointerController::Spot ---
580
581void PointerController::Spot::updateSprite(const SpriteIcon* icon, float x, float y) {
582    sprite->setLayer(Sprite::BASE_LAYER_SPOT + id);
583    sprite->setAlpha(alpha);
584    sprite->setTransformationMatrix(SpriteTransformationMatrix(scale, 0.0f, 0.0f, scale));
585    sprite->setPosition(x, y);
586
587    this->x = x;
588    this->y = y;
589
590    if (icon != lastIcon) {
591        lastIcon = icon;
592        if (icon) {
593            sprite->setIcon(*icon);
594            sprite->setVisible(true);
595        } else {
596            sprite->setVisible(false);
597        }
598    }
599}
600
601} // namespace android
602