/*
 * Copyright (C) 2019 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License
 */

package android.server.wm;

import static android.server.wm.ActivityManagerTestBase.launchHomeActivityNoWait;
import static android.server.wm.BarTestUtils.assumeHasStatusBar;
import static android.server.wm.UiDeviceUtils.pressUnlockButton;
import static android.server.wm.UiDeviceUtils.pressWakeupButton;
import static android.server.wm.WindowUntrustedTouchTest.MIN_POSITIVE_OPACITY;
import static android.server.wm.app.Components.OverlayTestService.EXTRA_LAYOUT_PARAMS;
import static android.view.WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN;
import static android.view.WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE;
import static android.view.WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE;
import static android.view.WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL;
import static android.view.WindowManager.LayoutParams.FLAG_WATCH_OUTSIDE_TOUCH;

import static androidx.test.platform.app.InstrumentationRegistry.getInstrumentation;

import static junit.framework.Assert.assertFalse;
import static junit.framework.Assert.assertTrue;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;

import android.app.Activity;
import android.app.Instrumentation;
import android.content.ContentResolver;
import android.content.Intent;
import android.graphics.Color;
import android.graphics.Point;
import android.graphics.Rect;
import android.hardware.input.InputManager;
import android.os.Bundle;
import android.os.SystemClock;
import android.platform.test.annotations.Presubmit;
import android.provider.Settings;
import android.server.wm.WindowManagerState.WindowState;
import android.server.wm.app.Components;
import android.server.wm.settings.SettingsSession;
import android.util.ArraySet;
import android.util.Log;
import android.view.Gravity;
import android.view.InputDevice;
import android.view.MotionEvent;
import android.view.View;
import android.view.WindowInsets;
import android.view.WindowManager;
import android.view.WindowMetrics;

import androidx.test.filters.FlakyTest;
import androidx.test.rule.ActivityTestRule;

import com.android.compatibility.common.util.CtsTouchUtils;
import com.android.compatibility.common.util.SystemUtil;

import org.junit.Before;
import org.junit.Test;

import java.util.ArrayList;
import java.util.Random;
import java.util.Set;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;

/**
 * Ensure moving windows and tapping is done synchronously.
 *
 * Build/Install/Run:
 *     atest CtsWindowManagerDeviceTestCases:WindowInputTests
 */
@Presubmit
public class WindowInputTests {
    private static final String TAG = "WindowInputTests";
    private final int TOTAL_NUMBER_OF_CLICKS = 100;
    private final ActivityTestRule<TestActivity> mActivityRule =
            new ActivityTestRule<>(TestActivity.class);
    private static final int TAPPING_TARGET_WINDOW_SIZE = 100;
    private static final int PARTIAL_OBSCURING_WINDOW_SIZE = 30;

    private Instrumentation mInstrumentation;
    private final WindowManagerStateHelper mWmState = new WindowManagerStateHelper();
    private TestActivity mActivity;
    private InputManager mInputManager;
    private View mView;
    private final Random mRandom = new Random(1);

    private int mClickCount = 0;
    private final long EVENT_FLAGS_WAIT_TIME = 2;

    @Before
    public void setUp() {
        pressWakeupButton();
        pressUnlockButton();
        launchHomeActivityNoWait();

        mInstrumentation = getInstrumentation();
        mActivity = mActivityRule.launchActivity(null);
        mInputManager = mActivity.getSystemService(InputManager.class);
        mInstrumentation.waitForIdleSync();
        mClickCount = 0;
    }

