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

Commit 455f288a authored by Michael Wright's avatar Michael Wright Committed by android-build-merger
Browse files

Merge "Add new MotionEvent flag for partially obscured windows." into mnc-dev... 

Merge "Add new MotionEvent flag for partially obscured windows." into mnc-dev am: 58dc18a4 am: ab4b3c3b am: 23526744
am: c8462781

* commit 'c8462781':
  Add new MotionEvent flag for partially obscured windows.

Change-Id: Ia0940c0440b94922fde7a93ef5d95df59aed3c3e
parents b2ec4ab3 c8462781

include/input/Input.h

+13 −0
Original line number Diff line number Diff line
@@ -45,6 +45,19 @@ enum { 
};



enum {



    /**

     * This flag indicates that the window that received this motion event is partly

     * or wholly obscured by another visible window above it.  This flag is set to true

     * even if the event did not directly pass through the obscured area.

     * A security sensitive application can check this flag to identify situations in which

     * a malicious application may have covered up part of its content for the purpose

     * of misleading the user or hijacking touches.  An appropriate response might be

     * to drop the suspect touches or to take additional precautions to confirm the user's

     * actual intent.

     */

    AMOTION_EVENT_FLAG_WINDOW_IS_PARTIALLY_OBSCURED = 0x2,



    /* Motion event is inconsistent with previously sent motion events. */

    AMOTION_EVENT_FLAG_TAINTED = 0x80000000,

};

services/inputflinger/InputDispatcher.cpp

+29 −0
Original line number Diff line number Diff line
@@ -1227,6 +1227,8 @@ int32_t InputDispatcher::findTouchedWindowTargetsLocked(nsecs_t currentTime, 
                    int32_t outsideTargetFlags = InputTarget::FLAG_DISPATCH_AS_OUTSIDE;

                    if (isWindowObscuredAtPointLocked(windowHandle, x, y)) {

                        outsideTargetFlags |= InputTarget::FLAG_WINDOW_IS_OBSCURED;

                    } else if (isWindowObscuredLocked(windowHandle)) {

                        outsideTargetFlags |= InputTarget::FLAG_WINDOW_IS_PARTIALLY_OBSCURED;

                    }



                    mTempTouchState.addOrUpdateWindow(
@@ -1264,6 +1266,8 @@ int32_t InputDispatcher::findTouchedWindowTargetsLocked(nsecs_t currentTime, 
        }

        if (isWindowObscuredAtPointLocked(newTouchedWindowHandle, x, y)) {

            targetFlags |= InputTarget::FLAG_WINDOW_IS_OBSCURED;

        } else if (isWindowObscuredLocked(newTouchedWindowHandle)) {

            targetFlags |= InputTarget::FLAG_WINDOW_IS_PARTIALLY_OBSCURED;

        }



        // Update hover state.
@@ -1439,6 +1443,7 @@ int32_t InputDispatcher::findTouchedWindowTargetsLocked(nsecs_t currentTime, 
                                == InputWindowInfo::TYPE_WALLPAPER) {

                    mTempTouchState.addOrUpdateWindow(windowHandle,

                            InputTarget::FLAG_WINDOW_IS_OBSCURED

                                    | InputTarget::FLAG_WINDOW_IS_PARTIALLY_OBSCURED

                                    | InputTarget::FLAG_DISPATCH_AS_IS,

                            BitSet32(0));

                }
@@ -1633,6 +1638,27 @@ bool InputDispatcher::isWindowObscuredAtPointLocked( 
    return false;

}





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

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

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

    size_t numWindows = mWindowHandles.size();

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

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

        if (otherHandle == windowHandle) {

            break;

        }



        const InputWindowInfo* otherInfo = otherHandle->getInfo();

        if (otherInfo->displayId == displayId

                && otherInfo->visible && !otherInfo->isTrustedOverlay()

                && otherInfo->overlaps(windowInfo)) {

            return true;

        }

    }

    return false;

}



