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

Commit f6849803 authored by Arpit Singh's avatar Arpit Singh
Browse files

[16/n Dispatcher refactor] Move transferWallpaperTouch 

In this CL we move transferWallpaperTouch to DispatcherTouchState
subclass.

Bug: 367661487
Bug: 245989146
Test: atest inputflinger_tests
Flag: EXEMPT refactor

Change-Id: I41ec66dcc56e4da395ab2b9dd7786e00fda5037d
parent bbd72f67

services/inputflinger/dispatcher/InputDispatcher.cpp

+45 −16
Original line number Diff line number Diff line
@@ -5907,8 +5907,24 @@ bool InputDispatcher::transferTouchGesture(const sp<IBinder>& fromToken, const s 
            synthesizeCancelationEventsForWindowLocked(fromWindowHandle, options, fromConnection);



            // Check if the wallpaper window should deliver the corresponding event.

            transferWallpaperTouch(oldTargetFlags, newTargetFlags, fromWindowHandle, toWindowHandle,

                                   *state, deviceId, pointers, traceContext.getTracker());

            const auto [cancellations, pointerDowns] =

                    mTouchStates.transferWallpaperTouch(fromWindowHandle, toWindowHandle, displayId,

                                                        deviceId, pointers, oldTargetFlags,

                                                        newTargetFlags, mWindowInfos,

                                                        mConnectionManager);

            for (const auto& cancellationArgs : cancellations) {

                // touch should be cancelled for old wallpaper window

                LOG_ALWAYS_FATAL_IF(cancellationArgs.mode !=

                                    CancelationOptions::Mode::CANCEL_POINTER_EVENTS);

                synthesizeCancelationEventsForWindowLocked(cancellationArgs.windowHandle, options);

            }

            for (const auto& pointerDownArgs : pointerDowns) {

                // expect pointer down on new the wallpaper window

                synthesizePointerDownEventsForConnectionLocked(pointerDownArgs.downTimeInTarget,

                                                               pointerDownArgs.connection,

                                                               pointerDownArgs.targetFlags,

                                                               traceContext.getTracker());

            }



            // Because new window may have a wallpaper window, it will merge input state from it

            // parent window, after this the firstNewPointerIdx in input state will be reset, then
@@ -7156,12 +7172,17 @@ void InputDispatcher::DispatcherTouchState::slipWallpaperTouch( 
    }

}