    @Test
    @FlakyTest(bugId = 188207199)
    public void testMoveWindowAndTap() throws Throwable {
        final WindowManager wm = mActivity.getWindowManager();
        final WindowManager.LayoutParams p = new WindowManager.LayoutParams();
        p.setFitInsetsTypes(WindowInsets.Type.systemBars()
                | WindowInsets.Type.systemGestures());
        p.flags = WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL
                | WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE;
        p.width = p.height = 20;
        p.gravity = Gravity.LEFT | Gravity.TOP;

        // Set up window.
        mActivityRule.runOnUiThread(() -> {
            mView = new View(mActivity);
            mView.setBackgroundColor(Color.RED);
            mView.setOnClickListener((v) -> {
                mClickCount++;
            });
            mActivity.addWindow(mView, p);
        });
        mInstrumentation.waitForIdleSync();

        final WindowMetrics windowMetrics = wm.getCurrentWindowMetrics();
        final WindowInsets windowInsets = windowMetrics.getWindowInsets();
        final Rect windowBounds = new Rect(windowMetrics.getBounds());
        windowBounds.inset(windowInsets.getInsetsIgnoringVisibility(p.getFitInsetsTypes()));

        // Move the window to a random location in the window and attempt to tap on view multiple
        // times.
        final Point locationInWindow = new Point();
        for (int i = 0; i < TOTAL_NUMBER_OF_CLICKS; i++) {
            selectRandomLocationInWindow(windowBounds, locationInWindow);
            mActivityRule.runOnUiThread(() -> {
                p.x = locationInWindow.x;
                p.y = locationInWindow.y;
                wm.updateViewLayout(mView, p);
            });
            mInstrumentation.waitForIdleSync();
            int previousCount = mClickCount;

            CtsTouchUtils.emulateTapOnViewCenter(mInstrumentation, mActivityRule, mView);

            mInstrumentation.waitForIdleSync();
            if (mClickCount != previousCount + 1) {
                final int vW = mView.getWidth();
                final int vH = mView.getHeight();
                final int[] viewOnScreenXY = new int[2];
                mView.getLocationOnScreen(viewOnScreenXY);
                final Point tapPosition =
                        new Point(viewOnScreenXY[0] + vW / 2, viewOnScreenXY[1] + vH / 2);
                final Rect realBounds = new Rect(viewOnScreenXY[0], viewOnScreenXY[1],
                        viewOnScreenXY[0] + vW, viewOnScreenXY[1] + vH);
                final Rect requestedBounds = new Rect(p.x, p.y, p.x + p.width, p.y + p.height);
                dumpWindows("Dumping windows due to failure");
                fail("Tap #" + i + " on " + tapPosition + " failed; realBounds=" + realBounds
                        + " requestedBounds=" + requestedBounds);
            }
        }

        assertEquals(TOTAL_NUMBER_OF_CLICKS, mClickCount);
    }

    private void dumpWindows(String message) {
        Log.d(TAG, message);
        mWmState.computeState();
        for (WindowState window : mWmState.getWindows()) {
            Log.d(TAG, "    => " + window.toLongString());
        }
    }

    private void selectRandomLocationInWindow(Rect bounds, Point outLocation) {
        int randomX = mRandom.nextInt(bounds.right - bounds.left) + bounds.left;
        int randomY = mRandom.nextInt(bounds.bottom - bounds.top) + bounds.top;
        outLocation.set(randomX, randomY);
    }

    @Test
    public void testTouchModalWindow() throws Throwable {
        final WindowManager.LayoutParams p = new WindowManager.LayoutParams();

        // Set up 2 touch modal windows, expect the last one will receive all touch events.
        mActivityRule.runOnUiThread(() -> {
            mView = new View(mActivity);
            p.width = 20;
            p.height = 20;
            p.gravity = Gravity.LEFT | Gravity.CENTER_VERTICAL;
            mView.setFilterTouchesWhenObscured(true);
            mView.setOnClickListener((v) -> {
                mClickCount++;
            });
            mActivity.addWindow(mView, p);

            View view2 = new View(mActivity);
            p.gravity = Gravity.RIGHT | Gravity.CENTER_VERTICAL;
            p.type = WindowManager.LayoutParams.TYPE_APPLICATION;
            mActivity.addWindow(view2, p);
        });
        mInstrumentation.waitForIdleSync();

        CtsTouchUtils.emulateTapOnViewCenter(mInstrumentation, mActivityRule, mView);
        assertEquals(0, mClickCount);
    }

