libs/input/PointerController.cpp - platform/frameworks/base - Gitiles

 /*
  * 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.
  */

 #define LOG_TAG "PointerController"
 //#define LOG_NDEBUG 0

 // Log debug messages about pointer updates
 #define DEBUG_POINTER_UPDATES 0

 #include "PointerController.h"

 #include <log/log.h>

 #include <SkBitmap.h>
 #include <SkCanvas.h>
 #include <SkColor.h>
 #include <SkPaint.h>
 #include <SkBlendMode.h>

 namespace android {

 // --- WeakLooperCallback ---

 class WeakLooperCallback: public LooperCallback {
 protected:
     virtual ~WeakLooperCallback() { }

 public:
     WeakLooperCallback(const wp<LooperCallback>& callback) :
         mCallback(callback) {
     }

     virtual int handleEvent(int fd, int events, void* data) {
         sp<LooperCallback> callback = mCallback.promote();
         if (callback != NULL) {
             return callback->handleEvent(fd, events, data);
         }
         return 0; // the client is gone, remove the callback
     }

 private:
     wp<LooperCallback> mCallback;
 };

 // --- PointerController ---

 // Time to wait before starting the fade when the pointer is inactive.
 static const nsecs_t INACTIVITY_TIMEOUT_DELAY_TIME_NORMAL = 15 * 1000 * 1000000LL; // 15 seconds
 static const nsecs_t INACTIVITY_TIMEOUT_DELAY_TIME_SHORT = 3 * 1000 * 1000000LL; // 3 seconds

 // Time to spend fading out the spot completely.
 static const nsecs_t SPOT_FADE_DURATION = 200 * 1000000LL; // 200 ms

 // Time to spend fading out the pointer completely.
 static const nsecs_t POINTER_FADE_DURATION = 500 * 1000000LL; // 500 ms

 // The number of events to be read at once for DisplayEventReceiver.
 static const int EVENT_BUFFER_SIZE = 100;

 // --- PointerController ---

 PointerController::PointerController(const sp<PointerControllerPolicyInterface>& policy,
         const sp<Looper>& looper, const sp<SpriteController>& spriteController) :
         mPolicy(policy), mLooper(looper), mSpriteController(spriteController) {
     mHandler = new WeakMessageHandler(this);
     mCallback = new WeakLooperCallback(this);

     if (mDisplayEventReceiver.initCheck() == NO_ERROR) {
         mLooper->addFd(mDisplayEventReceiver.getFd(), Looper::POLL_CALLBACK,
                        Looper::EVENT_INPUT, mCallback, nullptr);
     } else {
         ALOGE("Failed to initialize DisplayEventReceiver.");
     }

     AutoMutex _l(mLock);

     mLocked.animationPending = false;

     mLocked.presentation = PRESENTATION_POINTER;
     mLocked.presentationChanged = false;

     mLocked.inactivityTimeout = INACTIVITY_TIMEOUT_NORMAL;

     mLocked.pointerFadeDirection = 0;
     mLocked.pointerX = 0;
     mLocked.pointerY = 0;
     mLocked.pointerAlpha = 0.0f; // pointer is initially faded
     mLocked.pointerSprite = mSpriteController->createSprite();
     mLocked.pointerIconChanged = false;
     mLocked.requestedPointerType = mPolicy->getDefaultPointerIconId();

     mLocked.animationFrameIndex = 0;
     mLocked.lastFrameUpdatedTime = 0;

     mLocked.buttonState = 0;
 }

 PointerController::~PointerController() {
     mLooper->removeMessages(mHandler);

     AutoMutex _l(mLock);

     mLocked.pointerSprite.clear();

     for (size_t i = 0; i < mLocked.spots.size(); i++) {
         delete mLocked.spots.itemAt(i);
     }
     mLocked.spots.clear();
     mLocked.recycledSprites.clear();
 }

 bool PointerController::getBounds(float* outMinX, float* outMinY,
         float* outMaxX, float* outMaxY) const {
     AutoMutex _l(mLock);

     return getBoundsLocked(outMinX, outMinY, outMaxX, outMaxY);
 }

 bool PointerController::getBoundsLocked(float* outMinX, float* outMinY,
         float* outMaxX, float* outMaxY) const {

     if (!mLocked.viewport.isValid()) {
         return false;
     }

     *outMinX = mLocked.viewport.logicalLeft;
     *outMinY = mLocked.viewport.logicalTop;
     *outMaxX = mLocked.viewport.logicalRight - 1;
     *outMaxY = mLocked.viewport.logicalBottom - 1;
     return true;
 }

 void PointerController::move(float deltaX, float deltaY) {
 #if DEBUG_POINTER_UPDATES
     ALOGD("Move pointer by deltaX=%0.3f, deltaY=%0.3f", deltaX, deltaY);
 #endif
     if (deltaX == 0.0f && deltaY == 0.0f) {
         return;
     }

     AutoMutex _l(mLock);

     setPositionLocked(mLocked.pointerX + deltaX, mLocked.pointerY + deltaY);
 }

 void PointerController::setButtonState(int32_t buttonState) {
 #if DEBUG_POINTER_UPDATES
     ALOGD("Set button state 0x%08x", buttonState);
 #endif
     AutoMutex _l(mLock);

     if (mLocked.buttonState != buttonState) {
         mLocked.buttonState = buttonState;
     }
 }

 int32_t PointerController::getButtonState() const {
     AutoMutex _l(mLock);

     return mLocked.buttonState;
 }

 void PointerController::setPosition(float x, float y) {
 #if DEBUG_POINTER_UPDATES
     ALOGD("Set pointer position to x=%0.3f, y=%0.3f", x, y);
 #endif
     AutoMutex _l(mLock);

     setPositionLocked(x, y);
 }

 void PointerController::setPositionLocked(float x, float y) {
     float minX, minY, maxX, maxY;
     if (getBoundsLocked(&minX, &minY, &maxX, &maxY)) {
         if (x <= minX) {
             mLocked.pointerX = minX;
         } else if (x >= maxX) {
             mLocked.pointerX = maxX;
         } else {
             mLocked.pointerX = x;
         }
         if (y <= minY) {
             mLocked.pointerY = minY;
         } else if (y >= maxY) {
             mLocked.pointerY = maxY;
         } else {
             mLocked.pointerY = y;
         }
         updatePointerLocked();
     }
 }

 void PointerController::getPosition(float* outX, float* outY) const {
     AutoMutex _l(mLock);

     *outX = mLocked.pointerX;
     *outY = mLocked.pointerY;
 }

 int32_t PointerController::getDisplayId() const {
     AutoMutex _l(mLock);

     return mLocked.viewport.displayId;
 }

 void PointerController::fade(Transition transition) {
     AutoMutex _l(mLock);

     // Remove the inactivity timeout, since we are fading now.
     removeInactivityTimeoutLocked();

     // Start fading.
     if (transition == TRANSITION_IMMEDIATE) {
         mLocked.pointerFadeDirection = 0;
         mLocked.pointerAlpha = 0.0f;
         updatePointerLocked();
     } else {
         mLocked.pointerFadeDirection = -1;
         startAnimationLocked();
     }
 }

 void PointerController::unfade(Transition transition) {
     AutoMutex _l(mLock);

     // Always reset the inactivity timer.
     resetInactivityTimeoutLocked();

     // Start unfading.
     if (transition == TRANSITION_IMMEDIATE) {
         mLocked.pointerFadeDirection = 0;
         mLocked.pointerAlpha = 1.0f;
         updatePointerLocked();
     } else {
         mLocked.pointerFadeDirection = 1;
         startAnimationLocked();
     }
 }

 void PointerController::setPresentation(Presentation presentation) {
     AutoMutex _l(mLock);

     if (presentation == PRESENTATION_POINTER && mLocked.additionalMouseResources.empty()) {
         mPolicy->loadAdditionalMouseResources(&mLocked.additionalMouseResources,
                                               &mLocked.animationResources);
     }

     if (mLocked.presentation != presentation) {
         mLocked.presentation = presentation;
         mLocked.presentationChanged = true;

         if (presentation != PRESENTATION_SPOT) {
             fadeOutAndReleaseAllSpotsLocked();
         }

         updatePointerLocked();
     }
 }

 void PointerController::setSpots(const PointerCoords* spotCoords,
         const uint32_t* spotIdToIndex, BitSet32 spotIdBits) {
 #if DEBUG_POINTER_UPDATES
     ALOGD("setSpots: idBits=%08x", spotIdBits.value);
     for (BitSet32 idBits(spotIdBits); !idBits.isEmpty(); ) {
         uint32_t id = idBits.firstMarkedBit();
         idBits.clearBit(id);
         const PointerCoords& c = spotCoords[spotIdToIndex[id]];
         ALOGD(" spot %d: position=(%0.3f, %0.3f), pressure=%0.3f", id,
                 c.getAxisValue(AMOTION_EVENT_AXIS_X),
                 c.getAxisValue(AMOTION_EVENT_AXIS_Y),
                 c.getAxisValue(AMOTION_EVENT_AXIS_PRESSURE));
     }
 #endif

     AutoMutex _l(mLock);

     mSpriteController->openTransaction();

     // Add or move spots for fingers that are down.
     for (BitSet32 idBits(spotIdBits); !idBits.isEmpty(); ) {
         uint32_t id = idBits.clearFirstMarkedBit();
         const PointerCoords& c = spotCoords[spotIdToIndex[id]];
         const SpriteIcon& icon = c.getAxisValue(AMOTION_EVENT_AXIS_PRESSURE) > 0
                 ? mResources.spotTouch : mResources.spotHover;
         float x = c.getAxisValue(AMOTION_EVENT_AXIS_X);
         float y = c.getAxisValue(AMOTION_EVENT_AXIS_Y);

         Spot* spot = getSpotLocked(id);
         if (!spot) {
             spot = createAndAddSpotLocked(id);
         }

         spot->updateSprite(&icon, x, y);
     }

     // Remove spots for fingers that went up.
     for (size_t i = 0; i < mLocked.spots.size(); i++) {
         Spot* spot = mLocked.spots.itemAt(i);
         if (spot->id != Spot::INVALID_ID
                 && !spotIdBits.hasBit(spot->id)) {
             fadeOutAndReleaseSpotLocked(spot);
         }
     }

     mSpriteController->closeTransaction();
 }

 void PointerController::clearSpots() {
 #if DEBUG_POINTER_UPDATES
     ALOGD("clearSpots");
 #endif

     AutoMutex _l(mLock);

     fadeOutAndReleaseAllSpotsLocked();
 }

 void PointerController::setInactivityTimeout(InactivityTimeout inactivityTimeout) {
     AutoMutex _l(mLock);

     if (mLocked.inactivityTimeout != inactivityTimeout) {
         mLocked.inactivityTimeout = inactivityTimeout;
         resetInactivityTimeoutLocked();
     }
 }

 void PointerController::reloadPointerResources() {
     AutoMutex _l(mLock);

     loadResourcesLocked();
     updatePointerLocked();
 }

 /**
  * The viewport values for deviceHeight and deviceWidth have already been adjusted for rotation,
  * so here we are getting the dimensions in the original, unrotated orientation (orientation 0).
  */
 static void getNonRotatedSize(const DisplayViewport& viewport, int32_t& width, int32_t& height) {
     if (viewport.orientation == DISPLAY_ORIENTATION_90
             || viewport.orientation == DISPLAY_ORIENTATION_270) {
         width = viewport.deviceHeight;
         height = viewport.deviceWidth;
     } else {
         width = viewport.deviceWidth;
         height = viewport.deviceHeight;
     }
 }

 void PointerController::setDisplayViewport(const DisplayViewport& viewport) {
     AutoMutex _l(mLock);
     if (viewport == mLocked.viewport) {
         return;
     }

     const DisplayViewport oldViewport = mLocked.viewport;
     mLocked.viewport = viewport;

     int32_t oldDisplayWidth, oldDisplayHeight;
     getNonRotatedSize(oldViewport, oldDisplayWidth, oldDisplayHeight);
     int32_t newDisplayWidth, newDisplayHeight;
     getNonRotatedSize(viewport, newDisplayWidth, newDisplayHeight);

     // Reset cursor position to center if size or display changed.
     if (oldViewport.displayId != viewport.displayId
             || oldDisplayWidth != newDisplayWidth
             || oldDisplayHeight != newDisplayHeight) {

         float minX, minY, maxX, maxY;
         if (getBoundsLocked(&minX, &minY, &maxX, &maxY)) {
             mLocked.pointerX = (minX + maxX) * 0.5f;
             mLocked.pointerY = (minY + maxY) * 0.5f;
             // Reload icon resources for density may be changed.
             loadResourcesLocked();
         } else {
             mLocked.pointerX = 0;
             mLocked.pointerY = 0;
         }

         fadeOutAndReleaseAllSpotsLocked();
     } else if (oldViewport.orientation != viewport.orientation) {
         // Apply offsets to convert from the pixel top-left corner position to the pixel center.
         // This creates an invariant frame of reference that we can easily rotate when
         // taking into account that the pointer may be located at fractional pixel offsets.
         float x = mLocked.pointerX + 0.5f;
         float y = mLocked.pointerY + 0.5f;
         float temp;

         // Undo the previous rotation.
         switch (oldViewport.orientation) {
         case DISPLAY_ORIENTATION_90:
             temp = x;
             x =  oldViewport.deviceHeight - y;
             y = temp;
             break;
         case DISPLAY_ORIENTATION_180:
             x = oldViewport.deviceWidth - x;
             y = oldViewport.deviceHeight - y;
             break;
         case DISPLAY_ORIENTATION_270:
             temp = x;
             x = y;
             y = oldViewport.deviceWidth - temp;
             break;
         }

         // Perform the new rotation.
         switch (viewport.orientation) {
         case DISPLAY_ORIENTATION_90:
             temp = x;
             x = y;
             y = viewport.deviceHeight - temp;
             break;
         case DISPLAY_ORIENTATION_180:
             x = viewport.deviceWidth - x;
             y = viewport.deviceHeight - y;
             break;
         case DISPLAY_ORIENTATION_270:
             temp = x;
             x = viewport.deviceWidth - y;
             y = temp;
             break;
         }

         // Apply offsets to convert from the pixel center to the pixel top-left corner position
         // and save the results.
         mLocked.pointerX = x - 0.5f;
         mLocked.pointerY = y - 0.5f;
     }

     updatePointerLocked();
 }

 void PointerController::updatePointerIcon(int32_t iconId) {
     AutoMutex _l(mLock);
     if (mLocked.requestedPointerType != iconId) {
         mLocked.requestedPointerType = iconId;
         mLocked.presentationChanged = true;
         updatePointerLocked();
     }
 }

 void PointerController::setCustomPointerIcon(const SpriteIcon& icon) {
     AutoMutex _l(mLock);

     const int32_t iconId = mPolicy->getCustomPointerIconId();
     mLocked.additionalMouseResources[iconId] = icon;
     mLocked.requestedPointerType = iconId;
     mLocked.presentationChanged = true;

     updatePointerLocked();
 }

 void PointerController::handleMessage(const Message& message) {
     switch (message.what) {
     case MSG_INACTIVITY_TIMEOUT:
         doInactivityTimeout();
         break;
     }
 }

 int PointerController::handleEvent(int /* fd */, int events, void* /* data */) {
     if (events & (Looper::EVENT_ERROR | Looper::EVENT_HANGUP)) {
         ALOGE("Display event receiver pipe was closed or an error occurred.  "
               "events=0x%x", events);
         return 0; // remove the callback
     }

     if (!(events & Looper::EVENT_INPUT)) {
         ALOGW("Received spurious callback for unhandled poll event.  "
               "events=0x%x", events);
         return 1; // keep the callback
     }

     bool gotVsync = false;
     ssize_t n;
     nsecs_t timestamp;
     DisplayEventReceiver::Event buf[EVENT_BUFFER_SIZE];
     while ((n = mDisplayEventReceiver.getEvents(buf, EVENT_BUFFER_SIZE)) > 0) {
         for (size_t i = 0; i < static_cast<size_t>(n); ++i) {
             if (buf[i].header.type == DisplayEventReceiver::DISPLAY_EVENT_VSYNC) {
                 timestamp = buf[i].header.timestamp;
                 gotVsync = true;
             }
         }
     }
     if (gotVsync) {
         doAnimate(timestamp);
     }
     return 1;  // keep the callback
 }

 void PointerController::doAnimate(nsecs_t timestamp) {
     AutoMutex _l(mLock);

     mLocked.animationPending = false;

     bool keepFading = doFadingAnimationLocked(timestamp);
     bool keepBitmapFlipping = doBitmapAnimationLocked(timestamp);
     if (keepFading || keepBitmapFlipping) {
         startAnimationLocked();
     }
 }

 bool PointerController::doFadingAnimationLocked(nsecs_t timestamp) {
     bool keepAnimating = false;
     nsecs_t frameDelay = timestamp - mLocked.animationTime;

     // Animate pointer fade.
     if (mLocked.pointerFadeDirection < 0) {
         mLocked.pointerAlpha -= float(frameDelay) / POINTER_FADE_DURATION;
         if (mLocked.pointerAlpha <= 0.0f) {
             mLocked.pointerAlpha = 0.0f;
             mLocked.pointerFadeDirection = 0;
         } else {
             keepAnimating = true;
         }
         updatePointerLocked();
     } else if (mLocked.pointerFadeDirection > 0) {
         mLocked.pointerAlpha += float(frameDelay) / POINTER_FADE_DURATION;
         if (mLocked.pointerAlpha >= 1.0f) {
             mLocked.pointerAlpha = 1.0f;
             mLocked.pointerFadeDirection = 0;
         } else {
             keepAnimating = true;
         }
         updatePointerLocked();
     }

     // Animate spots that are fading out and being removed.
     for (size_t i = 0; i < mLocked.spots.size();) {
         Spot* spot = mLocked.spots.itemAt(i);
         if (spot->id == Spot::INVALID_ID) {
             spot->alpha -= float(frameDelay) / SPOT_FADE_DURATION;
             if (spot->alpha <= 0) {
                 mLocked.spots.removeAt(i);
                 releaseSpotLocked(spot);
                 continue;
             } else {
                 spot->sprite->setAlpha(spot->alpha);
                 keepAnimating = true;
             }
         }
         ++i;
     }
     return keepAnimating;
 }

 bool PointerController::doBitmapAnimationLocked(nsecs_t timestamp) {
     std::map<int32_t, PointerAnimation>::const_iterator iter = mLocked.animationResources.find(
             mLocked.requestedPointerType);
     if (iter == mLocked.animationResources.end()) {
         return false;
     }

     if (timestamp - mLocked.lastFrameUpdatedTime > iter->second.durationPerFrame) {
         mSpriteController->openTransaction();

         int incr = (timestamp - mLocked.lastFrameUpdatedTime) / iter->second.durationPerFrame;
         mLocked.animationFrameIndex += incr;
         mLocked.lastFrameUpdatedTime += iter->second.durationPerFrame * incr;
         while (mLocked.animationFrameIndex >= iter->second.animationFrames.size()) {
             mLocked.animationFrameIndex -= iter->second.animationFrames.size();
         }
         mLocked.pointerSprite->setIcon(iter->second.animationFrames[mLocked.animationFrameIndex]);

         mSpriteController->closeTransaction();
     }

     // Keep animating.
     return true;
 }

 void PointerController::doInactivityTimeout() {
     fade(TRANSITION_GRADUAL);
 }

 void PointerController::startAnimationLocked() {
     if (!mLocked.animationPending) {
         mLocked.animationPending = true;
         mLocked.animationTime = systemTime(SYSTEM_TIME_MONOTONIC);
         mDisplayEventReceiver.requestNextVsync();
     }
 }

 void PointerController::resetInactivityTimeoutLocked() {
     mLooper->removeMessages(mHandler, MSG_INACTIVITY_TIMEOUT);

     nsecs_t timeout = mLocked.inactivityTimeout == INACTIVITY_TIMEOUT_SHORT
             ? INACTIVITY_TIMEOUT_DELAY_TIME_SHORT : INACTIVITY_TIMEOUT_DELAY_TIME_NORMAL;
     mLooper->sendMessageDelayed(timeout, mHandler, MSG_INACTIVITY_TIMEOUT);
 }

 void PointerController::removeInactivityTimeoutLocked() {
     mLooper->removeMessages(mHandler, MSG_INACTIVITY_TIMEOUT);
 }

 void PointerController::updatePointerLocked() REQUIRES(mLock) {
     if (!mLocked.viewport.isValid()) {
         return;
     }

     mSpriteController->openTransaction();

     mLocked.pointerSprite->setLayer(Sprite::BASE_LAYER_POINTER);
     mLocked.pointerSprite->setPosition(mLocked.pointerX, mLocked.pointerY);
     mLocked.pointerSprite->setDisplayId(mLocked.viewport.displayId);

     if (mLocked.pointerAlpha > 0) {
         mLocked.pointerSprite->setAlpha(mLocked.pointerAlpha);
         mLocked.pointerSprite->setVisible(true);
     } else {
         mLocked.pointerSprite->setVisible(false);
     }

     if (mLocked.pointerIconChanged || mLocked.presentationChanged) {
         if (mLocked.presentation == PRESENTATION_POINTER) {
             if (mLocked.requestedPointerType == mPolicy->getDefaultPointerIconId()) {
                 mLocked.pointerSprite->setIcon(mLocked.pointerIcon);
             } else {
                 std::map<int32_t, SpriteIcon>::const_iterator iter =
                     mLocked.additionalMouseResources.find(mLocked.requestedPointerType);
                 if (iter != mLocked.additionalMouseResources.end()) {
                     std::map<int32_t, PointerAnimation>::const_iterator anim_iter =
                             mLocked.animationResources.find(mLocked.requestedPointerType);
                     if (anim_iter != mLocked.animationResources.end()) {
                         mLocked.animationFrameIndex = 0;
                         mLocked.lastFrameUpdatedTime = systemTime(SYSTEM_TIME_MONOTONIC);
                         startAnimationLocked();
                     }
                     mLocked.pointerSprite->setIcon(iter->second);
                 } else {
                     ALOGW("Can't find the resource for icon id %d", mLocked.requestedPointerType);
                     mLocked.pointerSprite->setIcon(mLocked.pointerIcon);
                 }
             }
         } else {
             mLocked.pointerSprite->setIcon(mResources.spotAnchor);
         }
         mLocked.pointerIconChanged = false;
         mLocked.presentationChanged = false;
     }

     mSpriteController->closeTransaction();
 }

 PointerController::Spot* PointerController::getSpotLocked(uint32_t id) {
     for (size_t i = 0; i < mLocked.spots.size(); i++) {
         Spot* spot = mLocked.spots.itemAt(i);
         if (spot->id == id) {
             return spot;
         }
     }
     return NULL;
 }

 PointerController::Spot* PointerController::createAndAddSpotLocked(uint32_t id) {
     // Remove spots until we have fewer than MAX_SPOTS remaining.
     while (mLocked.spots.size() >= MAX_SPOTS) {
         Spot* spot = removeFirstFadingSpotLocked();
         if (!spot) {
             spot = mLocked.spots.itemAt(0);
             mLocked.spots.removeAt(0);
         }
         releaseSpotLocked(spot);
     }

     // Obtain a sprite from the recycled pool.
     sp<Sprite> sprite;
     if (! mLocked.recycledSprites.isEmpty()) {
         sprite = mLocked.recycledSprites.top();
         mLocked.recycledSprites.pop();
     } else {
         sprite = mSpriteController->createSprite();
     }

     // Return the new spot.
     Spot* spot = new Spot(id, sprite);
     mLocked.spots.push(spot);
     return spot;
 }

 PointerController::Spot* PointerController::removeFirstFadingSpotLocked() {
     for (size_t i = 0; i < mLocked.spots.size(); i++) {
         Spot* spot = mLocked.spots.itemAt(i);
         if (spot->id == Spot::INVALID_ID) {
             mLocked.spots.removeAt(i);
             return spot;
         }
     }
     return NULL;
 }

 void PointerController::releaseSpotLocked(Spot* spot) {
     spot->sprite->clearIcon();

     if (mLocked.recycledSprites.size() < MAX_RECYCLED_SPRITES) {
         mLocked.recycledSprites.push(spot->sprite);
     }

     delete spot;
 }

 void PointerController::fadeOutAndReleaseSpotLocked(Spot* spot) {
     if (spot->id != Spot::INVALID_ID) {
         spot->id = Spot::INVALID_ID;
         startAnimationLocked();
     }
 }

 void PointerController::fadeOutAndReleaseAllSpotsLocked() {
     for (size_t i = 0; i < mLocked.spots.size(); i++) {
         Spot* spot = mLocked.spots.itemAt(i);
         fadeOutAndReleaseSpotLocked(spot);
     }
 }

 void PointerController::loadResourcesLocked() REQUIRES(mLock) {
     mPolicy->loadPointerResources(&mResources);

     if (mLocked.presentation == PRESENTATION_POINTER) {
         mLocked.additionalMouseResources.clear();
         mLocked.animationResources.clear();
         mPolicy->loadPointerIcon(&mLocked.pointerIcon);
         mPolicy->loadAdditionalMouseResources(&mLocked.additionalMouseResources,
                                               &mLocked.animationResources);
     }

     mLocked.pointerIconChanged = true;
 }


 // --- PointerController::Spot ---

 void PointerController::Spot::updateSprite(const SpriteIcon* icon, float x, float y) {
     sprite->setLayer(Sprite::BASE_LAYER_SPOT + id);
     sprite->setAlpha(alpha);
     sprite->setTransformationMatrix(SpriteTransformationMatrix(scale, 0.0f, 0.0f, scale));
     sprite->setPosition(x, y);

     this->x = x;
     this->y = y;

     if (icon != lastIcon) {
         lastIcon = icon;
         if (icon) {
             sprite->setIcon(*icon);
             sprite->setVisible(true);
         } else {
             sprite->setVisible(false);
         }
     }
 }

 } // namespace android
	/*
	* 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.
	*/

	#define LOG_TAG "PointerController"
	//#define LOG_NDEBUG 0

	// Log debug messages about pointer updates
	#define DEBUG_POINTER_UPDATES 0

	#include "PointerController.h"

	#include <log/log.h>

	#include <SkBitmap.h>
	#include <SkCanvas.h>
	#include <SkColor.h>
	#include <SkPaint.h>
	#include <SkBlendMode.h>

	namespace android {

	// --- WeakLooperCallback ---

	class WeakLooperCallback: public LooperCallback {
	protected:
	virtual ~WeakLooperCallback() { }

	public:
	WeakLooperCallback(const wp<LooperCallback>& callback) :
	mCallback(callback) {
	}

	virtual int handleEvent(int fd, int events, void* data) {
	sp<LooperCallback> callback = mCallback.promote();
	if (callback != NULL) {
	return callback->handleEvent(fd, events, data);
	}
	return 0; // the client is gone, remove the callback
	}

	private:
	wp<LooperCallback> mCallback;
	};

	// --- PointerController ---

	// Time to wait before starting the fade when the pointer is inactive.
	static const nsecs_t INACTIVITY_TIMEOUT_DELAY_TIME_NORMAL = 15 * 1000 * 1000000LL; // 15 seconds
	static const nsecs_t INACTIVITY_TIMEOUT_DELAY_TIME_SHORT = 3 * 1000 * 1000000LL; // 3 seconds

	// Time to spend fading out the spot completely.
	static const nsecs_t SPOT_FADE_DURATION = 200 * 1000000LL; // 200 ms

	// Time to spend fading out the pointer completely.
	static const nsecs_t POINTER_FADE_DURATION = 500 * 1000000LL; // 500 ms

	// The number of events to be read at once for DisplayEventReceiver.
	static const int EVENT_BUFFER_SIZE = 100;

	// --- PointerController ---

	PointerController::PointerController(const sp<PointerControllerPolicyInterface>& policy,
	const sp<Looper>& looper, const sp<SpriteController>& spriteController) :
	mPolicy(policy), mLooper(looper), mSpriteController(spriteController) {
	mHandler = new WeakMessageHandler(this);
	mCallback = new WeakLooperCallback(this);

	if (mDisplayEventReceiver.initCheck() == NO_ERROR) {
	mLooper->addFd(mDisplayEventReceiver.getFd(), Looper::POLL_CALLBACK,
	Looper::EVENT_INPUT, mCallback, nullptr);
	} else {
	ALOGE("Failed to initialize DisplayEventReceiver.");
	}

	AutoMutex _l(mLock);

	mLocked.animationPending = false;

	mLocked.presentation = PRESENTATION_POINTER;
	mLocked.presentationChanged = false;

	mLocked.inactivityTimeout = INACTIVITY_TIMEOUT_NORMAL;

	mLocked.pointerFadeDirection = 0;
	mLocked.pointerX = 0;
	mLocked.pointerY = 0;
	mLocked.pointerAlpha = 0.0f; // pointer is initially faded
	mLocked.pointerSprite = mSpriteController->createSprite();
	mLocked.pointerIconChanged = false;
	mLocked.requestedPointerType = mPolicy->getDefaultPointerIconId();

	mLocked.animationFrameIndex = 0;
	mLocked.lastFrameUpdatedTime = 0;

	mLocked.buttonState = 0;
	}

	PointerController::~PointerController() {
	mLooper->removeMessages(mHandler);

	AutoMutex _l(mLock);

	mLocked.pointerSprite.clear();

	for (size_t i = 0; i < mLocked.spots.size(); i++) {
	delete mLocked.spots.itemAt(i);
	}
	mLocked.spots.clear();
	mLocked.recycledSprites.clear();
	}

	bool PointerController::getBounds(float* outMinX, float* outMinY,
	float* outMaxX, float* outMaxY) const {
	AutoMutex _l(mLock);

	return getBoundsLocked(outMinX, outMinY, outMaxX, outMaxY);
	}

	bool PointerController::getBoundsLocked(float* outMinX, float* outMinY,
	float* outMaxX, float* outMaxY) const {

	if (!mLocked.viewport.isValid()) {
	return false;
	}

	*outMinX = mLocked.viewport.logicalLeft;
	*outMinY = mLocked.viewport.logicalTop;
	*outMaxX = mLocked.viewport.logicalRight - 1;
	*outMaxY = mLocked.viewport.logicalBottom - 1;
	return true;
	}

	void PointerController::move(float deltaX, float deltaY) {
	#if DEBUG_POINTER_UPDATES
	ALOGD("Move pointer by deltaX=%0.3f, deltaY=%0.3f", deltaX, deltaY);
	#endif
	if (deltaX == 0.0f && deltaY == 0.0f) {
	return;
	}

	AutoMutex _l(mLock);

	setPositionLocked(mLocked.pointerX + deltaX, mLocked.pointerY + deltaY);
	}

	void PointerController::setButtonState(int32_t buttonState) {
	#if DEBUG_POINTER_UPDATES
	ALOGD("Set button state 0x%08x", buttonState);
	#endif
	AutoMutex _l(mLock);

	if (mLocked.buttonState != buttonState) {
	mLocked.buttonState = buttonState;
	}
	}

	int32_t PointerController::getButtonState() const {
	AutoMutex _l(mLock);

	return mLocked.buttonState;
	}

	void PointerController::setPosition(float x, float y) {
	#if DEBUG_POINTER_UPDATES
	ALOGD("Set pointer position to x=%0.3f, y=%0.3f", x, y);
	#endif
	AutoMutex _l(mLock);

	setPositionLocked(x, y);
	}

	void PointerController::setPositionLocked(float x, float y) {
	float minX, minY, maxX, maxY;
	if (getBoundsLocked(&minX, &minY, &maxX, &maxY)) {
	if (x <= minX) {
	mLocked.pointerX = minX;
	} else if (x >= maxX) {
	mLocked.pointerX = maxX;
	} else {
	mLocked.pointerX = x;
	}
	if (y <= minY) {
	mLocked.pointerY = minY;
	} else if (y >= maxY) {
	mLocked.pointerY = maxY;
	} else {
	mLocked.pointerY = y;
	}
	updatePointerLocked();
	}
	}

	void PointerController::getPosition(float* outX, float* outY) const {
	AutoMutex _l(mLock);

	*outX = mLocked.pointerX;
	*outY = mLocked.pointerY;
	}

	int32_t PointerController::getDisplayId() const {
	AutoMutex _l(mLock);

	return mLocked.viewport.displayId;
	}

	void PointerController::fade(Transition transition) {
	AutoMutex _l(mLock);

	// Remove the inactivity timeout, since we are fading now.
	removeInactivityTimeoutLocked();

	// Start fading.
	if (transition == TRANSITION_IMMEDIATE) {
	mLocked.pointerFadeDirection = 0;
	mLocked.pointerAlpha = 0.0f;
	updatePointerLocked();
	} else {
	mLocked.pointerFadeDirection = -1;
	startAnimationLocked();
	}
	}

	void PointerController::unfade(Transition transition) {
	AutoMutex _l(mLock);

	// Always reset the inactivity timer.
	resetInactivityTimeoutLocked();

	// Start unfading.
	if (transition == TRANSITION_IMMEDIATE) {
	mLocked.pointerFadeDirection = 0;
	mLocked.pointerAlpha = 1.0f;
	updatePointerLocked();
	} else {
	mLocked.pointerFadeDirection = 1;
	startAnimationLocked();
	}
	}

	void PointerController::setPresentation(Presentation presentation) {
	AutoMutex _l(mLock);

	if (presentation == PRESENTATION_POINTER && mLocked.additionalMouseResources.empty()) {
	mPolicy->loadAdditionalMouseResources(&mLocked.additionalMouseResources,
	&mLocked.animationResources);
	}

	if (mLocked.presentation != presentation) {
	mLocked.presentation = presentation;
	mLocked.presentationChanged = true;

	if (presentation != PRESENTATION_SPOT) {
	fadeOutAndReleaseAllSpotsLocked();
	}

	updatePointerLocked();
	}
	}

	void PointerController::setSpots(const PointerCoords* spotCoords,
	const uint32_t* spotIdToIndex, BitSet32 spotIdBits) {
	#if DEBUG_POINTER_UPDATES
	ALOGD("setSpots: idBits=%08x", spotIdBits.value);
	for (BitSet32 idBits(spotIdBits); !idBits.isEmpty(); ) {
	uint32_t id = idBits.firstMarkedBit();
	idBits.clearBit(id);
	const PointerCoords& c = spotCoords[spotIdToIndex[id]];
	ALOGD(" spot %d: position=(%0.3f, %0.3f), pressure=%0.3f", id,
	c.getAxisValue(AMOTION_EVENT_AXIS_X),
	c.getAxisValue(AMOTION_EVENT_AXIS_Y),
	c.getAxisValue(AMOTION_EVENT_AXIS_PRESSURE));
	}
	#endif

	AutoMutex _l(mLock);

	mSpriteController->openTransaction();

	// Add or move spots for fingers that are down.
	for (BitSet32 idBits(spotIdBits); !idBits.isEmpty(); ) {
	uint32_t id = idBits.clearFirstMarkedBit();
	const PointerCoords& c = spotCoords[spotIdToIndex[id]];
	const SpriteIcon& icon = c.getAxisValue(AMOTION_EVENT_AXIS_PRESSURE) > 0
	? mResources.spotTouch : mResources.spotHover;
	float x = c.getAxisValue(AMOTION_EVENT_AXIS_X);
	float y = c.getAxisValue(AMOTION_EVENT_AXIS_Y);

	Spot* spot = getSpotLocked(id);
	if (!spot) {
	spot = createAndAddSpotLocked(id);
	}

	spot->updateSprite(&icon, x, y);
	}

	// Remove spots for fingers that went up.
	for (size_t i = 0; i < mLocked.spots.size(); i++) {
	Spot* spot = mLocked.spots.itemAt(i);
	if (spot->id != Spot::INVALID_ID
	&& !spotIdBits.hasBit(spot->id)) {
	fadeOutAndReleaseSpotLocked(spot);
	}
	}

	mSpriteController->closeTransaction();
	}

	void PointerController::clearSpots() {
	#if DEBUG_POINTER_UPDATES
	ALOGD("clearSpots");
	#endif

	AutoMutex _l(mLock);

	fadeOutAndReleaseAllSpotsLocked();
	}

	void PointerController::setInactivityTimeout(InactivityTimeout inactivityTimeout) {
	AutoMutex _l(mLock);

	if (mLocked.inactivityTimeout != inactivityTimeout) {
	mLocked.inactivityTimeout = inactivityTimeout;
	resetInactivityTimeoutLocked();
	}
	}

	void PointerController::reloadPointerResources() {
	AutoMutex _l(mLock);

	loadResourcesLocked();
	updatePointerLocked();
	}

	/**
	* The viewport values for deviceHeight and deviceWidth have already been adjusted for rotation,
	* so here we are getting the dimensions in the original, unrotated orientation (orientation 0).
	*/
	static void getNonRotatedSize(const DisplayViewport& viewport, int32_t& width, int32_t& height) {
	if (viewport.orientation == DISPLAY_ORIENTATION_90
	\|\| viewport.orientation == DISPLAY_ORIENTATION_270) {
	width = viewport.deviceHeight;
	height = viewport.deviceWidth;
	} else {
	width = viewport.deviceWidth;
	height = viewport.deviceHeight;
	}
	}

	void PointerController::setDisplayViewport(const DisplayViewport& viewport) {
	AutoMutex _l(mLock);
	if (viewport == mLocked.viewport) {
	return;
	}

	const DisplayViewport oldViewport = mLocked.viewport;
	mLocked.viewport = viewport;

	int32_t oldDisplayWidth, oldDisplayHeight;
	getNonRotatedSize(oldViewport, oldDisplayWidth, oldDisplayHeight);
	int32_t newDisplayWidth, newDisplayHeight;
	getNonRotatedSize(viewport, newDisplayWidth, newDisplayHeight);

	// Reset cursor position to center if size or display changed.
	if (oldViewport.displayId != viewport.displayId
	\|\| oldDisplayWidth != newDisplayWidth
	\|\| oldDisplayHeight != newDisplayHeight) {

	float minX, minY, maxX, maxY;
	if (getBoundsLocked(&minX, &minY, &maxX, &maxY)) {
	mLocked.pointerX = (minX + maxX) * 0.5f;
	mLocked.pointerY = (minY + maxY) * 0.5f;
	// Reload icon resources for density may be changed.
	loadResourcesLocked();
	} else {
	mLocked.pointerX = 0;
	mLocked.pointerY = 0;
	}

	fadeOutAndReleaseAllSpotsLocked();
	} else if (oldViewport.orientation != viewport.orientation) {
	// Apply offsets to convert from the pixel top-left corner position to the pixel center.
	// This creates an invariant frame of reference that we can easily rotate when
	// taking into account that the pointer may be located at fractional pixel offsets.
	float x = mLocked.pointerX + 0.5f;
	float y = mLocked.pointerY + 0.5f;
	float temp;

	// Undo the previous rotation.
	switch (oldViewport.orientation) {
	case DISPLAY_ORIENTATION_90:
	temp = x;
	x = oldViewport.deviceHeight - y;
	y = temp;
	break;
	case DISPLAY_ORIENTATION_180:
	x = oldViewport.deviceWidth - x;
	y = oldViewport.deviceHeight - y;
	break;
	case DISPLAY_ORIENTATION_270:
	temp = x;
	x = y;
	y = oldViewport.deviceWidth - temp;
	break;
	}

	// Perform the new rotation.
	switch (viewport.orientation) {
	case DISPLAY_ORIENTATION_90:
	temp = x;
	x = y;
	y = viewport.deviceHeight - temp;
	break;
	case DISPLAY_ORIENTATION_180:
	x = viewport.deviceWidth - x;
	y = viewport.deviceHeight - y;
	break;
	case DISPLAY_ORIENTATION_270:
	temp = x;
	x = viewport.deviceWidth - y;
	y = temp;
	break;
	}

	// Apply offsets to convert from the pixel center to the pixel top-left corner position
	// and save the results.
	mLocked.pointerX = x - 0.5f;
	mLocked.pointerY = y - 0.5f;
	}

	updatePointerLocked();
	}

	void PointerController::updatePointerIcon(int32_t iconId) {
	AutoMutex _l(mLock);
	if (mLocked.requestedPointerType != iconId) {
	mLocked.requestedPointerType = iconId;
	mLocked.presentationChanged = true;
	updatePointerLocked();
	}
	}

	void PointerController::setCustomPointerIcon(const SpriteIcon& icon) {
	AutoMutex _l(mLock);

	const int32_t iconId = mPolicy->getCustomPointerIconId();
	mLocked.additionalMouseResources[iconId] = icon;
	mLocked.requestedPointerType = iconId;
	mLocked.presentationChanged = true;

	updatePointerLocked();
	}

	void PointerController::handleMessage(const Message& message) {
	switch (message.what) {
	case MSG_INACTIVITY_TIMEOUT:
	doInactivityTimeout();
	break;
	}
	}

	int PointerController::handleEvent(int /* fd /, int events, void /* data */) {
	if (events & (Looper::EVENT_ERROR \| Looper::EVENT_HANGUP)) {
	ALOGE("Display event receiver pipe was closed or an error occurred. "
	"events=0x%x", events);
	return 0; // remove the callback
	}

	if (!(events & Looper::EVENT_INPUT)) {
	ALOGW("Received spurious callback for unhandled poll event. "
	"events=0x%x", events);
	return 1; // keep the callback
	}

	bool gotVsync = false;
	ssize_t n;
	nsecs_t timestamp;
	DisplayEventReceiver::Event buf[EVENT_BUFFER_SIZE];
	while ((n = mDisplayEventReceiver.getEvents(buf, EVENT_BUFFER_SIZE)) > 0) {
	for (size_t i = 0; i < static_cast<size_t>(n); ++i) {
	if (buf[i].header.type == DisplayEventReceiver::DISPLAY_EVENT_VSYNC) {
	timestamp = buf[i].header.timestamp;
	gotVsync = true;
	}
	}
	}
	if (gotVsync) {
	doAnimate(timestamp);
	}
	return 1; // keep the callback
	}

	void PointerController::doAnimate(nsecs_t timestamp) {
	AutoMutex _l(mLock);

	mLocked.animationPending = false;

	bool keepFading = doFadingAnimationLocked(timestamp);
	bool keepBitmapFlipping = doBitmapAnimationLocked(timestamp);
	if (keepFading \|\| keepBitmapFlipping) {
	startAnimationLocked();
	}
	}

	bool PointerController::doFadingAnimationLocked(nsecs_t timestamp) {
	bool keepAnimating = false;
	nsecs_t frameDelay = timestamp - mLocked.animationTime;

	// Animate pointer fade.
	if (mLocked.pointerFadeDirection < 0) {
	mLocked.pointerAlpha -= float(frameDelay) / POINTER_FADE_DURATION;
	if (mLocked.pointerAlpha <= 0.0f) {
	mLocked.pointerAlpha = 0.0f;
	mLocked.pointerFadeDirection = 0;
	} else {
	keepAnimating = true;
	}
	updatePointerLocked();
	} else if (mLocked.pointerFadeDirection > 0) {
	mLocked.pointerAlpha += float(frameDelay) / POINTER_FADE_DURATION;
	if (mLocked.pointerAlpha >= 1.0f) {
	mLocked.pointerAlpha = 1.0f;
	mLocked.pointerFadeDirection = 0;
	} else {
	keepAnimating = true;
	}
	updatePointerLocked();
	}

	// Animate spots that are fading out and being removed.
	for (size_t i = 0; i < mLocked.spots.size();) {
	Spot* spot = mLocked.spots.itemAt(i);
	if (spot->id == Spot::INVALID_ID) {
	spot->alpha -= float(frameDelay) / SPOT_FADE_DURATION;
	if (spot->alpha <= 0) {
	mLocked.spots.removeAt(i);
	releaseSpotLocked(spot);
	continue;
	} else {
	spot->sprite->setAlpha(spot->alpha);
	keepAnimating = true;
	}
	}
	++i;
	}
	return keepAnimating;
	}

	bool PointerController::doBitmapAnimationLocked(nsecs_t timestamp) {
	std::map<int32_t, PointerAnimation>::const_iterator iter = mLocked.animationResources.find(
	mLocked.requestedPointerType);
	if (iter == mLocked.animationResources.end()) {
	return false;
	}

	if (timestamp - mLocked.lastFrameUpdatedTime > iter->second.durationPerFrame) {
	mSpriteController->openTransaction();

	int incr = (timestamp - mLocked.lastFrameUpdatedTime) / iter->second.durationPerFrame;
	mLocked.animationFrameIndex += incr;
	mLocked.lastFrameUpdatedTime += iter->second.durationPerFrame * incr;
	while (mLocked.animationFrameIndex >= iter->second.animationFrames.size()) {
	mLocked.animationFrameIndex -= iter->second.animationFrames.size();
	}
	mLocked.pointerSprite->setIcon(iter->second.animationFrames[mLocked.animationFrameIndex]);

	mSpriteController->closeTransaction();
	}

	// Keep animating.
	return true;
	}

	void PointerController::doInactivityTimeout() {
	fade(TRANSITION_GRADUAL);
	}

	void PointerController::startAnimationLocked() {
	if (!mLocked.animationPending) {
	mLocked.animationPending = true;
	mLocked.animationTime = systemTime(SYSTEM_TIME_MONOTONIC);
	mDisplayEventReceiver.requestNextVsync();
	}
	}

	void PointerController::resetInactivityTimeoutLocked() {
	mLooper->removeMessages(mHandler, MSG_INACTIVITY_TIMEOUT);

	nsecs_t timeout = mLocked.inactivityTimeout == INACTIVITY_TIMEOUT_SHORT
	? INACTIVITY_TIMEOUT_DELAY_TIME_SHORT : INACTIVITY_TIMEOUT_DELAY_TIME_NORMAL;
	mLooper->sendMessageDelayed(timeout, mHandler, MSG_INACTIVITY_TIMEOUT);
	}

	void PointerController::removeInactivityTimeoutLocked() {
	mLooper->removeMessages(mHandler, MSG_INACTIVITY_TIMEOUT);
	}

	void PointerController::updatePointerLocked() REQUIRES(mLock) {
	if (!mLocked.viewport.isValid()) {
	return;
	}

	mSpriteController->openTransaction();

	mLocked.pointerSprite->setLayer(Sprite::BASE_LAYER_POINTER);
	mLocked.pointerSprite->setPosition(mLocked.pointerX, mLocked.pointerY);
	mLocked.pointerSprite->setDisplayId(mLocked.viewport.displayId);

	if (mLocked.pointerAlpha > 0) {
	mLocked.pointerSprite->setAlpha(mLocked.pointerAlpha);
	mLocked.pointerSprite->setVisible(true);
	} else {
	mLocked.pointerSprite->setVisible(false);
	}

	if (mLocked.pointerIconChanged \|\| mLocked.presentationChanged) {
	if (mLocked.presentation == PRESENTATION_POINTER) {
	if (mLocked.requestedPointerType == mPolicy->getDefaultPointerIconId()) {
	mLocked.pointerSprite->setIcon(mLocked.pointerIcon);
	} else {
	std::map<int32_t, SpriteIcon>::const_iterator iter =
	mLocked.additionalMouseResources.find(mLocked.requestedPointerType);
	if (iter != mLocked.additionalMouseResources.end()) {
	std::map<int32_t, PointerAnimation>::const_iterator anim_iter =
	mLocked.animationResources.find(mLocked.requestedPointerType);
	if (anim_iter != mLocked.animationResources.end()) {
	mLocked.animationFrameIndex = 0;
	mLocked.lastFrameUpdatedTime = systemTime(SYSTEM_TIME_MONOTONIC);
	startAnimationLocked();
	}
	mLocked.pointerSprite->setIcon(iter->second);
	} else {
	ALOGW("Can't find the resource for icon id %d", mLocked.requestedPointerType);
	mLocked.pointerSprite->setIcon(mLocked.pointerIcon);
	}
	}
	} else {
	mLocked.pointerSprite->setIcon(mResources.spotAnchor);
	}
	mLocked.pointerIconChanged = false;
	mLocked.presentationChanged = false;
	}

	mSpriteController->closeTransaction();
	}

	PointerController::Spot* PointerController::getSpotLocked(uint32_t id) {
	for (size_t i = 0; i < mLocked.spots.size(); i++) {
	Spot* spot = mLocked.spots.itemAt(i);
	if (spot->id == id) {
	return spot;
	}
	}
	return NULL;
	}

	PointerController::Spot* PointerController::createAndAddSpotLocked(uint32_t id) {
	// Remove spots until we have fewer than MAX_SPOTS remaining.
	while (mLocked.spots.size() >= MAX_SPOTS) {
	Spot* spot = removeFirstFadingSpotLocked();
	if (!spot) {
	spot = mLocked.spots.itemAt(0);
	mLocked.spots.removeAt(0);
	}
	releaseSpotLocked(spot);
	}

	// Obtain a sprite from the recycled pool.
	sp<Sprite> sprite;
	if (! mLocked.recycledSprites.isEmpty()) {
	sprite = mLocked.recycledSprites.top();
	mLocked.recycledSprites.pop();
	} else {
	sprite = mSpriteController->createSprite();
	}

	// Return the new spot.
	Spot* spot = new Spot(id, sprite);
	mLocked.spots.push(spot);
	return spot;
	}

	PointerController::Spot* PointerController::removeFirstFadingSpotLocked() {
	for (size_t i = 0; i < mLocked.spots.size(); i++) {
	Spot* spot = mLocked.spots.itemAt(i);
	if (spot->id == Spot::INVALID_ID) {
	mLocked.spots.removeAt(i);
	return spot;
	}
	}
	return NULL;
	}

	void PointerController::releaseSpotLocked(Spot* spot) {
	spot->sprite->clearIcon();

	if (mLocked.recycledSprites.size() < MAX_RECYCLED_SPRITES) {
	mLocked.recycledSprites.push(spot->sprite);
	}

	delete spot;
	}

	void PointerController::fadeOutAndReleaseSpotLocked(Spot* spot) {
	if (spot->id != Spot::INVALID_ID) {
	spot->id = Spot::INVALID_ID;
	startAnimationLocked();
	}
	}

	void PointerController::fadeOutAndReleaseAllSpotsLocked() {
	for (size_t i = 0; i < mLocked.spots.size(); i++) {
	Spot* spot = mLocked.spots.itemAt(i);
	fadeOutAndReleaseSpotLocked(spot);
	}
	}

	void PointerController::loadResourcesLocked() REQUIRES(mLock) {
	mPolicy->loadPointerResources(&mResources);

	if (mLocked.presentation == PRESENTATION_POINTER) {
	mLocked.additionalMouseResources.clear();
	mLocked.animationResources.clear();
	mPolicy->loadPointerIcon(&mLocked.pointerIcon);
	mPolicy->loadAdditionalMouseResources(&mLocked.additionalMouseResources,
	&mLocked.animationResources);
	}

	mLocked.pointerIconChanged = true;
	}


	// --- PointerController::Spot ---

	void PointerController::Spot::updateSprite(const SpriteIcon* icon, float x, float y) {
	sprite->setLayer(Sprite::BASE_LAYER_SPOT + id);
	sprite->setAlpha(alpha);
	sprite->setTransformationMatrix(SpriteTransformationMatrix(scale, 0.0f, 0.0f, scale));
	sprite->setPosition(x, y);

	this->x = x;
	this->y = y;

	if (icon != lastIcon) {
	lastIcon = icon;
	if (icon) {
	sprite->setIcon(*icon);
	sprite->setVisible(true);
	} else {
	sprite->setVisible(false);
	}
	}
	}

	} // namespace android