1 files changed, 38 insertions, 10 deletions

diff --git a/java/src/com/android/inputmethod/latin/Suggest.java b/java/src/com/android/inputmethod/latin/Suggest.java
index 3b898941f..4c9b7509a 100755..100644
--- a/java/src/com/android/inputmethod/latin/Suggest.java
+++ b/java/src/com/android/inputmethod/latin/Suggest.java
@@ -16,17 +16,17 @@
 
 package com.android.inputmethod.latin;
 
-import java.nio.ByteBuffer;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-
 import android.content.Context;
 import android.text.AutoText;
 import android.text.TextUtils;
 import android.util.Log;
 import android.view.View;
 
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
 /**
  * This class loads a dictionary and provides a list of suggestions for a given sequence of 
  * characters. This includes corrections and completions.
@@ -81,6 +81,7 @@ public class Suggest implements Dictionary.WordCallback {
 
     private boolean mAutoTextEnabled;
 
+    private double mAutoCompleteThreshold;
     private int[] mPriorities = new int[mPrefMaxSuggestions];
     private int[] mBigramPriorities = new int[PREF_MAX_BIGRAMS];
 
@@ -163,6 +164,10 @@ public class Suggest implements Dictionary.WordCallback {
         mUserBigramDictionary = userBigramDictionary;
     }
 
+    public void setAutoCompleteThreshold(double threshold) {
+        mAutoCompleteThreshold = threshold;
+    }
+
     /**
      * Number of suggestions to generate from the input key sequence. This has
      * to be a number between 1 and 100 (inclusive).
@@ -301,8 +306,14 @@ public class Suggest implements Dictionary.WordCallback {
             }
             mMainDict.getWords(wordComposer, this, mNextLettersFrequencies);
             if ((mCorrectionMode == CORRECTION_FULL || mCorrectionMode == CORRECTION_FULL_BIGRAM)
-                    && mSuggestions.size() > 0) {
-                mHaveCorrection = true;
+                    && mSuggestions.size() > 0 && mPriorities.length > 0) {
+                // TODO: when the normalized score of the first suggestion is nearly equals to
+                //       the normalized score of the second suggestion, behave less aggressive.
+                final double normalizedScore = LatinIMEUtil.calcNormalizedScore(
+                        mOriginalWord, mSuggestions.get(0), mPriorities[0]);
+                if (normalizedScore >= mAutoCompleteThreshold) {
+                    mHaveCorrection = true;
+                }
             }
         }
         if (mOriginalWord != null) {
@@ -326,8 +337,25 @@ public class Suggest implements Dictionary.WordCallback {
                 String suggestedWord = mSuggestions.get(i).toString().toLowerCase();
                 CharSequence autoText =
                         AutoText.get(suggestedWord, 0, suggestedWord.length(), view);
-                // Is there an AutoText correction?
+                // Is there an AutoText (also known as Quick Fixes) correction?
                 boolean canAdd = autoText != null;
+                // Capitalize as needed
+                final int autoTextLength = autoText != null ? autoText.length() : 0;
+                if (autoTextLength > 0 && (mIsAllUpperCase || mIsFirstCharCapitalized)) {
+                    int poolSize = mStringPool.size();
+                    StringBuilder sb = poolSize > 0 ? (StringBuilder) mStringPool.remove(
+                            poolSize - 1) : new StringBuilder(getApproxMaxWordLength());
+                    sb.setLength(0);
+                    if (mIsAllUpperCase) {
+                        sb.append(autoText.toString().toUpperCase());
+                    } else if (mIsFirstCharCapitalized) {
+                        sb.append(Character.toUpperCase(autoText.charAt(0)));
+                        if (autoTextLength > 1) {
+                            sb.append(autoText.subSequence(1, autoTextLength));
+                        }
+                    }
+                    autoText = sb.toString();
+                }
                 // Is that correction already the current prediction (or original word)?
                 canAdd &= !TextUtils.equals(autoText, mSuggestions.get(i));
                 // Is that correction already the next predicted word?
@@ -395,6 +423,7 @@ public class Suggest implements Dictionary.WordCallback {
         return false;
     }
 
+    @Override
     public boolean addWord(final char[] word, final int offset, final int length, int freq,
             final int dicTypeId, final Dictionary.DataType dataType) {
         Dictionary.DataType dataTypeForLog = dataType;
@@ -450,8 +479,7 @@ public class Suggest implements Dictionary.WordCallback {
             return true;
         }
 
-        System.arraycopy(priorities, pos, priorities, pos + 1,
-                prefMaxSuggestions - pos - 1);
+        System.arraycopy(priorities, pos, priorities, pos + 1, prefMaxSuggestions - pos - 1);
         priorities[pos] = freq;
         int poolSize = mStringPool.size();
         StringBuilder sb = poolSize > 0 ? (StringBuilder) mStringPool.remove(poolSize - 1)