diff options
Diffstat (limited to 'java/src')
11 files changed, 272 insertions, 276 deletions
diff --git a/java/src/com/android/inputmethod/accessibility/AccessibilityEntityProvider.java b/java/src/com/android/inputmethod/accessibility/AccessibilityEntityProvider.java index 063f2113d..720cf6b2a 100644 --- a/java/src/com/android/inputmethod/accessibility/AccessibilityEntityProvider.java +++ b/java/src/com/android/inputmethod/accessibility/AccessibilityEntityProvider.java @@ -19,15 +19,12 @@ package com.android.inputmethod.accessibility; import android.graphics.Rect; import android.inputmethodservice.InputMethodService; import android.os.Bundle; -import android.os.SystemClock; import android.support.v4.view.ViewCompat; import android.support.v4.view.accessibility.AccessibilityEventCompat; import android.support.v4.view.accessibility.AccessibilityNodeInfoCompat; import android.support.v4.view.accessibility.AccessibilityNodeProviderCompat; import android.support.v4.view.accessibility.AccessibilityRecordCompat; import android.util.Log; -import android.util.SparseArray; -import android.view.MotionEvent; import android.view.View; import android.view.accessibility.AccessibilityEvent; import android.view.inputmethod.EditorInfo; @@ -37,9 +34,10 @@ import com.android.inputmethod.keyboard.Keyboard; import com.android.inputmethod.keyboard.KeyboardView; import com.android.inputmethod.latin.settings.Settings; import com.android.inputmethod.latin.settings.SettingsValues; -import com.android.inputmethod.latin.utils.CollectionUtils; import com.android.inputmethod.latin.utils.CoordinateUtils; +import java.util.List; + /** * Exposes a virtual view sub-tree for {@link KeyboardView} and generates * {@link AccessibilityEvent}s for individual {@link Key}s. @@ -58,9 +56,6 @@ public final class AccessibilityEntityProvider extends AccessibilityNodeProvider private final KeyCodeDescriptionMapper mKeyCodeDescriptionMapper; private final AccessibilityUtils mAccessibilityUtils; - /** A map of integer IDs to {@link Key}s. */ - private final SparseArray<Key> mVirtualViewIdToKey = CollectionUtils.newSparseArray(); - /** Temporary rect used to calculate in-screen bounds. */ private final Rect mTempBoundsInScreen = new Rect(); @@ -73,6 +68,9 @@ public final class AccessibilityEntityProvider extends AccessibilityNodeProvider /** The current keyboard view. */ private KeyboardView mKeyboardView; + /** The current keyboard. */ + private Keyboard mKeyboard; + public AccessibilityEntityProvider(final KeyboardView keyboardView, final InputMethodService inputMethod) { mInputMethodService = inputMethod; @@ -92,14 +90,43 @@ public final class AccessibilityEntityProvider extends AccessibilityNodeProvider // Since this class is constructed lazily, we might not get a subsequent // call to setKeyboard() and therefore need to call it now. - setKeyboard(); + setKeyboard(keyboardView.getKeyboard()); } /** * Sets the keyboard represented by this node provider. + * + * @param keyboard The keyboard that is being set to the keyboard view. */ - public void setKeyboard() { - assignVirtualViewIds(); + public void setKeyboard(final Keyboard keyboard) { + mKeyboard = keyboard; + } + + private Key getKeyOf(final int virtualViewId) { + if (mKeyboard == null) { + return null; + } + final List<Key> sortedKeys = mKeyboard.getSortedKeys(); + // Use a virtual view id as an index of the sorted keys list. + if (virtualViewId >= 0 && virtualViewId < sortedKeys.size()) { + return sortedKeys.get(virtualViewId); + } + return null; + } + + private int getVirtualViewIdOf(final Key key) { + if (mKeyboard == null) { + return View.NO_ID; + } + final List<Key> sortedKeys = mKeyboard.getSortedKeys(); + final int size = sortedKeys.size(); + for (int index = 0; index < size; index++) { + if (sortedKeys.get(index) == key) { + // Use an index of the sorted keys list as a virtual view id. + return index; + } + } + return View.NO_ID; } /** @@ -112,7 +139,7 @@ public final class AccessibilityEntityProvider extends AccessibilityNodeProvider * @see AccessibilityEvent */ public AccessibilityEvent createAccessibilityEvent(final Key key, final int eventType) { - final int virtualViewId = generateVirtualViewIdForKey(key); + final int virtualViewId = getVirtualViewIdOf(key); final String keyDescription = getKeyDescription(key); final AccessibilityEvent event = AccessibilityEvent.obtain(eventType); event.setPackageName(mKeyboardView.getContext().getPackageName()); @@ -158,16 +185,21 @@ public final class AccessibilityEntityProvider extends AccessibilityNodeProvider ViewCompat.onInitializeAccessibilityNodeInfo(mKeyboardView, rootInfo); // Add the virtual children of the root View. - final Keyboard keyboard = mKeyboardView.getKeyboard(); - for (final Key key : keyboard.getSortedKeys()) { - final int childVirtualViewId = generateVirtualViewIdForKey(key); - rootInfo.addChild(mKeyboardView, childVirtualViewId); + final List<Key> sortedKeys = mKeyboard.getSortedKeys(); + final int size = sortedKeys.size(); + for (int index = 0; index < size; index++) { + final Key key = sortedKeys.get(index); + if (key.isSpacer()) { + continue; + } + // Use an index of the sorted keys list as a virtual view id. + rootInfo.addChild(mKeyboardView, index); } return rootInfo; } - // Find the view that corresponds to the given id. - final Key key = mVirtualViewIdToKey.get(virtualViewId); + // Find the key that corresponds to the given virtual view id. + final Key key = getKeyOf(virtualViewId); if (key == null) { Log.e(TAG, "Invalid virtual view ID: " + virtualViewId); return null; @@ -202,31 +234,10 @@ public final class AccessibilityEntityProvider extends AccessibilityNodeProvider return info; } - /** - * Simulates a key press by injecting touch events into the keyboard view. - * This avoids the complexity of trackers and listeners within the keyboard. - * - * @param key The key to press. - */ - void simulateKeyPress(final Key key) { - final int x = key.getHitBox().centerX(); - final int y = key.getHitBox().centerY(); - final long downTime = SystemClock.uptimeMillis(); - final MotionEvent downEvent = MotionEvent.obtain( - downTime, downTime, MotionEvent.ACTION_DOWN, x, y, 0); - final MotionEvent upEvent = MotionEvent.obtain( - downTime, SystemClock.uptimeMillis(), MotionEvent.ACTION_UP, x, y, 0); - - mKeyboardView.onTouchEvent(downEvent); - mKeyboardView.onTouchEvent(upEvent); - downEvent.recycle(); - upEvent.recycle(); - } - @Override public boolean performAction(final int virtualViewId, final int action, final Bundle arguments) { - final Key key = mVirtualViewIdToKey.get(virtualViewId); + final Key key = getKeyOf(virtualViewId); if (key == null) { return false; } @@ -242,7 +253,7 @@ public final class AccessibilityEntityProvider extends AccessibilityNodeProvider * @return The result of performing the action, or false if the action is not supported. */ boolean performActionForKey(final Key key, final int action, final Bundle arguments) { - final int virtualViewId = generateVirtualViewIdForKey(key); + final int virtualViewId = getVirtualViewIdOf(key); switch (action) { case AccessibilityNodeInfoCompat.ACTION_ACCESSIBILITY_FOCUS: @@ -288,7 +299,7 @@ public final class AccessibilityEntityProvider extends AccessibilityNodeProvider final boolean shouldObscure = mAccessibilityUtils.shouldObscureInput(editorInfo); final SettingsValues currentSettings = Settings.getInstance().getCurrent(); final String keyCodeDescription = mKeyCodeDescriptionMapper.getDescriptionForKey( - mKeyboardView.getContext(), mKeyboardView.getKeyboard(), key, shouldObscure); + mKeyboardView.getContext(), mKeyboard, key, shouldObscure); if (currentSettings.isWordSeparator(key.getCode())) { return mAccessibilityUtils.getAutoCorrectionDescription( keyCodeDescription, shouldObscure); @@ -298,39 +309,9 @@ public final class AccessibilityEntityProvider extends AccessibilityNodeProvider } /** - * Assigns virtual view IDs to keyboard keys and populates the related maps. - */ - private void assignVirtualViewIds() { - final Keyboard keyboard = mKeyboardView.getKeyboard(); - if (keyboard == null) { - return; - } - mVirtualViewIdToKey.clear(); - - for (final Key key : keyboard.getSortedKeys()) { - final int virtualViewId = generateVirtualViewIdForKey(key); - mVirtualViewIdToKey.put(virtualViewId, key); - } - } - - /** * Updates the parent's on-screen location. */ private void updateParentLocation() { mKeyboardView.getLocationOnScreen(mParentLocation); } - - /** - * Generates a virtual view identifier for the given key. Returned - * identifiers are valid until the next global layout state change. - * - * @param key The key to identify. - * @return A virtual view identifier. - */ - private static int generateVirtualViewIdForKey(final Key key) { - // The key x- and y-coordinates are stable between layout changes. - // Generate an identifier by bit-shifting the x-coordinate to the - // left-half of the integer and OR'ing with the y-coordinate. - return ((0xFFFF & key.getX()) << (Integer.SIZE / 2)) | (0xFFFF & key.getY()); - } } diff --git a/java/src/com/android/inputmethod/accessibility/AccessibleKeyboardViewProxy.java b/java/src/com/android/inputmethod/accessibility/AccessibleKeyboardViewProxy.java index 0043b7844..d2031d155 100644 --- a/java/src/com/android/inputmethod/accessibility/AccessibleKeyboardViewProxy.java +++ b/java/src/com/android/inputmethod/accessibility/AccessibleKeyboardViewProxy.java @@ -18,6 +18,7 @@ package com.android.inputmethod.accessibility; import android.content.Context; import android.inputmethodservice.InputMethodService; +import android.os.SystemClock; import android.support.v4.view.AccessibilityDelegateCompat; import android.support.v4.view.ViewCompat; import android.support.v4.view.accessibility.AccessibilityEventCompat; @@ -34,6 +35,7 @@ import com.android.inputmethod.keyboard.Keyboard; import com.android.inputmethod.keyboard.KeyboardId; import com.android.inputmethod.keyboard.MainKeyboardView; import com.android.inputmethod.latin.R; +import com.android.inputmethod.latin.utils.SubtypeLocaleUtils; public final class AccessibleKeyboardViewProxy extends AccessibilityDelegateCompat { private static final AccessibleKeyboardViewProxy sInstance = new AccessibleKeyboardViewProxy(); @@ -55,6 +57,7 @@ public final class AccessibleKeyboardViewProxy extends AccessibilityDelegateComp private InputMethodService mInputMethod; private MainKeyboardView mView; + private Keyboard mKeyboard; private AccessibilityEntityProvider mAccessibilityNodeProvider; private Key mLastHoverKey = null; @@ -65,7 +68,8 @@ public final class AccessibleKeyboardViewProxy extends AccessibilityDelegateComp private int mEdgeSlop; /** The most recently set keyboard mode. */ - private int mLastKeyboardMode; + private int mLastKeyboardMode = KEYBOARD_IS_HIDDEN; + private static final int KEYBOARD_IS_HIDDEN = -1; public static void init(final InputMethodService inputMethod) { sInstance.initInternal(inputMethod); @@ -104,6 +108,10 @@ public final class AccessibleKeyboardViewProxy extends AccessibilityDelegateComp return; } mAccessibilityNodeProvider.setView(view); + + // Since this class is constructed lazily, we might not get a subsequent + // call to setKeyboard() and therefore need to call it now. + setKeyboard(view.getKeyboard()); } /** @@ -111,24 +119,33 @@ public final class AccessibleKeyboardViewProxy extends AccessibilityDelegateComp * <p> * <b>Note:</b> This method will be called even if accessibility is not * enabled. + * @param keyboard The keyboard that is being set to the wrapping view. */ - public void setKeyboard() { - if (mView == null) { + public void setKeyboard(final Keyboard keyboard) { + if (keyboard == null) { return; } if (mAccessibilityNodeProvider != null) { - mAccessibilityNodeProvider.setKeyboard(); + mAccessibilityNodeProvider.setKeyboard(keyboard); } - final int keyboardMode = mView.getKeyboard().mId.mMode; + final Keyboard lastKeyboard = mKeyboard; + final int lastKeyboardMode = mLastKeyboardMode; + mKeyboard = keyboard; + mLastKeyboardMode = keyboard.mId.mMode; // Since this method is called even when accessibility is off, make sure - // to check the state before announcing anything. Also, don't announce - // changes within the same mode. - if (AccessibilityUtils.getInstance().isAccessibilityEnabled() - && (mLastKeyboardMode != keyboardMode)) { - announceKeyboardMode(keyboardMode); + // to check the state before announcing anything. + if (!AccessibilityUtils.getInstance().isAccessibilityEnabled()) { + return; + } + // Announce the language name only when the language is changed. + if (lastKeyboard == null || !lastKeyboard.mId.mSubtype.equals(keyboard.mId.mSubtype)) { + announceKeyboardLanguage(keyboard); + } + // Announce the mode only when the mode is changed. + if (lastKeyboardMode != keyboard.mId.mMode) { + announceKeyboardMode(keyboard); } - mLastKeyboardMode = keyboardMode; } /** @@ -139,23 +156,35 @@ public final class AccessibleKeyboardViewProxy extends AccessibilityDelegateComp return; } announceKeyboardHidden(); - mLastKeyboardMode = -1; + mLastKeyboardMode = KEYBOARD_IS_HIDDEN; } /** - * Announces which type of keyboard is being displayed. If the keyboard type - * is unknown, no announcement is made. + * Announces which language of keyboard is being displayed. * - * @param mode The new keyboard mode. + * @param keyboard The new keyboard. */ - private void announceKeyboardMode(int mode) { - final int resId = KEYBOARD_MODE_RES_IDS.get(mode); - if (resId == 0) { + private void announceKeyboardLanguage(final Keyboard keyboard) { + final String languageText = SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale( + keyboard.mId.mSubtype); + sendWindowStateChanged(languageText); + } + + /** + * Announces which type of keyboard is being displayed. + * If the keyboard type is unknown, no announcement is made. + * + * @param keyboard The new keyboard. + */ + private void announceKeyboardMode(final Keyboard keyboard) { + final int mode = keyboard.mId.mMode; + final Context context = mView.getContext(); + final int modeTextResId = KEYBOARD_MODE_RES_IDS.get(mode); + if (modeTextResId == 0) { return; } - final Context context = mView.getContext(); - final String keyboardMode = context.getString(resId); - final String text = context.getString(R.string.announce_keyboard_mode, keyboardMode); + final String modeText = context.getString(modeTextResId); + final String text = context.getString(R.string.announce_keyboard_mode, modeText); sendWindowStateChanged(text); } @@ -233,7 +262,8 @@ public final class AccessibleKeyboardViewProxy extends AccessibilityDelegateComp // Make sure we're not getting an EXIT event because the user slid // off the keyboard area, then force a key press. if (key != null) { - getAccessibilityNodeProvider().simulateKeyPress(key); + final long downTime = simulateKeyPress(key); + simulateKeyRelease(key, downTime); } //$FALL-THROUGH$ case MotionEvent.ACTION_HOVER_ENTER: @@ -274,6 +304,38 @@ public final class AccessibleKeyboardViewProxy extends AccessibilityDelegateComp } /** + * Simulates a key press by injecting touch event into the keyboard view. + * This avoids the complexity of trackers and listeners within the keyboard. + * + * @param key The key to press. + */ + private long simulateKeyPress(final Key key) { + final int x = key.getHitBox().centerX(); + final int y = key.getHitBox().centerY(); + final long downTime = SystemClock.uptimeMillis(); + final MotionEvent downEvent = MotionEvent.obtain( + downTime, downTime, MotionEvent.ACTION_DOWN, x, y, 0); + mView.onTouchEvent(downEvent); + downEvent.recycle(); + return downTime; + } + + /** + * Simulates a key release by injecting touch event into the keyboard view. + * This avoids the complexity of trackers and listeners within the keyboard. + * + * @param key The key to release. + */ + private void simulateKeyRelease(final Key key, final long downTime) { + final int x = key.getHitBox().centerX(); + final int y = key.getHitBox().centerY(); + final MotionEvent upEvent = MotionEvent.obtain( + downTime, SystemClock.uptimeMillis(), MotionEvent.ACTION_UP, x, y, 0); + mView.onTouchEvent(upEvent); + upEvent.recycle(); + } + + /** * Simulates a transition between two {@link Key}s by sending a HOVER_EXIT on the previous key, * a HOVER_ENTER on the current key, and a HOVER_MOVE on the current key. * @@ -329,12 +391,11 @@ public final class AccessibleKeyboardViewProxy extends AccessibilityDelegateComp * Notifies the user of changes in the keyboard shift state. */ public void notifyShiftState() { - if (mView == null) { + if (mView == null || mKeyboard == null) { return; } - final Keyboard keyboard = mView.getKeyboard(); - final KeyboardId keyboardId = keyboard.mId; + final KeyboardId keyboardId = mKeyboard.mId; final int elementId = keyboardId.mElementId; final Context context = mView.getContext(); final CharSequence text; @@ -359,14 +420,13 @@ public final class AccessibleKeyboardViewProxy extends AccessibilityDelegateComp * Notifies the user of changes in the keyboard symbols state. */ public void notifySymbolsState() { - if (mView == null) { + if (mView == null || mKeyboard == null) { return; } - final Keyboard keyboard = mView.getKeyboard(); - final Context context = mView.getContext(); - final KeyboardId keyboardId = keyboard.mId; + final KeyboardId keyboardId = mKeyboard.mId; final int elementId = keyboardId.mElementId; + final Context context = mView.getContext(); final int resId; switch (elementId) { @@ -388,12 +448,9 @@ public final class AccessibleKeyboardViewProxy extends AccessibilityDelegateComp resId = R.string.spoken_description_mode_phone_shift; break; default: - resId = -1; - } - - if (resId < 0) { return; } + final String text = context.getString(resId); AccessibilityUtils.getInstance().announceForAccessibility(mView, text); } diff --git a/java/src/com/android/inputmethod/keyboard/MainKeyboardView.java b/java/src/com/android/inputmethod/keyboard/MainKeyboardView.java index 1cafd4162..ecef8cc6c 100644 --- a/java/src/com/android/inputmethod/keyboard/MainKeyboardView.java +++ b/java/src/com/android/inputmethod/keyboard/MainKeyboardView.java @@ -406,7 +406,7 @@ public final class MainKeyboardView extends KeyboardView implements PointerTrack // This always needs to be set since the accessibility state can // potentially change without the keyboard being set again. - AccessibleKeyboardViewProxy.getInstance().setKeyboard(); + AccessibleKeyboardViewProxy.getInstance().setKeyboard(keyboard); } /** diff --git a/java/src/com/android/inputmethod/keyboard/ProximityInfo.java b/java/src/com/android/inputmethod/keyboard/ProximityInfo.java index 3746d5b79..c89bda40e 100644 --- a/java/src/com/android/inputmethod/keyboard/ProximityInfo.java +++ b/java/src/com/android/inputmethod/keyboard/ProximityInfo.java @@ -118,10 +118,11 @@ public class ProximityInfo { final int[] proximityCharsArray = new int[mGridSize * MAX_PROXIMITY_CHARS_SIZE]; Arrays.fill(proximityCharsArray, Constants.NOT_A_CODE); for (int i = 0; i < mGridSize; ++i) { - final int proximityCharsLength = gridNeighborKeys[i].size(); + final List<Key> neighborKeys = gridNeighborKeys[i]; + final int proximityCharsLength = neighborKeys.size(); int infoIndex = i * MAX_PROXIMITY_CHARS_SIZE; for (int j = 0; j < proximityCharsLength; ++j) { - final Key neighborKey = gridNeighborKeys[i].get(j); + final Key neighborKey = neighborKeys.get(j); // Excluding from proximityCharsArray if (!needsProximityInfo(neighborKey)) { continue; @@ -359,11 +360,11 @@ y |---+---+---+---+-v-+-|-+---+---+---+---+---| | thresholdBase and get for (int i = 0; i < gridSize; ++i) { final int indexStart = i * keyCount; final int indexEnd = indexStart + neighborCountPerCell[i]; - final ArrayList<Key> neighbords = CollectionUtils.newArrayList(indexEnd - indexStart); + final ArrayList<Key> neighbors = CollectionUtils.newArrayList(indexEnd - indexStart); for (int index = indexStart; index < indexEnd; index++) { - neighbords.add(neighborsFlatBuffer[index]); + neighbors.add(neighborsFlatBuffer[index]); } - mGridNeighbors[i] = Collections.unmodifiableList(neighbords); + mGridNeighbors[i] = Collections.unmodifiableList(neighbors); } } diff --git a/java/src/com/android/inputmethod/keyboard/internal/DynamicGridKeyboard.java b/java/src/com/android/inputmethod/keyboard/internal/DynamicGridKeyboard.java index 397c098ce..67a222732 100644 --- a/java/src/com/android/inputmethod/keyboard/internal/DynamicGridKeyboard.java +++ b/java/src/com/android/inputmethod/keyboard/internal/DynamicGridKeyboard.java @@ -213,8 +213,7 @@ public class DynamicGridKeyboard extends Keyboard { if (mCachedGridKeys != null) { return mCachedGridKeys; } - final ArrayList<Key> cachedKeys = CollectionUtils.newArrayList(mGridKeys.size()); - cachedKeys.addAll(mGridKeys); + final ArrayList<Key> cachedKeys = new ArrayList<Key>(mGridKeys); mCachedGridKeys = Collections.unmodifiableList(cachedKeys); return mCachedGridKeys; } 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); + } + } } |