Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit f5d03c19 authored by Treehugger Robot's avatar Treehugger Robot Committed by Android (Google) Code Review
Browse files

Merge changes Ib81d7289,I0fa10ef4 into main 

* changes:
  PointerChoreographer: Do not call the policy with the lock held
  PointerChoreographer: Remove ability to create mouse controllers OTF
parents 08726fcf 5a51a228

services/inputflinger/PointerChoreographer.cpp

+88 −51
Original line number Diff line number Diff line
@@ -26,6 +26,7 @@ 
namespace android {



namespace {



bool isFromMouse(const NotifyMotionArgs& args) {

    return isFromSource(args.source, AINPUT_SOURCE_MOUSE) &&

            args.pointerProperties[0].toolType == ToolType::MOUSE;
@@ -44,13 +45,23 @@ bool isHoverAction(int32_t action) { 
bool isStylusHoverEvent(const NotifyMotionArgs& args) {

    return isStylusEvent(args.source, args.pointerProperties) && isHoverAction(args.action);

}



inline void notifyPointerDisplayChange(std::optional<std::tuple<int32_t, FloatPoint>> change,

                                       PointerChoreographerPolicyInterface& policy) {

    if (!change) {

        return;

    }

    const auto& [displayId, cursorPosition] = *change;

    policy.notifyPointerDisplayIdChanged(displayId, cursorPosition);

}



} // namespace



// --- PointerChoreographer ---



PointerChoreographer::PointerChoreographer(InputListenerInterface& listener,

                                           PointerChoreographerPolicyInterface& policy)

      : mTouchControllerConstructor([this]() REQUIRES(mLock) {

      : mTouchControllerConstructor([this]() {

            return mPolicy.createPointerController(

                    PointerControllerInterface::ControllerType::TOUCH);

        }),
@@ -62,10 +73,16 @@ PointerChoreographer::PointerChoreographer(InputListenerInterface& listener, 
        mStylusPointerIconEnabled(false) {}



void PointerChoreographer::notifyInputDevicesChanged(const NotifyInputDevicesChangedArgs& args) {

    PointerDisplayChange pointerDisplayChange;



    { // acquire lock

        std::scoped_lock _l(mLock);



        mInputDeviceInfos = args.inputDeviceInfos;

    updatePointerControllersLocked();

        pointerDisplayChange = updatePointerControllersLocked();

    } // release lock



    notifyPointerDisplayChange(pointerDisplayChange, mPolicy);

    mNextListener.notify(args);

}
@@ -104,7 +121,7 @@ NotifyMotionArgs PointerChoreographer::processMouseEventLocked(const NotifyMotio 
                   << args.dump();

    }



    auto [displayId, pc] = getDisplayIdAndMouseControllerLocked(args.displayId);

    auto [displayId, pc] = ensureMouseControllerLocked(args.displayId);



    const float deltaX = args.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_RELATIVE_X);

    const float deltaY = args.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_RELATIVE_Y);
@@ -124,7 +141,7 @@ NotifyMotionArgs PointerChoreographer::processMouseEventLocked(const NotifyMotio 
}



NotifyMotionArgs PointerChoreographer::processTouchpadEventLocked(const NotifyMotionArgs& args) {

    auto [displayId, pc] = getDisplayIdAndMouseControllerLocked(args.displayId);

    auto [displayId, pc] = ensureMouseControllerLocked(args.displayId);



    NotifyMotionArgs newArgs(args);

    newArgs.displayId = displayId;
@@ -308,17 +325,13 @@ int32_t PointerChoreographer::getTargetMouseDisplayLocked(int32_t associatedDisp 
    return associatedDisplayId == ADISPLAY_ID_NONE ? mDefaultMouseDisplayId : associatedDisplayId;

}



std::pair<int32_t, PointerControllerInterface&>

PointerChoreographer::getDisplayIdAndMouseControllerLocked(int32_t associatedDisplayId) {

std::pair<int32_t, PointerControllerInterface&> PointerChoreographer::ensureMouseControllerLocked(

        int32_t associatedDisplayId) {

    const int32_t displayId = getTargetMouseDisplayLocked(associatedDisplayId);



    // Get the mouse pointer controller for the display, or create one if it doesn't exist.

    auto [it, emplaced] =

            mMousePointersByDisplay.try_emplace(displayId,

                                                getMouseControllerConstructor(displayId));

    if (emplaced) {

        notifyPointerDisplayIdChangedLocked();

    }

    auto it = mMousePointersByDisplay.find(displayId);

    LOG_ALWAYS_FATAL_IF(it == mMousePointersByDisplay.end(),

                        "There is no mouse controller created for display %d", displayId);



    return {displayId, *it->second};

}
@@ -333,7 +346,7 @@ bool PointerChoreographer::canUnfadeOnDisplay(int32_t displayId) { 
    return mDisplaysWithPointersHidden.find(displayId) == mDisplaysWithPointersHidden.end();

}



void PointerChoreographer::updatePointerControllersLocked() {

PointerChoreographer::PointerDisplayChange PointerChoreographer::updatePointerControllersLocked() {

    std::set<int32_t /*displayId*/> mouseDisplaysToKeep;

    std::set<DeviceId> touchDevicesToKeep;

    std::set<DeviceId> stylusDevicesToKeep;
@@ -382,11 +395,12 @@ void PointerChoreographer::updatePointerControllersLocked() { 
                mInputDeviceInfos.end();

    });



    // Notify the policy if there's a change on the pointer display ID.

    notifyPointerDisplayIdChangedLocked();

    // Check if we need to notify the policy if there's a change on the pointer display ID.

    return calculatePointerDisplayChangeToNotify();

}



void PointerChoreographer::notifyPointerDisplayIdChangedLocked() {

PointerChoreographer::PointerDisplayChange

PointerChoreographer::calculatePointerDisplayChangeToNotify() {

    int32_t displayIdToNotify = ADISPLAY_ID_NONE;

    FloatPoint cursorPosition = {0, 0};

    if (const auto it = mMousePointersByDisplay.find(mDefaultMouseDisplayId);
@@ -398,22 +412,30 @@ void PointerChoreographer::notifyPointerDisplayIdChangedLocked() { 
        displayIdToNotify = pointerController->getDisplayId();

        cursorPosition = pointerController->getPosition();

    }



    if (mNotifiedPointerDisplayId == displayIdToNotify) {

        return;

        return {};

    }

    mPolicy.notifyPointerDisplayIdChanged(displayIdToNotify, cursorPosition);

    mNotifiedPointerDisplayId = displayIdToNotify;

    return {{displayIdToNotify, cursorPosition}};

}



void PointerChoreographer::setDefaultMouseDisplayId(int32_t displayId) {

    PointerDisplayChange pointerDisplayChange;



    { // acquire lock

        std::scoped_lock _l(mLock);



        mDefaultMouseDisplayId = displayId;

    updatePointerControllersLocked();

        pointerDisplayChange = updatePointerControllersLocked();

    } // release lock



    notifyPointerDisplayChange(pointerDisplayChange, mPolicy);

}



void PointerChoreographer::setDisplayViewports(const std::vector<DisplayViewport>& viewports) {

    PointerDisplayChange pointerDisplayChange;



    { // acquire lock

        std::scoped_lock _l(mLock);

        for (const auto& viewport : viewports) {

            const int32_t displayId = viewport.displayId;
@@ -429,7 +451,10 @@ void PointerChoreographer::setDisplayViewports(const std::vector<DisplayViewport 
            }

        }

        mViewports = viewports;

    notifyPointerDisplayIdChangedLocked();

        pointerDisplayChange = calculatePointerDisplayChangeToNotify();

    } // release lock



    notifyPointerDisplayChange(pointerDisplayChange, mPolicy);

}



std::optional<DisplayViewport> PointerChoreographer::getViewportForPointerDevice(
@@ -453,21 +478,33 @@ FloatPoint PointerChoreographer::getMouseCursorPosition(int32_t displayId) { 
}



void PointerChoreographer::setShowTouchesEnabled(bool enabled) {

    PointerDisplayChange pointerDisplayChange;



    { // acquire lock

        std::scoped_lock _l(mLock);

        if (mShowTouchesEnabled == enabled) {

            return;

        }

        mShowTouchesEnabled = enabled;

    updatePointerControllersLocked();

        pointerDisplayChange = updatePointerControllersLocked();

    } // release lock



    notifyPointerDisplayChange(pointerDisplayChange, mPolicy);

}



void PointerChoreographer::setStylusPointerIconEnabled(bool enabled) {

    PointerDisplayChange pointerDisplayChange;



    { // acquire lock

        std::scoped_lock _l(mLock);

        if (mStylusPointerIconEnabled == enabled) {

            return;

        }

        mStylusPointerIconEnabled = enabled;

    updatePointerControllersLocked();

        pointerDisplayChange = updatePointerControllersLocked();

    } // release lock



    notifyPointerDisplayChange(pointerDisplayChange, mPolicy);

}



bool PointerChoreographer::setPointerIcon(

services/inputflinger/PointerChoreographer.h

+5 −3
Original line number Diff line number Diff line
@@ -109,11 +109,13 @@ public: 
    void dump(std::string& dump) override;



private:

    void updatePointerControllersLocked() REQUIRES(mLock);

    void notifyPointerDisplayIdChangedLocked() REQUIRES(mLock);

    using PointerDisplayChange =

            std::optional<std::tuple<int32_t /*displayId*/, FloatPoint /*cursorPosition*/>>;

    [[nodiscard]] PointerDisplayChange updatePointerControllersLocked() REQUIRES(mLock);

    [[nodiscard]] PointerDisplayChange calculatePointerDisplayChangeToNotify() REQUIRES(mLock);

    const DisplayViewport* findViewportByIdLocked(int32_t displayId) const REQUIRES(mLock);

    int32_t getTargetMouseDisplayLocked(int32_t associatedDisplayId) const REQUIRES(mLock);

    std::pair<int32_t, PointerControllerInterface&> getDisplayIdAndMouseControllerLocked(

    std::pair<int32_t /*displayId*/, PointerControllerInterface&> ensureMouseControllerLocked(

            int32_t associatedDisplayId) REQUIRES(mLock);

    InputDeviceInfo* findInputDeviceLocked(DeviceId deviceId) REQUIRES(mLock);

    bool canUnfadeOnDisplay(int32_t displayId) REQUIRES(mLock);

services/inputflinger/include/PointerChoreographerPolicyInterface.h

+6 −0
Original line number Diff line number Diff line
@@ -25,6 +25,9 @@ namespace android { 
 *

 * This is the interface that PointerChoreographer uses to talk to Window Manager and other

 * system components.

 *

 * NOTE: In general, the PointerChoreographer must not interact with the policy while

 * holding any locks.

 */

class PointerChoreographerPolicyInterface {

public:
@@ -37,6 +40,9 @@ public: 
     * for and runnable on the host, the PointerController implementation must be in a separate

     * library, libinputservice, that has the additional dependencies. The PointerController

     * will be mocked when testing PointerChoreographer.

     *

     * Since this is a factory method used to work around dependencies, it will not interact with

     * other input components and may be called with the PointerChoreographer lock held.

     */

    virtual std::shared_ptr<PointerControllerInterface> createPointerController(

            PointerControllerInterface::ControllerType type) = 0;