diff options
Diffstat (limited to 'src')
9 files changed, 365 insertions, 130 deletions
diff --git a/src/com/android/inputmethod/latin/AutoDictionary.java b/src/com/android/inputmethod/latin/AutoDictionary.java new file mode 100644 index 000000000..3d76dc301 --- /dev/null +++ b/src/com/android/inputmethod/latin/AutoDictionary.java @@ -0,0 +1,217 @@ +/* + * Copyright (C) 2010 Google Inc. + * + * 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 java.util.HashMap; + +import android.content.ContentValues; +import android.content.Context; +import android.database.Cursor; +import android.database.sqlite.SQLiteDatabase; +import android.database.sqlite.SQLiteOpenHelper; +import android.database.sqlite.SQLiteQueryBuilder; +import android.provider.BaseColumns; +import android.provider.UserDictionary.Words; +import android.util.Log; + +/** + * Stores new words temporarily until they are promoted to the user dictionary + * for longevity. Words in the auto dictionary are used to determine if it's ok + * to accept a word that's not in the main or user dictionary. Using a new word + * repeatedly will promote it to the user dictionary. + */ +public class AutoDictionary extends ExpandableDictionary { + // Weight added to a user picking a new word from the suggestion strip + static final int FREQUENCY_FOR_PICKED = 3; + // Weight added to a user typing a new word that doesn't get corrected (or is reverted) + static final int FREQUENCY_FOR_TYPED = 1; + // A word that is frequently typed and gets promoted to the user dictionary, uses this + // frequency. + static final int FREQUENCY_FOR_AUTO_ADD = 250; + // If the user touches a typed word 2 times or more, it will become valid. + private static final int VALIDITY_THRESHOLD = 2 * FREQUENCY_FOR_PICKED; + // If the user touches a typed word 4 times or more, it will be added to the user dict. + private static final int PROMOTION_THRESHOLD = 4 * FREQUENCY_FOR_PICKED; + + private LatinIME mIme; + // Locale for which this auto dictionary is storing words + private String mLocale; + + private static final String DATABASE_NAME = "auto_dict.db"; + private static final int DATABASE_VERSION = 1; + + // These are the columns in the dictionary + // TODO: Consume less space by using a unique id for locale instead of the whole + // 2-5 character string. + private static final String COLUMN_ID = BaseColumns._ID; + private static final String COLUMN_WORD = "word"; + private static final String COLUMN_FREQUENCY = "freq"; + private static final String COLUMN_LOCALE = "locale"; + + /** Sort by descending order of frequency. */ + public static final String DEFAULT_SORT_ORDER = COLUMN_FREQUENCY + " DESC"; + + /** Name of the words table in the auto_dict.db */ + private static final String AUTODICT_TABLE_NAME = "words"; + + private static HashMap<String, String> sDictProjectionMap; + + static { + sDictProjectionMap = new HashMap<String, String>(); + sDictProjectionMap.put(COLUMN_ID, COLUMN_ID); + sDictProjectionMap.put(COLUMN_WORD, COLUMN_WORD); + sDictProjectionMap.put(COLUMN_FREQUENCY, COLUMN_FREQUENCY); + sDictProjectionMap.put(COLUMN_LOCALE, COLUMN_LOCALE); + } + + private DatabaseHelper mOpenHelper; + + public AutoDictionary(Context context, LatinIME ime, String locale) { + super(context); + mIme = ime; + mLocale = locale; + mOpenHelper = new DatabaseHelper(getContext()); + if (mLocale != null && mLocale.length() > 1) { + loadDictionary(); + } + } + + @Override + public boolean isValidWord(CharSequence word) { + final int frequency = getWordFrequency(word); + return frequency >= VALIDITY_THRESHOLD; + } + + public void close() { + mOpenHelper.close(); + } + + private void loadDictionary() { + // Load the words that correspond to the current input locale + Cursor cursor = query(COLUMN_LOCALE + "=?", new String[] { mLocale }); + if (cursor.moveToFirst()) { + int wordIndex = cursor.getColumnIndex(COLUMN_WORD); + int frequencyIndex = cursor.getColumnIndex(COLUMN_FREQUENCY); + while (!cursor.isAfterLast()) { + String word = cursor.getString(wordIndex); + int frequency = cursor.getInt(frequencyIndex); + // Safeguard against adding really long words. Stack may overflow due + // to recursive lookup + if (word.length() < getMaxWordLength()) { + super.addWord(word, frequency); + } + cursor.moveToNext(); + } + } + cursor.close(); + } + + @Override + public void addWord(String word, int addFrequency) { + final int length = word.length(); + // Don't add very short or very long words. + if (length < 2 || length > getMaxWordLength()) return; + if (mIme.getCurrentWord().isAutoCapitalized()) { + // Remove caps before adding + word = Character.toLowerCase(word.charAt(0)) + word.substring(1); + } + int freq = getWordFrequency(word); + freq = freq < 0 ? addFrequency : freq + addFrequency; + super.addWord(word, freq); + if (freq >= PROMOTION_THRESHOLD) { + mIme.promoteToUserDictionary(word, FREQUENCY_FOR_AUTO_ADD); + // Delete the word (for input locale) from the auto dictionary db, as it + // is now in the user dictionary provider. + delete(COLUMN_WORD + "=? AND " + COLUMN_LOCALE + "=?", + new String[] { word, mLocale }); + } else { + update(word, freq, mLocale); + } + } + + /** + * This class helps open, create, and upgrade the database file. + */ + private static class DatabaseHelper extends SQLiteOpenHelper { + + DatabaseHelper(Context context) { + super(context, DATABASE_NAME, null, DATABASE_VERSION); + } + + @Override + public void onCreate(SQLiteDatabase db) { + db.execSQL("CREATE TABLE " + AUTODICT_TABLE_NAME + " (" + + COLUMN_ID + " INTEGER PRIMARY KEY," + + COLUMN_WORD + " TEXT," + + COLUMN_FREQUENCY + " INTEGER," + + COLUMN_LOCALE + " TEXT" + + ");"); + } + + @Override + public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) { + Log.w("AutoDictionary", "Upgrading database from version " + oldVersion + " to " + + newVersion + ", which will destroy all old data"); + db.execSQL("DROP TABLE IF EXISTS " + AUTODICT_TABLE_NAME); + onCreate(db); + } + } + + private Cursor query(String selection, String[] selectionArgs) { + SQLiteQueryBuilder qb = new SQLiteQueryBuilder(); + qb.setTables(AUTODICT_TABLE_NAME); + qb.setProjectionMap(sDictProjectionMap); + + // Get the database and run the query + SQLiteDatabase db = mOpenHelper.getReadableDatabase(); + Cursor c = qb.query(db, null, selection, selectionArgs, null, null, + DEFAULT_SORT_ORDER); + return c; + } + + private boolean insert(ContentValues values) { + SQLiteDatabase db = mOpenHelper.getWritableDatabase(); + long rowId = db.insert(AUTODICT_TABLE_NAME, Words.WORD, values); + if (rowId > 0) { + return true; + } + return false; + } + + private int delete(String where, String[] whereArgs) { + SQLiteDatabase db = mOpenHelper.getWritableDatabase(); + int count = db.delete(AUTODICT_TABLE_NAME, where, whereArgs); + return count; + } + + private int update(String word, int frequency, String locale) { + SQLiteDatabase db = mOpenHelper.getWritableDatabase(); + long count = db.delete(AUTODICT_TABLE_NAME, COLUMN_WORD + "=? AND " + COLUMN_LOCALE + "=?", + new String[] { word, locale }); + count = db.insert(AUTODICT_TABLE_NAME, null, + getContentValues(word, frequency, locale)); + return (int) count; + } + + private ContentValues getContentValues(String word, int frequency, String locale) { + ContentValues values = new ContentValues(4); + values.put(COLUMN_WORD, word); + values.put(COLUMN_FREQUENCY, frequency); + values.put(COLUMN_LOCALE, locale); + return values; + } +} diff --git a/src/com/android/inputmethod/latin/InputLanguageSelection.java b/src/com/android/inputmethod/latin/InputLanguageSelection.java index 2c5fec6e8..73298e33c 100644 --- a/src/com/android/inputmethod/latin/InputLanguageSelection.java +++ b/src/com/android/inputmethod/latin/InputLanguageSelection.java @@ -19,7 +19,6 @@ package com.android.inputmethod.latin; import java.text.Collator; import java.util.ArrayList; import java.util.Arrays; -import java.util.List; import java.util.Locale; import android.content.SharedPreferences; @@ -29,7 +28,7 @@ import android.preference.CheckBoxPreference; import android.preference.PreferenceActivity; import android.preference.PreferenceGroup; import android.preference.PreferenceManager; -import android.util.Log; +import android.text.TextUtils; public class InputLanguageSelection extends PreferenceActivity { @@ -91,7 +90,9 @@ public class InputLanguageSelection extends PreferenceActivity { } private String get5Code(Locale locale) { - return locale.getLanguage() + "_" + locale.getCountry(); + String country = locale.getCountry(); + return locale.getLanguage() + + (TextUtils.isEmpty(country) ? "" : "_" + country); } @Override diff --git a/src/com/android/inputmethod/latin/KeyboardSwitcher.java b/src/com/android/inputmethod/latin/KeyboardSwitcher.java index 529edeb81..4322997e8 100644 --- a/src/com/android/inputmethod/latin/KeyboardSwitcher.java +++ b/src/com/android/inputmethod/latin/KeyboardSwitcher.java @@ -178,11 +178,13 @@ public class KeyboardSwitcher { mPreferSymbols); } - void setKeyboardMode(int mode, int imeOptions, - boolean enableVoice, boolean isSymbols) { + void setKeyboardMode(int mode, int imeOptions, boolean enableVoice, boolean isSymbols) { + if (mInputView == null) return; mMode = mode; mImeOptions = imeOptions; - mHasVoice = enableVoice; + if (enableVoice != mHasVoice) { + setVoiceMode(mHasVoice, mVoiceOnPrimary); + } mIsSymbols = isSymbols; mInputView.setPreviewEnabled(true); @@ -210,7 +212,8 @@ public class KeyboardSwitcher { conf.locale = mInputLocale; orig.updateConfiguration(conf, null); LatinKeyboard keyboard = new LatinKeyboard( - mContext, id.mXml, id.mKeyboardMode, id.mHasVoice); + mContext, id.mXml, id.mKeyboardMode); + keyboard.setVoiceMode(hasVoiceButton(id.mXml == R.xml.kbd_symbols), mHasVoice); keyboard.setLanguageSwitcher(mLanguageSwitcher); if (id.mKeyboardMode == KEYBOARDMODE_NORMAL || id.mKeyboardMode == KEYBOARDMODE_URL diff --git a/src/com/android/inputmethod/latin/LanguageSwitcher.java b/src/com/android/inputmethod/latin/LanguageSwitcher.java index 68d0d15cc..12045125f 100644 --- a/src/com/android/inputmethod/latin/LanguageSwitcher.java +++ b/src/com/android/inputmethod/latin/LanguageSwitcher.java @@ -21,6 +21,7 @@ import java.util.Locale; import android.content.SharedPreferences; import android.content.SharedPreferences.Editor; import android.preference.PreferenceManager; +import android.text.TextUtils; /** * Keeps track of list of selected input languages and the current @@ -88,8 +89,9 @@ public class LanguageSwitcher { private void loadDefaults() { mDefaultInputLocale = mIme.getResources().getConfiguration().locale; - mDefaultInputLanguage = mDefaultInputLocale.getLanguage() + "_" - + mDefaultInputLocale.getCountry(); + String country = mDefaultInputLocale.getCountry(); + mDefaultInputLanguage = mDefaultInputLocale.getLanguage() + + (TextUtils.isEmpty(country) ? "" : "_" + country); } private void constructLocales() { diff --git a/src/com/android/inputmethod/latin/LatinIME.java b/src/com/android/inputmethod/latin/LatinIME.java index 2af59d651..18b277c5a 100644 --- a/src/com/android/inputmethod/latin/LatinIME.java +++ b/src/com/android/inputmethod/latin/LatinIME.java @@ -130,24 +130,14 @@ public class LatinIME extends InputMethodService // ignored, since it may in fact be two key presses in quick succession. private static final long MIN_MILLIS_AFTER_TYPING_BEFORE_SWIPE = 1000; - // If we detect a swipe gesture, and the user types N ms later, cancel the - // swipe since it was probably a false trigger. - private static final long MIN_MILLIS_AFTER_SWIPE_TO_WAIT_FOR_TYPING = 500; - // How many continuous deletes at which to start deleting at a higher speed. private static final int DELETE_ACCELERATE_AT = 20; // Key events coming any faster than this are long-presses. private static final int QUICK_PRESS = 200; - // Weight added to a user picking a new word from the suggestion strip - static final int FREQUENCY_FOR_PICKED = 3; - // Weight added to a user typing a new word that doesn't get corrected (or is reverted) - static final int FREQUENCY_FOR_TYPED = 1; - // A word that is frequently typed and get's promoted to the user dictionary, uses this - // frequency. - static final int FREQUENCY_FOR_AUTO_ADD = 250; static final int KEYCODE_ENTER = '\n'; static final int KEYCODE_SPACE = ' '; + static final int KEYCODE_PERIOD = '.'; // Contextual menu positions private static final int POS_SETTINGS = 0; @@ -318,23 +308,24 @@ public class LatinIME extends InputMethodService Resources orig = getResources(); Configuration conf = orig.getConfiguration(); Locale saveLocale = conf.locale; - boolean different = !conf.locale.getCountry().equalsIgnoreCase(locale.substring(0, 2)); conf.locale = new Locale(locale); orig.updateConfiguration(conf, orig.getDisplayMetrics()); if (mSuggest != null) { mSuggest.close(); } + SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(this); + mQuickFixes = sp.getBoolean(PREF_QUICK_FIXES, true); mSuggest = new Suggest(this, R.raw.main); - mSuggest.setAutoTextEnabled(!different); + updateAutoTextEnabled(saveLocale); if (mUserDictionary != null) mUserDictionary.close(); - mUserDictionary = new UserDictionary(this); + mUserDictionary = new UserDictionary(this, mLocale); if (mContactsDictionary == null) { mContactsDictionary = new ContactsDictionary(this); } - // TODO: Save and restore the dictionary for the current input language. - if (mAutoDictionary == null) { - mAutoDictionary = new AutoDictionary(this); + if (mAutoDictionary != null) { + mAutoDictionary.close(); } + mAutoDictionary = new AutoDictionary(this, this, mLocale); mSuggest.setUserDictionary(mUserDictionary); mSuggest.setContactsDictionary(mContactsDictionary); mSuggest.setAutoDictionary(mAutoDictionary); @@ -359,8 +350,18 @@ public class LatinIME extends InputMethodService @Override public void onConfigurationChanged(Configuration conf) { + // If the system locale changes and is different from the saved + // locale (mLocale), then reload the input locale list from the + // latin ime settings (shared prefs) and reset the input locale + // to the first one. if (!TextUtils.equals(conf.locale.toString(), mLocale)) { - initSuggest(conf.locale.toString()); + if (mLanguageSwitcher != null) { + mLanguageSwitcher.loadLocales( + PreferenceManager.getDefaultSharedPreferences(this)); + toggleLanguage(true, true); + } else { + reloadKeyboards(); + } } // If orientation changed while predicting, commit the change if (conf.orientation != mOrientation) { @@ -368,8 +369,8 @@ public class LatinIME extends InputMethodService commitTyped(ic); if (ic != null) ic.finishComposingText(); // For voice input mOrientation = conf.orientation; + reloadKeyboards(); } - reloadKeyboards(); super.onConfigurationChanged(conf); } @@ -447,7 +448,6 @@ public class LatinIME extends InputMethodService mShowingVoiceSuggestions = false; mImmediatelyAfterVoiceSuggestions = false; mVoiceInputHighlighted = false; - boolean disableAutoCorrect = false; mWordToSuggestions.clear(); mInputTypeNoAutoCorrect = false; mPredictionOn = false; @@ -534,24 +534,18 @@ public class LatinIME extends InputMethodService mDeleteCount = 0; mJustAddedAutoSpace = false; loadSettings(); + updateShiftKeyState(attribute); setCandidatesViewShown(false); setSuggestions(null, false, false, false); - // Override auto correct - if (disableAutoCorrect) { - mAutoCorrectOn = false; - if (mCorrectionMode == Suggest.CORRECTION_FULL) { - mCorrectionMode = Suggest.CORRECTION_BASIC; - } - } // If the dictionary is not big enough, don't auto correct mHasDictionary = mSuggest.hasMainDictionary(); updateCorrectionMode(); mInputView.setProximityCorrectionEnabled(true); - mPredictionOn = mPredictionOn && mCorrectionMode > 0; + mPredictionOn = mPredictionOn && (mCorrectionMode > 0 || mShowSuggestions); checkTutorial(attribute.privateImeOptions); if (TRACE) Debug.startMethodTracing("/data/trace/latinime"); } @@ -797,7 +791,7 @@ public class LatinIME extends InputMethodService } mKeyboardSwitcher.setLanguageSwitcher(mLanguageSwitcher); if (mInputView != null) { - mKeyboardSwitcher.setVoiceMode(mEnableVoice, mVoiceOnPrimary); + mKeyboardSwitcher.setVoiceMode(mEnableVoice && mEnableVoiceButton, mVoiceOnPrimary); } mKeyboardSwitcher.makeKeyboards(true); } @@ -811,7 +805,7 @@ public class LatinIME extends InputMethodService } mCommittedLength = mComposing.length(); TextEntryState.acceptedTyped(mComposing); - mAutoDictionary.addWord(mComposing.toString(), FREQUENCY_FOR_TYPED); + checkAddToDictionary(mComposing, AutoDictionary.FREQUENCY_FOR_TYPED); } updateSuggestions(); } @@ -854,6 +848,22 @@ public class LatinIME extends InputMethodService } } + private void reswapPeriodAndSpace() { + final InputConnection ic = getCurrentInputConnection(); + if (ic == null) return; + CharSequence lastThree = ic.getTextBeforeCursor(3, 0); + if (lastThree != null && lastThree.length() == 3 + && lastThree.charAt(0) == KEYCODE_PERIOD + && lastThree.charAt(1) == KEYCODE_SPACE + && lastThree.charAt(2) == KEYCODE_PERIOD) { + ic.beginBatchEdit(); + ic.deleteSurroundingText(3, 0); + ic.commitText(" ..", 1); + ic.endBatchEdit(); + updateShiftKeyState(getCurrentInputEditorInfo()); + } + } + private void doubleSpace() { //if (!mAutoPunctuate) return; if (mCorrectionMode == Suggest.CORRECTION_NONE) return; @@ -879,8 +889,9 @@ public class LatinIME extends InputMethodService // When the text's first character is '.', remove the previous period // if there is one. CharSequence lastOne = ic.getTextBeforeCursor(1, 0); - if (lastOne != null && lastOne.length() == 1 && lastOne.charAt(0) == '.' - && text.charAt(0) == '.') { + if (lastOne != null && lastOne.length() == 1 + && lastOne.charAt(0) == KEYCODE_PERIOD + && text.charAt(0) == KEYCODE_PERIOD) { ic.deleteSurroundingText(1, 0); } } @@ -976,6 +987,9 @@ public class LatinIME extends InputMethodService } public void onText(CharSequence text) { + if (VOICE_INSTALLED && mVoiceInputHighlighted) { + commitVoiceInput(); + } InputConnection ic = getCurrentInputConnection(); if (ic == null) return; ic.beginBatchEdit(); @@ -1117,6 +1131,14 @@ public class LatinIME extends InputMethodService mJustAddedAutoSpace = false; } sendKeyChar((char)primaryCode); + + // Handle the case of ". ." -> " .." with auto-space if necessary + // before changing the TextEntryState. + if (TextEntryState.getState() == TextEntryState.STATE_PUNCTUATION_AFTER_ACCEPTED + && primaryCode == KEYCODE_PERIOD) { + reswapPeriodAndSpace(); + } + TextEntryState.typedCharacter((char) primaryCode, true); if (TextEntryState.getState() == TextEntryState.STATE_PUNCTUATION_AFTER_ACCEPTED && primaryCode != KEYCODE_ENTER) { @@ -1164,7 +1186,6 @@ public class LatinIME extends InputMethodService private boolean isPredictionOn() { boolean predictionOn = mPredictionOn; - //if (isFullscreenMode()) predictionOn &= mPredictionLandscape; return predictionOn; } @@ -1419,6 +1440,8 @@ public class LatinIME extends InputMethodService TextEntryState.acceptedDefault(mWord.getTypedWord(), mBestWord); mJustAccepted = true; pickSuggestion(mBestWord); + // Add the word to the auto dictionary if it's not a known word + checkAddToDictionary(mBestWord, AutoDictionary.FREQUENCY_FOR_TYPED); } } @@ -1456,6 +1479,8 @@ public class LatinIME extends InputMethodService } mJustAccepted = true; pickSuggestion(suggestion); + // Add the word to the auto dictionary if it's not a known word + checkAddToDictionary(suggestion, AutoDictionary.FREQUENCY_FOR_PICKED); TextEntryState.acceptedSuggestion(mComposing.toString(), suggestion); // Follow it with a space if (mAutoSpace) { @@ -1464,7 +1489,7 @@ public class LatinIME extends InputMethodService } // Fool the state watcher so that a subsequent backspace will not do a revert TextEntryState.typedCharacter((char) KEYCODE_SPACE, true); - if (index == 0 && !mSuggest.isValidWord(suggestion)) { + if (index == 0 && mCorrectionMode > 0 && !mSuggest.isValidWord(suggestion)) { mCandidateView.showAddToDictionaryHint(suggestion); } if (ic != null) { @@ -1489,12 +1514,9 @@ public class LatinIME extends InputMethodService ic.commitText(suggestion, 1); } } - // Add the word to the auto dictionary if it's not a known word - if (mAutoDictionary.isValidWord(suggestion) || !mSuggest.isValidWord(suggestion)) { - mAutoDictionary.addWord(suggestion.toString(), FREQUENCY_FOR_PICKED); - } mPredicting = false; mCommittedLength = suggestion.length(); + ((LatinKeyboard) mInputView.getKeyboard()).setPreferredLetters(null); setNextSuggestions(); updateShiftKeyState(getCurrentInputEditorInfo()); } @@ -1503,6 +1525,13 @@ public class LatinIME extends InputMethodService setSuggestions(mSuggestPuncList, false, false, false); } + private void checkAddToDictionary(CharSequence suggestion, int frequencyDelta) { + if (mAutoDictionary.isValidWord(suggestion) + || !mSuggest.isValidWord(suggestion.toString().toLowerCase())) { + mAutoDictionary.addWord(suggestion.toString(), frequencyDelta); + } + } + private boolean isCursorTouchingWord() { InputConnection ic = getCurrentInputConnection(); if (ic == null) return false; @@ -1646,11 +1675,6 @@ public class LatinIME extends InputMethodService && !mVoiceInput.isBlacklistedField(fieldContext); } - private boolean fieldIsRecommendedForVoice(FieldContext fieldContext) { - // TODO: Move this logic into the VoiceInput method. - return !mPasswordText && !mEmailText && mVoiceInput.isRecommendedField(fieldContext); - } - private boolean shouldShowVoiceButton(FieldContext fieldContext, EditorInfo attribute) { return ENABLE_VOICE_BUTTON && fieldCanDoVoice(fieldContext) && !(attribute != null && attribute.privateImeOptions != null @@ -1681,21 +1705,6 @@ public class LatinIME extends InputMethodService > MIN_MILLIS_AFTER_TYPING_BEFORE_SWIPE; } - /* - * Only trigger a swipe action if the user hasn't typed X millis before - * now, and if they don't type Y millis after the swipe is detected. This - * delays the onset of the swipe action by Y millis. - */ - private void conservativelyTriggerSwipeAction(final Runnable action) { - if (userHasNotTypedRecently()) { - mSwipeTriggerTimeMillis = System.currentTimeMillis(); - mHandler.sendMessageDelayed( - mHandler.obtainMessage(MSG_START_LISTENING_AFTER_SWIPE), - MIN_MILLIS_AFTER_SWIPE_TO_WAIT_FOR_TYPING); - } - } - - private void playKeyClick(int primaryCode) { // if mAudioManager is null, we don't have the ringer state yet // mAudioManager will be set by updateRingerMode @@ -1759,18 +1768,28 @@ public class LatinIME extends InputMethodService mUserDictionary.addWord(word, frequency); } + WordComposer getCurrentWord() { + return mWord; + } + private void updateCorrectionMode() { mHasDictionary = mSuggest != null ? mSuggest.hasMainDictionary() : false; mAutoCorrectOn = (mAutoCorrectEnabled || mQuickFixes) && !mInputTypeNoAutoCorrect && mHasDictionary; - mCorrectionMode = mAutoCorrectOn + mCorrectionMode = (mAutoCorrectOn && mAutoCorrectEnabled) ? Suggest.CORRECTION_FULL - : (mQuickFixes ? Suggest.CORRECTION_BASIC : Suggest.CORRECTION_NONE); + : (mAutoCorrectOn ? Suggest.CORRECTION_BASIC : Suggest.CORRECTION_NONE); if (mSuggest != null) { mSuggest.setCorrectionMode(mCorrectionMode); } } + private void updateAutoTextEnabled(Locale systemLocale) { + if (mSuggest == null) return; + boolean different = !systemLocale.getLanguage().equalsIgnoreCase(mLocale.substring(0, 2)); + mSuggest.setAutoTextEnabled(!different && mQuickFixes); + } + protected void launchSettings() { launchSettings(LatinIMESettings.class); } @@ -1808,15 +1827,13 @@ public class LatinIME extends InputMethodService mLocaleSupportedForVoiceInput = voiceInputSupportedLocales.contains(mLocale); - // If there is no auto text data, then quickfix is forced to "on", so that the other options - // will continue to work - - if (AutoText.getSize(mInputView) < 1) mQuickFixes = true; - mShowSuggestions = sp.getBoolean(PREF_SHOW_SUGGESTIONS, true) & mQuickFixes; + mShowSuggestions = sp.getBoolean(PREF_SHOW_SUGGESTIONS, true); if (VOICE_INSTALLED) { - final String voiceMode = sp.getString(PREF_VOICE_MODE, ""); - boolean enableVoice = !voiceMode.equals(getString(R.string.voice_mode_off)); + final String voiceMode = sp.getString(PREF_VOICE_MODE, + getString(R.string.voice_mode_main)); + boolean enableVoice = !voiceMode.equals(getString(R.string.voice_mode_off)) + && mEnableVoiceButton; boolean voiceOnPrimary = voiceMode.equals(getString(R.string.voice_mode_main)); if (mKeyboardSwitcher != null && (enableVoice != mEnableVoice || voiceOnPrimary != mVoiceOnPrimary)) { @@ -1828,6 +1845,7 @@ public class LatinIME extends InputMethodService mAutoCorrectEnabled = sp.getBoolean(PREF_AUTO_COMPLETE, mResources.getBoolean(R.bool.enable_autocorrect)) & mShowSuggestions; updateCorrectionMode(); + updateAutoTextEnabled(mResources.getConfiguration().locale); mLanguageSwitcher.loadLocales(sp); } @@ -1932,38 +1950,4 @@ public class LatinIME extends InputMethodService System.out.println("CPS = " + ((CPS_BUFFER_SIZE * 1000f) / total)); } - class AutoDictionary extends ExpandableDictionary { - // If the user touches a typed word 2 times or more, it will become valid. - private static final int VALIDITY_THRESHOLD = 2 * FREQUENCY_FOR_PICKED; - // If the user touches a typed word 5 times or more, it will be added to the user dict. - private static final int PROMOTION_THRESHOLD = 4 * FREQUENCY_FOR_PICKED; - - public AutoDictionary(Context context) { - super(context); - } - - @Override - public boolean isValidWord(CharSequence word) { - final int frequency = getWordFrequency(word); - return frequency >= VALIDITY_THRESHOLD; - } - - @Override - public void addWord(String word, int addFrequency) { - final int length = word.length(); - // Don't add very short or very long words. - if (length < 2 || length > getMaxWordLength()) return; - if (mWord.isAutoCapitalized()) { - // Remove caps before adding - word = Character.toLowerCase(word.charAt(0)) - + word.substring(1); - } - int freq = getWordFrequency(word); - freq = freq < 0 ? addFrequency : freq + addFrequency; - super.addWord(word, freq); - if (freq >= PROMOTION_THRESHOLD) { - LatinIME.this.promoteToUserDictionary(word, FREQUENCY_FOR_AUTO_ADD); - } - } - } } diff --git a/src/com/android/inputmethod/latin/LatinIMESettings.java b/src/com/android/inputmethod/latin/LatinIMESettings.java index f87c56cfc..82f5d54b3 100644 --- a/src/com/android/inputmethod/latin/LatinIMESettings.java +++ b/src/com/android/inputmethod/latin/LatinIMESettings.java @@ -86,8 +86,6 @@ public class LatinIMESettings extends PreferenceActivity if (autoTextSize < 1) { ((PreferenceGroup) findPreference(PREDICTION_SETTINGS_KEY)) .removePreference(mQuickFixes); - } else { - mShowSuggestions.setDependency(QUICK_FIXES_KEY); } if (!LatinIME.VOICE_INSTALLED || !RecognitionManager.isRecognitionAvailable(this)) { diff --git a/src/com/android/inputmethod/latin/LatinKeyboard.java b/src/com/android/inputmethod/latin/LatinKeyboard.java index 9b742a5f9..58e1dc767 100644 --- a/src/com/android/inputmethod/latin/LatinKeyboard.java +++ b/src/com/android/inputmethod/latin/LatinKeyboard.java @@ -69,7 +69,12 @@ public class LatinKeyboard extends Keyboard { private Resources mRes; private Context mContext; private int mMode; - private boolean mHasVoice; + // Whether this keyboard has voice icon on it + private boolean mHasVoiceButton; + // Whether voice icon is enabled at all + private boolean mVoiceEnabled; + private boolean mIsAlphaKeyboard; + private CharSequence m123Label; private boolean mCurrentlyInSpace; private SlidingLocaleDrawable mSlidingLocaleIcon; private Rect mBounds = new Rect(); @@ -95,16 +100,15 @@ public class LatinKeyboard extends Keyboard { static int sSpacebarVerticalCorrection; public LatinKeyboard(Context context, int xmlLayoutResId) { - this(context, xmlLayoutResId, 0, false); + this(context, xmlLayoutResId, 0); } - public LatinKeyboard(Context context, int xmlLayoutResId, int mode, boolean hasVoice) { + public LatinKeyboard(Context context, int xmlLayoutResId, int mode) { super(context, xmlLayoutResId, mode); final Resources res = context.getResources(); mContext = context; mMode = mode; mRes = res; - mHasVoice = hasVoice; mShiftLockIcon = res.getDrawable(R.drawable.sym_keyboard_shift_locked); mShiftLockPreviewIcon = res.getDrawable(R.drawable.sym_keyboard_feedback_shift_locked); mShiftLockPreviewIcon.setBounds(0, 0, @@ -122,7 +126,7 @@ public class LatinKeyboard extends Keyboard { setDefaultBounds(m123MicPreviewIcon); sSpacebarVerticalCorrection = res.getDimensionPixelOffset( R.dimen.spacebar_vertical_correction); - setF1Key(xmlLayoutResId == R.xml.kbd_qwerty); + mIsAlphaKeyboard = xmlLayoutResId == R.xml.kbd_qwerty; mSpaceKeyIndex = indexOf((int) ' '); } @@ -147,6 +151,7 @@ public class LatinKeyboard extends Keyboard { break; case KEYCODE_MODE_CHANGE: m123Key = key; + m123Label = key.label; break; } return key; @@ -284,23 +289,36 @@ public class LatinKeyboard extends Keyboard { drawable.setBounds(0, 0, drawable.getIntrinsicWidth(), drawable.getIntrinsicHeight()); } - private void setF1Key(boolean isAlphaKeyboard) { + public void setVoiceMode(boolean hasVoiceButton, boolean hasVoice) { + mHasVoiceButton = hasVoiceButton; + mVoiceEnabled = hasVoice; + updateF1Key(); + } + + private void updateF1Key() { if (mF1Key == null) return; - if (!mHasVoice) { - mF1Key.label = ","; - mF1Key.codes = new int[] { ',' }; - mF1Key.icon = null; - mF1Key.iconPreview = null; - if (isAlphaKeyboard && m123Key != null) { + if (m123Key != null && mIsAlphaKeyboard) { + if (mVoiceEnabled && !mHasVoiceButton) { m123Key.icon = m123MicIcon; m123Key.iconPreview = m123MicPreviewIcon; m123Key.label = null; + } else { + m123Key.icon = null; + m123Key.iconPreview = null; + m123Key.label = m123Label; } - } else { + } + + if (mHasVoiceButton && mVoiceEnabled) { mF1Key.codes = new int[] { LatinKeyboardView.KEYCODE_VOICE }; mF1Key.label = null; mF1Key.icon = mMicIcon; mF1Key.iconPreview = mMicPreviewIcon; + } else { + mF1Key.label = ","; + mF1Key.codes = new int[] { ',' }; + mF1Key.icon = null; + mF1Key.iconPreview = null; } } diff --git a/src/com/android/inputmethod/latin/Suggest.java b/src/com/android/inputmethod/latin/Suggest.java index e806dc59b..712b9cf37 100755 --- a/src/com/android/inputmethod/latin/Suggest.java +++ b/src/com/android/inputmethod/latin/Suggest.java @@ -194,7 +194,8 @@ public class Suggest implements Dictionary.WordCallback { mContactsDictionary.getWords(wordComposer, this, mNextLettersFrequencies); } - if (mSuggestions.size() > 0 && isValidWord(mOriginalWord)) { + if (mSuggestions.size() > 0 && isValidWord(mOriginalWord) + && mCorrectionMode == CORRECTION_FULL) { mHaveCorrection = true; } } diff --git a/src/com/android/inputmethod/latin/UserDictionary.java b/src/com/android/inputmethod/latin/UserDictionary.java index edd82aaa3..4b98eacce 100644 --- a/src/com/android/inputmethod/latin/UserDictionary.java +++ b/src/com/android/inputmethod/latin/UserDictionary.java @@ -21,9 +21,11 @@ import java.util.List; import java.util.Locale; import android.content.ContentResolver; +import android.content.ContentValues; import android.content.Context; import android.database.ContentObserver; import android.database.Cursor; +import android.net.Uri; import android.provider.UserDictionary.Words; public class UserDictionary extends ExpandableDictionary { @@ -40,9 +42,11 @@ public class UserDictionary extends ExpandableDictionary { private ContentObserver mObserver; private boolean mRequiresReload; - - public UserDictionary(Context context) { + private String mLocale; + + public UserDictionary(Context context, String locale) { super(context); + mLocale = locale; // Perform a managed query. The Activity will handle closing and requerying the cursor // when needed. ContentResolver cres = context.getContentResolver(); @@ -67,7 +71,7 @@ public class UserDictionary extends ExpandableDictionary { private synchronized void loadDictionary() { Cursor cursor = getContext().getContentResolver() .query(Words.CONTENT_URI, PROJECTION, "(locale IS NULL) or (locale=?)", - new String[] { Locale.getDefault().toString() }, null); + new String[] { mLocale }, null); addWords(cursor); mRequiresReload = false; } @@ -88,7 +92,14 @@ public class UserDictionary extends ExpandableDictionary { super.addWord(word, frequency); - Words.addWord(getContext(), word, frequency, Words.LOCALE_TYPE_CURRENT); + // Update the user dictionary provider + ContentValues values = new ContentValues(5); + values.put(Words.WORD, word); + values.put(Words.FREQUENCY, frequency); + values.put(Words.LOCALE, mLocale); + values.put(Words.APP_ID, 0); + + getContext().getContentResolver().insert(Words.CONTENT_URI, values); // In case the above does a synchronous callback of the change observer mRequiresReload = false; } |