    // If a window is obscured by another window from the same app, touches should still get
    // delivered to the bottom window, and the FLAG_WINDOW_IS_OBSCURED should not be set.
    @Test
    public void testFilterTouchesWhenObscuredByWindowFromSameUid() throws Throwable {
        final WindowManager.LayoutParams p = new WindowManager.LayoutParams();

        final AtomicBoolean touchReceived = new AtomicBoolean(false);
        final CompletableFuture<Integer> eventFlags = new CompletableFuture<>();
        // Set up a touchable window.
        mActivityRule.runOnUiThread(() -> {
            mView = new View(mActivity);
            p.flags = FLAG_NOT_TOUCH_MODAL | FLAG_LAYOUT_IN_SCREEN;
            p.width = 100;
            p.height = 100;
            p.gravity = Gravity.CENTER;
            mView.setFilterTouchesWhenObscured(true);
            mView.setOnClickListener((v) -> {
                mClickCount++;
            });
            mView.setOnTouchListener((v, ev) -> {
                touchReceived.set(true);
                eventFlags.complete(ev.getFlags());
                return false;
            });
            mActivity.addWindow(mView, p);

            // Set up an overlap window, use same process.
            View overlay = new View(mActivity);
            p.flags = FLAG_NOT_TOUCH_MODAL | FLAG_LAYOUT_IN_SCREEN | FLAG_NOT_TOUCHABLE;
            p.width = 100;
            p.height = 100;
            p.gravity = Gravity.CENTER;
            p.type = WindowManager.LayoutParams.TYPE_APPLICATION;
            mActivity.addWindow(overlay, p);
        });
        mInstrumentation.waitForIdleSync();
        CtsTouchUtils.emulateTapOnViewCenter(mInstrumentation, mActivityRule, mView);

        assertTrue(touchReceived.get());
        assertEquals(0, eventFlags.get(EVENT_FLAGS_WAIT_TIME, TimeUnit.SECONDS)
                & MotionEvent.FLAG_WINDOW_IS_OBSCURED);
        assertEquals(1, mClickCount);
    }

    @Test
    public void testFilterTouchesWhenObscuredByWindowFromDifferentUid() throws Throwable {
        final WindowManager.LayoutParams p = new WindowManager.LayoutParams();

        final Intent intent = new Intent();
        intent.setComponent(Components.OVERLAY_TEST_SERVICE);
        final String windowName = "Test Overlay";
        final AtomicBoolean touchReceived = new AtomicBoolean(false);
        final int[] viewOnScreenLocation = new int[2];
        try {
            // Set up a touchable window.
            mActivityRule.runOnUiThread(() -> {
                mView = new View(mActivity);
                p.flags = FLAG_NOT_TOUCH_MODAL | FLAG_LAYOUT_IN_SCREEN;
                p.width = TAPPING_TARGET_WINDOW_SIZE;
                p.height = TAPPING_TARGET_WINDOW_SIZE;
                p.gravity = Gravity.CENTER;
                mView.setFilterTouchesWhenObscured(true);
                mView.setOnClickListener((v) -> {
                    mClickCount++;
                });
                mView.setOnTouchListener((v, ev) -> {
                    touchReceived.set(true);
                    return false;
                });
                mActivity.addWindow(mView, p);
            });
            mInstrumentation.waitForIdleSync();
            mActivityRule.runOnUiThread(() -> {
                mView.getLocationOnScreen(viewOnScreenLocation);
                // Set up an overlap window from service, use different process.
                WindowManager.LayoutParams params = getObscuringViewLayoutParams(windowName);
                params.flags |= FLAG_NOT_TOUCHABLE;
                placeWindowAtLayoutCenter(params, TAPPING_TARGET_WINDOW_SIZE,
                        viewOnScreenLocation[0], viewOnScreenLocation[1],
                        TAPPING_TARGET_WINDOW_SIZE);
                // Any opacity higher than this would make InputDispatcher block the touch
                params.alpha = mInputManager.getMaximumObscuringOpacityForTouch();
                intent.putExtra(EXTRA_LAYOUT_PARAMS, params);
                mActivity.startForegroundService(intent);
            });
            mInstrumentation.waitForIdleSync();
            waitForWindow(windowName);
            CtsTouchUtils.emulateTapOnViewCenter(mInstrumentation, mActivityRule, mView);

            // Touch not received due to setFilterTouchesWhenObscured(true)
            assertFalse(touchReceived.get());
            assertEquals(0, mClickCount);
        } finally {
            mActivity.stopService(intent);
        }
    }

