Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge changes from topics "pc-enum", "pointer_controller"

Browse Source 
* changes:
  Move PointerController enums to enum classes.
  Move PointerController from sp to shared_ptr
This commit is contained in:
Treehugger Robot
2020-07-08 01:19:13 +00:00
committed by Gerrit Code Review
parent 9ec2ad9dc6 6853fe6d78
commit 42875c3a99
4 changed files with 127 additions and 105 deletions
Download Patch File Download Diff File Expand all files Collapse all files

120
libs/input/PointerController.cpp
View File

@@ -24,37 +24,10 @@
#include <log/log.h>
#include <SkBitmap.h>
#include <SkCanvas.h>
#include <SkColor.h>
#include <SkPaint.h>
#include <SkBlendMode.h>
#include <memory>
namespace android {
// --- WeakLooperCallback ---
class WeakLooperCallback: public LooperCallback {
protected:
virtual ~WeakLooperCallback() { }
public:
explicit 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.
@@ -70,29 +43,50 @@ 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 ---
std::shared_ptr<PointerController> PointerController::create(
const sp<PointerControllerPolicyInterface>& policy, const sp<Looper>& looper,
const sp<SpriteController>& spriteController) {
std::shared_ptr<PointerController> controller = std::shared_ptr<PointerController>(
new PointerController(policy, looper, spriteController));
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);
/*
* Now we need to hook up the constructed PointerController object to its callbacks.
*
* This must be executed after the constructor but before any other methods on PointerController
* in order to ensure that the fully constructed object is visible on the Looper thread, since
* that may be a different thread than where the PointerController is initially constructed.
*
* Unfortunately, this cannot be done as part of the constructor since we need to hand out
* weak_ptr's which themselves cannot be constructed until there's at least one shared_ptr.
*/
if (mDisplayEventReceiver.initCheck() == NO_ERROR) {
mLooper->addFd(mDisplayEventReceiver.getFd(), Looper::POLL_CALLBACK,
Looper::EVENT_INPUT, mCallback, nullptr);
controller->mHandler->pointerController = controller;
controller->mCallback->pointerController = controller;
if (controller->mDisplayEventReceiver.initCheck() == NO_ERROR) {
controller->mLooper->addFd(controller->mDisplayEventReceiver.getFd(), Looper::POLL_CALLBACK,
Looper::EVENT_INPUT, controller->mCallback, nullptr);
} else {
ALOGE("Failed to initialize DisplayEventReceiver.");
}
return controller;
}
PointerController::PointerController(const sp<PointerControllerPolicyInterface>& policy,
const sp<Looper>& looper,
const sp<SpriteController>& spriteController)
: mPolicy(policy),
mLooper(looper),
mSpriteController(spriteController),
mHandler(new MessageHandler()),
mCallback(new LooperCallback()) {
AutoMutex _l(mLock);
mLocked.animationPending = false;
mLocked.presentation = PRESENTATION_POINTER;
mLocked.presentation = Presentation::POINTER;
mLocked.presentationChanged = false;
mLocked.inactivityTimeout = INACTIVITY_TIMEOUT_NORMAL;
mLocked.inactivityTimeout = InactivityTimeout::NORMAL;
mLocked.pointerFadeDirection = 0;
mLocked.pointerX = 0;
@@ -227,7 +221,7 @@ void PointerController::fade(Transition transition) {
removeInactivityTimeoutLocked();
// Start fading.
if (transition == TRANSITION_IMMEDIATE) {
if (transition == Transition::IMMEDIATE) {
mLocked.pointerFadeDirection = 0;
mLocked.pointerAlpha = 0.0f;
updatePointerLocked();
@@ -244,7 +238,7 @@ void PointerController::unfade(Transition transition) {
resetInactivityTimeoutLocked();
// Start unfading.
if (transition == TRANSITION_IMMEDIATE) {
if (transition == Transition::IMMEDIATE) {
mLocked.pointerFadeDirection = 0;
mLocked.pointerAlpha = 1.0f;
updatePointerLocked();
@@ -268,7 +262,7 @@ void PointerController::setPresentation(Presentation presentation) {
return;
}
if (presentation == PRESENTATION_POINTER) {
if (presentation == Presentation::POINTER) {
if (mLocked.additionalMouseResources.empty()) {
mPolicy->loadAdditionalMouseResources(&mLocked.additionalMouseResources,
&mLocked.animationResources,
@@ -486,24 +480,35 @@ void PointerController::setCustomPointerIcon(const SpriteIcon& icon) {
updatePointerLocked();
}
void PointerController::handleMessage(const Message& message) {
void PointerController::MessageHandler::handleMessage(const Message& message) {
std::shared_ptr<PointerController> controller = pointerController.lock();
if (controller == nullptr) {
ALOGE("PointerController instance was released before processing message: what=%d",
message.what);
return;
}
switch (message.what) {
case MSG_INACTIVITY_TIMEOUT:
doInactivityTimeout();
controller->doInactivityTimeout();
break;
}
}
int PointerController::handleEvent(int /* fd */, int events, void* /* data */) {
int PointerController::LooperCallback::handleEvent(int /* fd */, int events, void* /* data */) {
std::shared_ptr<PointerController> controller = pointerController.lock();
if (controller == nullptr) {
ALOGW("PointerController instance was released with pending callbacks. events=0x%x",
events);
return 0; // Remove the callback, the PointerController is gone anyways
}
if (events & (Looper::EVENT_ERROR | Looper::EVENT_HANGUP)) {
ALOGE("Display event receiver pipe was closed or an error occurred. "
"events=0x%x", events);
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);
ALOGW("Received spurious callback for unhandled poll event. events=0x%x", events);
return 1; // keep the callback
}
@@ -511,7 +516,7 @@ int PointerController::handleEvent(int /* fd */, int events, void* /* data */) {
ssize_t n;
nsecs_t timestamp;
DisplayEventReceiver::Event buf[EVENT_BUFFER_SIZE];
while ((n = mDisplayEventReceiver.getEvents(buf, EVENT_BUFFER_SIZE)) > 0) {
while ((n = controller->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;
@@ -520,7 +525,7 @@ int PointerController::handleEvent(int /* fd */, int events, void* /* data */) {
}
}
if (gotVsync) {
doAnimate(timestamp);
controller->doAnimate(timestamp);
}
return 1; // keep the callback
}
@@ -619,7 +624,7 @@ bool PointerController::doBitmapAnimationLocked(nsecs_t timestamp) {
}
void PointerController::doInactivityTimeout() {
fade(TRANSITION_GRADUAL);
fade(Transition::GRADUAL);
}
void PointerController::startAnimationLocked() {
@@ -633,8 +638,9 @@ void PointerController::startAnimationLocked() {
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;
nsecs_t timeout = mLocked.inactivityTimeout == InactivityTimeout::SHORT
? INACTIVITY_TIMEOUT_DELAY_TIME_SHORT
: INACTIVITY_TIMEOUT_DELAY_TIME_NORMAL;
mLooper->sendMessageDelayed(timeout, mHandler, MSG_INACTIVITY_TIMEOUT);
}
@@ -661,7 +667,7 @@ void PointerController::updatePointerLocked() REQUIRES(mLock) {
}
if (mLocked.pointerIconChanged || mLocked.presentationChanged) {
if (mLocked.presentation == PRESENTATION_POINTER) {
if (mLocked.presentation == Presentation::POINTER) {
if (mLocked.requestedPointerType == mPolicy->getDefaultPointerIconId()) {
mLocked.pointerSprite->setIcon(mLocked.pointerIcon);
} else {
@@ -737,7 +743,7 @@ PointerController::Spot* PointerController::removeFirstFadingSpotLocked(std::vec
return spot;
}
}
return NULL;
return nullptr;
}
void PointerController::releaseSpotLocked(Spot* spot) {
@@ -778,7 +784,7 @@ void PointerController::loadResourcesLocked() REQUIRES(mLock) {
mLocked.additionalMouseResources.clear();
mLocked.animationResources.clear();
if (mLocked.presentation == PRESENTATION_POINTER) {
if (mLocked.presentation == Presentation::POINTER) {
mPolicy->loadAdditionalMouseResources(&mLocked.additionalMouseResources,
&mLocked.animationResources, mLocked.viewport.displayId);
}

72
libs/input/PointerController.h
View File

@@ -17,19 +17,20 @@
#ifndef _UI_POINTER_CONTROLLER_H
#define _UI_POINTER_CONTROLLER_H
#include "SpriteController.h"
#include <map>
#include <vector>
#include <ui/DisplayInfo.h>
#include <PointerControllerInterface.h>
#include <gui/DisplayEventReceiver.h>
#include <input/DisplayViewport.h>
#include <input/Input.h>
#include <PointerControllerInterface.h>
#include <ui/DisplayInfo.h>
#include <utils/BitSet.h>
#include <utils/RefBase.h>
#include <utils/Looper.h>
#include <gui/DisplayEventReceiver.h>
#include <utils/RefBase.h>
#include <map>
#include <memory>
#include <vector>
#include "SpriteController.h"
namespace android {
@@ -70,25 +71,22 @@ public:
virtual int32_t getCustomPointerIconId() = 0;
};
/*
* Tracks pointer movements and draws the pointer sprite to a surface.
*
* Handles pointer acceleration and animation.
*/
class PointerController : public PointerControllerInterface, public MessageHandler,
public LooperCallback {
protected:
virtual ~PointerController();
class PointerController : public PointerControllerInterface {
public:
enum InactivityTimeout {
INACTIVITY_TIMEOUT_NORMAL = 0,
INACTIVITY_TIMEOUT_SHORT = 1,
static std::shared_ptr<PointerController> create(
const sp<PointerControllerPolicyInterface>& policy, const sp<Looper>& looper,
const sp<SpriteController>& spriteController);
enum class InactivityTimeout {
NORMAL = 0,
SHORT = 1,
};
PointerController(const sp<PointerControllerPolicyInterface>& policy,
const sp<Looper>& looper, const sp<SpriteController>& spriteController);
virtual ~PointerController();
virtual bool getBounds(float* outMinX, float* outMinY,
float* outMaxX, float* outMaxY) const;
@@ -113,8 +111,8 @@ public:
void reloadPointerResources();
private:
static const size_t MAX_RECYCLED_SPRITES = 12;
static const size_t MAX_SPOTS = 12;
static constexpr size_t MAX_RECYCLED_SPRITES = 12;
static constexpr size_t MAX_SPOTS = 12;
enum {
MSG_INACTIVITY_TIMEOUT,
@@ -130,8 +128,13 @@ private:
float x, y;
inline Spot(uint32_t id, const sp<Sprite>& sprite)
: id(id), sprite(sprite), alpha(1.0f), scale(1.0f),
x(0.0f), y(0.0f), lastIcon(NULL) { }
: id(id),
sprite(sprite),
alpha(1.0f),
scale(1.0f),
x(0.0f),
y(0.0f),
lastIcon(nullptr) {}
void updateSprite(const SpriteIcon* icon, float x, float y, int32_t displayId);
@@ -139,12 +142,24 @@ private:
const SpriteIcon* lastIcon;
};
class MessageHandler : public virtual android::MessageHandler {
public:
void handleMessage(const Message& message) override;
std::weak_ptr<PointerController> pointerController;
};
class LooperCallback : public virtual android::LooperCallback {
public:
int handleEvent(int fd, int events, void* data) override;
std::weak_ptr<PointerController> pointerController;
};
mutable Mutex mLock;
sp<PointerControllerPolicyInterface> mPolicy;
sp<Looper> mLooper;
sp<SpriteController> mSpriteController;
sp<WeakMessageHandler> mHandler;
sp<MessageHandler> mHandler;
sp<LooperCallback> mCallback;
DisplayEventReceiver mDisplayEventReceiver;
@@ -181,14 +196,15 @@ private:
int32_t buttonState;
std::map<int32_t /* displayId */, std::vector<Spot*>> spotsByDisplay;
std::vector<sp<Sprite> > recycledSprites;
std::vector<sp<Sprite>> recycledSprites;
} mLocked GUARDED_BY(mLock);
PointerController(const sp<PointerControllerPolicyInterface>& policy, const sp<Looper>& looper,
const sp<SpriteController>& spriteController);
bool getBoundsLocked(float* outMinX, float* outMinY, float* outMaxX, float* outMaxY) const;
void setPositionLocked(float x, float y);
void handleMessage(const Message& message);
int handleEvent(int fd, int events, void* data);
void doAnimate(nsecs_t timestamp);
bool doFadingAnimationLocked(nsecs_t timestamp);
bool doBitmapAnimationLocked(nsecs_t timestamp);

16
libs/input/tests/PointerController_test.cpp
View File

@@ -136,7 +136,7 @@ protected:
sp<MockSprite> mPointerSprite;
sp<MockPointerControllerPolicyInterface> mPolicy;
sp<MockSpriteController> mSpriteController;
sp<PointerController> mPointerController;
std::shared_ptr<PointerController> mPointerController;
private:
void loopThread();
@@ -160,7 +160,7 @@ PointerControllerTest::PointerControllerTest() : mPointerSprite(new NiceMock<Moc
EXPECT_CALL(*mSpriteController, createSprite())
.WillOnce(Return(mPointerSprite));
mPointerController = new PointerController(mPolicy, mLooper, mSpriteController);
mPointerController = PointerController::create(mPolicy, mLooper, mSpriteController);
}
PointerControllerTest::~PointerControllerTest() {
@@ -193,7 +193,7 @@ void PointerControllerTest::loopThread() {
TEST_F(PointerControllerTest, useDefaultCursorTypeByDefault) {
ensureDisplayViewportIsSet();
mPointerController->unfade(PointerController::TRANSITION_IMMEDIATE);
mPointerController->unfade(PointerController::Transition::IMMEDIATE);
std::pair<float, float> hotspot = getHotSpotCoordinatesForType(CURSOR_TYPE_DEFAULT);
EXPECT_CALL(*mPointerSprite, setVisible(true));
@@ -208,7 +208,7 @@ TEST_F(PointerControllerTest, useDefaultCursorTypeByDefault) {
TEST_F(PointerControllerTest, updatePointerIcon) {
ensureDisplayViewportIsSet();
mPointerController->unfade(PointerController::TRANSITION_IMMEDIATE);
mPointerController->unfade(PointerController::Transition::IMMEDIATE);
int32_t type = CURSOR_TYPE_ADDITIONAL;
std::pair<float, float> hotspot = getHotSpotCoordinatesForType(type);
@@ -224,7 +224,7 @@ TEST_F(PointerControllerTest, updatePointerIcon) {
TEST_F(PointerControllerTest, setCustomPointerIcon) {
ensureDisplayViewportIsSet();
mPointerController->unfade(PointerController::TRANSITION_IMMEDIATE);
mPointerController->unfade(PointerController::Transition::IMMEDIATE);
int32_t style = CURSOR_TYPE_CUSTOM;
float hotSpotX = 15;
@@ -246,13 +246,13 @@ TEST_F(PointerControllerTest, setCustomPointerIcon) {
}
TEST_F(PointerControllerTest, doesNotGetResourcesBeforeSettingViewport) {
mPointerController->setPresentation(PointerController::PRESENTATION_POINTER);
mPointerController->setPresentation(PointerController::Presentation::POINTER);
mPointerController->setSpots(nullptr, nullptr, BitSet32(), -1);
mPointerController->clearSpots();
mPointerController->setPosition(1.0f, 1.0f);
mPointerController->move(1.0f, 1.0f);
mPointerController->unfade(PointerController::TRANSITION_IMMEDIATE);
mPointerController->fade(PointerController::TRANSITION_IMMEDIATE);
mPointerController->unfade(PointerController::Transition::IMMEDIATE);
mPointerController->fade(PointerController::Transition::IMMEDIATE);
EXPECT_TRUE(mPolicy->noResourcesAreLoaded());

24
services/core/jni/com_android_server_input_InputManagerService.cpp
View File

@@ -233,7 +233,7 @@ public:
/* --- InputReaderPolicyInterface implementation --- */
virtual void getReaderConfiguration(InputReaderConfiguration* outConfig);
virtual sp<PointerControllerInterface> obtainPointerController(int32_t deviceId);
virtual std::shared_ptr<PointerControllerInterface> obtainPointerController(int32_t deviceId);
virtual void notifyInputDevicesChanged(const std::vector<InputDeviceInfo>& inputDevices);
virtual sp<KeyCharacterMap> getKeyboardLayoutOverlay(const InputDeviceIdentifier& identifier);
virtual std::string getDeviceAlias(const InputDeviceIdentifier& identifier);
@@ -306,7 +306,7 @@ private:
sp<SpriteController> spriteController;
// Pointer controller singleton, created and destroyed as needed.
wp<PointerController> pointerController;
std::weak_ptr<PointerController> pointerController;
// Input devices to be disabled
SortedVector<int32_t> disabledInputDevices;
@@ -551,15 +551,16 @@ void NativeInputManager::getReaderConfiguration(InputReaderConfiguration* outCon
} // release lock
}
sp<PointerControllerInterface> NativeInputManager::obtainPointerController(int32_t /* deviceId */) {
std::shared_ptr<PointerControllerInterface> NativeInputManager::obtainPointerController(
int32_t /* deviceId */) {
ATRACE_CALL();
AutoMutex _l(mLock);
sp<PointerController> controller = mLocked.pointerController.promote();
std::shared_ptr<PointerController> controller = mLocked.pointerController.lock();
if (controller == nullptr) {
ensureSpriteControllerLocked();
controller = new PointerController(this, mLooper, mLocked.spriteController);
controller = PointerController::create(this, mLooper, mLocked.spriteController);
mLocked.pointerController = controller;
updateInactivityTimeoutLocked();
}
@@ -840,15 +841,14 @@ void NativeInputManager::setSystemUiVisibility(int32_t visibility) {
}
void NativeInputManager::updateInactivityTimeoutLocked() REQUIRES(mLock) {
sp<PointerController> controller = mLocked.pointerController.promote();
std::shared_ptr<PointerController> controller = mLocked.pointerController.lock();
if (controller == nullptr) {
return;
}
bool lightsOut = mLocked.systemUiVisibility & ASYSTEM_UI_VISIBILITY_STATUS_BAR_HIDDEN;
controller->setInactivityTimeout(lightsOut
? PointerController::INACTIVITY_TIMEOUT_SHORT
: PointerController::INACTIVITY_TIMEOUT_NORMAL);
controller->setInactivityTimeout(lightsOut ? PointerController::InactivityTimeout::SHORT
: PointerController::InactivityTimeout::NORMAL);
}
void NativeInputManager::setPointerSpeed(int32_t speed) {
@@ -928,7 +928,7 @@ void NativeInputManager::reloadCalibration() {
void NativeInputManager::setPointerIconType(int32_t iconId) {
AutoMutex _l(mLock);
sp<PointerController> controller = mLocked.pointerController.promote();
std::shared_ptr<PointerController> controller = mLocked.pointerController.lock();
if (controller != nullptr) {
controller->updatePointerIcon(iconId);
}
@@ -936,7 +936,7 @@ void NativeInputManager::setPointerIconType(int32_t iconId) {
void NativeInputManager::reloadPointerIcons() {
AutoMutex _l(mLock);
sp<PointerController> controller = mLocked.pointerController.promote();
std::shared_ptr<PointerController> controller = mLocked.pointerController.lock();
if (controller != nullptr) {
controller->reloadPointerResources();
}
@@ -944,7 +944,7 @@ void NativeInputManager::reloadPointerIcons() {
void NativeInputManager::setCustomPointerIcon(const SpriteIcon& icon) {
AutoMutex _l(mLock);
sp<PointerController> controller = mLocked.pointerController.promote();
std::shared_ptr<PointerController> controller = mLocked.pointerController.lock();
if (controller != nullptr) {
controller->setCustomPointerIcon(icon);
}