void InputDispatcher::transferWallpaperTouch(

std::pair<std::list<InputDispatcher::DispatcherTouchState::CancellationArgs>,

          std::list<InputDispatcher::DispatcherTouchState::PointerDownArgs>>

InputDispatcher::DispatcherTouchState::transferWallpaperTouch(

        const sp<gui::WindowInfoHandle> fromWindowHandle,

        const sp<gui::WindowInfoHandle> toWindowHandle, ui::LogicalDisplayId displayId,

        android::DeviceId deviceId, const std::vector<PointerProperties>& pointers,

        ftl::Flags<InputTarget::Flags> oldTargetFlags,

        ftl::Flags<InputTarget::Flags> newTargetFlags, const sp<WindowInfoHandle> fromWindowHandle,

        const sp<WindowInfoHandle> toWindowHandle, TouchState& state, DeviceId deviceId,

        const std::vector<PointerProperties>& pointers,

        const std::unique_ptr<trace::EventTrackerInterface>& traceTracker) {

        ftl::Flags<InputTarget::Flags> newTargetFlags, const DispatcherWindowInfo& windowInfos,

        const ConnectionManager& connections) {

    TouchState& state = getTouchState(displayId);



    const bool oldHasWallpaper = oldTargetFlags.test(InputTarget::Flags::FOREGROUND) &&

            fromWindowHandle->getInfo()->inputConfig.test(

                    gui::WindowInfo::InputConfig::DUPLICATE_TOUCH_TO_WALLPAPER);
@@ -7172,16 +7193,17 @@ void InputDispatcher::transferWallpaperTouch( 
    const sp<WindowInfoHandle> oldWallpaper =

            oldHasWallpaper ? state.getWallpaperWindow(deviceId) : nullptr;

    const sp<WindowInfoHandle> newWallpaper =

            newHasWallpaper ? mWindowInfos.findWallpaperWindowBelow(toWindowHandle) : nullptr;

            newHasWallpaper ? windowInfos.findWallpaperWindowBelow(toWindowHandle) : nullptr;

    if (oldWallpaper == newWallpaper) {

        return;

        return {};

    }



    std::list<CancellationArgs> cancellations;

    std::list<PointerDownArgs> pointerDowns;

    if (oldWallpaper != nullptr) {

        CancelationOptions options(CancelationOptions::Mode::CANCEL_POINTER_EVENTS,

                                   "transferring touch focus to another window", traceTracker);

        state.removeWindowByToken(oldWallpaper->getToken());

        synthesizeCancelationEventsForWindowLocked(oldWallpaper, options);

        cancellations.emplace_back(oldWallpaper, CancelationOptions::Mode::CANCEL_POINTER_EVENTS,

                                   /*deviceId*/ std::nullopt);

    }



    if (newWallpaper != nullptr) {
@@ -7193,15 +7215,16 @@ void InputDispatcher::transferWallpaperTouch( 
        state.addOrUpdateWindow(newWallpaper, InputTarget::DispatchMode::AS_IS, wallpaperFlags,

                                deviceId, pointers, downTimeInTarget);

        std::shared_ptr<Connection> wallpaperConnection =

                mConnectionManager.getConnection(newWallpaper->getToken());

                connections.getConnection(newWallpaper->getToken());

        if (wallpaperConnection != nullptr) {

            std::shared_ptr<Connection> toConnection =

                    mConnectionManager.getConnection(toWindowHandle->getToken());

                    connections.getConnection(toWindowHandle->getToken());

            toConnection->inputState.mergePointerStateTo(wallpaperConnection->inputState);

            synthesizePointerDownEventsForConnectionLocked(downTimeInTarget, wallpaperConnection,

                                                           wallpaperFlags, traceTracker);

            pointerDowns.emplace_back(downTimeInTarget, wallpaperConnection, wallpaperFlags);

        }

        pointerDowns.emplace_back(downTimeInTarget, wallpaperConnection, wallpaperFlags);

    }

    return {cancellations, pointerDowns};

}



sp<WindowInfoHandle> InputDispatcher::DispatcherWindowInfo::findWallpaperWindowBelow(
@@ -7455,4 +7478,10 @@ void InputDispatcher::DispatcherTouchState::clear() { 
    mTouchStatesByDisplay.clear();

}



TouchState& InputDispatcher::DispatcherTouchState::getTouchState(ui::LogicalDisplayId displayId) {

    auto touchStateIt = mTouchStatesByDisplay.find(displayId);

    LOG_ALWAYS_FATAL_IF(touchStateIt == mTouchStatesByDisplay.end());

    return touchStateIt->second;

}



} // namespace android::inputdispatcher

services/inputflinger/dispatcher/InputDispatcher.h

+17 −10
Original line number Diff line number Diff line
@@ -358,6 +358,12 @@ private: 
            std::optional<DeviceId> deviceId;

        };



        struct PointerDownArgs {

            const nsecs_t downTimeInTarget;

            const std::shared_ptr<Connection> connection;

            const ftl::Flags<InputTarget::Flags> targetFlags;

        };



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

                                           InputTarget::DispatchMode dispatchMode,

                                           ftl::Flags<InputTarget::Flags> targetFlags,
@@ -387,17 +393,27 @@ private: 
        std::string dump() const;



        // Updates the touchState for display from WindowInfo,

        // return vector of CancellationArgs for every cancelled touch

        // returns list of CancellationArgs for every cancelled touch

        std::list<CancellationArgs> updateFromWindowInfo(ui::LogicalDisplayId displayId,

                                                         const DispatcherWindowInfo& windowInfos);



        void removeAllPointersForDevice(DeviceId deviceId);



        std::pair<std::list<CancellationArgs>, std::list<PointerDownArgs>> transferWallpaperTouch(

                const sp<gui::WindowInfoHandle> fromWindowHandle,

                const sp<gui::WindowInfoHandle> toWindowHandle, ui::LogicalDisplayId displayId,

                DeviceId deviceId, const std::vector<PointerProperties>& pointers,

                ftl::Flags<InputTarget::Flags> oldTargetFlags,

                ftl::Flags<InputTarget::Flags> newTargetFlags,

                const DispatcherWindowInfo& windowInfos, const ConnectionManager& connections);



        void clear();



        std::unordered_map<ui::LogicalDisplayId, TouchState> mTouchStatesByDisplay;



    private:

        TouchState& getTouchState(ui::LogicalDisplayId displayId);



        static std::list<CancellationArgs> eraseRemovedWindowsFromWindowInfo(

                TouchState& state, ui::LogicalDisplayId displayId,

                const DispatcherWindowInfo& windowInfos);
@@ -849,15 +865,6 @@ private: 


    sp<InputReporterInterface> mReporter;



    void transferWallpaperTouch(ftl::Flags<InputTarget::Flags> oldTargetFlags,

                                ftl::Flags<InputTarget::Flags> newTargetFlags,

                                const sp<android::gui::WindowInfoHandle> fromWindowHandle,

                                const sp<android::gui::WindowInfoHandle> toWindowHandle,

                                TouchState& state, DeviceId deviceId,

                                const std::vector<PointerProperties>& pointers,

                                const std::unique_ptr<trace::EventTrackerInterface>& traceTracker)

            REQUIRES(mLock);



    /** Stores the value of the input flag for per device input latency metrics. */

    const bool mPerDeviceInputLatencyMetricsFlag =

            com::android::input::flags::enable_per_device_input_latency_metrics();