/**
 * Copyright (C) 2017 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.accessibilityservice.cts;

import static android.accessibilityservice.cts.utils.ActivityLaunchUtils.launchActivityOnSpecifiedDisplayAndWaitForItToBeOnscreen;
import static android.accessibilityservice.cts.utils.DisplayUtils.VirtualDisplaySession;
import static android.accessibilityservice.cts.utils.GestureUtils.add;
import static android.accessibilityservice.cts.utils.GestureUtils.click;
import static android.accessibilityservice.cts.utils.GestureUtils.diff;
import static android.accessibilityservice.cts.utils.GestureUtils.endTimeOf;
import static android.accessibilityservice.cts.utils.GestureUtils.getGestureBuilder;
import static android.accessibilityservice.cts.utils.GestureUtils.longClick;
import static android.accessibilityservice.cts.utils.GestureUtils.startingAt;
import static android.app.UiAutomation.FLAG_DONT_SUPPRESS_ACCESSIBILITY_SERVICES;

import static org.junit.Assert.assertTrue;
import static org.junit.Assume.assumeTrue;
import static org.mockito.Mockito.any;
import static org.mockito.Mockito.timeout;
import static org.mockito.Mockito.verify;

import android.accessibility.cts.common.AccessibilityDumpOnFailureRule;
import android.accessibility.cts.common.InstrumentedAccessibilityServiceTestRule;
import android.accessibilityservice.AccessibilityService;
import android.accessibilityservice.GestureDescription;
import android.accessibilityservice.GestureDescription.StrokeDescription;
import android.accessibilityservice.cts.activities.AccessibilityWindowQueryActivity;
import android.accessibilityservice.cts.utils.GestureUtils;
import android.app.Activity;
import android.app.Instrumentation;
import android.app.UiAutomation;
import android.content.Context;
import android.content.pm.PackageManager;
import android.graphics.Path;
import android.graphics.Point;
import android.graphics.PointF;
import android.platform.test.annotations.AppModeFull;
import android.util.DisplayMetrics;
import android.view.Display;
import android.view.ViewConfiguration;
import android.view.WindowManager;
import android.view.accessibility.AccessibilityEvent;

import androidx.test.InstrumentationRegistry;
import androidx.test.runner.AndroidJUnit4;

import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.RuleChain;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;

/** Verify that motion events are recognized as accessibility gestures. */
@RunWith(AndroidJUnit4.class)
public class AccessibilityGestureDetectorTest {

    // Constants
    private static final float GESTURE_LENGTH_INCHES = 1.0f;
    // The movement should exceed the threshold 1 cm in 150 ms defined in Swipe.java. It means the
    // swipe velocity in testing should be greater than 2.54 cm / 381 ms. Therefore the
    // duration should be smaller than 381.
    private static final long STROKE_MS = 380;
    private static final long GESTURE_DISPATCH_TIMEOUT_MS = 3000;
    private static final long EVENT_DISPATCH_TIMEOUT_MS = 3000;
    private static final PointF FINGER_OFFSET_PX = new PointF(100f, -50f);

    private static Instrumentation sInstrumentation;
    private static UiAutomation sUiAutomation;

    private InstrumentedAccessibilityServiceTestRule<GestureDetectionStubAccessibilityService>
            mServiceRule = new InstrumentedAccessibilityServiceTestRule<>(
                    GestureDetectionStubAccessibilityService.class, false);

    private AccessibilityDumpOnFailureRule mDumpOnFailureRule =
            new AccessibilityDumpOnFailureRule();

    @Rule
    public final RuleChain mRuleChain = RuleChain
            .outerRule(mServiceRule)
            .around(mDumpOnFailureRule);

