Separate caps mode related utils to CapsModeUtils (ce6bcdd1) · Commits · e / os / android_packages_inputmethods_LatinIME

java/src/com/android/inputmethod/latin/CapsModeUtils.java

0 → 100644

+266 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2013 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.inputmethod.latin;

		import android.text.InputType;
		import android.text.TextUtils;

		import java.util.Locale;

		public final class CapsModeUtils {
		private CapsModeUtils() {
		// This utility class is not publicly instantiable.
		}

		/**
		* Apply an auto-caps mode to a string.
		*
		* This intentionally does NOT apply manual caps mode. It only changes the capitalization if
		* the mode is one of the auto-caps modes.
		* @param s The string to capitalize.
		* @param capitalizeMode The mode in which to capitalize.
		* @param locale The locale for capitalizing.
		* @return The capitalized string.
		*/
		public static String applyAutoCapsMode(final String s, final int capitalizeMode,
		final Locale locale) {
		if (WordComposer.CAPS_MODE_AUTO_SHIFT_LOCKED == capitalizeMode) {
		return s.toUpperCase(locale);
		} else if (WordComposer.CAPS_MODE_AUTO_SHIFTED == capitalizeMode) {
		return StringUtils.toTitleCase(s, locale);
		} else {
		return s;
		}
		}

		/**
		* Return whether a constant represents an auto-caps mode (either auto-shift or auto-shift-lock)
		* @param mode The mode to test for
		* @return true if this represents an auto-caps mode, false otherwise
		*/
		public static boolean isAutoCapsMode(final int mode) {
		return WordComposer.CAPS_MODE_AUTO_SHIFTED == mode
		\|\| WordComposer.CAPS_MODE_AUTO_SHIFT_LOCKED == mode;
		}

		/**
		* Determine what caps mode should be in effect at the current offset in
		* the text. Only the mode bits set in <var>reqModes</var> will be
		* checked. Note that the caps mode flags here are explicitly defined
		* to match those in {@link InputType}.
		*
		* This code is a straight copy of TextUtils.getCapsMode (modulo namespace and formatting
		* issues). This will change in the future as we simplify the code for our use and fix bugs.
		*
		* @param cs The text that should be checked for caps modes.
		* @param reqModes The modes to be checked: may be any combination of
		* {@link TextUtils#CAP_MODE_CHARACTERS}, {@link TextUtils#CAP_MODE_WORDS}, and
		* {@link TextUtils#CAP_MODE_SENTENCES}.
		* @param locale The locale to consider for capitalization rules
		* @param hasSpaceBefore Whether we should consider there is a space inserted at the end of cs
		*
		* @return Returns the actual capitalization modes that can be in effect
		* at the current position, which is any combination of
		* {@link TextUtils#CAP_MODE_CHARACTERS}, {@link TextUtils#CAP_MODE_WORDS}, and
		* {@link TextUtils#CAP_MODE_SENTENCES}.
		*/
		public static int getCapsMode(final CharSequence cs, final int reqModes, final Locale locale,
		final boolean hasSpaceBefore) {
		// Quick description of what we want to do:
		// CAP_MODE_CHARACTERS is always on.
		// CAP_MODE_WORDS is on if there is some whitespace before the cursor.
		// CAP_MODE_SENTENCES is on if there is some whitespace before the cursor, and the end
		// of a sentence just before that.
		// We ignore opening parentheses and the like just before the cursor for purposes of
		// finding whitespace for WORDS and SENTENCES modes.
		// The end of a sentence ends with a period, question mark or exclamation mark. If it's
		// a period, it also needs not to be an abbreviation, which means it also needs to either
		// be immediately preceded by punctuation, or by a string of only letters with single
		// periods interleaved.

		// Step 1 : check for cap MODE_CHARACTERS. If it's looked for, it's always on.
		if ((reqModes & (TextUtils.CAP_MODE_WORDS \| TextUtils.CAP_MODE_SENTENCES)) == 0) {
		// Here we are not looking for MODE_WORDS or MODE_SENTENCES, so since we already
		// evaluated MODE_CHARACTERS, we can return.
		return TextUtils.CAP_MODE_CHARACTERS & reqModes;
		}

		// Step 2 : Skip (ignore at the end of input) any opening punctuation. This includes
		// opening parentheses, brackets, opening quotes, everything that opens a span of
		// text in the linguistic sense. In RTL languages, this is still an opening sign, although
		// it may look like a right parenthesis for example. We also include double quote and
		// single quote since they aren't start punctuation in the unicode sense, but should still
		// be skipped for English. TODO: does this depend on the language?
		int i;
		if (hasSpaceBefore) {
		i = cs.length() + 1;
		} else {
		for (i = cs.length(); i > 0; i--) {
		final char c = cs.charAt(i - 1);
		if (c != Constants.CODE_DOUBLE_QUOTE && c != Constants.CODE_SINGLE_QUOTE
		&& Character.getType(c) != Character.START_PUNCTUATION) {
		break;
		}
		}
		}

		// We are now on the character that precedes any starting punctuation, so in the most
		// frequent case this will be whitespace or a letter, although it may occasionally be a
		// start of line, or some symbol.

		// Step 3 : Search for the start of a paragraph. From the starting point computed in step 2,
		// we go back over any space or tab char sitting there. We find the start of a paragraph
		// if the first char that's not a space or tab is a start of line (as in \n, start of text,
		// or some other similar characters).
		int j = i;
		char prevChar = Constants.CODE_SPACE;
		if (hasSpaceBefore) --j;
		while (j > 0) {
		prevChar = cs.charAt(j - 1);
		if (!Character.isSpaceChar(prevChar) && prevChar != Constants.CODE_TAB) break;
		j--;
		}
		if (j <= 0 \|\| Character.isWhitespace(prevChar)) {
		// There are only spacing chars between the start of the paragraph and the cursor,
		// defined as a isWhitespace() char that is neither a isSpaceChar() nor a tab. Both
		// MODE_WORDS and MODE_SENTENCES should be active.
		return (TextUtils.CAP_MODE_CHARACTERS \| TextUtils.CAP_MODE_WORDS
		\| TextUtils.CAP_MODE_SENTENCES) & reqModes;
		}
		if (i == j) {
		// If we don't have whitespace before index i, it means neither MODE_WORDS
		// nor mode sentences should be on so we can return right away.
		return TextUtils.CAP_MODE_CHARACTERS & reqModes;
		}
		if ((reqModes & TextUtils.CAP_MODE_SENTENCES) == 0) {
		// Here we know we have whitespace before the cursor (if not, we returned in the above
		// if i == j clause), so we need MODE_WORDS to be on. And we don't need to evaluate
		// MODE_SENTENCES so we can return right away.
		return (TextUtils.CAP_MODE_CHARACTERS \| TextUtils.CAP_MODE_WORDS) & reqModes;
		}
		// Please note that because of the reqModes & CAP_MODE_SENTENCES test a few lines above,
		// we know that MODE_SENTENCES is being requested.

		// Step 4 : Search for MODE_SENTENCES.
		// English is a special case in that "American typography" rules, which are the most common
		// in English, state that a sentence terminator immediately following a quotation mark
		// should be swapped with it and de-duplicated (included in the quotation mark),
		// e.g. <<Did he say, "let's go home?">>
		// No other language has such a rule as far as I know, instead putting inside the quotation
		// mark as the exact thing quoted and handling the surrounding punctuation independently,
		// e.g. <<Did he say, "let's go home"?>>
		// Hence, specifically for English, we treat this special case here.
		if (Locale.ENGLISH.getLanguage().equals(locale.getLanguage())) {
		for (; j > 0; j--) {
		// Here we look to go over any closing punctuation. This is because in dominant
		// variants of English, the final period is placed within double quotes and maybe
		// other closing punctuation signs. This is generally not true in other languages.
		final char c = cs.charAt(j - 1);
		if (c != Constants.CODE_DOUBLE_QUOTE && c != Constants.CODE_SINGLE_QUOTE
		&& Character.getType(c) != Character.END_PUNCTUATION) {
		break;
		}
		}
		}

		if (j <= 0) return TextUtils.CAP_MODE_CHARACTERS & reqModes;
		char c = cs.charAt(--j);

		// We found the next interesting chunk of text ; next we need to determine if it's the
		// end of a sentence. If we have a question mark or an exclamation mark, it's the end of
		// a sentence. If it's neither, the only remaining case is the period so we get the opposite
		// case out of the way.
		if (c == Constants.CODE_QUESTION_MARK \|\| c == Constants.CODE_EXCLAMATION_MARK) {
		return (TextUtils.CAP_MODE_CHARACTERS \| TextUtils.CAP_MODE_SENTENCES) & reqModes;
		}
		if (c != Constants.CODE_PERIOD \|\| j <= 0) {
		return (TextUtils.CAP_MODE_CHARACTERS \| TextUtils.CAP_MODE_WORDS) & reqModes;
		}

		// We found out that we have a period. We need to determine if this is a full stop or
		// otherwise sentence-ending period, or an abbreviation like "e.g.". An abbreviation
		// looks like (\w\.){2,}
		// To find out, we will have a simple state machine with the following states :
		// START, WORD, PERIOD, ABBREVIATION
		// On START : (just before the first period)
		// letter => WORD
		// whitespace => end with no caps (it was a stand-alone period)
		// otherwise => end with caps (several periods/symbols in a row)
		// On WORD : (within the word just before the first period)
		// letter => WORD
		// period => PERIOD
		// otherwise => end with caps (it was a word with a full stop at the end)
		// On PERIOD : (period within a potential abbreviation)
		// letter => LETTER
		// otherwise => end with caps (it was not an abbreviation)
		// On LETTER : (letter within a potential abbreviation)
		// letter => LETTER
		// period => PERIOD
		// otherwise => end with no caps (it was an abbreviation)
		// "Not an abbreviation" in the above chart essentially covers cases like "...yes.". This
		// should capitalize.

		final int START = 0;
		final int WORD = 1;
		final int PERIOD = 2;
		final int LETTER = 3;
		final int caps = (TextUtils.CAP_MODE_CHARACTERS \| TextUtils.CAP_MODE_WORDS
		\| TextUtils.CAP_MODE_SENTENCES) & reqModes;
		final int noCaps = (TextUtils.CAP_MODE_CHARACTERS \| TextUtils.CAP_MODE_WORDS) & reqModes;
		int state = START;
		while (j > 0) {
		c = cs.charAt(--j);
		switch (state) {
		case START:
		if (Character.isLetter(c)) {
		state = WORD;
		} else if (Character.isWhitespace(c)) {
		return noCaps;
		} else {
		return caps;
		}
		break;
		case WORD:
		if (Character.isLetter(c)) {
		state = WORD;
		} else if (c == Constants.CODE_PERIOD) {
		state = PERIOD;
		} else {
		return caps;
		}
		break;
		case PERIOD:
		if (Character.isLetter(c)) {
		state = LETTER;
		} else {
		return caps;
		}
		break;
		case LETTER:
		if (Character.isLetter(c)) {
		state = LETTER;
		} else if (c == Constants.CODE_PERIOD) {
		state = PERIOD;
		} else {
		return noCaps;
		}
		}
		}
		// Here we arrived at the start of the line. This should behave exactly like whitespace.
		return (START == state \|\| LETTER == state) ? noCaps : caps;
		}
		}

