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

Commit 34ce4ca4 authored by android-build-team Robot's avatar android-build-team Robot
Browse files

Merge cherrypicks of [4759681, 4759482] into qt-release 

Change-Id: I1dc27c9c81bd8e06b6a9ff8fa7f0a7f5f7202227
parents 3b9c326f 25e1ba14

services/inputflinger/InputDispatcher.cpp

+65 −106
Original line number Diff line number Diff line
@@ -515,10 +515,9 @@ void InputDispatcher::addRecentEventLocked(EventEntry* entry) { 
sp<InputWindowHandle> InputDispatcher::findTouchedWindowAtLocked(int32_t displayId,

        int32_t x, int32_t y) {

    // Traverse windows from front to back to find touched window.

    const Vector<sp<InputWindowHandle>> windowHandles = getWindowHandlesLocked(displayId);

    size_t numWindows = windowHandles.size();

    size_t numWindows = mWindowHandles.size();

    for (size_t i = 0; i < numWindows; i++) {

        sp<InputWindowHandle> windowHandle = windowHandles.itemAt(i);

        sp<InputWindowHandle> windowHandle = mWindowHandles.itemAt(i);

        const InputWindowInfo* windowInfo = windowHandle->getInfo();

        if (windowInfo->displayId == displayId) {

            int32_t flags = windowInfo->layoutParamsFlags;
@@ -1248,10 +1247,9 @@ int32_t InputDispatcher::findTouchedWindowTargetsLocked(nsecs_t currentTime, 
        bool isTouchModal = false;



        // Traverse windows from front to back to find touched window and outside targets.

        const Vector<sp<InputWindowHandle>> windowHandles = getWindowHandlesLocked(displayId);

        size_t numWindows = windowHandles.size();

        size_t numWindows = mWindowHandles.size();

        for (size_t i = 0; i < numWindows; i++) {

            sp<InputWindowHandle> windowHandle = windowHandles.itemAt(i);

            sp<InputWindowHandle> windowHandle = mWindowHandles.itemAt(i);

            const InputWindowInfo* windowInfo = windowHandle->getInfo();

            if (windowInfo->displayId != displayId) {

                continue; // wrong display
@@ -1474,10 +1472,8 @@ int32_t InputDispatcher::findTouchedWindowTargetsLocked(nsecs_t currentTime, 
        sp<InputWindowHandle> foregroundWindowHandle =

                mTempTouchState.getFirstForegroundWindowHandle();

        if (foregroundWindowHandle->getInfo()->hasWallpaper) {

            const Vector<sp<InputWindowHandle>> windowHandles = getWindowHandlesLocked(displayId);

            size_t numWindows = windowHandles.size();

            for (size_t i = 0; i < numWindows; i++) {

                sp<InputWindowHandle> windowHandle = windowHandles.itemAt(i);

            for (size_t i = 0; i < mWindowHandles.size(); i++) {

                sp<InputWindowHandle> windowHandle = mWindowHandles.itemAt(i);

                const InputWindowInfo* info = windowHandle->getInfo();

                if (info->displayId == displayId

                        && windowHandle->getInfo()->layoutParamsType
@@ -1662,10 +1658,9 @@ bool InputDispatcher::checkInjectionPermission(const sp<InputWindowHandle>& wind 
bool InputDispatcher::isWindowObscuredAtPointLocked(

        const sp<InputWindowHandle>& windowHandle, int32_t x, int32_t y) const {

    int32_t displayId = windowHandle->getInfo()->displayId;

    const Vector<sp<InputWindowHandle>> windowHandles = getWindowHandlesLocked(displayId);

    size_t numWindows = windowHandles.size();

    size_t numWindows = mWindowHandles.size();

    for (size_t i = 0; i < numWindows; i++) {

        sp<InputWindowHandle> otherHandle = windowHandles.itemAt(i);

        sp<InputWindowHandle> otherHandle = mWindowHandles.itemAt(i);

        if (otherHandle == windowHandle) {

            break;

        }
@@ -1683,11 +1678,10 @@ bool InputDispatcher::isWindowObscuredAtPointLocked( 


bool InputDispatcher::isWindowObscuredLocked(const sp<InputWindowHandle>& windowHandle) const {

    int32_t displayId = windowHandle->getInfo()->displayId;

    const Vector<sp<InputWindowHandle>> windowHandles = getWindowHandlesLocked(displayId);

    const InputWindowInfo* windowInfo = windowHandle->getInfo();

    size_t numWindows = windowHandles.size();

    size_t numWindows = mWindowHandles.size();

    for (size_t i = 0; i < numWindows; i++) {

        sp<InputWindowHandle> otherHandle = windowHandles.itemAt(i);

        sp<InputWindowHandle> otherHandle = mWindowHandles.itemAt(i);

        if (otherHandle == windowHandle) {

            break;

        }
@@ -2915,69 +2909,45 @@ void InputDispatcher::decrementPendingForegroundDispatchesLocked(EventEntry* ent 
    }

}



Vector<sp<InputWindowHandle>> InputDispatcher::getWindowHandlesLocked(int32_t displayId) const {

    std::unordered_map<int32_t, Vector<sp<InputWindowHandle>>>::const_iterator it

        = mWindowHandlesByDisplay.find(displayId);

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

        return it->second;

    }



    // Return an empty one if nothing found.

    return Vector<sp<InputWindowHandle>>();

}



sp<InputWindowHandle> InputDispatcher::getWindowHandleLocked(

        const sp<InputChannel>& inputChannel) const {

    for (auto& it : mWindowHandlesByDisplay) {

        const Vector<sp<InputWindowHandle>> windowHandles = it.second;

        size_t numWindows = windowHandles.size();

    size_t numWindows = mWindowHandles.size();

    for (size_t i = 0; i < numWindows; i++) {

            const sp<InputWindowHandle>& windowHandle = windowHandles.itemAt(i);

        const sp<InputWindowHandle>& windowHandle = mWindowHandles.itemAt(i);

        if (windowHandle->getInputChannel() == inputChannel) {

            return windowHandle;

        }

    }

    }

    return nullptr;

}



bool InputDispatcher::hasWindowHandleLocked(

        const sp<InputWindowHandle>& windowHandle, int32_t displayId) const {



    const Vector<sp<InputWindowHandle>> windowHandles = getWindowHandlesLocked(displayId);

    size_t numWindows = windowHandles.size();

        const sp<InputWindowHandle>& windowHandle) const {

    size_t numWindows = mWindowHandles.size();

    for (size_t i = 0; i < numWindows; i++) {

        if (windowHandles.itemAt(i) == windowHandle) {

        if (mWindowHandles.itemAt(i) == windowHandle) {

            return true;

        }

    }

    return false;

}



void InputDispatcher::setInputWindows(const Vector<sp<InputWindowHandle>>& inputWindowHandles,

        int displayId) {

void InputDispatcher::setInputWindows(const Vector<sp<InputWindowHandle> >& inputWindowHandles) {

#if DEBUG_FOCUS

    ALOGD("setInputWindows");

#endif

    { // acquire lock

        AutoMutex _l(mLock);



        const Vector<sp<InputWindowHandle>> oldWindowHandles = getWindowHandlesLocked(displayId);

        Vector<sp<InputWindowHandle>> windowHandles = inputWindowHandles;

        // Insert or replace

        mWindowHandlesByDisplay[displayId] = windowHandles;

        Vector<sp<InputWindowHandle> > oldWindowHandles = mWindowHandles;

        mWindowHandles = inputWindowHandles;



        // TODO(b/111361570): multi-display focus, one focus in all display in current.

        sp<InputWindowHandle> newFocusedWindowHandle = mFocusedWindowHandle;

        sp<InputWindowHandle> newFocusedWindowHandle;

        bool foundHoveredWindow = false;



        if (windowHandles.isEmpty()) {

            // Remove all handles on a display if there are no windows left.

            mWindowHandlesByDisplay.erase(displayId);

        } else {

            for (size_t i = 0; i < windowHandles.size(); i++) {

                const sp<InputWindowHandle>& windowHandle = windowHandles.itemAt(i);

        for (size_t i = 0; i < mWindowHandles.size(); i++) {

            const sp<InputWindowHandle>& windowHandle = mWindowHandles.itemAt(i);

            if (!windowHandle->updateInfo() || windowHandle->getInputChannel() == nullptr) {

                mWindowHandles.removeAt(i--);

                continue;

            }

            if (windowHandle->getInfo()->hasFocus) {
@@ -2987,13 +2957,11 @@ void InputDispatcher::setInputWindows(const Vector<sp<InputWindowHandle>>& input 
                foundHoveredWindow = true;

            }

        }

        }



        if (!foundHoveredWindow) {

            mLastHoverWindowHandle = nullptr;

        }



        // TODO(b/111361570): multi-display focus, one focus in all display in current.

        if (mFocusedWindowHandle != newFocusedWindowHandle) {

            if (mFocusedWindowHandle != nullptr) {

#if DEBUG_FOCUS
@@ -3017,12 +2985,11 @@ void InputDispatcher::setInputWindows(const Vector<sp<InputWindowHandle>>& input 
            mFocusedWindowHandle = newFocusedWindowHandle;

        }



        ssize_t stateIndex = mTouchStatesByDisplay.indexOfKey(displayId);

        if (stateIndex >= 0) {

            TouchState& state = mTouchStatesByDisplay.editValueAt(stateIndex);

        for (size_t d = 0; d < mTouchStatesByDisplay.size(); d++) {

            TouchState& state = mTouchStatesByDisplay.editValueAt(d);

            for (size_t i = 0; i < state.windows.size(); ) {

                TouchedWindow& touchedWindow = state.windows.editItemAt(i);

                if (!hasWindowHandleLocked(touchedWindow.windowHandle, displayId)) {

                if (!hasWindowHandleLocked(touchedWindow.windowHandle)) {

#if DEBUG_FOCUS

                    ALOGD("Touched window was removed: %s",

                            touchedWindow.windowHandle->getName().c_str());
@@ -3048,7 +3015,7 @@ void InputDispatcher::setInputWindows(const Vector<sp<InputWindowHandle>>& input 
        // which might not happen until the next GC.

        for (size_t i = 0; i < oldWindowHandles.size(); i++) {

            const sp<InputWindowHandle>& oldWindowHandle = oldWindowHandles.itemAt(i);

            if (!hasWindowHandleLocked(oldWindowHandle, displayId)) {

            if (!hasWindowHandleLocked(oldWindowHandle)) {

#if DEBUG_FOCUS

                ALOGD("Window went away: %s", oldWindowHandle->getName().c_str());

#endif
@@ -3299,14 +3266,10 @@ void InputDispatcher::dumpDispatchStateLocked(std::string& dump) { 
        dump += INDENT "TouchStates: <no displays touched>\n";

    }



    if (!mWindowHandlesByDisplay.empty()) {

       for (auto& it : mWindowHandlesByDisplay) {

            const Vector<sp<InputWindowHandle>> windowHandles = it.second;

            dump += StringPrintf(INDENT "Display: %d\n", it.first);

            if (!windowHandles.isEmpty()) {

    if (!mWindowHandles.isEmpty()) {

        dump += INDENT "Windows:\n";

                for (size_t i = 0; i < windowHandles.size(); i++) {

                    const sp<InputWindowHandle>& windowHandle = windowHandles.itemAt(i);

        for (size_t i = 0; i < mWindowHandles.size(); i++) {

            const sp<InputWindowHandle>& windowHandle = mWindowHandles.itemAt(i);

            const InputWindowInfo* windowInfo = windowHandle->getInfo();



            dump += StringPrintf(INDENT2 "%zu: name='%s', displayId=%d, "
@@ -3334,10 +3297,6 @@ void InputDispatcher::dumpDispatchStateLocked(std::string& dump) { 
    } else {

        dump += INDENT "Windows: <none>\n";

    }

        }

    } else {

        dump += INDENT "Displays: <none>\n";

    }



    if (!mMonitoringChannels.isEmpty()) {

        dump += INDENT "MonitoringChannels:\n";

services/inputflinger/InputDispatcher.h

+5 −9
Original line number Diff line number Diff line
@@ -31,7 +31,6 @@ 
#include <stddef.h>

#include <unistd.h>

#include <limits.h>

#include <unordered_map>



#include "InputWindow.h"

#include "InputApplication.h"
@@ -308,8 +307,7 @@ public: 
     *

     * This method may be called on any thread (usually by the input manager).

     */

    virtual void setInputWindows(const Vector<sp<InputWindowHandle> >& inputWindowHandles,

            int displayId) = 0;

    virtual void setInputWindows(const Vector<sp<InputWindowHandle> >& inputWindowHandles) = 0;



    /* Sets the focused application.

     *
@@ -389,8 +387,7 @@ public: 
            int32_t injectorPid, int32_t injectorUid, int32_t syncMode, int32_t timeoutMillis,

            uint32_t policyFlags);



    virtual void setInputWindows(const Vector<sp<InputWindowHandle> >& inputWindowHandles,

            int displayId);

    virtual void setInputWindows(const Vector<sp<InputWindowHandle> >& inputWindowHandles);

    virtual void setFocusedApplication(const sp<InputApplicationHandle>& inputApplicationHandle);

    virtual void setInputDispatchMode(bool enabled, bool frozen);

    virtual void setInputFilterEnabled(bool enabled);
@@ -959,11 +956,10 @@ private: 
    bool mDispatchFrozen;

    bool mInputFilterEnabled;



    std::unordered_map<int32_t, Vector<sp<InputWindowHandle>>> mWindowHandlesByDisplay;

    // Get window handles by display, return an empty vector if not found.

    Vector<sp<InputWindowHandle>> getWindowHandlesLocked(int32_t displayId) const;

    Vector<sp<InputWindowHandle> > mWindowHandles;



    sp<InputWindowHandle> getWindowHandleLocked(const sp<InputChannel>& inputChannel) const;

    bool hasWindowHandleLocked(const sp<InputWindowHandle>& windowHandle, int32_t displayId) const;

    bool hasWindowHandleLocked(const sp<InputWindowHandle>& windowHandle) const;



    // Focus tracking for keys, trackball, etc.

    sp<InputWindowHandle> mFocusedWindowHandle;