    // Test AccessibilityService that collects gestures.
    GestureDetectionStubAccessibilityService mService; 
    boolean mHasTouchScreen;
    boolean mScreenBigEnough;
    int mStrokeLenPxX; // Gesture stroke size, in pixels
    int mStrokeLenPxY;
    Point mCenter; // Center of screen. Gestures all start from this point.
    PointF mTapLocation;
    int mScaledTouchSlop;
    int mMaxAdjustedStrokeLenPxX;
    int mMaxAdjustedStrokeLenPxY;
    @Mock AccessibilityService.GestureResultCallback mGestureDispatchCallback;

    @BeforeClass
    public static void oneTimeSetup() {
        sInstrumentation = InstrumentationRegistry.getInstrumentation();
        sUiAutomation = sInstrumentation.getUiAutomation(FLAG_DONT_SUPPRESS_ACCESSIBILITY_SERVICES);
    }

    @AfterClass
    public static void finalTearDown() {
        sUiAutomation.destroy();
    }

    @Before
    public void setUp() throws Exception {
        MockitoAnnotations.initMocks(this);

        // Check that device has a touch screen.
        PackageManager pm = sInstrumentation.getContext().getPackageManager();
        mHasTouchScreen = pm.hasSystemFeature(PackageManager.FEATURE_TOUCHSCREEN)
                || pm.hasSystemFeature(PackageManager.FEATURE_FAKETOUCH);
        if (!mHasTouchScreen) {
            return;
        }

        // Find screen size, check that it is big enough for gestures.
        // Gestures will start in the center of the screen, so we need enough horiz/vert space.
        WindowManager windowManager = (WindowManager) sInstrumentation.getContext()
                .getSystemService(Context.WINDOW_SERVICE);
        final DisplayMetrics metrics = new DisplayMetrics();
        windowManager.getDefaultDisplay().getRealMetrics(metrics);
        mCenter = new Point((int) metrics.widthPixels / 2, (int) metrics.heightPixels / 2);
        mTapLocation = new PointF(mCenter);
        mScaledTouchSlop =
                ViewConfiguration.get(sInstrumentation.getContext()).getScaledTouchSlop();
        mStrokeLenPxX = (int) (GESTURE_LENGTH_INCHES * metrics.xdpi);
        // The threshold is determined by xdpi.
        mStrokeLenPxY = mStrokeLenPxX;
        mMaxAdjustedStrokeLenPxX = metrics.widthPixels / 2;
        mMaxAdjustedStrokeLenPxY = metrics.heightPixels / 2;
        final boolean screenWideEnough = metrics.widthPixels / 2 > mStrokeLenPxX;
        final boolean screenHighEnough =  metrics.heightPixels / 2 > mStrokeLenPxY;
        mScreenBigEnough = screenWideEnough && screenHighEnough;
        if (!mScreenBigEnough) {
            return;
        }
        // Start stub accessibility service.
        mService = mServiceRule.enableService();
    }

    @Test
    @AppModeFull
    public void testRecognizeGesturePath() {
        if (!mHasTouchScreen || !mScreenBigEnough) {
            return;
        }

        runGestureDetectionTestOnDisplay(Display.DEFAULT_DISPLAY);
        runMultiFingerGestureDetectionTestOnDisplay(Display.DEFAULT_DISPLAY);
    }

    @Test
    @AppModeFull
    public void testRecognizeGesturePathOnVirtualDisplay() throws Exception {
        assumeTrue(sInstrumentation.getContext().getPackageManager()
                .hasSystemFeature(PackageManager.FEATURE_ACTIVITIES_ON_SECONDARY_DISPLAYS));

        if (!mHasTouchScreen || !mScreenBigEnough) {
            return;
        }

        try (final VirtualDisplaySession displaySession = new VirtualDisplaySession()) {
            final int displayId = displaySession.createDisplayWithDefaultDisplayMetricsAndWait(
                    sInstrumentation.getTargetContext(), false).getDisplayId();
            // Launches an activity on virtual display to meet a real situation.
            final Activity activity = launchActivityOnSpecifiedDisplayAndWaitForItToBeOnscreen(
                    sInstrumentation, sUiAutomation, AccessibilityWindowQueryActivity.class,
                    displayId);

            try {
                runGestureDetectionTestOnDisplay(displayId);
                runMultiFingerGestureDetectionTestOnDisplay(displayId);
            } finally {
                sInstrumentation.runOnMainSync(() -> {
                    activity.finish();
                });
                sInstrumentation.waitForIdleSync();
            }
        }
    }