    @Test
    public void testFlagTouchesWhenObscuredByWindowFromDifferentUid() throws Throwable {
        final WindowManager.LayoutParams p = new WindowManager.LayoutParams();

        final Intent intent = new Intent();
        intent.setComponent(Components.OVERLAY_TEST_SERVICE);
        final String windowName = "Test Overlay";
        final AtomicBoolean touchReceived = new AtomicBoolean(false);
        final CompletableFuture<Integer> eventFlags = new CompletableFuture<>();
        final int[] viewOnScreenLocation = new int[2];
        try {
            // Set up a touchable window.
            mActivityRule.runOnUiThread(() -> {
                mView = new View(mActivity);
                p.flags = FLAG_NOT_TOUCH_MODAL | FLAG_LAYOUT_IN_SCREEN;
                p.width = TAPPING_TARGET_WINDOW_SIZE;
                p.height = TAPPING_TARGET_WINDOW_SIZE;
                p.gravity = Gravity.CENTER;
                mView.setOnClickListener((v) -> {
                    mClickCount++;
                });
                mView.setOnTouchListener((v, ev) -> {
                    touchReceived.set(true);
                    eventFlags.complete(ev.getFlags());
                    return false;
                });
                mActivity.addWindow(mView, p);
            });
            mInstrumentation.waitForIdleSync();
            mActivityRule.runOnUiThread(() -> {
                mView.getLocationOnScreen(viewOnScreenLocation);
                // Set up an overlap window from service, use different process.
                WindowManager.LayoutParams params = getObscuringViewLayoutParams(windowName);
                params.flags |= FLAG_NOT_TOUCHABLE;
                // Any opacity higher than this would make InputDispatcher block the touch
                params.alpha = mInputManager.getMaximumObscuringOpacityForTouch();
                placeWindowAtLayoutCenter(params, TAPPING_TARGET_WINDOW_SIZE,
                        viewOnScreenLocation[0], viewOnScreenLocation[1],
                        TAPPING_TARGET_WINDOW_SIZE);
                intent.putExtra(EXTRA_LAYOUT_PARAMS, params);
                mActivity.startForegroundService(intent);
            });
            waitForWindow(windowName);
            CtsTouchUtils.emulateTapOnViewCenter(mInstrumentation, mActivityRule, mView);

            assertTrue(touchReceived.get());
            assertEquals(MotionEvent.FLAG_WINDOW_IS_OBSCURED,
                    eventFlags.get(EVENT_FLAGS_WAIT_TIME, TimeUnit.SECONDS)
                            & MotionEvent.FLAG_WINDOW_IS_OBSCURED);
            assertEquals(1, mClickCount);
        } finally {
            mActivity.stopService(intent);
        }
    }

    @Test
    public void testDoNotFlagTouchesWhenObscuredByZeroOpacityWindow() throws Throwable {
        final WindowManager.LayoutParams p = new WindowManager.LayoutParams();

        final Intent intent = new Intent();
        intent.setComponent(Components.OVERLAY_TEST_SERVICE);
        final String windowName = "Test Overlay";
        final AtomicBoolean touchReceived = new AtomicBoolean(false);
        final CompletableFuture<Integer> eventFlags = new CompletableFuture<>();

        try {
            mActivityRule.runOnUiThread(() -> {
                mView = new View(mActivity);
                mView.setBackgroundColor(Color.GREEN);
                p.flags = FLAG_NOT_TOUCH_MODAL | FLAG_LAYOUT_IN_SCREEN;
                p.width = 100;
                p.height = 100;
                p.gravity = Gravity.CENTER;
                mView.setOnClickListener((v) -> {
                    mClickCount++;
                });
                mView.setOnTouchListener((v, ev) -> {
                    touchReceived.set(true);
                    eventFlags.complete(ev.getFlags());
                    return false;
                });
                mActivity.addWindow(mView, p);

                // Set up an overlap window from service, use different process.
                WindowManager.LayoutParams params = getObscuringViewLayoutParams(windowName);
                params.flags |= FLAG_NOT_TOUCHABLE;
                params.alpha = 0;
                intent.putExtra(EXTRA_LAYOUT_PARAMS, params);
                mActivity.startForegroundService(intent);
            });
            mInstrumentation.waitForIdleSync();
            waitForWindow(windowName);
            CtsTouchUtils.emulateTapOnViewCenter(mInstrumentation, mActivityRule, mView);

            assertTrue(touchReceived.get());
            assertEquals(0, eventFlags.get(EVENT_FLAGS_WAIT_TIME, TimeUnit.SECONDS)
                    & MotionEvent.FLAG_WINDOW_IS_OBSCURED);
            assertEquals(1, mClickCount);
        } finally {
            mActivity.stopService(intent);
        }
    }

