Introduce Mock IME for device-side test
This CL introduces a mock IME, with which we can fully control how
the IME behaves during tests. This mock IME also allows us to write
expectation rules regarding when and in which order the IME is
receiving related callbacks from the system.
At high level, you can use Mock IME via MockImeSession class.
It takes care of lifecycle of the Mock IME including clean up tasks.
try(MockImeSession imeSession = MockImeSession.create(
InstrumentationRegistry.getContext(),
InstrumentationRegistry.getInstrumentation()
.getUiAutomation()) {
// Mock IME is enabled and selected here.
}
// Mock IME is de-selected and disabled here.
To use Mock IME, you have to include Mock IME into your test APK as
follows:
<service
android:name="com.android.cts.mockime.MockIme"
android:label="Mock IME"
android:permission="android.permission.BIND_INPUT_METHOD"
android:process=":mockime">
<intent-filter>
<action android:name="android.view.InputMethod" />
</intent-filter>
<meta-data
android:name="android.view.im"
android:resource="@xml/method" />
</service>
Once our build system supports building *.aar, then we can simply
link to Mock IME aar and let manifest merger to do the above task,
but for each test APK that uses Mock IME needs to write the above
configuration with XML resource for IME.
Note that this CL only adds the mock IME build target and lets
CtsInputMethodTestCases.apk to include that mock IME within its APK.
Other than that, there should be no behavior change as far as CTS
tests are concerned.
Bug: 69845539
Test: atest CtsInputMethodTestCases
Change-Id: I2dedbad5d6276ec5bd20b0f31b05825b0c4a28d9
diff --git a/tests/inputmethod/Android.mk b/tests/inputmethod/Android.mk
index 0c1ed5f..979ad78 100644
--- a/tests/inputmethod/Android.mk
+++ b/tests/inputmethod/Android.mk
@@ -31,7 +31,8 @@
LOCAL_STATIC_JAVA_LIBRARIES := \
android-support-test \
compatibility-device-util \
- ctstestrunner
+ ctstestrunner \
+ CtsMockInputMethod
LOCAL_SRC_FILES := $(call all-java-files-under, src)
diff --git a/tests/inputmethod/AndroidManifest.xml b/tests/inputmethod/AndroidManifest.xml
index 11f008d..b490469 100644
--- a/tests/inputmethod/AndroidManifest.xml
+++ b/tests/inputmethod/AndroidManifest.xml
@@ -34,6 +34,24 @@
</intent-filter>
</activity>
+ <!-- In order to test typical use cases, let this MockIME run in a separate process -->
+ <!--
+ TODO: Move this sevice definition into MockIME package and let the build system to merge
+ manifests once soong supports to build aar package.
+ -->
+ <service
+ android:name="com.android.cts.mockime.MockIme"
+ android:label="Mock IME"
+ android:permission="android.permission.BIND_INPUT_METHOD"
+ android:process=":mockime">
+ <intent-filter>
+ <action android:name="android.view.InputMethod" />
+ </intent-filter>
+ <meta-data
+ android:name="android.view.im"
+ android:resource="@xml/method" />
+ </service>
+
</application>
<instrumentation
diff --git a/tests/inputmethod/AndroidTest.xml b/tests/inputmethod/AndroidTest.xml
index b696a52..b0711fe 100644
--- a/tests/inputmethod/AndroidTest.xml
+++ b/tests/inputmethod/AndroidTest.xml
@@ -19,6 +19,12 @@
<option name="config-descriptor:metadata" key="component" value="framework" />
<target_preparer class="com.android.tradefed.targetprep.suite.SuiteApkInstaller">
<option name="cleanup-apks" value="true" />
+ <!--
+ TODO(yukawa): come up with a proper way to take care of devices that do not support
+ installable IMEs. Ideally target_preparer should have an option to annotate required
+ features, e.g. android.software.input_methods so that we can conditionally install APKs
+ based on the feature supported in the target device.
+ -->
<option name="test-file-name" value="CtsInputMethodTestCases.apk" />
</target_preparer>
<test class="com.android.tradefed.testtype.AndroidJUnitTest" >
diff --git a/tests/inputmethod/mockime/Android.mk b/tests/inputmethod/mockime/Android.mk
new file mode 100644
index 0000000..10f80a6
--- /dev/null
+++ b/tests/inputmethod/mockime/Android.mk
@@ -0,0 +1,33 @@
+# 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.
+
+LOCAL_PATH:= $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := CtsMockInputMethod
+LOCAL_MODULE_TAGS := tests
+
+LOCAL_SDK_VERSION := current
+
+# tag this module as a cts test artifact
+LOCAL_COMPATIBILITY_SUITE := cts vts general-tests
+
+LOCAL_SRC_FILES := $(call all-java-files-under, src)
+LOCAL_JAVA_LIBRARIES := junit
+LOCAL_STATIC_JAVA_LIBRARIES := \
+ android-support-annotations \
+ compatibility-device-util
+
+include $(BUILD_STATIC_JAVA_LIBRARY)
diff --git a/tests/inputmethod/mockime/src/com/android/cts/mockime/ImeEvent.java b/tests/inputmethod/mockime/src/com/android/cts/mockime/ImeEvent.java
new file mode 100644
index 0000000..a37421b
--- /dev/null
+++ b/tests/inputmethod/mockime/src/com/android/cts/mockime/ImeEvent.java
@@ -0,0 +1,72 @@
+/*
+ * 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 com.android.cts.mockime;
+
+import android.os.Bundle;
+import android.support.annotation.NonNull;
+
+/**
+ * An immutable object that stores event happened in the {@link MockIme}.
+ */
+public final class ImeEvent {
+
+ ImeEvent(@NonNull String eventName, @NonNull Bundle arguments) {
+ mEventName = eventName;
+ mArguments = arguments;
+ }
+
+ @NonNull
+ final Bundle toBundle() {
+ final Bundle bundle = new Bundle();
+ bundle.putString("mEventName", mEventName);
+ bundle.putBundle("mArguments", mArguments);
+ return bundle;
+ }
+
+ @NonNull
+ static ImeEvent fromBundle(@NonNull Bundle bundle) {
+ final String eventName = bundle.getString("mEventName");
+ final Bundle arguments = bundle.getBundle("mArguments");
+ return new ImeEvent(eventName, arguments);
+ }
+
+ /**
+ * Returns a string that represents the type of this event.
+ *
+ * <p>Examples: "onCreate", "onStartInput", ...</p>
+ *
+ * <p>TODO: Use enum type or something like that instead of raw String type.</p>
+ * @return A string that represents the type of this event.
+ */
+ @NonNull
+ public String getEventName() {
+ return mEventName;
+ }
+
+ /**
+ * @return {@link Bundle} that stores parameters passed to the corresponding event handler.
+ */
+ @NonNull
+ public Bundle getArguments() {
+ return mArguments;
+ }
+
+ @NonNull
+ private final String mEventName;
+ @NonNull
+ private final Bundle mArguments;
+}
diff --git a/tests/inputmethod/mockime/src/com/android/cts/mockime/ImeSettings.java b/tests/inputmethod/mockime/src/com/android/cts/mockime/ImeSettings.java
new file mode 100644
index 0000000..67b6544
--- /dev/null
+++ b/tests/inputmethod/mockime/src/com/android/cts/mockime/ImeSettings.java
@@ -0,0 +1,43 @@
+/*
+ * 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 com.android.cts.mockime;
+
+import android.os.Parcel;
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+
+/**
+ * An immutable data store to control the behavior of {@link MockIme}.
+ */
+public class ImeSettings {
+
+ @NonNull
+ private final String mEventCallbackActionName;
+
+ ImeSettings(@NonNull Parcel parcel) {
+ mEventCallbackActionName = parcel.readString();
+ }
+
+ @Nullable
+ String getEventCallbackActionName() {
+ return mEventCallbackActionName;
+ }
+
+ static void writeToParcel(@NonNull Parcel parcel, @NonNull String eventCallbackActionName) {
+ parcel.writeString(eventCallbackActionName);
+ }
+}
diff --git a/tests/inputmethod/mockime/src/com/android/cts/mockime/MockIme.java b/tests/inputmethod/mockime/src/com/android/cts/mockime/MockIme.java
new file mode 100644
index 0000000..2b9728f
--- /dev/null
+++ b/tests/inputmethod/mockime/src/com/android/cts/mockime/MockIme.java
@@ -0,0 +1,207 @@
+/*
+ * 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 com.android.cts.mockime;
+
+import static com.android.cts.mockime.MockImeSession.MOCK_IME_SETTINGS_FILE;
+
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.inputmethodservice.InputMethodService;
+import android.os.Bundle;
+import android.os.Parcel;
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+import android.util.Log;
+import android.util.TypedValue;
+import android.view.Gravity;
+import android.view.View;
+import android.widget.LinearLayout;
+import android.widget.RelativeLayout;
+import android.widget.TextView;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.Supplier;
+
+/**
+ * Mock IME for end-to-end tests.
+ */
+public final class MockIme extends InputMethodService {
+
+ private static final String TAG = "MockIme";
+
+ static ComponentName getComponentName(@NonNull String packageName) {
+ return new ComponentName(packageName, MockIme.class.getName());
+ }
+
+ static String getImeId(@NonNull String packageName) {
+ return new ComponentName(packageName, MockIme.class.getName()).flattenToShortString();
+ }
+
+ @Nullable
+ private ImeSettings mSettings;
+
+ private final AtomicReference<String> mImeEventActionName = new AtomicReference<>();
+
+ @Nullable
+ String getImeEventActionName() {
+ return mImeEventActionName.get();
+ }
+
+ @Nullable
+ private ImeSettings readSettings() {
+ try (InputStream is = openFileInput(MOCK_IME_SETTINGS_FILE)) {
+ Parcel parcel = null;
+ try {
+ parcel = Parcel.obtain();
+ final byte[] buffer = new byte[4096];
+ while (true) {
+ final int numRead = is.read(buffer);
+ if (numRead <= 0) {
+ break;
+ }
+ parcel.unmarshall(buffer, 0, numRead);
+ }
+ parcel.setDataPosition(0);
+ return new ImeSettings(parcel);
+ } finally {
+ if (parcel != null) {
+ parcel.recycle();
+ }
+ }
+ } catch (IOException e) {
+ }
+ return null;
+ }
+
+ @Override
+ public void onCreate() {
+ getTracer().onCreate(() -> {
+ super.onCreate();
+ mSettings = readSettings();
+ if (mSettings == null) {
+ throw new IllegalStateException("Settings file is not found. "
+ + "Make sure MockImeSession.create() is used to launch Mock IME.");
+ }
+ mImeEventActionName.set(mSettings.getEventCallbackActionName());
+ });
+ }
+
+ private static final class KeyboardLayoutView extends LinearLayout {
+
+ public KeyboardLayoutView(Context context) {
+ super(context);
+
+ setOrientation(VERTICAL);
+
+ setBackgroundColor(getResources().getColor(android.R.color.holo_orange_dark, null));
+
+ {
+ final RelativeLayout layout = new RelativeLayout(getContext());
+ final TextView textView = new TextView(getContext());
+ final RelativeLayout.LayoutParams params = new RelativeLayout.LayoutParams(
+ RelativeLayout.LayoutParams.MATCH_PARENT,
+ RelativeLayout.LayoutParams.WRAP_CONTENT);
+ params.addRule(RelativeLayout.CENTER_IN_PARENT, RelativeLayout.TRUE);
+ textView.setLayoutParams(params);
+ textView.setTextSize(TypedValue.COMPLEX_UNIT_SP, 20);
+ textView.setGravity(Gravity.CENTER);
+ textView.setText(getImeId(getContext().getPackageName()));
+ layout.addView(textView);
+ addView(layout, LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT);
+ }
+ }
+ }
+
+ @Override
+ public View onCreateInputView() {
+ return getTracer().onCreateInputView(() -> new KeyboardLayoutView(this));
+ }
+
+ private final ThreadLocal<Tracer> mThreadLocalTracer = new ThreadLocal<>();
+
+ private Tracer getTracer() {
+ Tracer tracer = mThreadLocalTracer.get();
+ if (tracer == null) {
+ tracer = new Tracer(this);
+ mThreadLocalTracer.set(tracer);
+ }
+ return tracer;
+ }
+
+ /**
+ * Event tracing helper class for {@link MockIme}.
+ */
+ private static final class Tracer {
+
+ @NonNull
+ private final MockIme mIme;
+
+ private String mImeEventActionName;
+
+ public Tracer(@NonNull MockIme mockIme) {
+ mIme = mockIme;
+ }
+
+ private void sendEventInternal(@NonNull ImeEvent event) {
+ final Intent intent = new Intent();
+ intent.setPackage(mIme.getPackageName());
+ if (mImeEventActionName == null) {
+ mImeEventActionName = mIme.getImeEventActionName();
+ }
+ if (mImeEventActionName == null) {
+ Log.e(TAG, "Tracer cannot be used before onCreate()");
+ return;
+ }
+ intent.setAction(mImeEventActionName);
+ intent.putExtras(event.toBundle());
+ mIme.sendBroadcast(intent);
+ }
+
+ private void recordEventInternal(@NonNull String eventName, @NonNull Runnable runnable) {
+ recordEventInternal(eventName, runnable, new Bundle());
+ }
+
+ private void recordEventInternal(@NonNull String eventName, @NonNull Runnable runnable,
+ @NonNull Bundle arguments) {
+ runnable.run();
+ sendEventInternal(new ImeEvent(eventName, arguments));
+ }
+
+ private <T> T recordEventInternal(@NonNull String eventName,
+ @NonNull Supplier<T> supplier) {
+ return recordEventInternal(eventName, supplier, new Bundle());
+ }
+
+ private <T> T recordEventInternal(@NonNull String eventName,
+ @NonNull Supplier<T> supplier, @NonNull Bundle arguments) {
+ final T result = supplier.get();
+ sendEventInternal(new ImeEvent(eventName, arguments));
+ return result;
+ }
+
+ public void onCreate(@NonNull Runnable runnable) {
+ recordEventInternal("onCreate", runnable);
+ }
+
+ public View onCreateInputView(@NonNull Supplier<View> supplier) {
+ return recordEventInternal("onCreateInputView", supplier);
+ }
+ }
+}
diff --git a/tests/inputmethod/mockime/src/com/android/cts/mockime/MockImeSession.java b/tests/inputmethod/mockime/src/com/android/cts/mockime/MockImeSession.java
new file mode 100644
index 0000000..81f458b
--- /dev/null
+++ b/tests/inputmethod/mockime/src/com/android/cts/mockime/MockImeSession.java
@@ -0,0 +1,224 @@
+/*
+ * 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 com.android.cts.mockime;
+
+import static android.content.Context.MODE_PRIVATE;
+import static android.content.pm.PackageManager.COMPONENT_ENABLED_STATE_DISABLED;
+import static android.content.pm.PackageManager.COMPONENT_ENABLED_STATE_ENABLED;
+import static android.content.pm.PackageManager.DONT_KILL_APP;
+
+import android.app.UiAutomation;
+import android.content.BroadcastReceiver;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.os.Handler;
+import android.os.HandlerThread;
+import android.os.Parcel;
+import android.os.ParcelFileDescriptor;
+import android.os.SystemClock;
+import android.provider.Settings;
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+import android.text.TextUtils;
+import android.view.inputmethod.InputMethodManager;
+
+import com.android.compatibility.common.util.PollingCheck;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Represents an active Mock IME session, which provides basic primitives to write end-to-end tests
+ * for IME APIs.
+ *
+ * <p>To use {@link MockIme} via {@link MockImeSession}, you need to </p>
+ * <p>Public methods are not thread-safe.</p>
+ */
+public class MockImeSession implements AutoCloseable {
+ private final String mImeEventActionName =
+ "com.android.cts.mockime.action.IME_EVENT." + SystemClock.elapsedRealtimeNanos();
+
+ /** Setting file name to store initialization settings for {@link MockIme}. */
+ static final String MOCK_IME_SETTINGS_FILE = "mockimesettings.data";
+
+ private static final long TIMEOUT = TimeUnit.SECONDS.toMillis(10);
+
+ @NonNull
+ private final Context mContext;
+
+ private final HandlerThread mHandlerThread = new HandlerThread("EventReceiver");
+
+ private static final class MockImeEventReceiver extends BroadcastReceiver {
+ @NonNull
+ private final ArrayList<ImeEvent> mCurrentEventStore = new ArrayList<>();
+
+ @NonNull
+ private final String mActionName;
+
+ public MockImeEventReceiver(@NonNull String actionName) {
+ mActionName = actionName;
+ }
+
+ @Override
+ public void onReceive(Context context, Intent intent) {
+ if (TextUtils.equals(mActionName, intent.getAction())) {
+ mCurrentEventStore.add(ImeEvent.fromBundle(intent.getExtras()));
+ }
+ }
+ }
+ private final MockImeEventReceiver mEventReceiver =
+ new MockImeEventReceiver(mImeEventActionName);
+
+ private static String executeShellCommand(
+ @NonNull UiAutomation uiAutomation, @NonNull String command) {
+ try (ParcelFileDescriptor.AutoCloseInputStream in =
+ new ParcelFileDescriptor.AutoCloseInputStream(
+ uiAutomation.executeShellCommand(command))) {
+ try (BufferedReader br =
+ new BufferedReader(new InputStreamReader(in, StandardCharsets.UTF_8))) {
+ final String line = br.readLine();
+ return line != null ? line.trim() : "";
+ }
+ } catch (IOException e) {
+ return "";
+ }
+ }
+
+ @Nullable
+ private String getCurrentInputMethodId() {
+ // TODO: Replace this with IMM#getCurrentInputMethodIdForTesting()
+ return Settings.Secure.getString(mContext.getContentResolver(),
+ Settings.Secure.DEFAULT_INPUT_METHOD);
+ }
+
+ @Nullable
+ private static void writeMockImeSettings(@NonNull Context context,
+ @NonNull String imeEventActionName) throws Exception {
+ context.deleteFile(MOCK_IME_SETTINGS_FILE);
+ try (OutputStream os = context.openFileOutput(MOCK_IME_SETTINGS_FILE, MODE_PRIVATE)) {
+ Parcel parcel = null;
+ try {
+ parcel = Parcel.obtain();
+ ImeSettings.writeToParcel(parcel, imeEventActionName);
+ os.write(parcel.marshall());
+ } finally {
+ if (parcel != null) {
+ parcel.recycle();
+ }
+ }
+ os.flush();
+ }
+ }
+
+ private ComponentName getMockImeComponentName() {
+ return MockIme.getComponentName(mContext.getPackageName());
+ }
+
+ private String getMockImeId() {
+ return MockIme.getImeId(mContext.getPackageName());
+ }
+
+ private MockImeSession(Context context) {
+ mContext = context;
+ }
+
+ private void initialize(@NonNull UiAutomation uiAutomation) throws Exception {
+ // Make sure that MockIME is not selected.
+ mContext.getPackageManager().setComponentEnabledSetting(getMockImeComponentName(),
+ COMPONENT_ENABLED_STATE_DISABLED, DONT_KILL_APP);
+
+ PollingCheck.check("Make sure that MockIME becomes unavailable", TIMEOUT, () ->
+ mContext.getSystemService(InputMethodManager.class)
+ .getInputMethodList()
+ .stream()
+ .noneMatch(info -> getMockImeComponentName().equals(info.getComponent())));
+
+ writeMockImeSettings(mContext, mImeEventActionName);
+
+ mHandlerThread.start();
+ mContext.registerReceiver(mEventReceiver,
+ new IntentFilter(mImeEventActionName), null /* broadcastPermission */,
+ new Handler(mHandlerThread.getLooper()));
+
+ // Enable MockIME
+ mContext.getPackageManager().setComponentEnabledSetting(
+ getMockImeComponentName(), COMPONENT_ENABLED_STATE_ENABLED, DONT_KILL_APP);
+
+ PollingCheck.check("Wait until the Mock IME is recognized by the IMMS again",
+ TIMEOUT,
+ () -> mContext.getSystemService(InputMethodManager.class)
+ .getInputMethodList()
+ .stream()
+ .anyMatch(info -> getMockImeComponentName().equals(info.getComponent())));
+
+ executeShellCommand(uiAutomation, "ime enable " + getMockImeId());
+ executeShellCommand(uiAutomation, "ime set " + getMockImeId());
+
+ PollingCheck.check("Make sure that MockIME becomes available", TIMEOUT,
+ () -> getMockImeId().equals(getCurrentInputMethodId()));
+ }
+
+ /**
+ * Creates a new Mock IME session. During this session, you can receive various events from
+ * {@link MockIme}.
+ *
+ * @param context {@link Context} to be used to receive inter-process events from the
+ * {@link MockIme} (e.g. via {@link BroadcastReceiver}
+ * @param uiAutomation {@link UiAutomation} object to change the device state that are typically
+ * guarded by permissions.
+ * @return A session object, with which you can retrieve event logs from the {@link MockIme} and
+ * can clean up the session.
+ */
+ @NonNull
+ public static MockImeSession create(
+ @NonNull Context context,
+ @NonNull UiAutomation uiAutomation) throws Exception {
+ final MockImeSession client = new MockImeSession(context);
+ client.initialize(uiAutomation);
+ return client;
+ }
+
+ /**
+ * Closes the active session and de-selects {@link MockIme}. Currently which IME will be
+ * selected next is up to the system.
+ */
+ public void close() throws Exception {
+ final ComponentName mockImeComponent = MockIme.getComponentName(mContext.getPackageName());
+
+ // Kill Mock IME process
+ // TODO: Add a new Test API to make which IME will be selected next deterministic.
+ mContext.getPackageManager().setComponentEnabledSetting(
+ mockImeComponent, COMPONENT_ENABLED_STATE_DISABLED, DONT_KILL_APP);
+
+ PollingCheck.check("Make sure that MockIME becomes unavailable", TIMEOUT, () ->
+ mContext.getSystemService(InputMethodManager.class)
+ .getInputMethodList()
+ .stream()
+ .noneMatch(info -> getMockImeComponentName().equals(info.getComponent())));
+
+ mContext.unregisterReceiver(mEventReceiver);
+ mHandlerThread.quitSafely();
+ mContext.deleteFile(MOCK_IME_SETTINGS_FILE);
+ }
+}
diff --git a/tests/inputmethod/res/xml/method.xml b/tests/inputmethod/res/xml/method.xml
new file mode 100644
index 0000000..2266fba
--- /dev/null
+++ b/tests/inputmethod/res/xml/method.xml
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+ 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.
+-->
+
+<input-method xmlns:android="http://schemas.android.com/apk/res/android">
+</input-method>