    private void runGestureDetectionTestOnDisplay(int displayId) {
        // Compute gesture stroke lengths, in pixels.
        final int dx = mStrokeLenPxX;
        final int dy = mStrokeLenPxY;

        // Test recognizing various gestures.
        testGesture(
                doubleTap(displayId),
                AccessibilityService.GESTURE_DOUBLE_TAP,
                displayId);
        testGesture(
                doubleTapAndHold(displayId),
                AccessibilityService.GESTURE_DOUBLE_TAP_AND_HOLD,
                displayId);
        testPath(p(-dx, +0), AccessibilityService.GESTURE_SWIPE_LEFT, displayId);
        testPath(p(+dx, +0), AccessibilityService.GESTURE_SWIPE_RIGHT, displayId);
        testPath(p(+0, -dy), AccessibilityService.GESTURE_SWIPE_UP, displayId);
        testPath(p(+0, +dy), AccessibilityService.GESTURE_SWIPE_DOWN, displayId);

        testPath(p(-dx, +0), p(+0, +0), AccessibilityService.GESTURE_SWIPE_LEFT_AND_RIGHT,
                displayId);
        testPath(p(-dx, +0), p(-dx, -dy), AccessibilityService.GESTURE_SWIPE_LEFT_AND_UP,
                displayId);
        testPath(p(-dx, +0), p(-dx, +dy), AccessibilityService.GESTURE_SWIPE_LEFT_AND_DOWN,
                displayId);

        testPath(p(+dx, +0), p(+0, +0), AccessibilityService.GESTURE_SWIPE_RIGHT_AND_LEFT,
                displayId);
        testPath(p(+dx, +0), p(+dx, -dy), AccessibilityService.GESTURE_SWIPE_RIGHT_AND_UP,
                displayId);
        testPath(p(+dx, +0), p(+dx, +dy), AccessibilityService.GESTURE_SWIPE_RIGHT_AND_DOWN,
                displayId);

        testPath(p(+0, -dy), p(-dx, -dy), AccessibilityService.GESTURE_SWIPE_UP_AND_LEFT,
                displayId);
        testPath(p(+0, -dy), p(+dx, -dy), AccessibilityService.GESTURE_SWIPE_UP_AND_RIGHT,
                displayId);
        testPath(p(+0, -dy), p(+0, +0), AccessibilityService.GESTURE_SWIPE_UP_AND_DOWN,
                displayId);

        testPath(p(+0, +dy), p(-dx, +dy), AccessibilityService.GESTURE_SWIPE_DOWN_AND_LEFT,
                displayId);
        testPath(p(+0, +dy), p(+dx, +dy), AccessibilityService.GESTURE_SWIPE_DOWN_AND_RIGHT,
                displayId);
        testPath(p(+0, +dy), p(+0, +0), AccessibilityService.GESTURE_SWIPE_DOWN_AND_UP,
                displayId);
    }

