services/input/PointerController.cpp

   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