java/src/com/android/inputmethod/latin/LatinIME.java

+1 −1

Original line number	Diff line number	Diff line
		@@ -1228,7 +1228,7 @@ public final class LatinIME extends InputMethodService implements KeyboardAction
		return;
		}
		final String wordToEdit;
		if (StringUtils.isAutoCapsMode(mLastComposedWord.mCapitalizedMode)) {
		if (CapsModeUtils.isAutoCapsMode(mLastComposedWord.mCapitalizedMode)) {
		wordToEdit = word.toLowerCase(mSubtypeSwitcher.getCurrentSubtypeLocale());
		} else {
		wordToEdit = word;

java/src/com/android/inputmethod/latin/PositionalInfoForUserDictPendingAddition.java

+1 −1

Original line number	Diff line number	Diff line
		@@ -96,7 +96,7 @@ public final class PositionalInfoForUserDictPendingAddition {
		if (currentCursorPosition != mCursorPos) return true;
		// We have made all the checks : do the replacement and report success
		// If this was auto-capitalized, we need to restore the case before committing
		final String wordWithCaseFixed = StringUtils.applyAutoCapsMode(mActualWordBeingAdded,
		final String wordWithCaseFixed = CapsModeUtils.applyAutoCapsMode(mActualWordBeingAdded,
		mCapitalizedMode, locale);
		connection.setComposingRegion(currentCursorPosition - mOriginalWord.length(),
		currentCursorPosition);

java/src/com/android/inputmethod/latin/RichInputConnection.java

+1 −1

Original line number	Diff line number	Diff line
		@@ -221,7 +221,7 @@ public final class RichInputConnection {
		}
		// This never calls InputConnection#getCapsMode - in fact, it's a static method that
		// never blocks or initiates IPC.
		return StringUtils.getCapsMode(mCommittedTextBeforeComposingText, inputType, locale,
		return CapsModeUtils.getCapsMode(mCommittedTextBeforeComposingText, inputType, locale,
		hasSpaceBefore);
		}

java/src/com/android/inputmethod/latin/StringUtils.java

+0 −239

File changed.

Preview size limit exceeded, changes collapsed.