    private void runMultiFingerGestureDetectionTestOnDisplay(int displayId) {
        // Compute gesture stroke lengths, in pixels.
        final int dx = mStrokeLenPxX;
        final int dy = mStrokeLenPxY;
        testGesture(
                twoFingerSingleTap(displayId),
                AccessibilityService.GESTURE_2_FINGER_SINGLE_TAP,
                displayId);
                testGesture(
                        twoFingerTripleTapAndHold(displayId),
                        AccessibilityService.GESTURE_2_FINGER_TRIPLE_TAP_AND_HOLD,
                        displayId);
                testGesture(
                twoFingerDoubleTap(displayId),
                AccessibilityService.GESTURE_2_FINGER_DOUBLE_TAP,
                displayId);
                testGesture(
                twoFingerDoubleTapAndHold(displayId),
                AccessibilityService.GESTURE_2_FINGER_DOUBLE_TAP_AND_HOLD,
                displayId);
        testGesture(
                twoFingerTripleTap(displayId),
                AccessibilityService.GESTURE_2_FINGER_TRIPLE_TAP,
                displayId);

        testGesture(
                threeFingerSingleTap(displayId),
                AccessibilityService.GESTURE_3_FINGER_SINGLE_TAP,
                displayId);
                testGesture(
                        threeFingerSingleTapAndHold(displayId),
                        AccessibilityService.GESTURE_3_FINGER_SINGLE_TAP_AND_HOLD,
                        displayId);
                testGesture(
                threeFingerDoubleTap(displayId),
                AccessibilityService.GESTURE_3_FINGER_DOUBLE_TAP,
                displayId);
                testGesture(
                threeFingerDoubleTapAndHold(displayId),
                AccessibilityService.GESTURE_3_FINGER_DOUBLE_TAP_AND_HOLD,
                displayId);
        testGesture(
                threeFingerTripleTap(displayId),
                AccessibilityService.GESTURE_3_FINGER_TRIPLE_TAP,
                displayId);
                testGesture(
                        threeFingerTripleTapAndHold(displayId),
                        AccessibilityService.GESTURE_3_FINGER_TRIPLE_TAP_AND_HOLD,
                        displayId);

        testGesture(
                fourFingerSingleTap(displayId),
                AccessibilityService.GESTURE_4_FINGER_SINGLE_TAP,
                displayId);
        testGesture(
                fourFingerDoubleTap(displayId),
                AccessibilityService.GESTURE_4_FINGER_DOUBLE_TAP,
                displayId);
                testGesture(
                fourFingerDoubleTapAndHold(displayId),
                AccessibilityService.GESTURE_4_FINGER_DOUBLE_TAP_AND_HOLD,
                displayId);
        testGesture(
                fourFingerTripleTap(displayId),
                AccessibilityService.GESTURE_4_FINGER_TRIPLE_TAP,
                displayId);

        testGesture(
                MultiFingerSwipe(displayId, 3, 0, dy),
                AccessibilityService.GESTURE_3_FINGER_SWIPE_DOWN,
                displayId);
        testGesture(
                MultiFingerSwipe(displayId, 3, -dx, 0),
                AccessibilityService.GESTURE_3_FINGER_SWIPE_LEFT,
                displayId);
        testGesture(
                MultiFingerSwipe(displayId, 3, dx, 0),
                AccessibilityService.GESTURE_3_FINGER_SWIPE_RIGHT,
                displayId);
        testGesture(
                MultiFingerSwipe(displayId, 3, 0, -dy),
                AccessibilityService.GESTURE_3_FINGER_SWIPE_UP,
                displayId);
        testGesture(
                MultiFingerSwipe(displayId, 4, 0, dy),
                AccessibilityService.GESTURE_4_FINGER_SWIPE_DOWN,
                displayId);
        testGesture(
                MultiFingerSwipe(displayId, 4, -dx, 0),
                AccessibilityService.GESTURE_4_FINGER_SWIPE_LEFT,
                displayId);
        testGesture(
                MultiFingerSwipe(displayId, 4, dx, 0),
                AccessibilityService.GESTURE_4_FINGER_SWIPE_RIGHT,
                displayId);
        testGesture(
                MultiFingerSwipe(displayId, 4, 0, -dy),
                AccessibilityService.GESTURE_4_FINGER_SWIPE_UP,
                displayId);
    }

    /** Convenient short alias to make a Point. */
    private static Point p(int x, int y) {
        return new Point(x, y);
    }