    @Test
    public void testFlagTouchesWhenObscuredByMinPositiveOpacityWindow() throws Throwable {
        final WindowManager.LayoutParams p = new WindowManager.LayoutParams();
        final CompletableFuture<Integer> eventFlags = new CompletableFuture<>();
        final Intent intent = new Intent();
        intent.setComponent(Components.OVERLAY_TEST_SERVICE);
        final String windowName = "Test Overlay";
        final AtomicBoolean touchReceived = new AtomicBoolean(false);
        final int[] viewOnScreenLocation = new int[2];
        try {
            mActivityRule.runOnUiThread(() -> {
                mView = new View(mActivity);
                mView.setBackgroundColor(Color.GREEN);
                p.flags = FLAG_NOT_TOUCH_MODAL | FLAG_LAYOUT_IN_SCREEN;
                p.width = TAPPING_TARGET_WINDOW_SIZE;
                p.height = TAPPING_TARGET_WINDOW_SIZE;
                p.gravity = Gravity.CENTER;
                mView.setOnClickListener((v) -> {
                    mClickCount++;
                });
                mView.setOnTouchListener((v, ev) -> {
                    touchReceived.set(true);
                    eventFlags.complete(ev.getFlags());
                    return false;
                });
                mActivity.addWindow(mView, p);
            });
            mInstrumentation.waitForIdleSync();
            mActivityRule.runOnUiThread(() -> {
                mView.getLocationOnScreen(viewOnScreenLocation);
                // Set up an overlap window from service, use different process.
                WindowManager.LayoutParams params = getObscuringViewLayoutParams(windowName);
                params.flags |= FLAG_NOT_TOUCHABLE;
                params.alpha = MIN_POSITIVE_OPACITY;
                placeWindowAtLayoutCenter(params, TAPPING_TARGET_WINDOW_SIZE,
                        viewOnScreenLocation[0], viewOnScreenLocation[1],
                        TAPPING_TARGET_WINDOW_SIZE);
                intent.putExtra(EXTRA_LAYOUT_PARAMS, params);
                mActivity.startForegroundService(intent);
            });
            mInstrumentation.waitForIdleSync();
            waitForWindow(windowName);
            CtsTouchUtils.emulateTapOnViewCenter(mInstrumentation, mActivityRule, mView);

            assertTrue(touchReceived.get());
            assertEquals(MotionEvent.FLAG_WINDOW_IS_OBSCURED,
                    eventFlags.get(EVENT_FLAGS_WAIT_TIME, TimeUnit.SECONDS)
                            & MotionEvent.FLAG_WINDOW_IS_OBSCURED);
            assertEquals(1, mClickCount);
        } finally {
            mActivity.stopService(intent);
        }
    }

    @Test
    public void testFlagTouchesWhenPartiallyObscuredByZeroOpacityWindow() throws Throwable {
        final WindowManager.LayoutParams p = new WindowManager.LayoutParams();

        final Intent intent = new Intent();
        intent.setComponent(Components.OVERLAY_TEST_SERVICE);
        final String windowName = "Test Overlay";
        final AtomicBoolean touchReceived = new AtomicBoolean(false);
        final CompletableFuture<Integer> eventFlags = new CompletableFuture<>();
        final int[] viewOnScreenLocation = new int[2];
        try {
            mActivityRule.runOnUiThread(() -> {
                mView = new View(mActivity);
                mView.setBackgroundColor(Color.GREEN);
                p.flags = FLAG_NOT_TOUCH_MODAL | FLAG_LAYOUT_IN_SCREEN;
                p.width = TAPPING_TARGET_WINDOW_SIZE;
                p.height = TAPPING_TARGET_WINDOW_SIZE;
                p.gravity = Gravity.CENTER;
                mView.setOnClickListener((v) -> {
                    mClickCount++;
                });
                mView.setOnTouchListener((v, ev) -> {
                    touchReceived.set(true);
                    eventFlags.complete(ev.getFlags());
                    return false;
                });
                mActivity.addWindow(mView, p);
            });
            mInstrumentation.waitForIdleSync();
            mActivityRule.runOnUiThread(() -> {
                mView.getLocationOnScreen(viewOnScreenLocation);
                // Set up an overlap window from service, use different process.
                WindowManager.LayoutParams params = getObscuringViewLayoutParams(windowName,
                        PARTIAL_OBSCURING_WINDOW_SIZE);
                placeWindowAtLayoutCenter(params, PARTIAL_OBSCURING_WINDOW_SIZE,
                        viewOnScreenLocation[0], viewOnScreenLocation[1], TAPPING_TARGET_WINDOW_SIZE);
                // Move it off the touch path (center) but still overlap with window above
                params.y += PARTIAL_OBSCURING_WINDOW_SIZE;
                intent.putExtra(EXTRA_LAYOUT_PARAMS, params);
                mActivity.startForegroundService(intent);
            });
            mInstrumentation.waitForIdleSync();
            waitForWindow(windowName);
            CtsTouchUtils.emulateTapOnViewCenter(mInstrumentation, mActivityRule, mView);

            assertTrue(touchReceived.get());
            assertEquals(MotionEvent.FLAG_WINDOW_IS_PARTIALLY_OBSCURED,
                    eventFlags.get(EVENT_FLAGS_WAIT_TIME, TimeUnit.SECONDS)
                            & MotionEvent.FLAG_WINDOW_IS_PARTIALLY_OBSCURED);
            assertEquals(1, mClickCount);
        } finally {
            mActivity.stopService(intent);
        }
    }

