33c5903e77
Currently PointerController starts listening to display events immediately (in its constructor) and never explicitly removes the callback. The reference dangling from the looper prevents the PointerController instance from being deleted when all the clients have released their references. As a result, when USB or BT mouse is disconnected, the mouse stays frozen on screen and only goes away after a 15 sec inactivity timeout. This change introduces an intermediary LooperCallback which holds only a weak reference to PointerController. The pointer now disappears immediately upon mouse disconnect. Bug: 30824220 Change-Id: I5f7208dbfa381b3e21f248cc0da402f307faa184
762 lines
23 KiB
C++
762 lines
23 KiB
C++
/*
|
|
* 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 <cutils/log.h>
|
|
|
|
#pragma GCC diagnostic push
|
|
#pragma GCC diagnostic ignored "-Wunused-parameter"
|
|
#include <SkBitmap.h>
|
|
#include <SkCanvas.h>
|
|
#include <SkColor.h>
|
|
#include <SkPaint.h>
|
|
#include <SkXfermode.h>
|
|
#pragma GCC diagnostic pop
|
|
|
|
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.displayWidth = -1;
|
|
mLocked.displayHeight = -1;
|
|
mLocked.displayOrientation = DISPLAY_ORIENTATION_0;
|
|
|
|
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;
|
|
|
|
mPolicy->loadPointerIcon(&mLocked.pointerIcon);
|
|
|
|
loadResources();
|
|
|
|
if (mLocked.pointerIcon.isValid()) {
|
|
mLocked.pointerIconChanged = true;
|
|
updatePointerLocked();
|
|
}
|
|
}
|
|
|
|
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.displayWidth <= 0 || mLocked.displayHeight <= 0) {
|
|
return false;
|
|
}
|
|
|
|
*outMinX = 0;
|
|
*outMinY = 0;
|
|
switch (mLocked.displayOrientation) {
|
|
case DISPLAY_ORIENTATION_90:
|
|
case DISPLAY_ORIENTATION_270:
|
|
*outMaxX = mLocked.displayHeight - 1;
|
|
*outMaxY = mLocked.displayWidth - 1;
|
|
break;
|
|
default:
|
|
*outMaxX = mLocked.displayWidth - 1;
|
|
*outMaxY = mLocked.displayHeight - 1;
|
|
break;
|
|
}
|
|
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;
|
|
}
|
|
|
|
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);
|
|
|
|
loadResources();
|
|
|
|
if (mLocked.presentation == PRESENTATION_POINTER) {
|
|
mLocked.additionalMouseResources.clear();
|
|
mLocked.animationResources.clear();
|
|
mPolicy->loadPointerIcon(&mLocked.pointerIcon);
|
|
mPolicy->loadAdditionalMouseResources(&mLocked.additionalMouseResources,
|
|
&mLocked.animationResources);
|
|
}
|
|
|
|
mLocked.presentationChanged = true;
|
|
updatePointerLocked();
|
|
}
|
|
|
|
void PointerController::setDisplayViewport(int32_t width, int32_t height, int32_t orientation) {
|
|
AutoMutex _l(mLock);
|
|
|
|
// Adjust to use the display's unrotated coordinate frame.
|
|
if (orientation == DISPLAY_ORIENTATION_90
|
|
|| orientation == DISPLAY_ORIENTATION_270) {
|
|
int32_t temp = height;
|
|
height = width;
|
|
width = temp;
|
|
}
|
|
|
|
if (mLocked.displayWidth != width || mLocked.displayHeight != height) {
|
|
mLocked.displayWidth = width;
|
|
mLocked.displayHeight = height;
|
|
|
|
float minX, minY, maxX, maxY;
|
|
if (getBoundsLocked(&minX, &minY, &maxX, &maxY)) {
|
|
mLocked.pointerX = (minX + maxX) * 0.5f;
|
|
mLocked.pointerY = (minY + maxY) * 0.5f;
|
|
} else {
|
|
mLocked.pointerX = 0;
|
|
mLocked.pointerY = 0;
|
|
}
|
|
|
|
fadeOutAndReleaseAllSpotsLocked();
|
|
}
|
|
|
|
if (mLocked.displayOrientation != 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 (mLocked.displayOrientation) {
|
|
case DISPLAY_ORIENTATION_90:
|
|
temp = x;
|
|
x = mLocked.displayWidth - y;
|
|
y = temp;
|
|
break;
|
|
case DISPLAY_ORIENTATION_180:
|
|
x = mLocked.displayWidth - x;
|
|
y = mLocked.displayHeight - y;
|
|
break;
|
|
case DISPLAY_ORIENTATION_270:
|
|
temp = x;
|
|
x = y;
|
|
y = mLocked.displayHeight - temp;
|
|
break;
|
|
}
|
|
|
|
// Perform the new rotation.
|
|
switch (orientation) {
|
|
case DISPLAY_ORIENTATION_90:
|
|
temp = x;
|
|
x = y;
|
|
y = mLocked.displayWidth - temp;
|
|
break;
|
|
case DISPLAY_ORIENTATION_180:
|
|
x = mLocked.displayWidth - x;
|
|
y = mLocked.displayHeight - y;
|
|
break;
|
|
case DISPLAY_ORIENTATION_270:
|
|
temp = x;
|
|
x = mLocked.displayHeight - 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;
|
|
mLocked.displayOrientation = orientation;
|
|
}
|
|
|
|
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(); i++) {
|
|
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);
|
|
} else {
|
|
spot->sprite->setAlpha(spot->alpha);
|
|
keepAnimating = true;
|
|
}
|
|
}
|
|
}
|
|
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() {
|
|
mSpriteController->openTransaction();
|
|
|
|
mLocked.pointerSprite->setLayer(Sprite::BASE_LAYER_POINTER);
|
|
mLocked.pointerSprite->setPosition(mLocked.pointerX, mLocked.pointerY);
|
|
|
|
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::loadResources() {
|
|
mPolicy->loadPointerResources(&mResources);
|
|
}
|
|
|
|
|
|
// --- 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
|