    /** Test recognizing path from PATH_START to PATH_START+delta on default display. */
    private void testPath(Point delta, int gestureId) {
        testPath(delta, null, gestureId, Display.DEFAULT_DISPLAY);
    }

    /** Test recognizing path from PATH_START to PATH_START+delta on specified display. */
    private void testPath(Point delta, int gestureId, int displayId) {
        testPath(delta, null, gestureId, displayId);
    }
    /** Test recognizing path from PATH_START to PATH_START+delta on default display. */
    private void testPath(Point delta1, Point delta2, int gestureId) {
        testPath(delta1, delta2, gestureId, Display.DEFAULT_DISPLAY);
    }

    /**
     * Test recognizing path from PATH_START to PATH_START+delta1 to PATH_START+delta2. on specified
     * display.
     */
    private void testPath(Point delta1, Point delta2, int gestureId, int displayId) {
        // Create gesture motions.
        int numPathSegments = (delta2 == null) ? 1 : 2;
        long pathDurationMs = numPathSegments * STROKE_MS;
        GestureDescription gesture = new GestureDescription.Builder()
                .addStroke(new StrokeDescription(
                linePath(mCenter, delta1, delta2), 0, pathDurationMs, false))
                .setDisplayId(displayId)
                .build();

        testGesture(gesture, gestureId, displayId);
    }

    /** Dispatch a gesture and make sure it is detected as the specified gesture id. */
    private void testGesture(GestureDescription gesture, int gestureId, int displayId) {
        // Dispatch gesture motions to specified  display with GestureDescription..
        // Use AccessibilityService.dispatchGesture() instead of Instrumentation.sendPointerSync()
        // because accessibility services read gesture events upstream from the point where
        // sendPointerSync() injects events.
        mService.runOnServiceSync(() ->
        mService.dispatchGesture(gesture, mGestureDispatchCallback, null));
        verify(mGestureDispatchCallback, timeout(GESTURE_DISPATCH_TIMEOUT_MS).atLeastOnce())
                .onCompleted(any());

        // Wait for gesture recognizer, and check recognized gesture.
        mService.assertGestureReceived(gestureId, displayId);
    }
    /** Create a path from startPoint, moving by delta1, then delta2. (delta2 may be null.) */
    Path linePath(Point startPoint, Point delta1, Point delta2) {
        Path path = new Path();
        path.moveTo(startPoint.x, startPoint.y);
        path.lineTo(startPoint.x + delta1.x, startPoint.y + delta1.y);
        if (delta2 != null) {
            path.lineTo(startPoint.x + delta2.x, startPoint.y + delta2.y);
        }
        return path;
    }

    @Test
    @AppModeFull
    public void testVerifyGestureTouchEvent() {
        if (!mHasTouchScreen || !mScreenBigEnough) {
            return;
        }

        verifyGestureTouchEventOnDisplay(Display.DEFAULT_DISPLAY);
        verifyMultiFingerGestureTouchEventOnDisplay(Display.DEFAULT_DISPLAY);
    }

    @Test
    @AppModeFull
    public void testVerifyGestureTouchEventOnVirtualDisplay() throws Exception {
        assumeTrue(sInstrumentation.getContext().getPackageManager()
                .hasSystemFeature(PackageManager.FEATURE_ACTIVITIES_ON_SECONDARY_DISPLAYS));
        if (!mHasTouchScreen || !mScreenBigEnough) {
            return;
        }

        try (final VirtualDisplaySession displaySession = new VirtualDisplaySession()) {
            final int displayId = displaySession.createDisplayWithDefaultDisplayMetricsAndWait(
                    sInstrumentation.getTargetContext(),
                    false).getDisplayId();

            // Launches an activity on virtual display to meet a real situation.
            final Activity activity = launchActivityOnSpecifiedDisplayAndWaitForItToBeOnscreen(
                    sInstrumentation, sUiAutomation, AccessibilityWindowQueryActivity.class,
                    displayId);
            try {
                verifyGestureTouchEventOnDisplay(displayId);
                verifyMultiFingerGestureTouchEventOnDisplay(displayId);
            } finally {
                sInstrumentation.runOnMainSync(() -> {
                    activity.finish();
                });
                sInstrumentation.waitForIdleSync();
            }
        }
    }

