android/view/InputStageBenchmark.java

/*
 * Copyright (C) 2020 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.view;

import static android.view.Display.DEFAULT_DISPLAY;

import static org.junit.Assert.assertTrue;

import android.app.Activity;
import android.app.Instrumentation;
import android.content.Context;
import android.graphics.Rect;
import android.os.SystemClock;
import android.perftests.utils.BenchmarkState;
import android.perftests.utils.PerfStatusReporter;
import android.perftests.utils.PerfTestActivity;
import android.view.inputmethod.InputMethodManager;
import android.widget.EditText;

import androidx.test.InstrumentationRegistry;
import androidx.test.filters.LargeTest;
import androidx.test.rule.ActivityTestRule;

import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;

import java.util.Arrays;
import java.util.Collection;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

@LargeTest
@RunWith(Parameterized.class)
public class InputStageBenchmark {
    @Parameterized.Parameters(name = "mShowIme({0}), mHandlePreIme({1})")
    public static Collection cases() {
        return Arrays.asList(new Object[][] {
                { false /* no ime */, false /* skip preime */},
                { true /* show ime */, false /* skip preime */},
                { true /* show ime */, true /* handle preime */}
        });
    }

    @Rule
    public final ActivityTestRule<PerfTestActivity> mActivityRule =
            new ActivityTestRule<>(PerfTestActivity.class);
    @Rule
    public PerfStatusReporter mPerfStatusReporter = new PerfStatusReporter();

    @Parameterized.Parameter(0)
    public boolean mShowIme;
    @Parameterized.Parameter(1)
    public boolean mHandlePreIme;

    private Instrumentation mInstrumentation;
    private Window mWindow;
    private CountDownLatch mWaitForReceiveInput;
    private static final long TIMEOUT_MS = 5000;

    class InstrumentedView extends View {
        InstrumentedView(Context context) {
            super(context);
            setFocusable(true);
        }

        @Override
        public boolean dispatchKeyEventPreIme(KeyEvent event) {
            if (mHandlePreIme) {
                mWaitForReceiveInput.countDown();
            }
            return mHandlePreIme;
        }

        @Override
        public boolean dispatchTouchEvent(MotionEvent event) {
            mWaitForReceiveInput.countDown();
            return true;
        }

        @Override
        public boolean dispatchKeyEvent(KeyEvent event) {
            mWaitForReceiveInput.countDown();
            return true;
        }
    }

    class InstrumentedEditText extends EditText {
        InstrumentedEditText(Context context) {
            super(context);
            setFocusable(true);
        }

        @Override
        public boolean dispatchKeyEventPreIme(KeyEvent event) {
            if (mHandlePreIme) {
                mWaitForReceiveInput.countDown();
            }
            return mHandlePreIme;
        }

        @Override
        public boolean dispatchTouchEvent(MotionEvent event) {
            mWaitForReceiveInput.countDown();
            return true;
        }

        @Override
        public boolean dispatchKeyEvent(KeyEvent event) {
            mWaitForReceiveInput.countDown();
            return true;
        }
    }

    private CountDownLatch showSoftKeyboard(View view) {
        final CountDownLatch waitForIme = new CountDownLatch(1);
        view.setOnApplyWindowInsetsListener((v, insets) -> {
            if (insets.isVisible(WindowInsets.Type.ime())) {
                waitForIme.countDown();
            }
            return insets;
        });

        assertTrue("Failed to request focus.", view.requestFocus());
        final InputMethodManager imm =
                mActivityRule.getActivity().getSystemService(InputMethodManager.class);
        imm.showSoftInput(view, InputMethodManager.SHOW_IMPLICIT);

        return waitForIme;
    }

    @Before
    public void setUp() {
        mInstrumentation = InstrumentationRegistry.getInstrumentation();
        final Activity activity = mActivityRule.getActivity();

        final CountDownLatch[] waitForIme = new CountDownLatch[1];
        mInstrumentation.runOnMainSync(() -> {
            mWindow = mActivityRule.getActivity().getWindow();

            if (mShowIme) {
                final EditText edit = new InstrumentedEditText(activity);
                mWindow.setContentView(edit);
                waitForIme[0] = showSoftKeyboard(edit);
            } else {
                final View v = new InstrumentedView(activity);
                // set FLAG_LOCAL_FOCUS_MODE to prevent delivering input events to the ime
                // in ImeInputStage.
                mWindow.addFlags(WindowManager.LayoutParams.FLAG_LOCAL_FOCUS_MODE);
                mWindow.setContentView(v);
                assertTrue("Failed to request focus.", v.requestFocus());
            }
        });
        if (waitForIme[0] != null) {
            try {
                assertTrue("Failed to show InputMethod.",
                        waitForIme[0].await(TIMEOUT_MS, TimeUnit.MILLISECONDS));
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
        mInstrumentation.waitForIdleSync();
    }

    private void injectInputEvent(InputEvent event) {
        mWaitForReceiveInput = new CountDownLatch(1);
        mInstrumentation.runOnMainSync(() -> mWindow.injectInputEvent(event));
        try {
            mWaitForReceiveInput.await(TIMEOUT_MS, TimeUnit.MILLISECONDS);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }

    @Test
    public void testKeyEvent() {
        BenchmarkState state = mPerfStatusReporter.getBenchmarkState();
        while (state.keepRunning()) {
            final KeyEvent eventDown =
                    new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_BACKSLASH);
            injectInputEvent(eventDown);

            state.pauseTiming();
            final KeyEvent eventUp =
                    new KeyEvent(KeyEvent.ACTION_UP, KeyEvent.KEYCODE_BACKSLASH);
            injectInputEvent(eventUp);
            state.resumeTiming();
        }
    }

    @Test
    public void testMotionEvent() {
        BenchmarkState state = mPerfStatusReporter.getBenchmarkState();
        final Rect contentFrame = new Rect();
        mInstrumentation.runOnMainSync(() ->
                mWindow.getDecorView().getBoundsOnScreen(contentFrame));
        final int x = contentFrame.centerX();
        final int y = contentFrame.centerY();
        final long eventTime = SystemClock.uptimeMillis();

        while (state.keepRunning()) {
            final MotionEvent eventDown = MotionEvent.obtain(eventTime, eventTime,
                    MotionEvent.ACTION_DOWN, x, y,
                    1.0f /* pressure */, 1.0f /* size */, 0 /* metaState */,
                    1.0f /* xPrecision */, 1.0f /* yPrecision */,
                    0 /* deviceId */, 0 /* edgeFlags */,
                    InputDevice.SOURCE_TOUCHSCREEN, DEFAULT_DISPLAY);
            injectInputEvent(eventDown);

            state.pauseTiming();
            final MotionEvent eventUp = MotionEvent.obtain(eventTime, eventTime,
                    MotionEvent.ACTION_UP, x, y,
                    1.0f /* pressure */, 1.0f /* size */, 0 /* metaState */,
                    1.0f /* xPrecision */, 1.0f /* yPrecision */,
                    0 /* deviceId */, 0 /* edgeFlags */,
                    InputDevice.SOURCE_TOUCHSCREEN, DEFAULT_DISPLAY);
            injectInputEvent(eventUp);
            state.resumeTiming();
        }
    }
}