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 <log/log.h>
#include <SkBitmap.h> #include <memory>
#include <SkCanvas.h>
#include <SkColor.h>
#include <SkPaint.h>
#include <SkBlendMode.h>
namespace android { 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 --- // --- PointerController ---
// Time to wait before starting the fade when the pointer is inactive. // 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. // The number of events to be read at once for DisplayEventReceiver.
static const int EVENT_BUFFER_SIZE = 100; 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) : * Now we need to hook up the constructed PointerController object to its callbacks.
mPolicy(policy), mLooper(looper), mSpriteController(spriteController) { *
mHandler = new WeakMessageHandler(this); * This must be executed after the constructor but before any other methods on PointerController
mCallback = new WeakLooperCallback(this); * 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) { controller->mHandler->pointerController = controller;
mLooper->addFd(mDisplayEventReceiver.getFd(), Looper::POLL_CALLBACK, controller->mCallback->pointerController = controller;
Looper::EVENT_INPUT, mCallback, nullptr); if (controller->mDisplayEventReceiver.initCheck() == NO_ERROR) {
controller->mLooper->addFd(controller->mDisplayEventReceiver.getFd(), Looper::POLL_CALLBACK,
Looper::EVENT_INPUT, controller->mCallback, nullptr);
} else { } else {
ALOGE("Failed to initialize DisplayEventReceiver."); 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); AutoMutex _l(mLock);
mLocked.animationPending = false; mLocked.animationPending = false;
mLocked.presentation = PRESENTATION_POINTER; mLocked.presentation = Presentation::POINTER;
mLocked.presentationChanged = false; mLocked.presentationChanged = false;
mLocked.inactivityTimeout = INACTIVITY_TIMEOUT_NORMAL; mLocked.inactivityTimeout = InactivityTimeout::NORMAL;
mLocked.pointerFadeDirection = 0; mLocked.pointerFadeDirection = 0;
mLocked.pointerX = 0; mLocked.pointerX = 0;
@@ -227,7 +221,7 @@ void PointerController::fade(Transition transition) {
removeInactivityTimeoutLocked(); removeInactivityTimeoutLocked();
// Start fading. // Start fading.
if (transition == TRANSITION_IMMEDIATE) { if (transition == Transition::IMMEDIATE) {
mLocked.pointerFadeDirection = 0; mLocked.pointerFadeDirection = 0;
mLocked.pointerAlpha = 0.0f; mLocked.pointerAlpha = 0.0f;
updatePointerLocked(); updatePointerLocked();
@@ -244,7 +238,7 @@ void PointerController::unfade(Transition transition) {
resetInactivityTimeoutLocked(); resetInactivityTimeoutLocked();
// Start unfading. // Start unfading.
if (transition == TRANSITION_IMMEDIATE) { if (transition == Transition::IMMEDIATE) {
mLocked.pointerFadeDirection = 0; mLocked.pointerFadeDirection = 0;
mLocked.pointerAlpha = 1.0f; mLocked.pointerAlpha = 1.0f;
updatePointerLocked(); updatePointerLocked();
@@ -268,7 +262,7 @@ void PointerController::setPresentation(Presentation presentation) {
return; return;
} }
if (presentation == PRESENTATION_POINTER) { if (presentation == Presentation::POINTER) {
if (mLocked.additionalMouseResources.empty()) { if (mLocked.additionalMouseResources.empty()) {
mPolicy->loadAdditionalMouseResources(&mLocked.additionalMouseResources, mPolicy->loadAdditionalMouseResources(&mLocked.additionalMouseResources,
&mLocked.animationResources, &mLocked.animationResources,
@@ -486,24 +480,35 @@ void PointerController::setCustomPointerIcon(const SpriteIcon& icon) {
updatePointerLocked(); 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) { switch (message.what) {
case MSG_INACTIVITY_TIMEOUT: case MSG_INACTIVITY_TIMEOUT:
doInactivityTimeout(); controller->doInactivityTimeout();
break; 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)) { if (events & (Looper::EVENT_ERROR | Looper::EVENT_HANGUP)) {
ALOGE("Display event receiver pipe was closed or an error occurred. " ALOGE("Display event receiver pipe was closed or an error occurred. events=0x%x", events);
"events=0x%x", events);
return 0; // remove the callback return 0; // remove the callback
} }
if (!(events & Looper::EVENT_INPUT)) { if (!(events & Looper::EVENT_INPUT)) {
ALOGW("Received spurious callback for unhandled poll event. " ALOGW("Received spurious callback for unhandled poll event. events=0x%x", events);
"events=0x%x", events);
return 1; // keep the callback return 1; // keep the callback
} }
@@ -511,7 +516,7 @@ int PointerController::handleEvent(int /* fd */, int events, void* /* data */) {
ssize_t n; ssize_t n;
nsecs_t timestamp; nsecs_t timestamp;
DisplayEventReceiver::Event buf[EVENT_BUFFER_SIZE]; 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) { for (size_t i = 0; i < static_cast<size_t>(n); ++i) {
if (buf[i].header.type == DisplayEventReceiver::DISPLAY_EVENT_VSYNC) { if (buf[i].header.type == DisplayEventReceiver::DISPLAY_EVENT_VSYNC) {
timestamp = buf[i].header.timestamp; timestamp = buf[i].header.timestamp;
@@ -520,7 +525,7 @@ int PointerController::handleEvent(int /* fd */, int events, void* /* data */) {
} }
} }
if (gotVsync) { if (gotVsync) {
doAnimate(timestamp); controller->doAnimate(timestamp);
} }
return 1; // keep the callback return 1; // keep the callback
} }
@@ -619,7 +624,7 @@ bool PointerController::doBitmapAnimationLocked(nsecs_t timestamp) {
} }
void PointerController::doInactivityTimeout() { void PointerController::doInactivityTimeout() {
fade(TRANSITION_GRADUAL); fade(Transition::GRADUAL);
} }
void PointerController::startAnimationLocked() { void PointerController::startAnimationLocked() {
@@ -633,8 +638,9 @@ void PointerController::startAnimationLocked() {
void PointerController::resetInactivityTimeoutLocked() { void PointerController::resetInactivityTimeoutLocked() {
mLooper->removeMessages(mHandler, MSG_INACTIVITY_TIMEOUT); mLooper->removeMessages(mHandler, MSG_INACTIVITY_TIMEOUT);
nsecs_t timeout = mLocked.inactivityTimeout == INACTIVITY_TIMEOUT_SHORT nsecs_t timeout = mLocked.inactivityTimeout == InactivityTimeout::SHORT
? INACTIVITY_TIMEOUT_DELAY_TIME_SHORT : INACTIVITY_TIMEOUT_DELAY_TIME_NORMAL; ? INACTIVITY_TIMEOUT_DELAY_TIME_SHORT
: INACTIVITY_TIMEOUT_DELAY_TIME_NORMAL;
mLooper->sendMessageDelayed(timeout, mHandler, MSG_INACTIVITY_TIMEOUT); mLooper->sendMessageDelayed(timeout, mHandler, MSG_INACTIVITY_TIMEOUT);
} }
@@ -661,7 +667,7 @@ void PointerController::updatePointerLocked() REQUIRES(mLock) {
} }
if (mLocked.pointerIconChanged || mLocked.presentationChanged) { if (mLocked.pointerIconChanged || mLocked.presentationChanged) {
if (mLocked.presentation == PRESENTATION_POINTER) { if (mLocked.presentation == Presentation::POINTER) {
if (mLocked.requestedPointerType == mPolicy->getDefaultPointerIconId()) { if (mLocked.requestedPointerType == mPolicy->getDefaultPointerIconId()) {
mLocked.pointerSprite->setIcon(mLocked.pointerIcon); mLocked.pointerSprite->setIcon(mLocked.pointerIcon);
} else { } else {
@@ -737,7 +743,7 @@ PointerController::Spot* PointerController::removeFirstFadingSpotLocked(std::vec
return spot; return spot;
} }
} }
return NULL; return nullptr;
} }
void PointerController::releaseSpotLocked(Spot* spot) { void PointerController::releaseSpotLocked(Spot* spot) {
@@ -778,7 +784,7 @@ void PointerController::loadResourcesLocked() REQUIRES(mLock) {
mLocked.additionalMouseResources.clear(); mLocked.additionalMouseResources.clear();
mLocked.animationResources.clear(); mLocked.animationResources.clear();
if (mLocked.presentation == PRESENTATION_POINTER) { if (mLocked.presentation == Presentation::POINTER) {
mPolicy->loadAdditionalMouseResources(&mLocked.additionalMouseResources, mPolicy->loadAdditionalMouseResources(&mLocked.additionalMouseResources,
&mLocked.animationResources, mLocked.viewport.displayId); &mLocked.animationResources, mLocked.viewport.displayId);
} }

72
libs/input/PointerController.h
View File

@@ -17,19 +17,20 @@
#ifndef _UI_POINTER_CONTROLLER_H #ifndef _UI_POINTER_CONTROLLER_H
#define _UI_POINTER_CONTROLLER_H #define _UI_POINTER_CONTROLLER_H
#include "SpriteController.h" #include <PointerControllerInterface.h>
#include <gui/DisplayEventReceiver.h>
#include <map>
#include <vector>
#include <ui/DisplayInfo.h>
#include <input/DisplayViewport.h> #include <input/DisplayViewport.h>
#include <input/Input.h> #include <input/Input.h>
#include <PointerControllerInterface.h> #include <ui/DisplayInfo.h>
#include <utils/BitSet.h> #include <utils/BitSet.h>
#include <utils/RefBase.h>
#include <utils/Looper.h> #include <utils/Looper.h>
#include <gui/DisplayEventReceiver.h> #include <utils/RefBase.h>
#include <map>
#include <memory>
#include <vector>
#include "SpriteController.h"
namespace android { namespace android {
@@ -70,25 +71,22 @@ public:
virtual int32_t getCustomPointerIconId() = 0; virtual int32_t getCustomPointerIconId() = 0;
}; };
/* /*
* Tracks pointer movements and draws the pointer sprite to a surface. * Tracks pointer movements and draws the pointer sprite to a surface.
* *
* Handles pointer acceleration and animation. * Handles pointer acceleration and animation.
*/ */
class PointerController : public PointerControllerInterface, public MessageHandler, class PointerController : public PointerControllerInterface {
public LooperCallback {
protected:
virtual ~PointerController();
public: public:
enum InactivityTimeout { static std::shared_ptr<PointerController> create(
INACTIVITY_TIMEOUT_NORMAL = 0, const sp<PointerControllerPolicyInterface>& policy, const sp<Looper>& looper,
INACTIVITY_TIMEOUT_SHORT = 1, const sp<SpriteController>& spriteController);
enum class InactivityTimeout {
NORMAL = 0,
SHORT = 1,
}; };
PointerController(const sp<PointerControllerPolicyInterface>& policy, virtual ~PointerController();
const sp<Looper>& looper, const sp<SpriteController>& spriteController);
virtual bool getBounds(float* outMinX, float* outMinY, virtual bool getBounds(float* outMinX, float* outMinY,
float* outMaxX, float* outMaxY) const; float* outMaxX, float* outMaxY) const;
@@ -113,8 +111,8 @@ public:
void reloadPointerResources(); void reloadPointerResources();
private: private:
static const size_t MAX_RECYCLED_SPRITES = 12; static constexpr size_t MAX_RECYCLED_SPRITES = 12;
static const size_t MAX_SPOTS = 12; static constexpr size_t MAX_SPOTS = 12;
enum { enum {
MSG_INACTIVITY_TIMEOUT, MSG_INACTIVITY_TIMEOUT,
@@ -130,8 +128,13 @@ private:
float x, y; float x, y;
inline Spot(uint32_t id, const sp<Sprite>& sprite) inline Spot(uint32_t id, const sp<Sprite>& sprite)
: id(id), sprite(sprite), alpha(1.0f), scale(1.0f), : id(id),
x(0.0f), y(0.0f), lastIcon(NULL) { } 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); void updateSprite(const SpriteIcon* icon, float x, float y, int32_t displayId);
@@ -139,12 +142,24 @@ private:
const SpriteIcon* lastIcon; 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; mutable Mutex mLock;
sp<PointerControllerPolicyInterface> mPolicy; sp<PointerControllerPolicyInterface> mPolicy;
sp<Looper> mLooper; sp<Looper> mLooper;
sp<SpriteController> mSpriteController; sp<SpriteController> mSpriteController;
sp<WeakMessageHandler> mHandler; sp<MessageHandler> mHandler;
sp<LooperCallback> mCallback; sp<LooperCallback> mCallback;
DisplayEventReceiver mDisplayEventReceiver; DisplayEventReceiver mDisplayEventReceiver;
@@ -181,14 +196,15 @@ private:
int32_t buttonState; int32_t buttonState;
std::map<int32_t /* displayId */, std::vector<Spot*>> spotsByDisplay; std::map<int32_t /* displayId */, std::vector<Spot*>> spotsByDisplay;
std::vector<sp<Sprite> > recycledSprites; std::vector<sp<Sprite>> recycledSprites;
} mLocked GUARDED_BY(mLock); } 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; bool getBoundsLocked(float* outMinX, float* outMinY, float* outMaxX, float* outMaxY) const;
void setPositionLocked(float x, float y); void setPositionLocked(float x, float y);
void handleMessage(const Message& message);
int handleEvent(int fd, int events, void* data);
void doAnimate(nsecs_t timestamp); void doAnimate(nsecs_t timestamp);
bool doFadingAnimationLocked(nsecs_t timestamp); bool doFadingAnimationLocked(nsecs_t timestamp);
bool doBitmapAnimationLocked(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<MockSprite> mPointerSprite;
sp<MockPointerControllerPolicyInterface> mPolicy; sp<MockPointerControllerPolicyInterface> mPolicy;
sp<MockSpriteController> mSpriteController; sp<MockSpriteController> mSpriteController;
sp<PointerController> mPointerController; std::shared_ptr<PointerController> mPointerController;
private: private:
void loopThread(); void loopThread();
@@ -160,7 +160,7 @@ PointerControllerTest::PointerControllerTest() : mPointerSprite(new NiceMock<Moc
EXPECT_CALL(*mSpriteController, createSprite()) EXPECT_CALL(*mSpriteController, createSprite())
.WillOnce(Return(mPointerSprite)); .WillOnce(Return(mPointerSprite));
mPointerController = new PointerController(mPolicy, mLooper, mSpriteController); mPointerController = PointerController::create(mPolicy, mLooper, mSpriteController);
} }
PointerControllerTest::~PointerControllerTest() { PointerControllerTest::~PointerControllerTest() {
@@ -193,7 +193,7 @@ void PointerControllerTest::loopThread() {
TEST_F(PointerControllerTest, useDefaultCursorTypeByDefault) { TEST_F(PointerControllerTest, useDefaultCursorTypeByDefault) {
ensureDisplayViewportIsSet(); ensureDisplayViewportIsSet();
mPointerController->unfade(PointerController::TRANSITION_IMMEDIATE); mPointerController->unfade(PointerController::Transition::IMMEDIATE);
std::pair<float, float> hotspot = getHotSpotCoordinatesForType(CURSOR_TYPE_DEFAULT); std::pair<float, float> hotspot = getHotSpotCoordinatesForType(CURSOR_TYPE_DEFAULT);
EXPECT_CALL(*mPointerSprite, setVisible(true)); EXPECT_CALL(*mPointerSprite, setVisible(true));
@@ -208,7 +208,7 @@ TEST_F(PointerControllerTest, useDefaultCursorTypeByDefault) {
TEST_F(PointerControllerTest, updatePointerIcon) { TEST_F(PointerControllerTest, updatePointerIcon) {
ensureDisplayViewportIsSet(); ensureDisplayViewportIsSet();
mPointerController->unfade(PointerController::TRANSITION_IMMEDIATE); mPointerController->unfade(PointerController::Transition::IMMEDIATE);
int32_t type = CURSOR_TYPE_ADDITIONAL; int32_t type = CURSOR_TYPE_ADDITIONAL;
std::pair<float, float> hotspot = getHotSpotCoordinatesForType(type); std::pair<float, float> hotspot = getHotSpotCoordinatesForType(type);
@@ -224,7 +224,7 @@ TEST_F(PointerControllerTest, updatePointerIcon) {
TEST_F(PointerControllerTest, setCustomPointerIcon) { TEST_F(PointerControllerTest, setCustomPointerIcon) {
ensureDisplayViewportIsSet(); ensureDisplayViewportIsSet();
mPointerController->unfade(PointerController::TRANSITION_IMMEDIATE); mPointerController->unfade(PointerController::Transition::IMMEDIATE);
int32_t style = CURSOR_TYPE_CUSTOM; int32_t style = CURSOR_TYPE_CUSTOM;
float hotSpotX = 15; float hotSpotX = 15;
@@ -246,13 +246,13 @@ TEST_F(PointerControllerTest, setCustomPointerIcon) {
} }
TEST_F(PointerControllerTest, doesNotGetResourcesBeforeSettingViewport) { TEST_F(PointerControllerTest, doesNotGetResourcesBeforeSettingViewport) {
mPointerController->setPresentation(PointerController::PRESENTATION_POINTER); mPointerController->setPresentation(PointerController::Presentation::POINTER);
mPointerController->setSpots(nullptr, nullptr, BitSet32(), -1); mPointerController->setSpots(nullptr, nullptr, BitSet32(), -1);
mPointerController->clearSpots(); mPointerController->clearSpots();
mPointerController->setPosition(1.0f, 1.0f); mPointerController->setPosition(1.0f, 1.0f);
mPointerController->move(1.0f, 1.0f); mPointerController->move(1.0f, 1.0f);
mPointerController->unfade(PointerController::TRANSITION_IMMEDIATE); mPointerController->unfade(PointerController::Transition::IMMEDIATE);
mPointerController->fade(PointerController::TRANSITION_IMMEDIATE); mPointerController->fade(PointerController::Transition::IMMEDIATE);
EXPECT_TRUE(mPolicy->noResourcesAreLoaded()); EXPECT_TRUE(mPolicy->noResourcesAreLoaded());

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

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