    private void verifyGestureTouchEventOnDisplay(int displayId) {
        assertEventAfterGesture(swipe(displayId),
                AccessibilityEvent.TYPE_TOUCH_INTERACTION_START,
                AccessibilityEvent.TYPE_TOUCH_INTERACTION_END);

        assertEventAfterGesture(tap(displayId),
                AccessibilityEvent.TYPE_TOUCH_INTERACTION_START,
                AccessibilityEvent.TYPE_TOUCH_EXPLORATION_GESTURE_START,
                AccessibilityEvent.TYPE_TOUCH_EXPLORATION_GESTURE_END,
                AccessibilityEvent.TYPE_TOUCH_INTERACTION_END);

        assertEventAfterGesture(doubleTap(displayId),
                AccessibilityEvent.TYPE_TOUCH_INTERACTION_START,
                AccessibilityEvent.TYPE_TOUCH_INTERACTION_END);

        assertEventAfterGesture(doubleTapAndHold(displayId),
                AccessibilityEvent.TYPE_TOUCH_INTERACTION_START,
                AccessibilityEvent.TYPE_TOUCH_INTERACTION_END);
    }

    private void verifyMultiFingerGestureTouchEventOnDisplay(int displayId) {
        assertEventAfterGesture(twoFingerSingleTap(displayId),
                AccessibilityEvent.TYPE_TOUCH_INTERACTION_START,
                AccessibilityEvent.TYPE_TOUCH_INTERACTION_END);
        assertEventAfterGesture(twoFingerDoubleTap(displayId),
                AccessibilityEvent.TYPE_TOUCH_INTERACTION_START,
                AccessibilityEvent.TYPE_TOUCH_INTERACTION_END);
        assertEventAfterGesture(twoFingerTripleTap(displayId),
                AccessibilityEvent.TYPE_TOUCH_INTERACTION_START,
                AccessibilityEvent.TYPE_TOUCH_INTERACTION_END);

        assertEventAfterGesture(threeFingerSingleTap(displayId),
                AccessibilityEvent.TYPE_TOUCH_INTERACTION_START,
                AccessibilityEvent.TYPE_TOUCH_INTERACTION_END);
        assertEventAfterGesture(threeFingerDoubleTap(displayId),
                AccessibilityEvent.TYPE_TOUCH_INTERACTION_START,
                AccessibilityEvent.TYPE_TOUCH_INTERACTION_END);
        assertEventAfterGesture(threeFingerTripleTap(displayId),
                AccessibilityEvent.TYPE_TOUCH_INTERACTION_START,
                AccessibilityEvent.TYPE_TOUCH_INTERACTION_END);
    }

    @Test
    @AppModeFull
    public void testDispatchGesture_privateDisplay_gestureCancelled() throws Exception{
        assumeTrue(sInstrumentation.getContext().getPackageManager()
            .hasSystemFeature(PackageManager.FEATURE_ACTIVITIES_ON_SECONDARY_DISPLAYS));
        if (!mHasTouchScreen || !mScreenBigEnough) {
            return;
        }

        try (final VirtualDisplaySession displaySession = new VirtualDisplaySession()) {
            final int displayId = displaySession.createDisplayWithDefaultDisplayMetricsAndWait
                    (sInstrumentation.getTargetContext(),
                            true).getDisplayId();
            GestureDescription gesture = swipe(displayId);
            mService.clearGestures();
            mService.runOnServiceSync(() ->
                    mService.dispatchGesture(gesture, mGestureDispatchCallback, null));
            verify(mGestureDispatchCallback, timeout(GESTURE_DISPATCH_TIMEOUT_MS).atLeastOnce())
                    .onCancelled(any());
        }
    }