    @Test
    public void testDoNotFlagTouchesWhenPartiallyObscuredByNotTouchableZeroOpacityWindow()
            throws Throwable {
        final WindowManager.LayoutParams p = new WindowManager.LayoutParams();

        final Intent intent = new Intent();
        intent.setComponent(Components.OVERLAY_TEST_SERVICE);
        final String windowName = "Test Overlay";
        final AtomicBoolean touchReceived = new AtomicBoolean(false);
        final CompletableFuture<Integer> eventFlags = new CompletableFuture<>();

        try {
            mActivityRule.runOnUiThread(() -> {
                mView = new View(mActivity);
                mView.setBackgroundColor(Color.GREEN);
                p.flags = FLAG_NOT_TOUCH_MODAL | FLAG_LAYOUT_IN_SCREEN;
                p.width = 100;
                p.height = 100;
                p.gravity = Gravity.CENTER;
                mView.setOnClickListener((v) -> {
                    mClickCount++;
                });
                mView.setOnTouchListener((v, ev) -> {
                    touchReceived.set(true);
                    eventFlags.complete(ev.getFlags());
                    return false;
                });
                mActivity.addWindow(mView, p);

                // Set up an overlap window from service, use different process.
                WindowManager.LayoutParams params = getObscuringViewLayoutParams(windowName, 30);
                params.flags |= FLAG_NOT_TOUCHABLE;
                // Move it off the touch path (center) but still overlap with window above
                params.y = 30;
                params.alpha = 0;
                intent.putExtra(EXTRA_LAYOUT_PARAMS, params);
                mActivity.startForegroundService(intent);
            });
            mInstrumentation.waitForIdleSync();
            waitForWindow(windowName);
            CtsTouchUtils.emulateTapOnViewCenter(mInstrumentation, mActivityRule, mView);

            assertTrue(touchReceived.get());
            assertEquals(0, eventFlags.get(EVENT_FLAGS_WAIT_TIME, TimeUnit.SECONDS)
                    & MotionEvent.FLAG_WINDOW_IS_PARTIALLY_OBSCURED);
            assertEquals(1, mClickCount);
        } finally {
            mActivity.stopService(intent);
        }
    }

    private WindowManager.LayoutParams getObscuringViewLayoutParams(String windowName) {
        return getObscuringViewLayoutParams(windowName, 100);
    }

    private WindowManager.LayoutParams getObscuringViewLayoutParams(String windowName, int size) {
        WindowManager.LayoutParams params = new WindowManager.LayoutParams();
        params.setTitle(windowName);
        params.type = WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY;
        params.flags = FLAG_NOT_TOUCH_MODAL | FLAG_LAYOUT_IN_SCREEN;
        params.width = size;
        params.height = size;
        params.gravity = Gravity.CENTER;
        return params;
    }

    @Test
    public void testTrustedOverlapWindow() throws Throwable {
        final WindowManager.LayoutParams p = new WindowManager.LayoutParams();
        try (final PointerLocationSession session = new PointerLocationSession()) {
            session.set(true);
            session.waitForReady(mActivity.getDisplayId());

            // Set up window.
            mActivityRule.runOnUiThread(() -> {
                mView = new View(mActivity);
                p.width = 20;
                p.height = 20;
                p.gravity = Gravity.CENTER;
                mView.setFilterTouchesWhenObscured(true);
                mView.setOnClickListener((v) -> {
                    mClickCount++;
                });
                mActivity.addWindow(mView, p);

            });
            mInstrumentation.waitForIdleSync();

            CtsTouchUtils.emulateTapOnViewCenter(mInstrumentation, mActivityRule, mView);
        }
        assertEquals(1, mClickCount);
    }

