| /* |
| * 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.widget.cts; |
| |
| import static android.view.ContentInfo.FLAG_CONVERT_TO_PLAIN_TEXT; |
| import static android.view.ContentInfo.SOURCE_AUTOFILL; |
| import static android.view.ContentInfo.SOURCE_CLIPBOARD; |
| import static android.view.ContentInfo.SOURCE_DRAG_AND_DROP; |
| import static android.view.ContentInfo.SOURCE_INPUT_METHOD; |
| import static android.view.ContentInfo.SOURCE_PROCESS_TEXT; |
| |
| import static com.google.common.truth.Truth.assertThat; |
| import static com.google.common.truth.Truth.assertWithMessage; |
| |
| import static org.mockito.ArgumentMatchers.any; |
| import static org.mockito.ArgumentMatchers.argThat; |
| import static org.mockito.ArgumentMatchers.eq; |
| import static org.mockito.Mockito.mock; |
| import static org.mockito.Mockito.times; |
| import static org.mockito.Mockito.verify; |
| import static org.mockito.Mockito.verifyNoMoreInteractions; |
| import static org.mockito.Mockito.when; |
| |
| import android.annotation.NonNull; |
| import android.annotation.Nullable; |
| import android.app.Activity; |
| import android.content.ClipData; |
| import android.content.ClipDescription; |
| import android.content.ClipboardManager; |
| import android.content.Intent; |
| import android.net.Uri; |
| import android.os.Build; |
| import android.os.Bundle; |
| import android.text.Editable; |
| import android.text.Selection; |
| import android.text.SpannableStringBuilder; |
| import android.text.Spanned; |
| import android.text.method.QwertyKeyListener; |
| import android.text.method.TextKeyListener.Capitalize; |
| import android.text.style.UnderlineSpan; |
| import android.view.ContentInfo; |
| import android.view.DragEvent; |
| import android.view.OnReceiveContentListener; |
| import android.view.View.MeasureSpec; |
| import android.view.autofill.AutofillValue; |
| import android.view.inputmethod.EditorInfo; |
| import android.view.inputmethod.InputConnection; |
| import android.view.inputmethod.InputContentInfo; |
| import android.widget.TextView; |
| import android.widget.TextView.BufferType; |
| import android.widget.TextViewOnReceiveContentListener; |
| |
| import androidx.test.annotation.UiThreadTest; |
| import androidx.test.filters.MediumTest; |
| import androidx.test.rule.ActivityTestRule; |
| import androidx.test.runner.AndroidJUnit4; |
| |
| import com.android.compatibility.common.util.WindowUtil; |
| |
| import org.junit.After; |
| import org.junit.Assert; |
| import org.junit.Before; |
| import org.junit.Rule; |
| import org.junit.Test; |
| import org.junit.runner.RunWith; |
| import org.mockito.ArgumentMatcher; |
| import org.mockito.Mockito; |
| |
| import java.util.Objects; |
| |
| /** |
| * Tests for {@link TextView#performReceiveContent} and related code. |
| */ |
| @MediumTest |
| @RunWith(AndroidJUnit4.class) |
| public class TextViewReceiveContentTest { |
| public static final Uri SAMPLE_CONTENT_URI = Uri.parse("content://com.example/path"); |
| @Rule |
| public ActivityTestRule<TextViewCtsActivity> mActivityRule = |
| new ActivityTestRule<>(TextViewCtsActivity.class); |
| |
| private Activity mActivity; |
| private TextView mTextView; |
| private OnReceiveContentListener mDefaultReceiver; |
| private OnReceiveContentListener mMockReceiver; |
| private ClipboardManager mClipboardManager; |
| |
| @Before |
| public void before() { |
| mActivity = mActivityRule.getActivity(); |
| WindowUtil.waitForFocus(mActivity); |
| mTextView = mActivity.findViewById(R.id.textview_text); |
| mDefaultReceiver = new TextViewOnReceiveContentListener(); |
| |
| mMockReceiver = Mockito.mock(OnReceiveContentListener.class); |
| when(mMockReceiver.onReceiveContent(any(), any())).thenReturn(null); |
| |
| mClipboardManager = mActivity.getSystemService(ClipboardManager.class); |
| mClipboardManager.clearPrimaryClip(); |
| |
| configureAppTargetSdkToS(); |
| } |
| |
| @After |
| public void after() { |
| resetTargetSdk(); |
| } |
| |
| // ============================================================================================ |
| // Tests to verify TextView APIs/accessors/defaults related to OnReceiveContentListener. |
| // ============================================================================================ |
| |
| @UiThreadTest |
| @Test |
| public void testTextView_onCreateInputConnection_nullEditorInfo() throws Exception { |
| initTextViewForEditing("xz", 1); |
| try { |
| mTextView.onCreateInputConnection(null); |
| Assert.fail("Expected exception"); |
| } catch (NullPointerException expected) { |
| } |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testTextView_onCreateInputConnection_noCustomReceiver() throws Exception { |
| initTextViewForEditing("xz", 1); |
| |
| // Call onCreateInputConnection() and assert that contentMimeTypes is not set when there is |
| // no custom receiver configured. |
| EditorInfo editorInfo = new EditorInfo(); |
| InputConnection ic = mTextView.onCreateInputConnection(editorInfo); |
| assertThat(ic).isNotNull(); |
| assertThat(editorInfo.contentMimeTypes).isNull(); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testTextView_onCreateInputConnection_customReceiver() throws Exception { |
| initTextViewForEditing("xz", 1); |
| |
| // Setup: Configure the receiver to a mock impl. |
| String[] receiverMimeTypes = new String[] {"text/plain", "image/png", "video/mp4"}; |
| mTextView.setOnReceiveContentListener(receiverMimeTypes, mMockReceiver); |
| |
| // Call onCreateInputConnection() and assert that contentMimeTypes is set from the receiver. |
| EditorInfo editorInfo = new EditorInfo(); |
| InputConnection ic = mTextView.onCreateInputConnection(editorInfo); |
| assertThat(ic).isNotNull(); |
| assertThat(editorInfo.contentMimeTypes).isEqualTo(receiverMimeTypes); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testTextView_onCreateInputConnection_customReceiver_oldTargetSdk() |
| throws Exception { |
| configureAppTargetSdkToR(); |
| initTextViewForEditing("xz", 1); |
| |
| // Setup: Configure the receiver to a mock impl. |
| String[] receiverMimeTypes = new String[] {"text/plain", "image/png", "video/mp4"}; |
| mTextView.setOnReceiveContentListener(receiverMimeTypes, mMockReceiver); |
| |
| // Call onCreateInputConnection() and assert that contentMimeTypes is set from the receiver. |
| EditorInfo editorInfo = new EditorInfo(); |
| InputConnection ic = mTextView.onCreateInputConnection(editorInfo); |
| assertThat(ic).isNotNull(); |
| assertThat(editorInfo.contentMimeTypes).isEqualTo(receiverMimeTypes); |
| } |
| |
| // ============================================================================================ |
| // Tests to verify the behavior of TextViewOnReceiveContentListener. |
| // ============================================================================================ |
| |
| @UiThreadTest |
| @Test |
| public void testDefaultReceiver_onReceive_text() throws Exception { |
| initTextViewForEditing("xz", 1); |
| |
| ClipData clip = ClipData.newPlainText("test", "y"); |
| onReceive(mDefaultReceiver, clip, SOURCE_CLIPBOARD, 0); |
| |
| assertTextAndCursorPosition("xyz", 2); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testDefaultReceiver_onReceive_styledText() throws Exception { |
| initTextViewForEditing("xz", 1); |
| |
| UnderlineSpan underlineSpan = new UnderlineSpan(); |
| SpannableStringBuilder ssb = new SpannableStringBuilder("hi world"); |
| ssb.setSpan(underlineSpan, 3, 7, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE); |
| ClipData clip = ClipData.newPlainText("test", ssb); |
| |
| onReceive(mDefaultReceiver, clip, SOURCE_CLIPBOARD, 0); |
| |
| assertTextAndCursorPosition("xhi worldz", 9); |
| int spanStart = mTextView.getEditableText().getSpanStart(underlineSpan); |
| assertThat(spanStart).isEqualTo(4); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testDefaultReceiver_onReceive_text_convertToPlainText() throws Exception { |
| initTextViewForEditing("xz", 1); |
| |
| ClipData clip = ClipData.newPlainText("test", "y"); |
| onReceive(mDefaultReceiver, clip, SOURCE_CLIPBOARD, FLAG_CONVERT_TO_PLAIN_TEXT); |
| |
| assertTextAndCursorPosition("xyz", 2); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testDefaultReceiver_onReceive_styledText_convertToPlainText() throws Exception { |
| initTextViewForEditing("xz", 1); |
| |
| UnderlineSpan underlineSpan = new UnderlineSpan(); |
| SpannableStringBuilder ssb = new SpannableStringBuilder("hi world"); |
| ssb.setSpan(underlineSpan, 3, 7, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE); |
| ClipData clip = ClipData.newPlainText("test", ssb); |
| |
| onReceive(mDefaultReceiver, clip, SOURCE_CLIPBOARD, FLAG_CONVERT_TO_PLAIN_TEXT); |
| |
| assertTextAndCursorPosition("xhi worldz", 9); |
| int spanStart = mTextView.getEditableText().getSpanStart(underlineSpan); |
| assertThat(spanStart).isEqualTo(-1); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testDefaultReceiver_onReceive_html() throws Exception { |
| initTextViewForEditing("xz", 1); |
| |
| ClipData clip = ClipData.newHtmlText("test", "*y*", "<b>y</b>"); |
| onReceive(mDefaultReceiver, clip, SOURCE_CLIPBOARD, 0); |
| |
| assertTextAndCursorPosition("xyz", 2); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testDefaultReceiver_onReceive_html_convertToPlainText() throws Exception { |
| initTextViewForEditing("xz", 1); |
| |
| ClipData clip = ClipData.newHtmlText("test", "*y*", "<b>y</b>"); |
| onReceive(mDefaultReceiver, clip, SOURCE_CLIPBOARD, FLAG_CONVERT_TO_PLAIN_TEXT); |
| |
| assertTextAndCursorPosition("x*y*z", 4); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testDefaultReceiver_onReceive_unsupportedMimeType() throws Exception { |
| initTextViewForEditing("xz", 1); |
| |
| ClipData clip = new ClipData("test", new String[]{"video/mp4"}, |
| new ClipData.Item("text", "html", null, SAMPLE_CONTENT_URI)); |
| onReceive(mDefaultReceiver, clip, SOURCE_CLIPBOARD, 0); |
| |
| assertTextAndCursorPosition("xhtmlz", 5); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testDefaultReceiver_onReceive_unsupportedMimeType_convertToPlainText() |
| throws Exception { |
| initTextViewForEditing("xz", 1); |
| |
| ClipData clip = new ClipData("test", new String[]{"video/mp4"}, |
| new ClipData.Item("text", "html", null, SAMPLE_CONTENT_URI)); |
| onReceive(mDefaultReceiver, clip, SOURCE_CLIPBOARD, |
| FLAG_CONVERT_TO_PLAIN_TEXT); |
| |
| assertTextAndCursorPosition("xtextz", 5); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testDefaultReceiver_onReceive_multipleItemsInClipData() throws Exception { |
| initTextViewForEditing("xz", 1); |
| |
| ClipData clip = ClipData.newPlainText("test", "ONE"); |
| clip.addItem(new ClipData.Item("TWO")); |
| clip.addItem(new ClipData.Item("THREE")); |
| |
| // Verify the resulting text when pasting a clip that contains multiple text items. |
| String expectedText = "xONE\nTWO\nTHREEz"; |
| onReceive(mDefaultReceiver, clip, SOURCE_CLIPBOARD, 0); |
| assertTextAndCursorPosition(expectedText, 14); |
| |
| // Verify the resulting text when inserting the same clip via drag-and-drop. The result |
| // should be the same as when pasting. |
| initTextViewForEditing("xz", 1); |
| onReceive(mDefaultReceiver, clip, SOURCE_DRAG_AND_DROP, 0); |
| assertTextAndCursorPosition(expectedText, 14); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testDefaultReceiver_onReceive_noSelectionPriorToPaste() throws Exception { |
| // Set the text and then clear the selection (ie, ensure that nothing is selected and |
| // that the cursor is not present). |
| initTextViewForEditing("xz", 0); |
| Selection.removeSelection(mTextView.getEditableText()); |
| assertTextAndCursorPosition("xz", -1); |
| |
| // Pasting should still work (should just insert the text at the beginning). |
| ClipData clip = ClipData.newPlainText("test", "y"); |
| onReceive(mDefaultReceiver, clip, SOURCE_CLIPBOARD, 0); |
| |
| assertTextAndCursorPosition("yxz", 1); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testDefaultReceiver_onReceive_selectionStartAndEndSwapped() throws Exception { |
| initTextViewForEditing("", 0); |
| |
| // Set the selection such that "end" is before "start". |
| mTextView.setText("hey", BufferType.EDITABLE); |
| Selection.setSelection(mTextView.getEditableText(), 3, 1); |
| assertTextAndSelection("hey", 3, 1); |
| |
| // Pasting should still work (should still successfully overwrite the selection). |
| ClipData clip = ClipData.newPlainText("test", "i"); |
| onReceive(mDefaultReceiver, clip, SOURCE_CLIPBOARD, 0); |
| |
| assertTextAndCursorPosition("hi", 2); |
| } |
| |
| // ============================================================================================ |
| // Tests to verify that the OnReceiveContentListener is invoked for all the appropriate user |
| // interactions: |
| // * Paste from clipboard ("Paste" and "Paste as plain text" actions) |
| // * Content insertion from IME |
| // * Drag and drop |
| // * Autofill |
| // * Process text (Intent.ACTION_PROCESS_TEXT) |
| // ============================================================================================ |
| |
| @UiThreadTest |
| @Test |
| public void testPaste_noCustomReceiver() throws Exception { |
| // Setup: Populate the text field. |
| initTextViewForEditing("xz", 1); |
| |
| // Setup: Copy text to the clipboard. |
| ClipData clip = ClipData.newPlainText("test", "y"); |
| copyToClipboard(clip); |
| |
| // Trigger the "Paste" action. This should execute the default receiver. |
| boolean result = triggerContextMenuAction(android.R.id.paste); |
| assertThat(result).isTrue(); |
| assertTextAndCursorPosition("xyz", 2); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testPaste_customReceiver() throws Exception { |
| // Setup: Populate the text field. |
| initTextViewForEditing("xz", 1); |
| |
| // Setup: Copy text to the clipboard. |
| ClipData clip = ClipData.newPlainText("test", "y"); |
| copyToClipboard(clip); |
| |
| // Setup: Configure the receiver to a mock impl. |
| String[] receiverMimeTypes = new String[] {"text/plain"}; |
| mTextView.setOnReceiveContentListener(receiverMimeTypes, mMockReceiver); |
| |
| // Trigger the "Paste" action and assert that the custom receiver was executed. |
| triggerContextMenuAction(android.R.id.paste); |
| verify(mMockReceiver, times(1)).onReceiveContent( |
| eq(mTextView), contentEq(clip, SOURCE_CLIPBOARD, 0)); |
| verifyNoMoreInteractions(mMockReceiver); |
| assertTextAndCursorPosition("xz", 1); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testPaste_customReceiver_unsupportedMimeType() throws Exception { |
| // Setup: Populate the text field. |
| initTextViewForEditing("xz", 1); |
| |
| // Setup: Copy a URI to the clipboard with a MIME type that's not supported by the receiver. |
| ClipData clip = new ClipData("test", new String[]{"video/mp4"}, |
| new ClipData.Item("y", null, SAMPLE_CONTENT_URI)); |
| copyToClipboard(clip); |
| |
| // Setup: Configure the receiver to a mock impl. |
| String[] receiverMimeTypes = new String[] {"text/plain", "video/avi"}; |
| mTextView.setOnReceiveContentListener(receiverMimeTypes, mMockReceiver); |
| |
| // Trigger the "Paste" action and assert that the custom receiver was executed. |
| triggerContextMenuAction(android.R.id.paste); |
| verify(mMockReceiver, times(1)).onReceiveContent( |
| eq(mTextView), contentEq(clip, SOURCE_CLIPBOARD, 0)); |
| verifyNoMoreInteractions(mMockReceiver); |
| assertTextAndCursorPosition("xz", 1); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testPasteAsPlainText_noCustomReceiver() throws Exception { |
| // Setup: Populate the text field. |
| initTextViewForEditing("xz", 1); |
| |
| // Setup: Copy HTML to the clipboard. |
| ClipData clip = ClipData.newHtmlText("test", "*y*", "<b>y</b>"); |
| copyToClipboard(clip); |
| |
| // Trigger the "Paste as plain text" action. This should execute the platform paste |
| // handling, so the content should be inserted according to whatever behavior is implemented |
| // in the OS version that's running. |
| boolean result = triggerContextMenuAction(android.R.id.pasteAsPlainText); |
| assertThat(result).isTrue(); |
| assertTextAndCursorPosition("x*y*z", 4); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testPasteAsPlainText_customReceiver() throws Exception { |
| // Setup: Populate the text field. |
| initTextViewForEditing("xz", 1); |
| |
| // Setup: Copy text to the clipboard. |
| ClipData clip = ClipData.newPlainText("test", "y"); |
| copyToClipboard(clip); |
| |
| // Setup: Configure the receiver to a mock impl. |
| String[] receiverMimeTypes = new String[] {"text/plain"}; |
| mTextView.setOnReceiveContentListener(receiverMimeTypes, mMockReceiver); |
| |
| // Trigger the "Paste as plain text" action and assert that the custom receiver was |
| // executed. |
| triggerContextMenuAction(android.R.id.pasteAsPlainText); |
| verify(mMockReceiver, times(1)).onReceiveContent( |
| eq(mTextView), |
| contentEq(clip, SOURCE_CLIPBOARD, FLAG_CONVERT_TO_PLAIN_TEXT)); |
| verifyNoMoreInteractions(mMockReceiver); |
| assertTextAndCursorPosition("xz", 1); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testImeCommitContent_noCustomReceiver() throws Exception { |
| initTextViewForEditing("xz", 1); |
| |
| // Trigger the IME's commitContent() call and assert its outcome. |
| boolean result = triggerImeCommitContent("image/png"); |
| assertThat(result).isFalse(); |
| assertTextAndCursorPosition("xz", 1); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testImeCommitContent_customReceiver() throws Exception { |
| initTextViewForEditing("xz", 1); |
| |
| // Setup: Configure the receiver to a mock impl. |
| String[] receiverMimeTypes = new String[] {"text/*", "image/*"}; |
| mTextView.setOnReceiveContentListener(receiverMimeTypes, mMockReceiver); |
| |
| // Trigger the IME's commitContent() call and assert that the custom receiver was executed. |
| triggerImeCommitContent("image/png"); |
| ClipData clip = ClipData.newRawUri("expected", SAMPLE_CONTENT_URI); |
| verify(mMockReceiver, times(1)).onReceiveContent( |
| eq(mTextView), contentEq(clip, SOURCE_INPUT_METHOD, 0)); |
| verifyNoMoreInteractions(mMockReceiver); |
| assertTextAndCursorPosition("xz", 1); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testImeCommitContent_customReceiver_unsupportedMimeType() throws Exception { |
| initTextViewForEditing("xz", 1); |
| |
| // Setup: Configure the receiver to a mock impl. |
| String[] receiverMimeTypes = new String[] {"text/*", "image/*"}; |
| mTextView.setOnReceiveContentListener(receiverMimeTypes, mMockReceiver); |
| |
| // Trigger the IME's commitContent() call and assert that the custom receiver was executed. |
| triggerImeCommitContent("video/mp4"); |
| ClipData clip = ClipData.newRawUri("expected", SAMPLE_CONTENT_URI); |
| verify(mMockReceiver, times(1)).onReceiveContent( |
| eq(mTextView), contentEq(clip, SOURCE_INPUT_METHOD, 0)); |
| verifyNoMoreInteractions(mMockReceiver); |
| assertTextAndCursorPosition("xz", 1); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testImeCommitContent_customReceiver_oldTargetSdk() throws Exception { |
| configureAppTargetSdkToR(); |
| initTextViewForEditing("xz", 1); |
| |
| // Setup: Configure the receiver to a mock impl. |
| String[] receiverMimeTypes = new String[] {"text/*", "image/*"}; |
| mTextView.setOnReceiveContentListener(receiverMimeTypes, mMockReceiver); |
| |
| // Trigger the IME's commitContent() call and assert that the custom receiver was executed. |
| triggerImeCommitContent("image/png"); |
| ClipData clip = ClipData.newRawUri("expected", SAMPLE_CONTENT_URI); |
| verify(mMockReceiver, times(1)).onReceiveContent( |
| eq(mTextView), contentEq(clip, SOURCE_INPUT_METHOD, 0)); |
| verifyNoMoreInteractions(mMockReceiver); |
| assertTextAndCursorPosition("xz", 1); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testImeCommitContent_linkUri() throws Exception { |
| initTextViewForEditing("xz", 1); |
| |
| // Setup: Configure the receiver to a mock impl. |
| String[] receiverMimeTypes = new String[] {"text/*", "image/*"}; |
| mTextView.setOnReceiveContentListener(receiverMimeTypes, mMockReceiver); |
| |
| // Trigger the IME's commitContent() call with a linkUri and assert receiver extras. |
| Uri sampleLinkUri = Uri.parse("http://example.com"); |
| triggerImeCommitContent("image/png", sampleLinkUri, null); |
| ClipData clip = ClipData.newRawUri("expected", SAMPLE_CONTENT_URI); |
| verify(mMockReceiver, times(1)).onReceiveContent( |
| eq(mTextView), |
| contentEq(clip, SOURCE_INPUT_METHOD, 0, sampleLinkUri, null)); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testImeCommitContent_opts() throws Exception { |
| initTextViewForEditing("xz", 1); |
| |
| // Setup: Configure the receiver to a mock impl. |
| String[] receiverMimeTypes = new String[] {"text/*", "image/*"}; |
| mTextView.setOnReceiveContentListener(receiverMimeTypes, mMockReceiver); |
| |
| // Trigger the IME's commitContent() call with opts and assert receiver extras. |
| String sampleOptValue = "sampleOptValue"; |
| triggerImeCommitContent("image/png", null, sampleOptValue); |
| ClipData clip = ClipData.newRawUri("expected", SAMPLE_CONTENT_URI); |
| verify(mMockReceiver, times(1)).onReceiveContent( |
| eq(mTextView), |
| contentEq(clip, SOURCE_INPUT_METHOD, 0, null, sampleOptValue)); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testImeCommitContent_linkUriAndOpts() throws Exception { |
| initTextViewForEditing("xz", 1); |
| |
| // Setup: Configure the receiver to a mock impl. |
| String[] receiverMimeTypes = new String[] {"text/*", "image/*"}; |
| mTextView.setOnReceiveContentListener(receiverMimeTypes, mMockReceiver); |
| |
| // Trigger the IME's commitContent() call with a linkUri & opts and assert receiver extras. |
| Uri sampleLinkUri = Uri.parse("http://example.com"); |
| String sampleOptValue = "sampleOptValue"; |
| triggerImeCommitContent("image/png", sampleLinkUri, sampleOptValue); |
| ClipData clip = ClipData.newRawUri("expected", SAMPLE_CONTENT_URI); |
| verify(mMockReceiver, times(1)).onReceiveContent( |
| eq(mTextView), |
| contentEq(clip, SOURCE_INPUT_METHOD, 0, sampleLinkUri, sampleOptValue)); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testDragAndDrop_noCustomReceiver() throws Exception { |
| initTextViewForEditing("xz", 2); |
| |
| // Trigger drop event. This should execute the default receiver. |
| ClipData clip = ClipData.newPlainText("test", "y"); |
| triggerDropEvent(clip); |
| assertTextAndCursorPosition("yxz", 1); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testDragAndDrop_customReceiver() throws Exception { |
| initTextViewForEditing("xz", 2); |
| String[] receiverMimeTypes = new String[] {"text/*"}; |
| mTextView.setOnReceiveContentListener(receiverMimeTypes, mMockReceiver); |
| |
| // Trigger drop event and assert that the custom receiver was executed. |
| ClipData clip = ClipData.newPlainText("test", "y"); |
| triggerDropEvent(clip); |
| verify(mMockReceiver, times(1)).onReceiveContent( |
| eq(mTextView), contentEq(clip, SOURCE_DRAG_AND_DROP, 0)); |
| verifyNoMoreInteractions(mMockReceiver); |
| // Note: The cursor is moved to the location of the drop before calling the receiver. |
| assertTextAndCursorPosition("xz", 0); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testDragAndDrop_customReceiver_nonEditableTextView() throws Exception { |
| // Initialize the view and assert preconditions. |
| mTextView.setText("Hello"); |
| assertTextAndSelection("Hello", -1, -1); |
| assertThat(mTextView.isTextSelectable()).isFalse(); |
| assertThat(mTextView.getText()).isNotInstanceOf(Editable.class); |
| |
| // Configure the listener. |
| String[] receiverMimeTypes = new String[] {"text/*"}; |
| mTextView.setOnReceiveContentListener(receiverMimeTypes, mMockReceiver); |
| |
| // Trigger drop event and assert that the custom receiver was executed. |
| ClipData clip = ClipData.newPlainText("test", "y"); |
| triggerDropEvent(clip); |
| verify(mMockReceiver, times(1)).onReceiveContent( |
| eq(mTextView), contentEq(clip, SOURCE_DRAG_AND_DROP, 0)); |
| verifyNoMoreInteractions(mMockReceiver); |
| // Note: The cursor/selection should not change since the view is not editable. |
| assertTextAndSelection("Hello", -1, -1); |
| } |
| |
| /** |
| * This test checks the edge case where a {@link TextView} starts as non-editable and becomes |
| * editable during dragging. The test simulates this scenario by setting up an editable |
| * {@link TextView}, clearing its focus and then injecting an |
| * {@link DragEvent#ACTION_DRAG_LOCATION} event without a prior |
| * {@link DragEvent#ACTION_DRAG_STARTED} or {@link DragEvent#ACTION_DRAG_ENTERED} event. |
| */ |
| @UiThreadTest |
| @Test |
| public void testDragAndDrop_nonEditableTextViewChangedToEditable_actionDragLocation() |
| throws Exception { |
| // Setup an editable TextView and assert that its insertion controller is enabled. |
| initTextViewForEditing("Test drag and drop", 4); |
| assertThat(mTextView.getEditorForTesting().getInsertionController()).isNotNull(); |
| |
| // Focus on another view and assert that the TextView we are going to test doesn't have |
| // focus (but still has its insertion controller enabled). |
| TextView anotherTextView = mActivity.findViewById(R.id.textview_singleLine); |
| anotherTextView.setTextIsSelectable(true); |
| anotherTextView.requestFocus(); |
| assertThat(mTextView.hasFocus()).isFalse(); |
| assertThat(mTextView.getEditorForTesting().getInsertionController()).isNotNull(); |
| |
| // Trigger an ACTION_DRAG_LOCATION event without any prior drag events. The TextView should |
| // still gracefully handle the event and update its cursor position for the event's |
| // location. |
| DragEvent dragEvent = createDragEvent(DragEvent.ACTION_DRAG_LOCATION, mTextView.getX(), |
| mTextView.getY(), null); |
| assertThat(mTextView.onDragEvent(dragEvent)).isTrue(); |
| assertTextAndCursorPosition("Test drag and drop", 0); |
| } |
| |
| /** |
| * This test checks the edge case where a {@link TextView} starts as non-editable and becomes |
| * editable during dragging. The test simulates this scenario by setting up an editable |
| * {@link TextView}, clearing its focus and then injecting an |
| * {@link DragEvent#ACTION_DROP} event without a prior |
| * {@link DragEvent#ACTION_DRAG_STARTED} or {@link DragEvent#ACTION_DRAG_ENTERED} or |
| * {@link DragEvent#ACTION_DRAG_LOCATION} event. |
| */ |
| @UiThreadTest |
| @Test |
| public void testDragAndDrop_nonEditableTextViewChangedToEditable_actionDrop() throws Exception { |
| // Setup an editable TextView and assert that its insertion controller is enabled. |
| initTextViewForEditing("Test drag and drop", 4); |
| assertThat(mTextView.getEditorForTesting().getInsertionController()).isNotNull(); |
| |
| // Focus on another view and assert that the TextView we are going to test doesn't have |
| // focus (but still has its insertion controller enabled). |
| TextView anotherTextView = mActivity.findViewById(R.id.textview_singleLine); |
| anotherTextView.setTextIsSelectable(true); |
| anotherTextView.requestFocus(); |
| assertThat(mTextView.hasFocus()).isFalse(); |
| assertThat(mTextView.getEditorForTesting().getInsertionController()).isNotNull(); |
| |
| // Trigger an ACTION_DROP event without any prior drag events. The TextView should still |
| // gracefully handle the event and accept the drop. |
| ClipData clip = ClipData.newPlainText("test", "Hi "); |
| DragEvent dragEvent = createDragEvent(DragEvent.ACTION_DROP, mTextView.getX(), |
| mTextView.getY(), clip); |
| assertThat(mTextView.onDragEvent(dragEvent)).isTrue(); |
| assertTextAndCursorPosition("Hi Test drag and drop", 3); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testDragAndDrop_customReceiver_unsupportedMimeType() throws Exception { |
| initTextViewForEditing("xz", 2); |
| String[] receiverMimeTypes = new String[] {"text/*"}; |
| mTextView.setOnReceiveContentListener(receiverMimeTypes, mMockReceiver); |
| |
| // Trigger drop event and assert that the custom receiver was executed. |
| ClipData clip = new ClipData("test", new String[]{"video/mp4"}, |
| new ClipData.Item("y", null, SAMPLE_CONTENT_URI)); |
| triggerDropEvent(clip); |
| verify(mMockReceiver, times(1)).onReceiveContent( |
| eq(mTextView), contentEq(clip, SOURCE_DRAG_AND_DROP, 0)); |
| verifyNoMoreInteractions(mMockReceiver); |
| // Note: The cursor is moved to the location of the drop before calling the receiver. |
| assertTextAndCursorPosition("xz", 0); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testAutofill_noCustomReceiver() throws Exception { |
| initTextViewForEditing("xz", 1); |
| |
| // Trigger autofill. This should execute the default receiver. |
| triggerAutofill("y"); |
| assertTextAndCursorPosition("y", 1); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testAutofill_customReceiver() throws Exception { |
| initTextViewForEditing("xz", 1); |
| String[] receiverMimeTypes = new String[] {"text/*"}; |
| mTextView.setOnReceiveContentListener(receiverMimeTypes, mMockReceiver); |
| |
| // Trigger autofill and assert that the custom receiver was executed. |
| triggerAutofill("y"); |
| ClipData clip = ClipData.newPlainText("", "y"); |
| verify(mMockReceiver, times(1)).onReceiveContent( |
| eq(mTextView), contentEq(clip, SOURCE_AUTOFILL, 0)); |
| verifyNoMoreInteractions(mMockReceiver); |
| assertTextAndCursorPosition("xz", 1); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testProcessText_noCustomReceiver() throws Exception { |
| initTextViewForEditing("Original text", 0); |
| Selection.setSelection(mTextView.getEditableText(), 0, mTextView.getText().length()); |
| |
| String newText = "Replacement text"; |
| triggerProcessTextOnActivityResult(newText); |
| assertTextAndCursorPosition(newText, newText.length()); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testProcessText_customReceiver() throws Exception { |
| String originalText = "Original text"; |
| initTextViewForEditing(originalText, 0); |
| Selection.setSelection(mTextView.getEditableText(), 0, originalText.length()); |
| assertTextAndSelection(originalText, 0, originalText.length()); |
| |
| String[] receiverMimeTypes = new String[] {"text/plain"}; |
| mTextView.setOnReceiveContentListener(receiverMimeTypes, mMockReceiver); |
| |
| String newText = "Replacement text"; |
| triggerProcessTextOnActivityResult(newText); |
| ClipData clip = ClipData.newPlainText("", newText); |
| verify(mMockReceiver, times(1)).onReceiveContent( |
| eq(mTextView), contentEq(clip, SOURCE_PROCESS_TEXT, 0)); |
| verifyNoMoreInteractions(mMockReceiver); |
| assertTextAndSelection(originalText, 0, originalText.length()); |
| } |
| |
| |
| private void initTextViewForEditing(final String text, final int cursorPosition) { |
| mTextView.setKeyListener(QwertyKeyListener.getInstance(false, Capitalize.NONE)); |
| mTextView.setTextIsSelectable(true); |
| mTextView.requestFocus(); |
| |
| SpannableStringBuilder ssb = new SpannableStringBuilder(text); |
| mTextView.setText(ssb, BufferType.EDITABLE); |
| mTextView.measure(MeasureSpec.UNSPECIFIED, MeasureSpec.UNSPECIFIED); |
| Selection.setSelection(mTextView.getEditableText(), cursorPosition); |
| |
| assertWithMessage("TextView should have focus").that(mTextView.hasFocus()).isTrue(); |
| assertTextAndCursorPosition(text, cursorPosition); |
| } |
| |
| private void assertTextAndCursorPosition(String expectedText, int cursorPosition) { |
| assertTextAndSelection(expectedText, cursorPosition, cursorPosition); |
| } |
| |
| private void assertTextAndSelection(String expectedText, int start, int end) { |
| assertThat(mTextView.getText().toString()).isEqualTo(expectedText); |
| int[] expected = new int[]{start, end}; |
| int[] actual = new int[]{mTextView.getSelectionStart(), mTextView.getSelectionEnd()}; |
| assertWithMessage("Unexpected selection start/end indexes") |
| .that(actual).isEqualTo(expected); |
| } |
| |
| private void onReceive(final OnReceiveContentListener receiver, |
| final ClipData clip, final int source, final int flags) { |
| ContentInfo payload = |
| new ContentInfo.Builder(clip, source) |
| .setFlags(flags) |
| .build(); |
| receiver.onReceiveContent(mTextView, payload); |
| } |
| |
| private void resetTargetSdk() { |
| mActivity.getApplicationInfo().targetSdkVersion = Build.VERSION_CODES.CUR_DEVELOPMENT; |
| } |
| |
| private void configureAppTargetSdkToR() { |
| mActivity.getApplicationInfo().targetSdkVersion = Build.VERSION_CODES.R; |
| } |
| |
| private void configureAppTargetSdkToS() { |
| mActivity.getApplicationInfo().targetSdkVersion = Build.VERSION_CODES.S; |
| } |
| |
| private void copyToClipboard(ClipData clip) { |
| mClipboardManager.setPrimaryClip(clip); |
| } |
| |
| private boolean triggerContextMenuAction(final int actionId) { |
| return mTextView.onTextContextMenuItem(actionId); |
| } |
| |
| private boolean triggerImeCommitContent(String mimeType) { |
| return triggerImeCommitContent(mimeType, null, null); |
| } |
| |
| private boolean triggerImeCommitContent(String mimeType, Uri linkUri, String extra) { |
| final InputContentInfo contentInfo = new InputContentInfo( |
| SAMPLE_CONTENT_URI, |
| new ClipDescription("from test", new String[]{mimeType}), |
| linkUri); |
| final Bundle opts; |
| if (extra == null) { |
| opts = null; |
| } else { |
| opts = new Bundle(); |
| opts.putString(ContentInfoArgumentMatcher.EXTRA_KEY, extra); |
| } |
| EditorInfo editorInfo = new EditorInfo(); |
| InputConnection ic = mTextView.onCreateInputConnection(editorInfo); |
| return ic.commitContent(contentInfo, 0, opts); |
| } |
| |
| private void triggerAutofill(CharSequence text) { |
| mTextView.autofill(AutofillValue.forText(text)); |
| } |
| |
| private boolean triggerDropEvent(ClipData clip) { |
| DragEvent dropEvent = createDragEvent(DragEvent.ACTION_DROP, mTextView.getX(), |
| mTextView.getY(), clip); |
| return mTextView.onDragEvent(dropEvent); |
| } |
| |
| private static DragEvent createDragEvent(int action, float x, float y, ClipData clip) { |
| DragEvent dragEvent = mock(DragEvent.class); |
| when(dragEvent.getAction()).thenReturn(action); |
| when(dragEvent.getX()).thenReturn(x); |
| when(dragEvent.getY()).thenReturn(y); |
| when(dragEvent.getClipData()).thenReturn(clip); |
| return dragEvent; |
| } |
| |
| private void triggerProcessTextOnActivityResult(CharSequence replacementText) { |
| Intent data = new Intent(); |
| data.putExtra(Intent.EXTRA_PROCESS_TEXT, replacementText); |
| mTextView.onActivityResult(TextView.PROCESS_TEXT_REQUEST_CODE, Activity.RESULT_OK, data); |
| } |
| |
| private static ContentInfo contentEq(@NonNull ClipData clip, int source, int flags) { |
| return argThat(new ContentInfoArgumentMatcher(clip, source, flags, null, null)); |
| } |
| |
| private static ContentInfo contentEq(@NonNull ClipData clip, int source, int flags, |
| Uri linkUri, String extra) { |
| return argThat(new ContentInfoArgumentMatcher(clip, source, flags, linkUri, extra)); |
| } |
| |
| private static class ContentInfoArgumentMatcher implements ArgumentMatcher<ContentInfo> { |
| public static final String EXTRA_KEY = "testExtra"; |
| |
| @NonNull private final ClipData mClip; |
| private final int mSource; |
| private final int mFlags; |
| @Nullable private final Uri mLinkUri; |
| @Nullable private final String mExtra; |
| |
| private ContentInfoArgumentMatcher(@NonNull ClipData clip, int source, int flags, |
| @Nullable Uri linkUri, @Nullable String extra) { |
| mClip = clip; |
| mSource = source; |
| mFlags = flags; |
| mLinkUri = linkUri; |
| mExtra = extra; |
| } |
| |
| @Override |
| public boolean matches(ContentInfo actual) { |
| ClipData.Item expectedItem = mClip.getItemAt(0); |
| ClipData.Item actualItem = actual.getClip().getItemAt(0); |
| return Objects.equals(expectedItem.getText(), actualItem.getText()) |
| && Objects.equals(expectedItem.getUri(), actualItem.getUri()) |
| && mSource == actual.getSource() |
| && mFlags == actual.getFlags() |
| && Objects.equals(mLinkUri, actual.getLinkUri()) |
| && extrasMatch(actual.getExtras()); |
| } |
| |
| private boolean extrasMatch(Bundle actualExtras) { |
| if (mExtra == null) { |
| return actualExtras == null; |
| } |
| String actualExtraValue = actualExtras.getString(EXTRA_KEY); |
| return Objects.equals(mExtra, actualExtraValue); |
| } |
| } |
| } |