    /** Test touch for accessibility events */
    private void assertEventAfterGesture(GestureDescription gesture, int... events) {
        mService.clearEvents();
        mService.runOnServiceSync(
                () -> mService.dispatchGesture(gesture, mGestureDispatchCallback, null));
        verify(mGestureDispatchCallback, timeout(EVENT_DISPATCH_TIMEOUT_MS).atLeastOnce())
                .onCompleted(any());

        mService.assertPropagated(events);
    }

    private GestureDescription swipe(int displayId) {
        StrokeDescription swipe = new StrokeDescription(
                linePath(mCenter, p(0, mStrokeLenPxY), null), 0, STROKE_MS, false);
        return getGestureBuilder(displayId, swipe).build();
    }

    private GestureDescription tap(int displayId) {
        StrokeDescription tap = click(mTapLocation);
        return getGestureBuilder(displayId, tap).build();
    }

    private GestureDescription doubleTap(int displayId) {
        StrokeDescription tap1 = click(mTapLocation);
        StrokeDescription tap2 = startingAt(endTimeOf(tap1) + 20, click(mTapLocation));
        return getGestureBuilder(displayId, tap1, tap2).build();
    }

    private GestureDescription doubleTapAndHold(int displayId) {
        StrokeDescription tap1 = click(mTapLocation);
        StrokeDescription tap2 = startingAt(endTimeOf(tap1) + 20, longClick(mTapLocation));
        return getGestureBuilder(displayId, tap1, tap2).build();
    }

    private GestureDescription twoFingerSingleTap(int displayId) {
        return multiFingerMultiTap(2, 1, displayId);
    }

    private GestureDescription twoFingerTripleTapAndHold(int displayId) {
        return multiFingerMultiTapAndHold(2, 3, displayId);
    }

    private GestureDescription twoFingerDoubleTap(int displayId) {
        return multiFingerMultiTap(2, 2, displayId);
    }

    private GestureDescription twoFingerDoubleTapAndHold(int displayId) {
        return multiFingerMultiTapAndHold(2, 2, displayId);
    }
 
    private GestureDescription twoFingerTripleTap(int displayId) {
        return multiFingerMultiTap(2, 3, displayId);
    }

    private GestureDescription threeFingerSingleTap(int displayId) {
        return multiFingerMultiTap(3, 1, displayId);
    }

    private GestureDescription threeFingerSingleTapAndHold(int displayId) {
        return multiFingerMultiTapAndHold(3, 1, displayId);
    }

    private GestureDescription threeFingerDoubleTap(int displayId) {
        return multiFingerMultiTap(3, 2, displayId);
    }

    private GestureDescription threeFingerDoubleTapAndHold(int displayId) {
        return multiFingerMultiTapAndHold(3, 2, displayId);
    }

    private GestureDescription threeFingerTripleTap(int displayId) {
        return multiFingerMultiTap(3, 3, displayId);
    }

    private GestureDescription threeFingerTripleTapAndHold(int displayId) {
        return multiFingerMultiTapAndHold(3, 3, displayId);
    }

    private GestureDescription fourFingerSingleTap(int displayId) {
        return multiFingerMultiTap(4, 1, displayId);
    }

    private GestureDescription fourFingerDoubleTap(int displayId) {
        return multiFingerMultiTap(4, 2, displayId);
    }

    private GestureDescription fourFingerDoubleTapAndHold(int displayId) {
        return multiFingerMultiTapAndHold(4, 2, displayId);
    }

    private GestureDescription fourFingerTripleTap(int displayId) {
        return multiFingerMultiTap(4, 3, displayId);
    }