    @Test
    public void testWindowBecomesUnTouchable() throws Throwable {
        final WindowManager wm = mActivity.getWindowManager();
        final WindowManager.LayoutParams p = new WindowManager.LayoutParams();

        final View viewOverlap = new View(mActivity);

        // Set up window.
        mActivityRule.runOnUiThread(() -> {
            mView = new View(mActivity);
            p.width = 20;
            p.height = 20;
            p.gravity = Gravity.CENTER;
            mView.setOnClickListener((v) -> {
                mClickCount++;
            });
            mActivity.addWindow(mView, p);

            p.width = 100;
            p.height = 100;
            p.gravity = Gravity.CENTER;
            p.type = WindowManager.LayoutParams.TYPE_APPLICATION;
            mActivity.addWindow(viewOverlap, p);
        });
        mInstrumentation.waitForIdleSync();

        CtsTouchUtils.emulateTapOnViewCenter(mInstrumentation, mActivityRule, mView);
        assertEquals(0, mClickCount);

        mActivityRule.runOnUiThread(() -> {
            p.flags = FLAG_NOT_FOCUSABLE | FLAG_NOT_TOUCHABLE;
            wm.updateViewLayout(viewOverlap, p);
        });
        mInstrumentation.waitForIdleSync();

        CtsTouchUtils.emulateTapOnViewCenter(mInstrumentation, mActivityRule, mView);
        assertEquals(1, mClickCount);
    }

    @Test
    public void testTapInsideUntouchableWindowResultInOutsideTouches() throws Throwable {
        final WindowManager.LayoutParams p = new WindowManager.LayoutParams();

        final Set<MotionEvent> events = new ArraySet<>();
        mActivityRule.runOnUiThread(() -> {
            mView = new View(mActivity);
            p.width = 20;
            p.height = 20;
            p.gravity = Gravity.CENTER;
            p.flags = FLAG_NOT_TOUCHABLE | FLAG_WATCH_OUTSIDE_TOUCH;
            mView.setOnTouchListener((v, e) -> {
                // Copying to make sure we are not dealing with a reused object
                events.add(MotionEvent.obtain(e));
                return false;
            });
            mActivity.addWindow(mView, p);
        });
        mInstrumentation.waitForIdleSync();

        CtsTouchUtils.emulateTapOnViewCenter(mInstrumentation, mActivityRule, mView);

        assertEquals(1, events.size());
        MotionEvent event = events.iterator().next();
        assertEquals(MotionEvent.ACTION_OUTSIDE, event.getAction());
    }

    @Test
    public void testTapOutsideUntouchableWindowResultInOutsideTouches() throws Throwable {
        final WindowManager.LayoutParams p = new WindowManager.LayoutParams();

        Set<MotionEvent> events = new ArraySet<>();
        int size = 20;
        mActivityRule.runOnUiThread(() -> {
            mView = new View(mActivity);
            p.width = size;
            p.height = size;
            p.gravity = Gravity.CENTER;
            p.flags = FLAG_NOT_TOUCHABLE | FLAG_WATCH_OUTSIDE_TOUCH;
            mView.setOnTouchListener((v, e) -> {
                // Copying to make sure we are not dealing with a reused object
                events.add(MotionEvent.obtain(e));
                return false;
            });
            mActivity.addWindow(mView, p);
        });
        mInstrumentation.waitForIdleSync();

        CtsTouchUtils.emulateTapOnView(mInstrumentation, mActivityRule, mView, size + 5, size + 5);

        assertEquals(1, events.size());
        MotionEvent event = events.iterator().next();
        assertEquals(MotionEvent.ACTION_OUTSIDE, event.getAction());
    }

    @Test
    public void testInjectToStatusBar() {
        // Try to inject event to status bar.
        assumeHasStatusBar(mActivityRule);
        final long downTime = SystemClock.uptimeMillis();
        final MotionEvent eventHover = MotionEvent.obtain(
                downTime, downTime, MotionEvent.ACTION_HOVER_MOVE, 0, 0, 0);
        eventHover.setSource(InputDevice.SOURCE_MOUSE);
        try {
            mInstrumentation.sendPointerSync(eventHover);
            fail("Not allowed to inject to windows owned by another uid from Instrumentation.");
        } catch (RuntimeException e) {
            // Should not be allowed to inject event to a window owned by another uid from the
            // Instrumentation class.
        }
    }

