[CM1] Let predictions be aware of capitalize mode.

Bug: 15554503
Change-Id: If5e8c0d94ed26d929400ccbb0d45ac23dd98d180

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

@@ -1376,18 +1376,8 @@ public class LatinIME extends InputMethodService implements KeyboardActionListen
             callback.onGetSuggestedWords(SuggestedWords.EMPTY);
             return;
         }
-        final SettingsValues currentSettings = mSettings.getCurrent();
-        final int[] additionalFeaturesOptions = currentSettings.mAdditionalFeaturesSettingValues;
-        mInputLogic.mSuggest.getSuggestedWords(mInputLogic.mWordComposer,
-                mInputLogic.getPrevWordsInfoFromNthPreviousWordForSuggestion(
-                        currentSettings.mSpacingAndPunctuations,
-                        // Get the word on which we should search the bigrams. If we are composing
-                        // a word, it's whatever is *before* the half-committed word in the buffer,
-                        // hence 2; if we aren't, we should just skip whitespace if any, so 1.
-                        mInputLogic.mWordComposer.isComposingWord() ? 2 : 1),
-                keyboard.getProximityInfo(), currentSettings.mBlockPotentiallyOffensive,
-                currentSettings.mAutoCorrectionEnabled, additionalFeaturesOptions, sessionId,
-                sequenceNumber, callback);
+        mInputLogic.getSuggestedWords(mSettings.getCurrent(), keyboard.getProximityInfo(),
+                mKeyboardSwitcher.getKeyboardShiftMode(), sessionId, sequenceNumber, callback);
     }
 
     @Override

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

@@ -110,7 +110,8 @@ public final class Suggest {
                 wordComposer, prevWordsInfo, proximityInfo, blockOffensiveWords,
                 additionalFeaturesOptions, SESSION_TYPING, rawSuggestions);
 
-        final boolean isOnlyFirstCharCapitalized = wordComposer.isOnlyFirstCharCapitalized();
+        final boolean isOnlyFirstCharCapitalized =
+                wordComposer.isOrWillBeOnlyFirstCharCapitalized();
         // If resumed, then we don't want to upcase everything: resuming on a fully-capitalized
         // words is rarely done to switch to another fully-capitalized word, but usually to a
         // normal, non-capitalized suggestion.

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

@@ -310,12 +310,18 @@ public final class WordComposer {
     }
 
     /**
-     * Whether or not the user typed a capital letter as the first letter in the word, and no
-     * other letter is capitalized
+     * Whether this composer is composing or about to compose a word in which only the first letter
+     * is a capital.
+     *
+     * If we do have a composing word, we just return whether the word has indeed only its first
+     * character capitalized. If we don't, then we return a value based on the capitalized mode,
+     * which tell us what is likely to happen for the next composing word.
+     *
      * @return capitalization preference
      */
-    public boolean isOnlyFirstCharCapitalized() {
-        return mIsOnlyFirstCharCapitalized;
+    public boolean isOrWillBeOnlyFirstCharCapitalized() {
+        return isComposingWord() ? mIsOnlyFirstCharCapitalized
+                : (CAPS_MODE_OFF != mCapitalizedMode);
     }
 
     /**
@@ -365,6 +371,20 @@ public final class WordComposer {
         mCapitalizedMode = mode;
     }
 
+    /**
+     * Before fetching suggestions, we don't necessarily know about the capitalized mode yet.
+     *
+     * If we don't have a composing word yet, we take a note of this mode so that we can then
+     * supply this information to the suggestion process. If we have a composing word, then
+     * the previous mode has priority over this.
+     * @param mode the mode just before fetching suggestions
+     */
+    public void adviseCapitalizedModeBeforeFetchingSuggestions(final int mode) {
+        if (!isComposingWord()) {
+            mCapitalizedMode = mode;
+        }
+    }
+
     /**
      * Returns whether the word was automatically capitalized.
      * @return whether the word was automatically capitalized

java/src/com/android/inputmethod/latin/inputlogic/InputLogic.java

@@ -30,6 +30,7 @@ import com.android.inputmethod.compat.SuggestionSpanUtils;
 import com.android.inputmethod.event.Event;
 import com.android.inputmethod.event.InputTransaction;
 import com.android.inputmethod.keyboard.KeyboardSwitcher;
+import com.android.inputmethod.keyboard.ProximityInfo;
 import com.android.inputmethod.latin.Constants;
 import com.android.inputmethod.latin.Dictionary;
 import com.android.inputmethod.latin.DictionaryFacilitator;
@@ -1917,4 +1918,22 @@ public final class InputLogic {
         }
         return true;
     }
+
+    public void getSuggestedWords(final SettingsValues settingsValues,
+            final ProximityInfo proximityInfo, final int keyboardShiftMode, final int sessionId,
+            final int sequenceNumber, final OnGetSuggestedWordsCallback callback) {
+        mWordComposer.adviseCapitalizedModeBeforeFetchingSuggestions(
+                getActualCapsMode(settingsValues, keyboardShiftMode));
+        mSuggest.getSuggestedWords(mWordComposer,
+                getPrevWordsInfoFromNthPreviousWordForSuggestion(
+                        settingsValues.mSpacingAndPunctuations,
+                        // Get the word on which we should search the bigrams. If we are composing
+                        // a word, it's whatever is *before* the half-committed word in the buffer,
+                        // hence 2; if we aren't, we should just skip whitespace if any, so 1.
+                        mWordComposer.isComposingWord() ? 2 : 1),
+                proximityInfo, settingsValues.mBlockPotentiallyOffensive,
+                settingsValues.mAutoCorrectionEnabled,
+                settingsValues.mAdditionalFeaturesSettingValues,
+                sessionId, sequenceNumber, callback);
+    }
 }