Added support for asian characters in text selection. (87380bca) · Commits · e / os / android_frameworks_base

core/java/android/widget/TextView.java

+8 −8

Original line number	Diff line number	Diff line
		@@ -7639,6 +7639,7 @@ public class TextView extends View implements ViewTreeObserver.OnPreDrawListener
		type == Character.LOWERCASE_LETTER \|\|
		type == Character.TITLECASE_LETTER \|\|
		type == Character.MODIFIER_LETTER \|\|
		type == Character.OTHER_LETTER \|\| // Should handle asian characters
		type == Character.DECIMAL_DIGIT_NUMBER);
		}

		@@ -7647,15 +7648,15 @@ public class TextView extends View implements ViewTreeObserver.OnPreDrawListener
		*
		* @param offset An offset in the text.
		* @return The offsets for the start and end of the word located at <code>offset</code>.
		* The two ints offsets are packed in a long, with the starting offset shifted by 32 bits.
		* Returns a negative value if no valid word was found.
		* The two ints offsets are packed in a long using {@link #packRangeInLong(int, int)}.
		* Returns -1 if no valid word was found.
		*/
		private long getWordLimitsAt(int offset) {
		int klass = mInputType & InputType.TYPE_MASK_CLASS;
		int variation = mInputType & InputType.TYPE_MASK_VARIATION;

		// Text selection is not permitted in password fields
		if (isPasswordInputType(mInputType) \|\| isVisiblePasswordInputType(mInputType)) {
		if (hasPasswordTransformationMethod()) {
		return -1;
		}

		@@ -7739,17 +7740,16 @@ public class TextView extends View implements ViewTreeObserver.OnPreDrawListener
		}

		if (hasPasswordTransformationMethod()) {
		// selectCurrentWord is not available on a password field and would return an
		// arbitrary 10-charater selection around pressed position. Select all instead.
		// Always select all on a password field.
		// Cut/copy menu entries are not available for passwords, but being able to select all
		// is however useful to delete or paste to replace the entire content.
		selectAll();
		return;
		}

		long lastTouchOffset = getLastTouchOffsets();
		final int minOffset = extractRangeStartFromLong(lastTouchOffset);
		final int maxOffset = extractRangeEndFromLong(lastTouchOffset);
		long lastTouchOffsets = getLastTouchOffsets();
		final int minOffset = extractRangeStartFromLong(lastTouchOffsets);
		final int maxOffset = extractRangeEndFromLong(lastTouchOffsets);

		int selectionStart, selectionEnd;

core/tests/coretests/src/android/widget/TextViewWordLimitsTest.java

0 → 100644

+276 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2010 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;

		import android.test.AndroidTestCase;
		import android.test.suitebuilder.annotation.LargeTest;
		import android.text.InputType;
		import android.text.Selection;
		import android.text.Spannable;
		import android.text.SpannableString;

		import java.lang.reflect.Field;
		import java.lang.reflect.InvocationTargetException;
		import java.lang.reflect.Method;

		/**
		* TextViewPatchTest tests {@link TextView}'s definition of word. Finds and
		* verifies word limits to be in strings containing different kinds of
		* characters.
		*/
		public class TextViewWordLimitsTest extends AndroidTestCase {

		TextView mTv = null;
		Method mGetWordLimits, mSelectCurrentWord;
		Field mContextMenuTriggeredByKey, mSelectionControllerEnabled;


		/**
		* Sets up common fields used in all test cases.
		* @throws NoSuchFieldException
		* @throws SecurityException
		*/
		@Override
		protected void setUp() throws NoSuchMethodException, SecurityException, NoSuchFieldException {
		mTv = new TextView(getContext());
		mTv.setInputType(InputType.TYPE_CLASS_TEXT);

		mGetWordLimits = mTv.getClass().getDeclaredMethod("getWordLimitsAt",
		new Class[] {int.class});
		mGetWordLimits.setAccessible(true);

		mSelectCurrentWord = mTv.getClass().getDeclaredMethod("selectCurrentWord", new Class[] {});
		mSelectCurrentWord.setAccessible(true);

		mContextMenuTriggeredByKey = mTv.getClass().getDeclaredField("mContextMenuTriggeredByKey");
		mContextMenuTriggeredByKey.setAccessible(true);
		mSelectionControllerEnabled = mTv.getClass().getDeclaredField("mSelectionControllerEnabled");
		mSelectionControllerEnabled.setAccessible(true);
		}

		/**
		* Calculate and verify word limits. Depends on the TextView implementation.
		* Uses a private method and internal data representation.
		*
		* @param text Text to select a word from
		* @param pos Position to expand word around
		* @param correctStart Correct start position for the word
		* @param correctEnd Correct end position for the word
		* @throws InvocationTargetException
		* @throws IllegalAccessException
		* @throws IllegalArgumentException
		* @throws InvocationTargetException
		* @throws IllegalAccessException
		*/
		private void verifyWordLimits(String text, int pos, int correctStart, int correctEnd)
		throws IllegalArgumentException, IllegalAccessException, InvocationTargetException {
		mTv.setText(text, TextView.BufferType.SPANNABLE);

		long limits = (Long)mGetWordLimits.invoke(mTv, new Object[] {new Integer(pos)});
		int actualStart = (int)(limits >>> 32);
		int actualEnd = (int)(limits & 0x00000000FFFFFFFFL);
		assertEquals(correctStart, actualStart);
		assertEquals(correctEnd, actualEnd);
		}


		private void verifySelectCurrentWord(Spannable text, int selectionStart, int selectionEnd, int correctStart,
		int correctEnd) throws InvocationTargetException, IllegalAccessException {
		mTv.setText(text, TextView.BufferType.SPANNABLE);

		Selection.setSelection((Spannable)mTv.getText(), selectionStart, selectionEnd);
		mContextMenuTriggeredByKey.setBoolean(mTv, true);
		mSelectionControllerEnabled.setBoolean(mTv, true);
		mSelectCurrentWord.invoke(mTv);

		assertEquals(correctStart, mTv.getSelectionStart());
		assertEquals(correctEnd, mTv.getSelectionEnd());
		}


		/**
		* Corner cases for string length.
		*/
		@LargeTest
		public void testLengths() throws Exception {
		final String ONE_TWO = "one two";
		final String EMPTY = "";
		final String TOOLONG = "ThisWordIsTooLongToBeDefinedAsAWordInTheSenseUsedInTextView";

		// Select first word
		verifyWordLimits(ONE_TWO, 0, 0, 3);
		verifyWordLimits(ONE_TWO, 3, 0, 3);

		// Select last word
		verifyWordLimits(ONE_TWO, 4, 4, 7);
		verifyWordLimits(ONE_TWO, 7, 4, 7);

		// Empty string
		verifyWordLimits(EMPTY, 0, -1, -1);

		// Too long word
		verifyWordLimits(TOOLONG, 0, -1, -1);
		}

		/**
		* Unicode classes included.
		*/
		@LargeTest
		public void testIncludedClasses() throws Exception {
		final String LOWER = "njlj";
		final String UPPER = "NJLJ";
		final String TITLECASE = "\u01C8\u01CB\u01F2"; // Lj Nj Dz
		final String OTHER = "\u3042\u3044\u3046"; // Hiragana AIU
		final String MODIFIER = "\u02C6\u02CA\u02CB"; // Circumflex Acute Grave

		// Each string contains a single valid word
		verifyWordLimits(LOWER, 1, 0, 4);
		verifyWordLimits(UPPER, 1, 0, 4);
		verifyWordLimits(TITLECASE, 1, 0, 3);
		verifyWordLimits(OTHER, 1, 0, 3);
		verifyWordLimits(MODIFIER, 1, 0, 3);
		}

		/**
		* Unicode classes included if combined with a letter.
		*/
		@LargeTest
		public void testPartlyIncluded() throws Exception {
		final String NUMBER = "123";
		final String NUMBER_LOWER = "1st";
		final String APOSTROPHE = "''";
		final String APOSTROPHE_LOWER = "'Android's'";

		// Pure decimal number is ignored
		verifyWordLimits(NUMBER, 1, -1, -1);

		// Number with letter is valid
		verifyWordLimits(NUMBER_LOWER, 1, 0, 3);

		// Stand apostrophes are ignore
		verifyWordLimits(APOSTROPHE, 1, -1, -1);

		// Apostrophes are accepted if they are a part of a word
		verifyWordLimits(APOSTROPHE_LOWER, 1, 0, 11);
		}

		/**
		* Unicode classes included if combined with a letter.
		*/
		@LargeTest
		public void testFinalSeparator() throws Exception {
		final String PUNCTUATION = "abc, def.";

		// Starting from the comma
		verifyWordLimits(PUNCTUATION, 3, 0, 3);
		verifyWordLimits(PUNCTUATION, 4, 0, 4);

		// Starting from the final period
		verifyWordLimits(PUNCTUATION, 8, 5, 8);
		verifyWordLimits(PUNCTUATION, 9, 5, 9);
		}

		/**
		* Unicode classes other than listed in testIncludedClasses and
		* testPartlyIncluded act as word separators.
		*/
		@LargeTest
		public void testNotIncluded() throws Exception {
		// Selection of character classes excluded
		final String MARK_NONSPACING = "a\u030A"; // a Combining ring above
		final String PUNCTUATION_OPEN_CLOSE = "(c)"; // Parenthesis
		final String PUNCTUATION_DASH = "non-fiction"; // Hyphen
		final String PUNCTUATION_OTHER = "b&b"; // Ampersand
		final String SYMBOL_OTHER = "Android\u00AE"; // Registered
		final String SEPARATOR_SPACE = "one two"; // Space

		// "a"
		verifyWordLimits(MARK_NONSPACING, 1, 0, 1);

		// "c"
		verifyWordLimits(PUNCTUATION_OPEN_CLOSE, 1, 1, 2);

		// "non-"
		verifyWordLimits(PUNCTUATION_DASH, 3, 0, 3);
		verifyWordLimits(PUNCTUATION_DASH, 4, 4, 11);

		// "b"
		verifyWordLimits(PUNCTUATION_OTHER, 0, 0, 1);
		verifyWordLimits(PUNCTUATION_OTHER, 1, 0, 1);
		verifyWordLimits(PUNCTUATION_OTHER, 2, 0, 3); // & is considered a punctuation sign.
		verifyWordLimits(PUNCTUATION_OTHER, 3, 2, 3);

		// "Android"
		verifyWordLimits(SYMBOL_OTHER, 7, 0, 7);
		verifyWordLimits(SYMBOL_OTHER, 8, -1, -1);

		// "one"
		verifyWordLimits(SEPARATOR_SPACE, 1, 0, 3);
		}

		/**
		* Surrogate characters are treated as their code points.
		*/
		@LargeTest
		public void testSurrogate() throws Exception {
		final String SURROGATE_LETTER = "\uD800\uDC00\uD800\uDC01\uD800\uDC02"; // Linear B AEI
		final String SURROGATE_SYMBOL = "\uD83D\uDE01\uD83D\uDE02\uD83D\uDE03"; // Three smileys

		// Letter Other is included even when coded as surrogate pairs
		verifyWordLimits(SURROGATE_LETTER, 1, -1, -1);
		verifyWordLimits(SURROGATE_LETTER, 2, -1, -1);

		// Not included classes are ignored even when coded as surrogate pairs
		verifyWordLimits(SURROGATE_SYMBOL, 1, -1, -1);
		verifyWordLimits(SURROGATE_SYMBOL, 2, -1, -1);
		}

		/**
		* Selection is used if present and valid word.
		*/
		@LargeTest
		public void testSelectCurrentWord() throws Exception {
		SpannableString textLower = new SpannableString("first second");
		SpannableString textOther = new SpannableString("\u3042\3044\3046"); // Hiragana AIU
		SpannableString textDash = new SpannableString("non-fiction"); // Hyphen
		SpannableString textPunctOther = new SpannableString("b&b"); // Ampersand
		SpannableString textSymbolOther = new SpannableString("Android\u00AE"); // Registered

		// Valid selection - Letter, Lower
		verifySelectCurrentWord(textLower, 2, 5, 0, 5);

		// Adding the space spreads to the second word
		verifySelectCurrentWord(textLower, 2, 6, 0, 12);

		// Valid selection -- Letter, Other
		verifySelectCurrentWord(textOther, 1, 2, 0, 5);

		// Zero-width selection is interpreted as a cursor and the selection is ignored
		verifySelectCurrentWord(textLower, 2, 2, 0, 5);

		// Hyphen is part of selection
		verifySelectCurrentWord(textDash, 2, 5, 0, 11);

		// Ampersand part of selection or not
		verifySelectCurrentWord(textPunctOther, 1, 2, 0, 3);
		verifySelectCurrentWord(textPunctOther, 1, 3, 0, 3);

		// (R) part of the selection
		verifySelectCurrentWord(textSymbolOther, 2, 7, 0, 7);
		verifySelectCurrentWord(textSymbolOther, 2, 8, 0, 8);
		}
		}