    @Test
    public void testInjectFromThread() throws InterruptedException {
        // Continually inject event to activity from thread.
        final int[] decorViewLocation = new int[2];
        final View decorView = mActivity.getWindow().getDecorView();
        decorView.getLocationOnScreen(decorViewLocation);
        // Tap at the center of the view. Calculate and tap at the absolute view center location on
        // screen, so that the tapping location is always as expected regardless of windowing mode.
        final Point testPoint = new Point(decorViewLocation[0] + decorView.getWidth() / 2,
                decorViewLocation[1] + decorView.getHeight() / 2);

        final long downTime = SystemClock.uptimeMillis();
        final MotionEvent eventDown = MotionEvent.obtain(
                downTime, downTime, MotionEvent.ACTION_DOWN, testPoint.x, testPoint.y, 1);
        mInstrumentation.sendPointerSync(eventDown);

        final ExecutorService executor = Executors.newSingleThreadExecutor();
        boolean[] securityExceptionCaught = new boolean[1];
        executor.execute(() -> {
            mInstrumentation.sendPointerSync(eventDown);
            for (int i = 0; i < 20; i++) {
                final long eventTime = SystemClock.uptimeMillis();
                final MotionEvent eventMove = MotionEvent.obtain(
                        downTime, eventTime, MotionEvent.ACTION_MOVE, testPoint.x, testPoint.y, 1);
                try {
                    mInstrumentation.sendPointerSync(eventMove);
                } catch (SecurityException e) {
                    securityExceptionCaught[0] = true;
                }
            }
        });

        // Launch another activity, should not crash the process.
        final Intent intent = new Intent(mActivity, TestActivity.class);
        mActivityRule.launchActivity(intent);
        mInstrumentation.waitForIdleSync();

        executor.shutdown();
        executor.awaitTermination(5L, TimeUnit.SECONDS);

        if (securityExceptionCaught[0]) {
            // Fail the test here instead of in the executor lambda,
            // so the failure is thrown in the test thread.
            fail("Should be allowed to inject event.");
        }
    }

    private void waitForWindow(String name) {
        mWmState.waitForWithAmState(state -> state.isWindowSurfaceShown(name),
                name + "'s surface is appeared");
    }

    public static class TestActivity extends Activity {
        private ArrayList<View> mViews = new ArrayList<>();

        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
        }

        void addWindow(View view, WindowManager.LayoutParams attrs) {
            getWindowManager().addView(view, attrs);
            mViews.add(view);
        }

        void removeAllWindows() {
            for (View view : mViews) {
                getWindowManager().removeViewImmediate(view);
            }
            mViews.clear();
        }

        @Override
        protected void onPause() {
            super.onPause();
            removeAllWindows();
        }
    }

    /** Set a square window to display at the center of a square layout*/
    static void placeWindowAtLayoutCenter(WindowManager.LayoutParams windowParams, int windowWidth,
            int layoutLeft, int layoutTop, int layoutWidth) {
        windowParams.gravity = Gravity.TOP | Gravity.LEFT;
        int offset = (layoutWidth - windowWidth) / 2;
        windowParams.x = layoutLeft + offset;
        windowParams.y = layoutTop + offset;
    }

    /** Helper class to save, set, and restore pointer location preferences. */
    private static class PointerLocationSession extends SettingsSession<Boolean> {
        PointerLocationSession() {
            super(Settings.System.getUriFor("pointer_location" /* POINTER_LOCATION */),
                    PointerLocationSession::get,
                    PointerLocationSession::put);
        }

        private static void put(ContentResolver contentResolver, String s, boolean v) {
            SystemUtil.runShellCommand(
                    "settings put system " + "pointer_location" + " " + (v ? 1 : 0));
        }

        private static boolean get(ContentResolver contentResolver, String s) {
            try {
                return Integer.parseInt(SystemUtil.runShellCommand(
                        "settings get system " + "pointer_location").trim()) == 1;
            } catch (NumberFormatException e) {
                return false;
            }
        }

        // Wait until pointer location surface shown.
        static void waitForReady(int displayId) {
            final WindowManagerStateHelper wmState = new WindowManagerStateHelper();
            final String windowName = "PointerLocation - display " + displayId;
            wmState.waitForWithAmState(state -> {
                return state.isWindowSurfaceShown(windowName);
            }, windowName + "'s surface is appeared");
        }
    }
}