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

Commit 0a99c925 authored by Prabir Pradhan's avatar Prabir Pradhan
Browse files

InputDispatcher: Remove offsets for gesture monitors 

Offsets for gesture monitors are not used and are always initialized to
their default values of 0. We remove these offsets, allowing us to
remove the TouchedMonitor class as well.

Bug: 179274888
Test: atest inputflinger_tests
Change-Id: I1eea9a856fc5c70f18f50eda01d256cda8d17c2d
parent b9b18509

services/inputflinger/dispatcher/InputDispatcher.cpp

+23 −50
Original line number Diff line number Diff line
@@ -410,18 +410,6 @@ std::unique_ptr<DispatchEntry> createDispatchEntry(const InputTarget& inputTarge 
    return dispatchEntry;

}



void addGestureMonitors(const std::vector<Monitor>& monitors,

                        std::vector<TouchedMonitor>& outTouchedMonitors, float xOffset = 0,

                        float yOffset = 0) {

    if (monitors.empty()) {

        return;

    }

    outTouchedMonitors.reserve(monitors.size() + outTouchedMonitors.size());

    for (const Monitor& monitor : monitors) {

        outTouchedMonitors.emplace_back(monitor, xOffset, yOffset);

    }

}



status_t openInputChannelPair(const std::string& name, std::shared_ptr<InputChannel>& serverChannel,

                              std::unique_ptr<InputChannel>& clientChannel) {

    std::unique_ptr<InputChannel> uniqueServerChannel;
@@ -943,10 +931,9 @@ bool InputDispatcher::shouldPruneInboundQueueLocked(const MotionEntry& motionEnt 
        }



        // Alternatively, maybe there's a gesture monitor that could handle this event

        std::vector<TouchedMonitor> gestureMonitors = findTouchedGestureMonitorsLocked(displayId);

        for (TouchedMonitor& gestureMonitor : gestureMonitors) {

        for (const auto& monitor : getValueByKey(mGestureMonitorsByDisplay, displayId)) {

            sp<Connection> connection =

                    getConnectionLocked(gestureMonitor.monitor.inputChannel->getConnectionToken());

                    getConnectionLocked(monitor.inputChannel->getConnectionToken());

            if (connection != nullptr && connection->responsive) {

                // This monitor could take more input. Drop all events preceding this

                // event, so that gesture monitor could get a chance to receive the stream
@@ -1073,15 +1060,6 @@ sp<WindowInfoHandle> InputDispatcher::findTouchedWindowAtLocked(int32_t displayI 
    return nullptr;

}



std::vector<TouchedMonitor> InputDispatcher::findTouchedGestureMonitorsLocked(

        int32_t displayId) const {

    std::vector<TouchedMonitor> touchedMonitors;



    std::vector<Monitor> monitors = getValueByKey(mGestureMonitorsByDisplay, displayId);

    addGestureMonitors(monitors, touchedMonitors);

    return touchedMonitors;

}



void InputDispatcher::dropInboundEventLocked(const EventEntry& entry, DropReason dropReason) {

    const char* reason;

    switch (dropReason) {
@@ -1943,16 +1921,16 @@ InputEventInjectionResult InputDispatcher::findFocusedWindowTargetsLocked( 
 * Given a list of monitors, remove the ones we cannot find a connection for, and the ones

 * that are currently unresponsive.

 */

std::vector<TouchedMonitor> InputDispatcher::selectResponsiveMonitorsLocked(

        const std::vector<TouchedMonitor>& monitors) const {

    std::vector<TouchedMonitor> responsiveMonitors;

std::vector<Monitor> InputDispatcher::selectResponsiveMonitorsLocked(

        const std::vector<Monitor>& monitors) const {

    std::vector<Monitor> responsiveMonitors;

    std::copy_if(monitors.begin(), monitors.end(), std::back_inserter(responsiveMonitors),

                 [this](const TouchedMonitor& monitor) REQUIRES(mLock) {

                     sp<Connection> connection = getConnectionLocked(

                             monitor.monitor.inputChannel->getConnectionToken());

                 [this](const Monitor& monitor) REQUIRES(mLock) {

                     sp<Connection> connection =

                             getConnectionLocked(monitor.inputChannel->getConnectionToken());

                     if (connection == nullptr) {

                         ALOGE("Could not find connection for monitor %s",

                               monitor.monitor.inputChannel->getName().c_str());

                               monitor.inputChannel->getName().c_str());

                         return false;

                     }

                     if (!connection->responsive) {
@@ -2053,14 +2031,10 @@ InputEventInjectionResult InputDispatcher::findTouchedWindowTargetsLocked( 
            x = int32_t(entry.pointerCoords[pointerIndex].getAxisValue(AMOTION_EVENT_AXIS_X));

            y = int32_t(entry.pointerCoords[pointerIndex].getAxisValue(AMOTION_EVENT_AXIS_Y));

        }

        bool isDown = maskedAction == AMOTION_EVENT_ACTION_DOWN;

        const bool isDown = maskedAction == AMOTION_EVENT_ACTION_DOWN;

        newTouchedWindowHandle = findTouchedWindowAtLocked(displayId, x, y, &tempTouchState,

                                                           isDown /*addOutsideTargets*/);



        std::vector<TouchedMonitor> newGestureMonitors = isDown

                ? findTouchedGestureMonitorsLocked(displayId)

                : std::vector<TouchedMonitor>{};



        // Figure out whether splitting will be allowed for this window.

        if (newTouchedWindowHandle != nullptr &&

            newTouchedWindowHandle->getInfo()->supportsSplitTouch()) {
@@ -2120,8 +2094,10 @@ InputEventInjectionResult InputDispatcher::findTouchedWindowTargetsLocked( 
            newTouchedWindowHandle = nullptr;

        }



        // Also don't send the new touch event to unresponsive gesture monitors

        newGestureMonitors = selectResponsiveMonitorsLocked(newGestureMonitors);

        const std::vector<Monitor> newGestureMonitors = isDown

                ? selectResponsiveMonitorsLocked(

                          getValueByKey(mGestureMonitorsByDisplay, displayId))

                : std::vector<Monitor>{};



        if (newTouchedWindowHandle == nullptr && newGestureMonitors.empty()) {

            ALOGI("Dropping event because there is no touchable window or gesture monitor at "
@@ -2341,9 +2317,8 @@ InputEventInjectionResult InputDispatcher::findTouchedWindowTargetsLocked( 
                              touchedWindow.pointerIds, inputTargets);

    }



    for (const TouchedMonitor& touchedMonitor : tempTouchState.gestureMonitors) {

        addMonitoringTargetLocked(touchedMonitor.monitor, touchedMonitor.xOffset,

                                  touchedMonitor.yOffset, displayId, inputTargets);

    for (const auto& monitor : tempTouchState.gestureMonitors) {

        addMonitoringTargetLocked(monitor, displayId, inputTargets);

    }



    // Drop the outside or hover touch windows since we will not care about them
@@ -2538,26 +2513,24 @@ void InputDispatcher::addWindowTargetLocked(const sp<WindowInfoHandle>& windowHa 
}



void InputDispatcher::addGlobalMonitoringTargetsLocked(std::vector<InputTarget>& inputTargets,

                                                       int32_t displayId, float xOffset,

                                                       float yOffset) {

                                                       int32_t displayId) {

    std::unordered_map<int32_t, std::vector<Monitor>>::const_iterator it =

            mGlobalMonitorsByDisplay.find(displayId);



    if (it != mGlobalMonitorsByDisplay.end()) {

        const std::vector<Monitor>& monitors = it->second;

        for (const Monitor& monitor : monitors) {

            addMonitoringTargetLocked(monitor, xOffset, yOffset, displayId, inputTargets);

            addMonitoringTargetLocked(monitor, displayId, inputTargets);

        }

    }

}



void InputDispatcher::addMonitoringTargetLocked(const Monitor& monitor, float xOffset,

                                                float yOffset, int32_t displayId,

void InputDispatcher::addMonitoringTargetLocked(const Monitor& monitor, int32_t displayId,

                                                std::vector<InputTarget>& inputTargets) {

    InputTarget target;

    target.inputChannel = monitor.inputChannel;

    target.flags = InputTarget::FLAG_DISPATCH_AS_IS;

    ui::Transform t = ui::Transform(xOffset, yOffset);

    ui::Transform t;

    if (const auto& it = mDisplayInfos.find(displayId); it != mDisplayInfos.end()) {

        // Input monitors always get un-rotated display coordinates. We undo the display

        // rotation that is present in the display transform so that display rotation is not
@@ -5490,9 +5463,9 @@ status_t InputDispatcher::pilferPointers(const sp<IBinder>& token) { 
        TouchState& state = stateIt->second;

        std::shared_ptr<InputChannel> requestingChannel;

        std::optional<int32_t> foundDeviceId;

        for (const TouchedMonitor& touchedMonitor : state.gestureMonitors) {

            if (touchedMonitor.monitor.inputChannel->getConnectionToken() == token) {

                requestingChannel = touchedMonitor.monitor.inputChannel;

        for (const auto& monitor : state.gestureMonitors) {

            if (monitor.inputChannel->getConnectionToken() == token) {

                requestingChannel = monitor.inputChannel;

                foundDeviceId = state.deviceId;

            }

        }

services/inputflinger/dispatcher/InputDispatcher.h

+5 −8
Original line number Diff line number Diff line
@@ -516,19 +516,16 @@ private: 
    android::os::InputEventInjectionResult findTouchedWindowTargetsLocked(

            nsecs_t currentTime, const MotionEntry& entry, std::vector<InputTarget>& inputTargets,

            nsecs_t* nextWakeupTime, bool* outConflictingPointerActions) REQUIRES(mLock);

    std::vector<TouchedMonitor> findTouchedGestureMonitorsLocked(int32_t displayId) const

            REQUIRES(mLock);

    std::vector<TouchedMonitor> selectResponsiveMonitorsLocked(

            const std::vector<TouchedMonitor>& gestureMonitors) const REQUIRES(mLock);

    std::vector<Monitor> selectResponsiveMonitorsLocked(

            const std::vector<Monitor>& gestureMonitors) const REQUIRES(mLock);



    void addWindowTargetLocked(const sp<android::gui::WindowInfoHandle>& windowHandle,

                               int32_t targetFlags, BitSet32 pointerIds,

                               std::vector<InputTarget>& inputTargets) REQUIRES(mLock);

    void addMonitoringTargetLocked(const Monitor& monitor, float xOffset, float yOffset,

                                   int32_t displayId, std::vector<InputTarget>& inputTargets)

    void addMonitoringTargetLocked(const Monitor& monitor, int32_t displayId,

                                   std::vector<InputTarget>& inputTargets) REQUIRES(mLock);

    void addGlobalMonitoringTargetsLocked(std::vector<InputTarget>& inputTargets, int32_t displayId)

            REQUIRES(mLock);

    void addGlobalMonitoringTargetsLocked(std::vector<InputTarget>& inputTargets, int32_t displayId,

                                          float xOffset = 0, float yOffset = 0) REQUIRES(mLock);

    void pokeUserActivityLocked(const EventEntry& eventEntry) REQUIRES(mLock);

    bool checkInjectionPermission(const sp<android::gui::WindowInfoHandle>& windowHandle,

                                  const InjectionState* injectionState);

services/inputflinger/dispatcher/Monitor.cpp

+0 −4
Original line number Diff line number Diff line
@@ -22,8 +22,4 @@ namespace android::inputdispatcher { 
Monitor::Monitor(const std::shared_ptr<InputChannel>& inputChannel, int32_t pid)

      : inputChannel(inputChannel), pid(pid) {}



// --- TouchedMonitor ---

TouchedMonitor::TouchedMonitor(const Monitor& monitor, float xOffset, float yOffset)

      : monitor(monitor), xOffset(xOffset), yOffset(yOffset) {}



} // namespace android::inputdispatcher

services/inputflinger/dispatcher/Monitor.h

+0 −9
Original line number Diff line number Diff line
@@ -29,15 +29,6 @@ struct Monitor { 
    explicit Monitor(const std::shared_ptr<InputChannel>& inputChannel, int32_t pid);

};



// For tracking the offsets we need to apply when adding gesture monitor targets.

struct TouchedMonitor {

    Monitor monitor;

    float xOffset = 0.f;

    float yOffset = 0.f;



    explicit TouchedMonitor(const Monitor& monitor, float xOffset, float yOffset);

};



} // namespace android::inputdispatcher



#endif // _UI_INPUT_INPUTDISPATCHER_MONITOR_H

services/inputflinger/dispatcher/TouchState.cpp

+1 −1
Original line number Diff line number Diff line
@@ -75,7 +75,7 @@ void TouchState::addOrUpdateWindow(const sp<WindowInfoHandle>& windowHandle, int 
    windows.push_back(touchedWindow);

}



void TouchState::addGestureMonitors(const std::vector<TouchedMonitor>& newMonitors) {

void TouchState::addGestureMonitors(const std::vector<Monitor>& newMonitors) {

    const size_t newSize = gestureMonitors.size() + newMonitors.size();

    gestureMonitors.reserve(newSize);

    gestureMonitors.insert(std::end(gestureMonitors), std::begin(newMonitors),