String8 InputDispatcher::checkWindowReadyForMoreInputLocked(nsecs_t currentTime,

        const sp<InputWindowHandle>& windowHandle, const EventEntry* eventEntry,

        const char* targetType) {
@@ -1907,6 +1933,9 @@ void InputDispatcher::enqueueDispatchEntryLocked( 
        if (dispatchEntry->targetFlags & InputTarget::FLAG_WINDOW_IS_OBSCURED) {

            dispatchEntry->resolvedFlags |= AMOTION_EVENT_FLAG_WINDOW_IS_OBSCURED;

        }

        if (dispatchEntry->targetFlags & InputTarget::FLAG_WINDOW_IS_PARTIALLY_OBSCURED) {

            dispatchEntry->resolvedFlags |= AMOTION_EVENT_FLAG_WINDOW_IS_PARTIALLY_OBSCURED;

        }



        if (!connection->inputState.trackMotion(motionEntry,

                dispatchEntry->resolvedAction, dispatchEntry->resolvedFlags)) {

services/inputflinger/InputDispatcher.h

+8 −1
Original line number Diff line number Diff line
@@ -89,7 +89,7 @@ struct InputTarget { 
        /* This flag indicates that the event is being delivered to a foreground application. */

        FLAG_FOREGROUND = 1 << 0,



        /* This flag indicates that the target of a MotionEvent is partly or wholly

        /* This flag indicates that the MotionEvent falls within the area of the target

         * obscured by another visible window above it.  The motion event should be

         * delivered with flag AMOTION_EVENT_FLAG_WINDOW_IS_OBSCURED. */

        FLAG_WINDOW_IS_OBSCURED = 1 << 1,
@@ -139,6 +139,12 @@ struct InputTarget { 
                | FLAG_DISPATCH_AS_HOVER_EXIT

                | FLAG_DISPATCH_AS_SLIPPERY_EXIT

                | FLAG_DISPATCH_AS_SLIPPERY_ENTER,



        /* This flag indicates that the target of a MotionEvent is partly or wholly

         * obscured by another visible window above it.  The motion event should be

         * delivered with flag AMOTION_EVENT_FLAG_WINDOW_IS_PARTIALLY_OBSCURED. */

        FLAG_WINDOW_IS_PARTIALLY_OBSCURED = 1 << 14,



    };



    // The input channel to be targeted.
@@ -1048,6 +1054,7 @@ private: 
            const InjectionState* injectionState);

    bool isWindowObscuredAtPointLocked(const sp<InputWindowHandle>& windowHandle,

            int32_t x, int32_t y) const;

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

    String8 getApplicationWindowLabelLocked(const sp<InputApplicationHandle>& applicationHandle,

            const sp<InputWindowHandle>& windowHandle);

services/inputflinger/InputWindow.cpp

+9 −2
Original line number Diff line number Diff line
@@ -36,14 +36,16 @@ bool InputWindowInfo::touchableRegionContainsPoint(int32_t x, int32_t y) const { 
}



bool InputWindowInfo::frameContainsPoint(int32_t x, int32_t y) const {

    return x >= frameLeft && x <= frameRight

            && y >= frameTop && y <= frameBottom;

    return x >= frameLeft && x < frameRight

            && y >= frameTop && y < frameBottom;

}



bool InputWindowInfo::isTrustedOverlay() const {

    return layoutParamsType == TYPE_INPUT_METHOD

            || layoutParamsType == TYPE_INPUT_METHOD_DIALOG

            || layoutParamsType == TYPE_MAGNIFICATION_OVERLAY

            || layoutParamsType == TYPE_STATUS_BAR

            || layoutParamsType == TYPE_NAVIGATION_BAR

            || layoutParamsType == TYPE_SECURE_SYSTEM_OVERLAY;

}
@@ -51,6 +53,11 @@ bool InputWindowInfo::supportsSplitTouch() const { 
    return layoutParamsFlags & FLAG_SPLIT_TOUCH;

}



bool InputWindowInfo::overlaps(const InputWindowInfo* other) const {

    return frameLeft < other->frameRight && frameRight > other->frameLeft

            && frameTop < other->frameBottom && frameBottom > other->frameTop;

}





// --- InputWindowHandle ---

services/inputflinger/InputWindow.h

+2 −0
Original line number Diff line number Diff line
@@ -146,6 +146,8 @@ struct InputWindowInfo { 
    bool isTrustedOverlay() const;



    bool supportsSplitTouch() const;



    bool overlaps(const InputWindowInfo* other) const;

};