    private GestureDescription multiFingerMultiTap(int fingerCount, int tapCount, int displayId) {
        // We dispatch the first finger, base, placed at left down side by an offset
        // from the center of the display and the rest ones at right up side by delta
        // from the base.
        final PointF base = diff(mTapLocation, FINGER_OFFSET_PX);
        return GestureUtils.multiFingerMultiTap(
                base, FINGER_OFFSET_PX, fingerCount, tapCount, /* slop= */ 0, displayId);
    }

    private GestureDescription multiFingerMultiTapAndHold(
            int fingerCount, int tapCount, int displayId) {
        // We dispatch the first finger, base, placed at left down side by an offset
        // from the center of the display and the rest ones at right up side by delta
        // from the base.
        final PointF base = diff(mTapLocation, FINGER_OFFSET_PX);
        return GestureUtils.multiFingerMultiTapAndHold(
                base, FINGER_OFFSET_PX, fingerCount, tapCount, /* slop= */ 0, displayId);
    }

    private GestureDescription MultiFingerSwipe(
            int displayId, int fingerCount, float dx, float dy) {
        float fingerOffset = 10f;
        GestureDescription.Builder builder = new GestureDescription.Builder();
        builder.setDisplayId(displayId);

        // MultiFingerSwipe.java scales delta thresholds for multifinger gestures by multiplying
        // the touch slop with the amount of fingers used in the gesture.
        // With higher touch slops than default (8dp), the swipe lengths and duration needs to be
        // adjusted in order for the a11y-service to interpret it as a swipe gesture.
        float slopAdjustedDx = adjustStrokeDeltaForSlop(fingerCount, dx);
        float slopAdjustedDy = adjustStrokeDeltaForSlop(fingerCount, dy);
        long slopAdjustedStrokeDuration = Math.min(
                adjustStrokeDurationForSlop(STROKE_MS, dx, slopAdjustedDx),
                adjustStrokeDurationForSlop(STROKE_MS, dy, slopAdjustedDy));

        final PointF tapLocation = new PointF(mTapLocation);
        final float locationOffsetX = (fingerCount - 1) * fingerOffset;
        tapLocation.offset(dx > 0 ? -locationOffsetX : locationOffsetX , 0);
        for (int currentFinger = 0; currentFinger < fingerCount; ++currentFinger) {
            // Make sure adjustments don't take us outside of screen boundaries.
            assertTrue(slopAdjustedDx + (fingerOffset * currentFinger) < (mMaxAdjustedStrokeLenPxX
                    + locationOffsetX));
            assertTrue(slopAdjustedDy < mMaxAdjustedStrokeLenPxY);
            builder.addStroke(
                    GestureUtils.swipe(
                            add(tapLocation, fingerOffset * currentFinger, 0),
                            add(tapLocation, slopAdjustedDx + (fingerOffset * currentFinger),
                                    slopAdjustedDy),
                            slopAdjustedStrokeDuration));
        }
        return builder.build();
    }

    private float adjustStrokeDeltaForSlop(int fingerCount, float strokeDelta) {
        if (strokeDelta > 0.0f) {
            return Math.max(strokeDelta, fingerCount * mScaledTouchSlop + 10);
        } else if (strokeDelta < 0.0f) {
            return Math.min(strokeDelta, -(fingerCount * mScaledTouchSlop + 10));
        }
        return strokeDelta;
    }

    private long adjustStrokeDurationForSlop(
            long strokeDuration, float unadjustedDelta, float adjustedDelta) {
        if (unadjustedDelta == 0.0f || adjustedDelta == 0.0f) {
            return strokeDuration;
        }
        float absUnadjustedDelta = Math.abs(unadjustedDelta);
        float absAdjustedDelta = Math.abs(adjustedDelta);
        // Adjusted delta in this case, has additional delta added due to touch slop.
        return Math.round((float) strokeDuration * absUnadjustedDelta / absAdjustedDelta);
    }
}