diff options
Diffstat (limited to 'java/src/com/android/inputmethod/latin')
6 files changed, 122 insertions, 164 deletions
diff --git a/java/src/com/android/inputmethod/latin/DictionaryFacilitatorForSuggest.java b/java/src/com/android/inputmethod/latin/DictionaryFacilitatorForSuggest.java index 0b6258a7f..fa58fb09e 100644 --- a/java/src/com/android/inputmethod/latin/DictionaryFacilitatorForSuggest.java +++ b/java/src/com/android/inputmethod/latin/DictionaryFacilitatorForSuggest.java @@ -69,78 +69,74 @@ public class DictionaryFacilitatorForSuggest { public final Locale mLocale; public final ConcurrentHashMap<String, Dictionary> mDictMap = CollectionUtils.newConcurrentHashMap(); - // Main dictionary will be asynchronously loaded. - public Dictionary mMainDictionary; + public final ConcurrentHashMap<String, ExpandableBinaryDictionary> mSubDictMap = + CollectionUtils.newConcurrentHashMap(); + // TODO: Remove sub dictionary members and use mSubDictMap. public final ContactsBinaryDictionary mContactsDictionary; public final UserBinaryDictionary mUserDictionary; - public final UserHistoryDictionary mUserHistoryDictionary; public final PersonalizationDictionary mPersonalizationDictionary; public Dictionaries() { mLocale = null; - mMainDictionary = null; mContactsDictionary = null; mUserDictionary = null; - mUserHistoryDictionary = null; mPersonalizationDictionary = null; } public Dictionaries(final Locale locale, final Dictionary mainDict, final ContactsBinaryDictionary contactsDict, final UserBinaryDictionary userDict, - final UserHistoryDictionary userHistoryDict, + final ExpandableBinaryDictionary userHistoryDict, final PersonalizationDictionary personalizationDict) { mLocale = locale; + // Main dictionary can be asynchronously loaded. setMainDict(mainDict); mContactsDictionary = contactsDict; - if (mContactsDictionary != null) { - mDictMap.put(Dictionary.TYPE_CONTACTS, mContactsDictionary); - } + setSubDict(Dictionary.TYPE_CONTACTS, mContactsDictionary); mUserDictionary = userDict; - if (mUserDictionary != null) { - mDictMap.put(Dictionary.TYPE_USER, mUserDictionary); - } - mUserHistoryDictionary = userHistoryDict; - if (mUserHistoryDictionary != null) { - mDictMap.put(Dictionary.TYPE_USER_HISTORY, mUserHistoryDictionary); - } + setSubDict(Dictionary.TYPE_USER, mUserDictionary); + setSubDict(Dictionary.TYPE_USER_HISTORY, userHistoryDict); mPersonalizationDictionary = personalizationDict; - if (mPersonalizationDictionary != null) { - mDictMap.put(Dictionary.TYPE_PERSONALIZATION, mPersonalizationDictionary); + setSubDict(Dictionary.TYPE_PERSONALIZATION, mPersonalizationDictionary); + } + + private void setSubDict(final String dictType, final ExpandableBinaryDictionary dict) { + if (dict != null) { + mDictMap.put(dictType, dict); + mSubDictMap.put(dictType, dict); } } public void setMainDict(final Dictionary mainDict) { - mMainDictionary = mainDict; // Close old dictionary if exists. Main dictionary can be assigned multiple times. final Dictionary oldDict; - if (mMainDictionary != null) { - oldDict = mDictMap.put(Dictionary.TYPE_MAIN, mMainDictionary); + if (mainDict != null) { + oldDict = mDictMap.put(Dictionary.TYPE_MAIN, mainDict); } else { oldDict = mDictMap.remove(Dictionary.TYPE_MAIN); } - if (oldDict != null && mMainDictionary != oldDict) { + if (oldDict != null && mainDict != oldDict) { oldDict.close(); } } - public boolean hasMainDict() { - return mMainDictionary != null; - } - - public boolean hasContactsDict() { - return mContactsDictionary != null; + public Dictionary getMainDict() { + return mDictMap.get(Dictionary.TYPE_MAIN); } - public boolean hasUserDict() { - return mUserDictionary != null; + public ExpandableBinaryDictionary getSubDict(final String dictType) { + return mSubDictMap.get(dictType); } - public boolean hasUserHistoryDict() { - return mUserHistoryDictionary != null; + public boolean hasDict(final String dictType) { + return mDictMap.contains(dictType); } - public boolean hasPersonalizationDict() { - return mPersonalizationDictionary != null; + public void closeDict(final String dictType) { + final Dictionary dict = mDictMap.remove(dictType); + mSubDictMap.remove(dictType); + if (dict != null) { + dict.close(); + } } } @@ -172,12 +168,12 @@ public class DictionaryFacilitatorForSuggest { // The main dictionary will be asynchronously loaded. newMainDict = null; } else { - newMainDict = mDictionaries.mMainDictionary; + newMainDict = mDictionaries.getMainDict(); } // Open or move contacts dictionary. final ContactsBinaryDictionary newContactsDict; - if (!closeContactsDictionary && mDictionaries.hasContactsDict()) { + if (!closeContactsDictionary && mDictionaries.hasDict(Dictionary.TYPE_CONTACTS)) { newContactsDict = mDictionaries.mContactsDictionary; } else if (useContactsDict) { newContactsDict = new ContactsBinaryDictionary(context, newLocale); @@ -187,16 +183,16 @@ public class DictionaryFacilitatorForSuggest { // Open or move user dictionary. final UserBinaryDictionary newUserDictionary; - if (!closeUserDictionary && mDictionaries.hasUserDict()) { + if (!closeUserDictionary && mDictionaries.hasDict(Dictionary.TYPE_USER)) { newUserDictionary = mDictionaries.mUserDictionary; } else { newUserDictionary = new UserBinaryDictionary(context, newLocale); } // Open or move user history dictionary. - final UserHistoryDictionary newUserHistoryDict; - if (!closeUserHistoryDictionary && mDictionaries.hasUserHistoryDict()) { - newUserHistoryDict = mDictionaries.mUserHistoryDictionary; + final ExpandableBinaryDictionary newUserHistoryDict; + if (!closeUserHistoryDictionary && mDictionaries.hasDict(Dictionary.TYPE_USER_HISTORY)) { + newUserHistoryDict = mDictionaries.getSubDict(Dictionary.TYPE_USER_HISTORY); } else if (usePersonalizedDicts) { newUserHistoryDict = PersonalizationHelper.getUserHistoryDictionary(context, newLocale); } else { @@ -205,7 +201,8 @@ public class DictionaryFacilitatorForSuggest { // Open or move personalization dictionary. final PersonalizationDictionary newPersonalizationDict; - if (!closePersonalizationDictionary && mDictionaries.hasPersonalizationDict()) { + if (!closePersonalizationDictionary + && mDictionaries.hasDict(Dictionary.TYPE_PERSONALIZATION)) { newPersonalizationDict = mDictionaries.mPersonalizationDictionary; } else if (usePersonalizedDicts) { newPersonalizationDict = @@ -217,9 +214,6 @@ public class DictionaryFacilitatorForSuggest { // Replace Dictionaries. final Dictionaries newDictionaries = new Dictionaries(newLocale, newMainDict, newContactsDict, newUserDictionary, newUserHistoryDict, newPersonalizationDict); - if (listener != null) { - listener.onUpdateMainDictionaryAvailability(newDictionaries.hasMainDict()); - } final Dictionaries oldDictionaries; synchronized (mLock) { oldDictionaries = mDictionaries; @@ -228,24 +222,28 @@ public class DictionaryFacilitatorForSuggest { asyncReloadMainDictionary(context, newLocale, listener); } } + if (listener != null) { + listener.onUpdateMainDictionaryAvailability(hasInitializedMainDictionary()); + } // Clean up old dictionaries. - oldDictionaries.mDictMap.clear(); - if (reloadMainDictionary && oldDictionaries.hasMainDict()) { - oldDictionaries.mMainDictionary.close(); + if (reloadMainDictionary) { + oldDictionaries.closeDict(Dictionary.TYPE_MAIN); } - if (closeContactsDictionary && oldDictionaries.hasContactsDict()) { - oldDictionaries.mContactsDictionary.close(); + if (closeContactsDictionary) { + oldDictionaries.closeDict(Dictionary.TYPE_CONTACTS); } - if (closeUserDictionary && oldDictionaries.hasUserDict()) { - oldDictionaries.mUserDictionary.close(); + if (closeUserDictionary) { + oldDictionaries.closeDict(Dictionary.TYPE_USER); } - if (closeUserHistoryDictionary && oldDictionaries.hasUserHistoryDict()) { - oldDictionaries.mUserHistoryDictionary.close(); + if (closeUserHistoryDictionary) { + oldDictionaries.closeDict(Dictionary.TYPE_USER_HISTORY); } - if (closePersonalizationDictionary && oldDictionaries.hasPersonalizationDict()) { - oldDictionaries.mPersonalizationDictionary.close(); + if (closePersonalizationDictionary) { + oldDictionaries.closeDict(Dictionary.TYPE_PERSONALIZATION); } + oldDictionaries.mDictMap.clear(); + oldDictionaries.mSubDictMap.clear(); } private void asyncReloadMainDictionary(final Context context, final Locale locale, @@ -266,7 +264,7 @@ public class DictionaryFacilitatorForSuggest { } } if (listener != null) { - listener.onUpdateMainDictionaryAvailability(mDictionaries.hasMainDict()); + listener.onUpdateMainDictionaryAvailability(hasInitializedMainDictionary()); } latchForWaitingLoadingMainDictionary.countDown(); } @@ -332,39 +330,27 @@ public class DictionaryFacilitatorForSuggest { dictionaries = mDictionaries; mDictionaries = new Dictionaries(); } - if (dictionaries.hasMainDict()) { - dictionaries.mMainDictionary.close(); - } - if (dictionaries.hasContactsDict()) { - dictionaries.mContactsDictionary.close(); - } - if (dictionaries.hasUserDict()) { - dictionaries.mUserDictionary.close(); - } - if (dictionaries.hasUserHistoryDict()) { - dictionaries.mUserHistoryDictionary.close(); - } - if (dictionaries.hasPersonalizationDict()) { - dictionaries.mPersonalizationDictionary.close(); + for (final Dictionary dict : dictionaries.mDictMap.values()) { + dict.close(); } } // The main dictionary could have been loaded asynchronously. Don't cache the return value // of this method. public boolean hasInitializedMainDictionary() { - final Dictionaries dictionaries = mDictionaries; - return dictionaries.hasMainDict() && dictionaries.mMainDictionary.isInitialized(); + final Dictionary mainDict = mDictionaries.getMainDict(); + return mainDict != null && mainDict.isInitialized(); } public boolean hasPersonalizationDictionary() { - return mDictionaries.hasPersonalizationDict(); + return mDictionaries.hasDict(Dictionary.TYPE_PERSONALIZATION); } public void flushPersonalizationDictionary() { final PersonalizationDictionary personalizationDict = mDictionaries.mPersonalizationDictionary; if (personalizationDict != null) { - personalizationDict.flush(); + personalizationDict.asyncFlushBinaryDictionary(); } } @@ -377,18 +363,9 @@ public class DictionaryFacilitatorForSuggest { public void waitForLoadingDictionariesForTesting(final long timeout, final TimeUnit unit) throws InterruptedException { waitForLoadingMainDictionary(timeout, unit); - final Dictionaries dictionaries = mDictionaries; - if (dictionaries.hasContactsDict()) { - dictionaries.mContactsDictionary.waitAllTasksForTests(); - } - if (dictionaries.hasUserDict()) { - dictionaries.mUserDictionary.waitAllTasksForTests(); - } - if (dictionaries.hasUserHistoryDict()) { - dictionaries.mUserHistoryDictionary.waitAllTasksForTests(); - } - if (dictionaries.hasPersonalizationDict()) { - dictionaries.mPersonalizationDictionary.waitAllTasksForTests(); + final Map<String, ExpandableBinaryDictionary> dictMap = mDictionaries.mSubDictMap; + for (final ExpandableBinaryDictionary dict : dictMap.values()) { + dict.waitAllTasksForTests(); } } @@ -411,7 +388,9 @@ public class DictionaryFacilitatorForSuggest { public void addToUserHistory(final String suggestion, final boolean wasAutoCapitalized, final String previousWord, final int timeStampInSeconds) { final Dictionaries dictionaries = mDictionaries; - if (!dictionaries.hasUserHistoryDict()) { + final ExpandableBinaryDictionary userHistoryDictionary = + dictionaries.getSubDict(Dictionary.TYPE_USER_HISTORY); + if (userHistoryDictionary != null) { return; } final int maxFreq = getMaxFrequency(suggestion); @@ -439,8 +418,8 @@ public class DictionaryFacilitatorForSuggest { // History dictionary in order to avoid suggesting them until the dictionary // consolidation is done. // TODO: Remove this hack when ready. - final int lowerCaseFreqInMainDict = dictionaries.hasMainDict() ? - dictionaries.mMainDictionary.getFrequency(suggestionLowerCase) : + final int lowerCaseFreqInMainDict = dictionaries.hasDict(Dictionary.TYPE_MAIN) ? + dictionaries.getMainDict().getFrequency(suggestionLowerCase) : Dictionary.NOT_A_PROBABILITY; if (maxFreq < lowerCaseFreqInMainDict && lowerCaseFreqInMainDict >= CAPITALIZED_FORM_MAX_PROBABILITY_FOR_INSERT) { @@ -453,14 +432,15 @@ public class DictionaryFacilitatorForSuggest { // We demote unrecognized words (frequency < 0, below) by specifying them as "invalid". // We don't add words with 0-frequency (assuming they would be profanity etc.). final boolean isValid = maxFreq > 0; - dictionaries.mUserHistoryDictionary.addToDictionary( - previousWord, secondWord, isValid, timeStampInSeconds); + UserHistoryDictionary.addToDictionary(userHistoryDictionary, previousWord, secondWord, + isValid, timeStampInSeconds); } public void cancelAddingUserHistory(final String previousWord, final String committedWord) { - final UserHistoryDictionary userHistoryDictionary = mDictionaries.mUserHistoryDictionary; + final ExpandableBinaryDictionary userHistoryDictionary = + mDictionaries.getSubDict(Dictionary.TYPE_USER_HISTORY); if (userHistoryDictionary != null) { - userHistoryDictionary.cancelAddingUserHistory(previousWord, committedWord); + userHistoryDictionary.removeBigramDynamically(previousWord, committedWord); } } @@ -492,10 +472,10 @@ public class DictionaryFacilitatorForSuggest { public boolean isValidMainDictWord(final String word) { final Dictionaries dictionaries = mDictionaries; - if (TextUtils.isEmpty(word) || !dictionaries.hasMainDict()) { + if (TextUtils.isEmpty(word) || !dictionaries.hasDict(Dictionary.TYPE_MAIN)) { return false; } - return dictionaries.mMainDictionary.isValidWord(word); + return dictionaries.getMainDict().isValidWord(word); } public boolean isValidWord(final String word, final boolean ignoreCase) { @@ -538,22 +518,23 @@ public class DictionaryFacilitatorForSuggest { public void clearUserHistoryDictionary() { - final UserHistoryDictionary userHistoryDict = mDictionaries.mUserHistoryDictionary; + final ExpandableBinaryDictionary userHistoryDict = + mDictionaries.getSubDict(Dictionary.TYPE_USER_HISTORY); if (userHistoryDict == null) { return; } - userHistoryDict.clearAndFlushDictionary(); + userHistoryDict.clear(); } // This method gets called only when the IME receives a notification to remove the // personalization dictionary. public void clearPersonalizationDictionary() { - final PersonalizationDictionary personalizationDict = - mDictionaries.mPersonalizationDictionary; + final ExpandableBinaryDictionary personalizationDict = + mDictionaries.getSubDict(Dictionary.TYPE_PERSONALIZATION); if (personalizationDict == null) { return; } - personalizationDict.clearAndFlushDictionary(); + personalizationDict.clear(); } public void addMultipleDictionaryEntriesToPersonalizationDictionary( @@ -571,18 +552,7 @@ public class DictionaryFacilitatorForSuggest { } public void dumpDictionaryForDebug(final String dictName) { - final ExpandableBinaryDictionary dictToDump; - if (dictName.equals(Dictionary.TYPE_CONTACTS)) { - dictToDump = mDictionaries.mContactsDictionary; - } else if (dictName.equals(Dictionary.TYPE_USER)) { - dictToDump = mDictionaries.mUserDictionary; - } else if (dictName.equals(Dictionary.TYPE_USER_HISTORY)) { - dictToDump = mDictionaries.mUserHistoryDictionary; - } else if (dictName.equals(Dictionary.TYPE_PERSONALIZATION)) { - dictToDump = mDictionaries.mPersonalizationDictionary; - } else { - dictToDump = null; - } + final ExpandableBinaryDictionary dictToDump = mDictionaries.getSubDict(dictName); if (dictToDump == null) { Log.e(TAG, "Cannot dump " + dictName + ". " + "The dictionary is not being used for suggestion or cannot be dumped."); diff --git a/java/src/com/android/inputmethod/latin/ExpandableBinaryDictionary.java b/java/src/com/android/inputmethod/latin/ExpandableBinaryDictionary.java index 8431838e1..1adf3497f 100644 --- a/java/src/com/android/inputmethod/latin/ExpandableBinaryDictionary.java +++ b/java/src/com/android/inputmethod/latin/ExpandableBinaryDictionary.java @@ -244,7 +244,7 @@ abstract public class ExpandableBinaryDictionary extends Dictionary { DICTIONARY_FORMAT_VERSION, getHeaderAttributeMap()); } - protected void clear() { + public void clear() { ExecutorUtils.getExecutor(mDictName).execute(new Runnable() { @Override public void run() { @@ -297,7 +297,7 @@ abstract public class ExpandableBinaryDictionary extends Dictionary { /** * Dynamically adds a word unigram to the dictionary. May overwrite an existing entry. */ - protected void addWordDynamically(final String word, final int frequency, + public void addWordDynamically(final String word, final int frequency, final String shortcutTarget, final int shortcutFreq, final boolean isNotAWord, final boolean isBlacklisted, final int timestamp) { reloadDictionaryIfRequired(); @@ -324,7 +324,7 @@ abstract public class ExpandableBinaryDictionary extends Dictionary { /** * Dynamically adds a word bigram in the dictionary. May overwrite an existing entry. */ - protected void addBigramDynamically(final String word0, final String word1, + public void addBigramDynamically(final String word0, final String word1, final int frequency, final int timestamp) { reloadDictionaryIfRequired(); ExecutorUtils.getExecutor(mDictName).execute(new Runnable() { @@ -347,7 +347,7 @@ abstract public class ExpandableBinaryDictionary extends Dictionary { /** * Dynamically remove a word bigram in the dictionary. */ - protected void removeBigramDynamically(final String word0, final String word1) { + public void removeBigramDynamically(final String word0, final String word1) { reloadDictionaryIfRequired(); ExecutorUtils.getExecutor(mDictName).execute(new Runnable() { @Override @@ -632,7 +632,7 @@ abstract public class ExpandableBinaryDictionary extends Dictionary { /** * Flush binary dictionary to dictionary file. */ - protected void asyncFlushBinaryDictionary() { + public void asyncFlushBinaryDictionary() { final Runnable newTask = new Runnable() { @Override public void run() { diff --git a/java/src/com/android/inputmethod/latin/inputlogic/InputLogic.java b/java/src/com/android/inputmethod/latin/inputlogic/InputLogic.java index f1f906042..d2100d415 100644 --- a/java/src/com/android/inputmethod/latin/inputlogic/InputLogic.java +++ b/java/src/com/android/inputmethod/latin/inputlogic/InputLogic.java @@ -451,8 +451,10 @@ public final class InputLogic { break; case Constants.CODE_SHIFT_ENTER: // TODO: remove this object + final Event tmpEvent = Event.createSoftwareKeypressEvent(Constants.CODE_ENTER, + event.mKeyCode, event.mX, event.mY, event.isKeyRepeat()); final InputTransaction tmpTransaction = new InputTransaction( - inputTransaction.mSettingsValues, inputTransaction.mEvent, + inputTransaction.mSettingsValues, tmpEvent, inputTransaction.mTimestamp, inputTransaction.mSpaceState, inputTransaction.mShiftState); didAutoCorrect = handleNonSpecialCharacter(tmpTransaction, handler); diff --git a/java/src/com/android/inputmethod/latin/personalization/DecayingExpandableBinaryDictionaryBase.java b/java/src/com/android/inputmethod/latin/personalization/DecayingExpandableBinaryDictionaryBase.java index 712e314a8..35b4ccd40 100644 --- a/java/src/com/android/inputmethod/latin/personalization/DecayingExpandableBinaryDictionaryBase.java +++ b/java/src/com/android/inputmethod/latin/personalization/DecayingExpandableBinaryDictionaryBase.java @@ -65,12 +65,8 @@ public abstract class DecayingExpandableBinaryDictionaryBase extends ExpandableB dumpAllWordsForDebug(); } // Flush pending writes. - flush(); - super.close(); - } - - public void flush() { asyncFlushBinaryDictionary(); + super.close(); } @Override @@ -103,51 +99,16 @@ public abstract class DecayingExpandableBinaryDictionaryBase extends ExpandableB addMultipleDictionaryEntriesDynamically(languageModelParams, callback); } - /** - * Pair will be added to the decaying dictionary. - * - * The first word may be null. That means we don't know the context, in other words, - * it's only a unigram. The first word may also be an empty string : this means start - * context, as in beginning of a sentence for example. - * The second word may not be null (a NullPointerException would be thrown). - */ - public void addToDictionary(final String word0, final String word1, final boolean isValid, - final int timestamp) { - if (word1.length() >= Constants.DICTIONARY_MAX_WORD_LENGTH || - (word0 != null && word0.length() >= Constants.DICTIONARY_MAX_WORD_LENGTH)) { - return; - } - final int frequency = isValid ? - FREQUENCY_FOR_WORDS_IN_DICTS : FREQUENCY_FOR_WORDS_NOT_IN_DICTS; - addWordDynamically(word1, frequency, null /* shortcutTarget */, 0 /* shortcutFreq */, - false /* isNotAWord */, false /* isBlacklisted */, timestamp); - // Do not insert a word as a bigram of itself - if (word1.equals(word0)) { - return; - } - if (null != word0) { - addBigramDynamically(word0, word1, frequency, timestamp); - } - } - @Override protected void loadInitialContentsLocked() { // No initial contents. } @UsedForTesting - public void clearAndFlushDictionary() { - // Clear the node structure on memory - clear(); - // Then flush the cleared state of the dictionary on disk. - asyncFlushBinaryDictionary(); - } - - @UsedForTesting public void clearAndFlushDictionaryWithAdditionalAttributes( final Map<String, String> attributeMap) { mAdditionalAttributeMap = attributeMap; - clearAndFlushDictionary(); + clear(); } /* package */ void runGCIfRequired() { diff --git a/java/src/com/android/inputmethod/latin/personalization/PersonalizationHelper.java b/java/src/com/android/inputmethod/latin/personalization/PersonalizationHelper.java index 385b525b6..7c43182bc 100644 --- a/java/src/com/android/inputmethod/latin/personalization/PersonalizationHelper.java +++ b/java/src/com/android/inputmethod/latin/personalization/PersonalizationHelper.java @@ -135,7 +135,7 @@ public class PersonalizationHelper { if (entry.getValue() != null) { final DecayingExpandableBinaryDictionaryBase dict = entry.getValue().get(); if (dict != null) { - dict.clearAndFlushDictionary(); + dict.clear(); } } } diff --git a/java/src/com/android/inputmethod/latin/personalization/UserHistoryDictionary.java b/java/src/com/android/inputmethod/latin/personalization/UserHistoryDictionary.java index 504e9b2f3..8a29c354d 100644 --- a/java/src/com/android/inputmethod/latin/personalization/UserHistoryDictionary.java +++ b/java/src/com/android/inputmethod/latin/personalization/UserHistoryDictionary.java @@ -18,7 +18,9 @@ package com.android.inputmethod.latin.personalization; import android.content.Context; +import com.android.inputmethod.latin.Constants; import com.android.inputmethod.latin.Dictionary; +import com.android.inputmethod.latin.ExpandableBinaryDictionary; import java.io.File; import java.util.Locale; @@ -40,13 +42,36 @@ public class UserHistoryDictionary extends DecayingExpandableBinaryDictionaryBas dictFile); } - public void cancelAddingUserHistory(final String word0, final String word1) { - removeBigramDynamically(word0, word1); - } - @Override public boolean isValidWord(final String word) { // Strings out of this dictionary should not be considered existing words. return false; } + + /** + * Pair will be added to the user history dictionary. + * + * The first word may be null. That means we don't know the context, in other words, + * it's only a unigram. The first word may also be an empty string : this means start + * context, as in beginning of a sentence for example. + * The second word may not be null (a NullPointerException would be thrown). + */ + public static void addToDictionary(final ExpandableBinaryDictionary userHistoryDictionary, + final String word0, final String word1, final boolean isValid, final int timestamp) { + if (word1.length() >= Constants.DICTIONARY_MAX_WORD_LENGTH || + (word0 != null && word0.length() >= Constants.DICTIONARY_MAX_WORD_LENGTH)) { + return; + } + final int frequency = isValid ? + FREQUENCY_FOR_WORDS_IN_DICTS : FREQUENCY_FOR_WORDS_NOT_IN_DICTS; + userHistoryDictionary.addWordDynamically(word1, frequency, null /* shortcutTarget */, + 0 /* shortcutFreq */, false /* isNotAWord */, false /* isBlacklisted */, timestamp); + // Do not insert a word as a bigram of itself + if (word1.equals(word0)) { + return; + } + if (null != word0) { + userHistoryDictionary.addBigramDynamically(word0, word1, frequency, timestamp); + } + } } |