diff options
Diffstat (limited to 'java/src')
15 files changed, 203 insertions, 403 deletions
diff --git a/java/src/com/android/inputmethod/accessibility/KeyCodeDescriptionMapper.java b/java/src/com/android/inputmethod/accessibility/KeyCodeDescriptionMapper.java index efaf58fc2..3b4149d7f 100644 --- a/java/src/com/android/inputmethod/accessibility/KeyCodeDescriptionMapper.java +++ b/java/src/com/android/inputmethod/accessibility/KeyCodeDescriptionMapper.java @@ -176,25 +176,6 @@ public class KeyCodeDescriptionMapper { } /** - * Returns the keycode for the specified key given the current keyboard - * state. - * - * @param keyboard The keyboard on which the key resides. - * @param key The key from which to obtain a key code. - * @return the key code for the specified key - */ - private int getCorrectKeyCode(Keyboard keyboard, Key key) { - // If keyboard is in manual temporary upper case state and key has - // manual temporary uppercase letter as key hint letter, alternate - // character code should be sent. - if (keyboard.isManualTemporaryUpperCase() && key.hasUppercaseLetter() - && !TextUtils.isEmpty(key.mHintLabel)) { - return key.mHintLabel.charAt(0); - } - return key.mCode; - } - - /** * Returns a localized character sequence describing what will happen when * the specified key is pressed based on its key code. * <p> @@ -217,7 +198,7 @@ public class KeyCodeDescriptionMapper { */ private CharSequence getDescriptionForKeyCode(Context context, Keyboard keyboard, Key key, boolean shouldObscure) { - final int code = getCorrectKeyCode(keyboard, key); + final int code = key.mCode; if (keyboard.isShiftLocked() && mShiftLockedKeyCodeMap.containsKey(code)) { return context.getString(mShiftLockedKeyCodeMap.get(code)); diff --git a/java/src/com/android/inputmethod/keyboard/Key.java b/java/src/com/android/inputmethod/keyboard/Key.java index a2d379643..d4419aeaf 100644 --- a/java/src/com/android/inputmethod/keyboard/Key.java +++ b/java/src/com/android/inputmethod/keyboard/Key.java @@ -66,14 +66,13 @@ public class Key { private static final int LABEL_FLAGS_FOLLOW_KEY_LETTER_RATIO = 0x80; private static final int LABEL_FLAGS_FOLLOW_KEY_HINT_LABEL_RATIO = 0x100; private static final int LABEL_FLAGS_HAS_POPUP_HINT = 0x200; - private static final int LABEL_FLAGS_HAS_UPPERCASE_LETTER = 0x400; + private static final int LABEL_FLAGS_HAS_SHIFTED_LETTER_HINT = 0x400; private static final int LABEL_FLAGS_HAS_HINT_LABEL = 0x800; private static final int LABEL_FLAGS_WITH_ICON_LEFT = 0x1000; private static final int LABEL_FLAGS_WITH_ICON_RIGHT = 0x2000; private static final int LABEL_FLAGS_AUTO_X_SCALE = 0x4000; private static final int LABEL_FLAGS_PRESERVE_CASE = 0x8000; - private static final int LABEL_FLAGS_INACTIVATED_LABEL = 0x10000; - private static final int LABEL_FLAGS_INACTIVATED_UPPERCASE_LETTER = 0x20000; + private static final int LABEL_FLAGS_SHIFTED_LETTER_ACTIVATED = 0x10000; /** Icon to display instead of a label. Icon takes precedence over a label */ private final int mIconAttrId; @@ -114,7 +113,8 @@ public class Key { public static final int BACKGROUND_TYPE_NORMAL = 0; public static final int BACKGROUND_TYPE_FUNCTIONAL = 1; public static final int BACKGROUND_TYPE_ACTION = 2; - public static final int BACKGROUND_TYPE_STICKY = 3; + public static final int BACKGROUND_TYPE_STICKY_OFF = 3; + public static final int BACKGROUND_TYPE_STICKY_ON = 4; private final int mActionFlags; private static final int ACTION_FLAGS_IS_REPEATABLE = 0x01; @@ -125,8 +125,6 @@ public class Key { /** The current pressed state of this key */ private boolean mPressed; - /** If this is a sticky key, is its highlight on? */ - private boolean mHighlightOn; /** Key is enabled and responds on press */ private boolean mEnabled = true; @@ -303,31 +301,46 @@ public class Key { keyAttr, R.styleable.Keyboard_Key_keyLabel), preserveCase, params.mId); mHintLabel = adjustCaseOfStringForKeyboardId(style.getString( keyAttr, R.styleable.Keyboard_Key_keyHintLabel), preserveCase, params.mId); - mOutputText = adjustCaseOfStringForKeyboardId(style.getString( + String outputText = adjustCaseOfStringForKeyboardId(style.getString( keyAttr, R.styleable.Keyboard_Key_keyOutputText), preserveCase, params.mId); - // Choose the first letter of the label as primary code if not - // specified. - final int code = adjustCaseOfCodeForKeyboardId(style.getInt( - keyAttr, R.styleable.Keyboard_Key_code, Keyboard.CODE_UNSPECIFIED), preserveCase, - params.mId); - if (code == Keyboard.CODE_UNSPECIFIED && mOutputText == null + final int code = style.getInt( + keyAttr, R.styleable.Keyboard_Key_code, Keyboard.CODE_UNSPECIFIED); + // Choose the first letter of the label as primary code if not specified. + if (code == Keyboard.CODE_UNSPECIFIED && TextUtils.isEmpty(outputText) && !TextUtils.isEmpty(mLabel)) { - if (mLabel.length() != 1) { - Log.w(TAG, "Label is not a single letter: label=" + mLabel); + if (mLabel.codePointCount(0, mLabel.length()) == 1) { + final int activatedCode; + // Use the first letter of the hint label if shiftedLetterActivated flag is + // specified. + if (hasShiftedLetterHint() && isShiftedLetterActivated() + && !TextUtils.isEmpty(mHintLabel)) { + activatedCode = mHintLabel.codePointAt(0); + } else { + activatedCode = mLabel.codePointAt(0); + } + mCode = getRtlParenthesisCode(activatedCode, params.mIsRtlKeyboard); + } else { + // In some locale and case, the character might be represented by multiple code + // points, such as upper case Eszett of German alphabet. + outputText = mLabel; + mCode = Keyboard.CODE_OUTPUT_TEXT; } - final int firstChar = mLabel.charAt(0); - mCode = getRtlParenthesisCode(firstChar, params.mIsRtlKeyboard); - } else if (code == Keyboard.CODE_UNSPECIFIED && mOutputText != null) { + } else if (code == Keyboard.CODE_UNSPECIFIED && outputText != null) { mCode = Keyboard.CODE_OUTPUT_TEXT; } else { - mCode = code; + mCode = adjustCaseOfCodeForKeyboardId(code, preserveCase, params.mId); } + mOutputText = outputText; mAltCode = adjustCaseOfCodeForKeyboardId(style.getInt(keyAttr, R.styleable.Keyboard_Key_altCode, Keyboard.CODE_UNSPECIFIED), preserveCase, params.mId); mHashCode = hashCode(this); keyAttr.recycle(); + + if (hasShiftedLetterHint() && TextUtils.isEmpty(mHintLabel)) { + Log.w(TAG, "hasShiftedLetterHint specified without keyHintLabel: " + this); + } } private static int adjustCaseOfCodeForKeyboardId(int code, boolean preserveCase, @@ -335,7 +348,8 @@ public class Key { if (!Keyboard.isLetterCode(code) || preserveCase) return code; final String text = new String(new int[] { code } , 0, 1); final String casedText = adjustCaseOfStringForKeyboardId(text, preserveCase, id); - return casedText.codePointAt(0); + return casedText.codePointCount(0, casedText.length()) == 1 + ? casedText.codePointAt(0) : Keyboard.CODE_UNSPECIFIED; } private static String adjustCaseOfStringForKeyboardId(String text, boolean preserveCase, @@ -362,6 +376,7 @@ public class Key { key.mLabel, key.mHintLabel, key.mIconAttrId, + key.mBackgroundType, // Key can be distinguishable without the following members. // key.mAltCode, // key.mOutputText, @@ -370,7 +385,6 @@ public class Key { // key.mIcon, // key.mDisabledIconAttrId, // key.mPreviewIconAttrId, - // key.mBackgroundType, // key.mHorizontalGap, // key.mVerticalGap, // key.mVisualInsetLeft, @@ -388,7 +402,9 @@ public class Key { && o.mHeight == mHeight && o.mCode == mCode && TextUtils.equals(o.mLabel, mLabel) - && TextUtils.equals(o.mHintLabel, mHintLabel); + && TextUtils.equals(o.mHintLabel, mHintLabel) + && o.mIconAttrId != mIconAttrId + && o.mBackgroundType != mBackgroundType; } @Override @@ -401,6 +417,15 @@ public class Key { return o instanceof Key && equals((Key)o); } + @Override + public String toString() { + String top = Keyboard.printableCode(mCode); + if (mLabel != null && mLabel.length() != 1) { + top += "/\"" + mLabel + '"'; + } + return String.format("%s %d,%d", top, mX, mY); + } + public void markAsLeftEdge(Keyboard.Params params) { mHitBox.left = params.mHorizontalEdgesPadding; } @@ -417,10 +442,6 @@ public class Key { mHitBox.bottom = params.mOccupiedHeight + params.mBottomPadding; } - public boolean isSticky() { - return mBackgroundType == BACKGROUND_TYPE_STICKY; - } - public boolean isSpacer() { return false; } @@ -486,8 +507,8 @@ public class Key { return (mLabelFlags & LABEL_FLAGS_HAS_POPUP_HINT) != 0; } - public boolean hasUppercaseLetter() { - return (mLabelFlags & LABEL_FLAGS_HAS_UPPERCASE_LETTER) != 0; + public boolean hasShiftedLetterHint() { + return (mLabelFlags & LABEL_FLAGS_HAS_SHIFTED_LETTER_HINT) != 0; } public boolean hasHintLabel() { @@ -506,12 +527,8 @@ public class Key { return (mLabelFlags & LABEL_FLAGS_AUTO_X_SCALE) != 0; } - public boolean isInactivatedLabel() { - return (mLabelFlags & LABEL_FLAGS_INACTIVATED_LABEL) != 0; - } - - public boolean isInactivatedUppercaseLetter() { - return (mLabelFlags & LABEL_FLAGS_INACTIVATED_UPPERCASE_LETTER) != 0; + public boolean isShiftedLetterActivated() { + return (mLabelFlags & LABEL_FLAGS_SHIFTED_LETTER_ACTIVATED) != 0; } // TODO: Get rid of this method. @@ -542,10 +559,6 @@ public class Key { mPressed = false; } - public void setHighlightOn(boolean highlightOn) { - mHighlightOn = highlightOn; - } - public boolean isEnabled() { return mEnabled; } @@ -639,21 +652,17 @@ public class Key { * @see android.graphics.drawable.StateListDrawable#setState(int[]) */ public int[] getCurrentDrawableState() { - final boolean pressed = mPressed; - switch (mBackgroundType) { case BACKGROUND_TYPE_FUNCTIONAL: - return pressed ? KEY_STATE_FUNCTIONAL_PRESSED : KEY_STATE_FUNCTIONAL_NORMAL; + return mPressed ? KEY_STATE_FUNCTIONAL_PRESSED : KEY_STATE_FUNCTIONAL_NORMAL; case BACKGROUND_TYPE_ACTION: - return pressed ? KEY_STATE_ACTIVE_PRESSED : KEY_STATE_ACTIVE_NORMAL; - case BACKGROUND_TYPE_STICKY: - if (mHighlightOn) { - return pressed ? KEY_STATE_PRESSED_HIGHLIGHT_ON : KEY_STATE_NORMAL_HIGHLIGHT_ON; - } else { - return pressed ? KEY_STATE_PRESSED_HIGHLIGHT_OFF : KEY_STATE_NORMAL_HIGHLIGHT_OFF; - } + return mPressed ? KEY_STATE_ACTIVE_PRESSED : KEY_STATE_ACTIVE_NORMAL; + case BACKGROUND_TYPE_STICKY_OFF: + return mPressed ? KEY_STATE_PRESSED_HIGHLIGHT_OFF : KEY_STATE_NORMAL_HIGHLIGHT_OFF; + case BACKGROUND_TYPE_STICKY_ON: + return mPressed ? KEY_STATE_PRESSED_HIGHLIGHT_ON : KEY_STATE_NORMAL_HIGHLIGHT_ON; default: /* BACKGROUND_TYPE_NORMAL */ - return pressed ? KEY_STATE_PRESSED : KEY_STATE_NORMAL; + return mPressed ? KEY_STATE_PRESSED : KEY_STATE_NORMAL; } } diff --git a/java/src/com/android/inputmethod/keyboard/Keyboard.java b/java/src/com/android/inputmethod/keyboard/Keyboard.java index dd882098d..8832d8fd1 100644 --- a/java/src/com/android/inputmethod/keyboard/Keyboard.java +++ b/java/src/com/android/inputmethod/keyboard/Keyboard.java @@ -20,7 +20,6 @@ import android.content.Context; import android.content.res.Resources; import android.content.res.TypedArray; import android.content.res.XmlResourceParser; -import android.text.TextUtils; import android.util.AttributeSet; import android.util.DisplayMetrics; import android.util.Log; @@ -31,7 +30,6 @@ import android.view.InflateException; import com.android.inputmethod.compat.EditorInfoCompatUtils; import com.android.inputmethod.keyboard.internal.KeyStyles; import com.android.inputmethod.keyboard.internal.KeyboardIconsSet; -import com.android.inputmethod.keyboard.internal.KeyboardShiftState; import com.android.inputmethod.latin.LatinImeLogger; import com.android.inputmethod.latin.R; import com.android.inputmethod.latin.XmlParseUtils; @@ -130,16 +128,12 @@ public class Keyboard { /** List of keys and icons in this keyboard */ public final Set<Key> mKeys; public final Set<Key> mShiftKeys; - public final Set<Key> mShiftLockKeys; public final KeyboardIconsSet mIconsSet; private final Map<Integer, Key> mKeyCache = new HashMap<Integer, Key>(); private final ProximityInfo mProximityInfo; - // TODO: Remove this variable. - private final KeyboardShiftState mShiftState = new KeyboardShiftState(); - public Keyboard(Params params) { mId = params.mId; mThemeId = params.mThemeId; @@ -156,7 +150,6 @@ public class Keyboard { mKeys = Collections.unmodifiableSet(params.mKeys); mShiftKeys = Collections.unmodifiableSet(params.mShiftKeys); - mShiftLockKeys = Collections.unmodifiableSet(params.mShiftLockKeys); mIconsSet = params.mIconsSet; mProximityInfo = new ProximityInfo( @@ -188,70 +181,18 @@ public class Keyboard { } // TODO: Remove this method. - boolean hasShiftLockKey() { - return !mShiftLockKeys.isEmpty(); - } - - // TODO: Remove this method. - void setShiftLocked(boolean newShiftLockState) { - for (final Key key : mShiftLockKeys) { - // To represent "shift locked" state. The highlight is handled by background image that - // might be a StateListDrawable. - key.setHighlightOn(newShiftLockState); - final int attrId = newShiftLockState - ? R.styleable.Keyboard_iconShiftKeyShifted - : R.styleable.Keyboard_iconShiftKey; - key.setIcon(mIconsSet.getIconByAttrId(attrId)); - } - mShiftState.setShiftLocked(newShiftLockState); - } - - // TODO: Move this method to KeyboardId. public boolean isShiftLocked() { - return mShiftState.isShiftLocked(); - } - - private void setShiftKeyGraphics(boolean newShiftState) { - if (mShiftState.isShiftLocked()) { - return; - } - for (final Key key : mShiftKeys) { - final int attrId = newShiftState - ? R.styleable.Keyboard_iconShiftKeyShifted - : R.styleable.Keyboard_iconShiftKey; - key.setIcon(mIconsSet.getIconByAttrId(attrId)); - } + return mId.isAlphabetShiftLockedKeyboard(); } // TODO: Remove this method. - void setShifted(boolean newShiftState) { - setShiftKeyGraphics(newShiftState); - mShiftState.setShifted(newShiftState); - } - - // TODO: Move this method to KeyboardId. public boolean isShiftedOrShiftLocked() { - return mShiftState.isShiftedOrShiftLocked(); - } - - // TODO: Remove this method - void setAutomaticTemporaryUpperCase() { - setShiftKeyGraphics(true); - mShiftState.setAutomaticTemporaryUpperCase(); - } - - // TODO: Move this method to KeyboardId. - public boolean isManualTemporaryUpperCase() { - return mShiftState.isManualTemporaryUpperCase(); + return mId.isAlphabetShiftedOrShiftLockedKeyboard(); } // TODO: Remove this method. - public String adjustLabelCase(String label) { - if (mId.isAlphabetKeyboard() && isShiftedOrShiftLocked() && !TextUtils.isEmpty(label) - && label.length() < 3 && Character.isLowerCase(label.charAt(0))) { - return label.toUpperCase(mId.mLocale); - } - return label; + public boolean isManualShifted() { + return mId.isAlphabetManualShiftedKeyboard(); } public static boolean isLetterCode(int code) { @@ -291,7 +232,6 @@ public class Keyboard { public final Set<Key> mKeys = new HashSet<Key>(); public final Set<Key> mShiftKeys = new HashSet<Key>(); - public final Set<Key> mShiftLockKeys = new HashSet<Key>(); public final KeyboardIconsSet mIconsSet = new KeyboardIconsSet(); public KeyboardSet.KeysCache mKeysCache; @@ -360,7 +300,6 @@ public class Keyboard { protected void clearKeys() { mKeys.clear(); mShiftKeys.clear(); - mShiftLockKeys.clear(); clearHistogram(); } @@ -370,9 +309,6 @@ public class Keyboard { updateHistogram(key); if (key.mCode == Keyboard.CODE_SHIFT) { mShiftKeys.add(key); - if (key.isSticky()) { - mShiftLockKeys.add(key); - } } } @@ -437,6 +373,8 @@ public class Keyboard { case CODE_DELETE: return "delete"; case CODE_SHORTCUT: return "shortcut"; case CODE_UNSPECIFIED: return "unspec"; + case CODE_TAB: return "tab"; + case CODE_ENTER: return "enter"; default: if (code <= 0) Log.w(TAG, "Unknown non-positive key code=" + code); if (code < CODE_SPACE) return String.format("'\\u%02x'", code); diff --git a/java/src/com/android/inputmethod/keyboard/KeyboardId.java b/java/src/com/android/inputmethod/keyboard/KeyboardId.java index 8db8c9460..997b952de 100644 --- a/java/src/com/android/inputmethod/keyboard/KeyboardId.java +++ b/java/src/com/android/inputmethod/keyboard/KeyboardId.java @@ -124,6 +124,22 @@ public class KeyboardId { return mElementId < ELEMENT_SYMBOLS; } + // This should be aligned with {@link KeyboardShiftState#isShiftLocked}. + public boolean isAlphabetShiftLockedKeyboard() { + return mElementId == ELEMENT_ALPHABET_SHIFT_LOCKED + || mElementId == ELEMENT_ALPHABET_SHIFT_LOCK_SHIFTED; + } + + // This should be aligned with {@link KeyboardShiftState#isShiftedOrShiftLocked}. + public boolean isAlphabetShiftedOrShiftLockedKeyboard() { + return isAlphabetKeyboard() && mElementId != ELEMENT_ALPHABET; + } + + // This should be aligned with {@link KeyboardShiftState#isManualShifted}. + public boolean isAlphabetManualShiftedKeyboard() { + return mElementId != ELEMENT_ALPHABET_MANUAL_SHIFTED; + } + public boolean isSymbolsKeyboard() { return mElementId == ELEMENT_SYMBOLS || mElementId == ELEMENT_SYMBOLS_SHIFTED; } diff --git a/java/src/com/android/inputmethod/keyboard/KeyboardSet.java b/java/src/com/android/inputmethod/keyboard/KeyboardSet.java index ae5e4e860..0aed5068c 100644 --- a/java/src/com/android/inputmethod/keyboard/KeyboardSet.java +++ b/java/src/com/android/inputmethod/keyboard/KeyboardSet.java @@ -77,17 +77,6 @@ public class KeyboardSet { } } - static class KeyboardElement { - final int mElementId; - final int mLayoutId; - final boolean mAutoGenerate; - KeyboardElement(int elementId, int layoutId, boolean autoGenerate) { - mElementId = elementId; - mLayoutId = layoutId; - mAutoGenerate = autoGenerate; - } - } - static class Params { int mMode; int mInputType; @@ -100,8 +89,9 @@ public class KeyboardSet { Locale mLocale; int mOrientation; int mWidth; - final Map<Integer, KeyboardElement> mElementKeyboards = - new HashMap<Integer, KeyboardElement>(); + // KeyboardSet element id to keyboard layout XML id map. + final Map<Integer, Integer> mKeyboardSetElementIdToXmlIdMap = + new HashMap<Integer, Integer>(); Params() {} } @@ -117,41 +107,38 @@ public class KeyboardSet { mParams = params; } + // TODO: Remove this method, use {@link #getKeyboard} directly. public Keyboard getMainKeyboard() { - return getKeyboard(false, false, false); + return getKeyboard(KeyboardId.ELEMENT_ALPHABET); } - public Keyboard getSymbolsKeyboard() { - return getKeyboard(true, false, false); - } - - public Keyboard getSymbolsShiftedKeyboard() { - final Keyboard keyboard = getKeyboard(true, false, true); - // TODO: Remove this logic once we introduce initial keyboard shift state attribute. - // Symbol shift keyboard may have a shift key that has a caps lock style indicator (a.k.a. - // sticky shift key). To show or dismiss the indicator, we need to call setShiftLocked() - // that takes care of the current keyboard having such shift key or not. - keyboard.setShiftLocked(keyboard.hasShiftLockKey()); - return keyboard; - } + public Keyboard getKeyboard(int baseKeyboardSetElementId) { + final int keyboardSetElementId; + switch (mParams.mMode) { + case KeyboardId.MODE_PHONE: + keyboardSetElementId = + (baseKeyboardSetElementId == KeyboardId.ELEMENT_ALPHABET_MANUAL_SHIFTED) + ? KeyboardId.ELEMENT_PHONE_SHIFTED : KeyboardId.ELEMENT_PHONE; + break; + case KeyboardId.MODE_NUMBER: + keyboardSetElementId = KeyboardId.ELEMENT_NUMBER; + break; + default: + keyboardSetElementId = baseKeyboardSetElementId; + break; + } - private Keyboard getKeyboard(boolean isSymbols, boolean isShiftLock, boolean isShift) { - final int elementId = KeyboardSet.getElementId( - mParams.mMode, isSymbols, isShiftLock, isShift); - final KeyboardElement keyboardElement = mParams.mElementKeyboards.get(elementId); - // TODO: If keyboardElement.mAutoGenerate is true, the keyboard will be auto generated - // based on keyboardElement.mKayoutId Keyboard XML definition. - final KeyboardId id = KeyboardSet.getKeyboardId(elementId, isSymbols, mParams); - final Keyboard keyboard = getKeyboard(mContext, keyboardElement, id); + Integer keyboardXmlId = mParams.mKeyboardSetElementIdToXmlIdMap.get(keyboardSetElementId); + if (keyboardXmlId == null) { + keyboardXmlId = mParams.mKeyboardSetElementIdToXmlIdMap.get( + KeyboardId.ELEMENT_ALPHABET); + } + final KeyboardId id = getKeyboardId(keyboardSetElementId); + final Keyboard keyboard = getKeyboard(mContext, keyboardXmlId, id); return keyboard; } - public KeyboardId getMainKeyboardId() { - final int elementId = KeyboardSet.getElementId(mParams.mMode, false, false, false); - return KeyboardSet.getKeyboardId(elementId, false, mParams); - } - - private Keyboard getKeyboard(Context context, KeyboardElement element, KeyboardId id) { + private Keyboard getKeyboard(Context context, int keyboardXmlId, KeyboardId id) { final Resources res = context.getResources(); final SoftReference<Keyboard> ref = sKeyboardCache.get(id); Keyboard keyboard = (ref == null) ? null : ref.get(); @@ -160,10 +147,10 @@ public class KeyboardSet { try { final Keyboard.Builder<Keyboard.Params> builder = new Keyboard.Builder<Keyboard.Params>(context, new Keyboard.Params()); - if (element.mAutoGenerate) { + if (id.isAlphabetKeyboard()) { builder.setAutoGenerate(mKeysCache); } - builder.load(element.mLayoutId, id); + builder.load(keyboardXmlId, id); builder.setTouchPositionCorrectionEnabled(mParams.mTouchPositionCorrectionEnabled); keyboard = builder.build(); } finally { @@ -179,36 +166,23 @@ public class KeyboardSet { Log.d(TAG, "keyboard cache size=" + sKeyboardCache.size() + ": HIT id=" + id); } - // TODO: Remove setShiftLocked and setShift calls. - keyboard.setShiftLocked(false); - keyboard.setShifted(false); return keyboard; } - private static int getElementId(int mode, boolean isSymbols, boolean isShiftLock, - boolean isShift) { - switch (mode) { - case KeyboardId.MODE_PHONE: - return (isSymbols && isShift) - ? KeyboardId.ELEMENT_PHONE_SHIFTED : KeyboardId.ELEMENT_PHONE; - case KeyboardId.MODE_NUMBER: - return KeyboardId.ELEMENT_NUMBER; - default: - if (isSymbols) { - return isShift - ? KeyboardId.ELEMENT_SYMBOLS_SHIFTED : KeyboardId.ELEMENT_SYMBOLS; - } - // TODO: Consult isShiftLock and isShift to determine the element. - return KeyboardId.ELEMENT_ALPHABET; - } - } - - private static KeyboardId getKeyboardId(int elementId, boolean isSymbols, Params params) { + // TODO: Make this method private. + // Note: The keyboard for each locale, shift state, and mode are represented as KeyboardSet + // element id that is a key in keyboard_set.xml. Also that file specifies which XML layout + // should be used for each keyboard. The KeyboardId is an internal key for Keyboard object. + public KeyboardId getKeyboardId(int keyboardSetElementId) { + final Params params = mParams; + final boolean isSymbols = (keyboardSetElementId == KeyboardId.ELEMENT_SYMBOLS + || keyboardSetElementId == KeyboardId.ELEMENT_SYMBOLS_SHIFTED); final boolean hasShortcutKey = params.mVoiceKeyEnabled && (isSymbols != params.mVoiceKeyOnMain); - return new KeyboardId(elementId, params.mLocale, params.mOrientation, params.mWidth, - params.mMode, params.mInputType, params.mImeOptions, params.mSettingsKeyEnabled, - params.mNoSettingsKey, params.mVoiceKeyEnabled, hasShortcutKey); + return new KeyboardId(keyboardSetElementId, params.mLocale, params.mOrientation, + params.mWidth, params.mMode, params.mInputType, params.mImeOptions, + params.mSettingsKeyEnabled, params.mNoSettingsKey, params.mVoiceKeyEnabled, + hasShortcutKey); } public static class Builder { @@ -345,10 +319,7 @@ public class KeyboardSet { R.styleable.KeyboardSet_Element_elementName, 0); final int elementKeyboard = a.getResourceId( R.styleable.KeyboardSet_Element_elementKeyboard, 0); - final boolean elementAutoGenerate = a.getBoolean( - R.styleable.KeyboardSet_Element_elementAutoGenerate, false); - mParams.mElementKeyboards.put(elementName, new KeyboardElement( - elementName, elementKeyboard, elementAutoGenerate)); + mParams.mKeyboardSetElementIdToXmlIdMap.put(elementName, elementKeyboard); } finally { a.recycle(); } diff --git a/java/src/com/android/inputmethod/keyboard/KeyboardSwitcher.java b/java/src/com/android/inputmethod/keyboard/KeyboardSwitcher.java index 5a59cc1c7..17ad45df0 100644 --- a/java/src/com/android/inputmethod/keyboard/KeyboardSwitcher.java +++ b/java/src/com/android/inputmethod/keyboard/KeyboardSwitcher.java @@ -135,24 +135,19 @@ public class KeyboardSwitcher implements KeyboardState.SwitchActions, settingsValues.isVoiceKeyEnabled(editorInfo), settingsValues.isVoiceKeyOnMain()); mKeyboardSet = builder.build(); - final KeyboardId mainKeyboardId = mKeyboardSet.getMainKeyboardId(); try { mState.onLoadKeyboard(mResources.getString(R.string.layout_switch_back_symbols)); } catch (RuntimeException e) { - Log.w(TAG, "loading keyboard failed: " + mainKeyboardId, e); - LatinImeLogger.logOnException(mainKeyboardId.toString(), e); + Log.w(TAG, "loading keyboard failed: " + mKeyboardSet.getKeyboardId( + KeyboardId.ELEMENT_ALPHABET), e); + LatinImeLogger.logOnException(mKeyboardSet.getKeyboardId( + KeyboardId.ELEMENT_ALPHABET).toString(), e); return; } - // TODO: Should get rid of this special case handling for Phone Number layouts once we - // have separate layouts with unique KeyboardIds for alphabet and alphabet-shifted - // respectively. - if (mainKeyboardId.isPhoneKeyboard()) { - mState.setSymbolsKeyboard(); - } } public void saveKeyboardState() { - if (isKeyboardAvailable()) { + if (getKeyboard() != null) { mState.onSaveKeyboardState(); } } @@ -184,31 +179,23 @@ public class KeyboardSwitcher implements KeyboardState.SwitchActions, mInputMethodService.mHandler.startDisplayLanguageOnSpacebar(localeChanged); } + // TODO: Remove this method. public boolean isAlphabetMode() { final Keyboard keyboard = getKeyboard(); return keyboard != null && keyboard.mId.isAlphabetKeyboard(); } + // TODO: Remove this method. public boolean isInputViewShown() { return mCurrentInputView != null && mCurrentInputView.isShown(); } + // TODO: Remove this method. public boolean isShiftedOrShiftLocked() { final Keyboard keyboard = getKeyboard(); return keyboard != null && keyboard.isShiftedOrShiftLocked(); } - public boolean isManualTemporaryUpperCase() { - final Keyboard keyboard = getKeyboard(); - return keyboard != null && keyboard.isManualTemporaryUpperCase(); - } - - public boolean isKeyboardAvailable() { - if (mKeyboardView != null) - return mKeyboardView.getKeyboard() != null; - return false; - } - public Keyboard getKeyboard() { if (mKeyboardView != null) { return mKeyboardView.getKeyboard(); @@ -235,91 +222,46 @@ public class KeyboardSwitcher implements KeyboardState.SwitchActions, mState.onCancelInput(isSinglePointer()); } - // TODO: Remove these constants. - private static final int ALPHABET_UNSHIFTED = 0; - private static final int ALPHABET_MANUAL_SHIFTED = 1; - private static final int ALPHABET_AUTOMATIC_SHIFTED = 2; - private static final int ALPHABET_SHIFT_LOCKED = 3; - private static final int ALPHABET_SHIFT_LOCK_SHIFTED = 4; - - // TODO: Remove this method. - private void updateAlphabetKeyboardShiftState(int shiftMode) { - mInputMethodService.mHandler.cancelUpdateShiftState(); - Keyboard keyboard = getKeyboard(); - if (keyboard == null) - return; - switch (shiftMode) { - case ALPHABET_UNSHIFTED: - keyboard.setShifted(false); - break; - case ALPHABET_MANUAL_SHIFTED: - keyboard.setShifted(true); - break; - case ALPHABET_AUTOMATIC_SHIFTED: - keyboard.setAutomaticTemporaryUpperCase(); - break; - case ALPHABET_SHIFT_LOCKED: - keyboard.setShiftLocked(true); - break; - case ALPHABET_SHIFT_LOCK_SHIFTED: - keyboard.setShiftLocked(true); - keyboard.setShifted(true); - break; - } - mKeyboardView.invalidateAllKeys(); - if (shiftMode != ALPHABET_SHIFT_LOCKED) { - // To be able to turn off caps lock by "double tap" on shift key, we should ignore - // the second tap of the "double tap" from now for a while because we just have - // already turned off caps lock above. - mKeyboardView.startIgnoringDoubleTap(); - } - } - // Implements {@link KeyboardState.SwitchActions}. @Override public void setAlphabetKeyboard() { - setKeyboard(mKeyboardSet.getMainKeyboard()); - updateAlphabetKeyboardShiftState(ALPHABET_UNSHIFTED); + setKeyboard(mKeyboardSet.getKeyboard(KeyboardId.ELEMENT_ALPHABET)); } // Implements {@link KeyboardState.SwitchActions}. @Override public void setAlphabetManualShiftedKeyboard() { - setKeyboard(mKeyboardSet.getMainKeyboard()); - updateAlphabetKeyboardShiftState(ALPHABET_MANUAL_SHIFTED); + setKeyboard(mKeyboardSet.getKeyboard(KeyboardId.ELEMENT_ALPHABET_MANUAL_SHIFTED)); } // Implements {@link KeyboardState.SwitchActions}. @Override public void setAlphabetAutomaticShiftedKeyboard() { - setKeyboard(mKeyboardSet.getMainKeyboard()); - updateAlphabetKeyboardShiftState(ALPHABET_AUTOMATIC_SHIFTED); + setKeyboard(mKeyboardSet.getKeyboard(KeyboardId.ELEMENT_ALPHABET_AUTOMATIC_SHIFTED)); } // Implements {@link KeyboardState.SwitchActions}. @Override public void setAlphabetShiftLockedKeyboard() { - setKeyboard(mKeyboardSet.getMainKeyboard()); - updateAlphabetKeyboardShiftState(ALPHABET_SHIFT_LOCKED); + setKeyboard(mKeyboardSet.getKeyboard(KeyboardId.ELEMENT_ALPHABET_SHIFT_LOCKED)); } // Implements {@link KeyboardState.SwitchActions}. @Override public void setAlphabetShiftLockShiftedKeyboard() { - setKeyboard(mKeyboardSet.getMainKeyboard()); - updateAlphabetKeyboardShiftState(ALPHABET_SHIFT_LOCK_SHIFTED); + setKeyboard(mKeyboardSet.getKeyboard(KeyboardId.ELEMENT_ALPHABET_SHIFT_LOCK_SHIFTED)); } // Implements {@link KeyboardState.SwitchActions}. @Override public void setSymbolsKeyboard() { - setKeyboard(mKeyboardSet.getSymbolsKeyboard()); + setKeyboard(mKeyboardSet.getKeyboard(KeyboardId.ELEMENT_SYMBOLS)); } // Implements {@link KeyboardState.SwitchActions}. @Override public void setSymbolsShiftedKeyboard() { - setKeyboard(mKeyboardSet.getSymbolsShiftedKeyboard()); + setKeyboard(mKeyboardSet.getKeyboard(KeyboardId.ELEMENT_SYMBOLS_SHIFTED)); } // Implements {@link KeyboardState.SwitchActions}. diff --git a/java/src/com/android/inputmethod/keyboard/KeyboardView.java b/java/src/com/android/inputmethod/keyboard/KeyboardView.java index d977327a8..2cbd132ca 100644 --- a/java/src/com/android/inputmethod/keyboard/KeyboardView.java +++ b/java/src/com/android/inputmethod/keyboard/KeyboardView.java @@ -53,12 +53,12 @@ import java.util.HashMap; * @attr ref R.styleable#KeyboardView_keyLargeLetterRatio * @attr ref R.styleable#KeyboardView_keyLabelRatio * @attr ref R.styleable#KeyboardView_keyHintLetterRatio - * @attr ref R.styleable#KeyboardView_keyUppercaseLetterRatio + * @attr ref R.styleable#KeyboardView_keyShiftedLetterHintRatio * @attr ref R.styleable#KeyboardView_keyHintLabelRatio * @attr ref R.styleable#KeyboardView_keyLabelHorizontalPadding * @attr ref R.styleable#KeyboardView_keyHintLetterPadding * @attr ref R.styleable#KeyboardView_keyPopupHintLetterPadding - * @attr ref R.styleable#KeyboardView_keyUppercaseLetterPadding + * @attr ref R.styleable#KeyboardView_keyShiftedLetterHintPadding * @attr ref R.styleable#KeyboardView_keyTextStyle * @attr ref R.styleable#KeyboardView_keyPreviewLayout * @attr ref R.styleable#KeyboardView_keyPreviewTextRatio @@ -68,8 +68,8 @@ import java.util.HashMap; * @attr ref R.styleable#KeyboardView_keyTextColorDisabled * @attr ref R.styleable#KeyboardView_keyHintLetterColor * @attr ref R.styleable#KeyboardView_keyHintLabelColor - * @attr ref R.styleable#KeyboardView_keyUppercaseLetterInactivatedColor - * @attr ref R.styleable#KeyboardView_keyUppercaseLetterActivatedColor + * @attr ref R.styleable#KeyboardView_keyShiftedLetterHintInactivatedColor + * @attr ref R.styleable#KeyboardView_keyShiftedLetterHintActivatedColor * @attr ref R.styleable#KeyboardView_shadowColor * @attr ref R.styleable#KeyboardView_shadowRadius */ @@ -175,20 +175,20 @@ public class KeyboardView extends View implements PointerTracker.DrawingProxy { public final float mKeyLabelHorizontalPadding; public final float mKeyHintLetterPadding; public final float mKeyPopupHintLetterPadding; - public final float mKeyUppercaseLetterPadding; + public final float mKeyShiftedLetterHintPadding; public final int mShadowColor; public final float mShadowRadius; public final Drawable mKeyBackground; public final int mKeyHintLetterColor; public final int mKeyHintLabelColor; - public final int mKeyUppercaseLetterInactivatedColor; - public final int mKeyUppercaseLetterActivatedColor; + public final int mKeyShiftedLetterHintInactivatedColor; + public final int mKeyShiftedLetterHintActivatedColor; private final float mKeyLetterRatio; private final float mKeyLargeLetterRatio; private final float mKeyLabelRatio; private final float mKeyHintLetterRatio; - private final float mKeyUppercaseLetterRatio; + private final float mKeyShiftedLetterHintRatio; private final float mKeyHintLabelRatio; private static final float UNDEFINED_RATIO = -1.0f; @@ -197,7 +197,7 @@ public class KeyboardView extends View implements PointerTracker.DrawingProxy { public int mKeyLargeLetterSize; public int mKeyLabelSize; public int mKeyHintLetterSize; - public int mKeyUppercaseLetterSize; + public int mKeyShiftedLetterHintSize; public int mKeyHintLabelSize; public KeyDrawParams(TypedArray a) { @@ -216,8 +216,8 @@ public class KeyboardView extends View implements PointerTracker.DrawingProxy { } mKeyLargeLetterRatio = getRatio(a, R.styleable.KeyboardView_keyLargeLetterRatio); mKeyHintLetterRatio = getRatio(a, R.styleable.KeyboardView_keyHintLetterRatio); - mKeyUppercaseLetterRatio = getRatio(a, - R.styleable.KeyboardView_keyUppercaseLetterRatio); + mKeyShiftedLetterHintRatio = getRatio(a, + R.styleable.KeyboardView_keyShiftedLetterHintRatio); mKeyHintLabelRatio = getRatio(a, R.styleable.KeyboardView_keyHintLabelRatio); mKeyLabelHorizontalPadding = a.getDimension( R.styleable.KeyboardView_keyLabelHorizontalPadding, 0); @@ -225,17 +225,17 @@ public class KeyboardView extends View implements PointerTracker.DrawingProxy { R.styleable.KeyboardView_keyHintLetterPadding, 0); mKeyPopupHintLetterPadding = a.getDimension( R.styleable.KeyboardView_keyPopupHintLetterPadding, 0); - mKeyUppercaseLetterPadding = a.getDimension( - R.styleable.KeyboardView_keyUppercaseLetterPadding, 0); + mKeyShiftedLetterHintPadding = a.getDimension( + R.styleable.KeyboardView_keyShiftedLetterHintPadding, 0); mKeyTextColor = a.getColor(R.styleable.KeyboardView_keyTextColor, 0xFF000000); mKeyTextInactivatedColor = a.getColor( R.styleable.KeyboardView_keyTextInactivatedColor, 0xFF000000); mKeyHintLetterColor = a.getColor(R.styleable.KeyboardView_keyHintLetterColor, 0); mKeyHintLabelColor = a.getColor(R.styleable.KeyboardView_keyHintLabelColor, 0); - mKeyUppercaseLetterInactivatedColor = a.getColor( - R.styleable.KeyboardView_keyUppercaseLetterInactivatedColor, 0); - mKeyUppercaseLetterActivatedColor = a.getColor( - R.styleable.KeyboardView_keyUppercaseLetterActivatedColor, 0); + mKeyShiftedLetterHintInactivatedColor = a.getColor( + R.styleable.KeyboardView_keyShiftedLetterHintInactivatedColor, 0); + mKeyShiftedLetterHintActivatedColor = a.getColor( + R.styleable.KeyboardView_keyShiftedLetterHintActivatedColor, 0); mKeyTextStyle = Typeface.defaultFromStyle( a.getInt(R.styleable.KeyboardView_keyTextStyle, Typeface.NORMAL)); mShadowColor = a.getColor(R.styleable.KeyboardView_shadowColor, 0); @@ -251,7 +251,7 @@ public class KeyboardView extends View implements PointerTracker.DrawingProxy { mKeyLabelSize = (int)(keyHeight * mKeyLabelRatio); mKeyLargeLetterSize = (int)(keyHeight * mKeyLargeLetterRatio); mKeyHintLetterSize = (int)(keyHeight * mKeyHintLetterRatio); - mKeyUppercaseLetterSize = (int)(keyHeight * mKeyUppercaseLetterRatio); + mKeyShiftedLetterHintSize = (int)(keyHeight * mKeyShiftedLetterHintRatio); mKeyHintLabelSize = (int)(keyHeight * mKeyHintLabelRatio); } } @@ -527,8 +527,7 @@ public class KeyboardView extends View implements PointerTracker.DrawingProxy { final Drawable icon = key.getIcon(mKeyboard.mIconsSet); float positionX = centerX; if (key.mLabel != null) { - // Switch the character to uppercase if shift is pressed - final String label = mKeyboard.adjustLabelCase(key.mLabel); + final String label = key.mLabel; // For characters, use large font. For labels like "Done", use smaller font. paint.setTypeface(key.selectTypeface(params.mKeyTextStyle)); final int labelSize = key.selectTextSize(params.mKeyLetterSize, @@ -571,14 +570,8 @@ public class KeyboardView extends View implements PointerTracker.DrawingProxy { Math.min(1.0f, (keyWidth * MAX_LABEL_RATIO) / getLabelWidth(label, paint))); } - // TODO: Remove this first if-clause. - if (key.hasUppercaseLetter() && mKeyboard.isManualTemporaryUpperCase()) { - paint.setColor(params.mKeyTextInactivatedColor); - } else if (key.isInactivatedLabel()) { - paint.setColor(params.mKeyTextInactivatedColor); - } else { - paint.setColor(params.mKeyTextColor); - } + paint.setColor(key.isShiftedLetterActivated() + ? params.mKeyTextInactivatedColor : params.mKeyTextColor); if (key.isEnabled()) { // Set a drop shadow for the text paint.setShadowLayer(params.mShadowRadius, 0, 0, params.mShadowColor); @@ -620,16 +613,11 @@ public class KeyboardView extends View implements PointerTracker.DrawingProxy { hintColor = params.mKeyHintLabelColor; hintSize = params.mKeyHintLabelSize; paint.setTypeface(Typeface.DEFAULT); - } else if (key.hasUppercaseLetter()) { - // TODO: Remove this first if-clause. - if (mKeyboard.isManualTemporaryUpperCase()) { - hintColor = params.mKeyUppercaseLetterActivatedColor; - } else if (!key.isInactivatedUppercaseLetter()) { - hintColor = params.mKeyUppercaseLetterActivatedColor; - } else { - hintColor = params.mKeyUppercaseLetterInactivatedColor; - } - hintSize = params.mKeyUppercaseLetterSize; + } else if (key.hasShiftedLetterHint()) { + hintColor = key.isShiftedLetterActivated() + ? params.mKeyShiftedLetterHintActivatedColor + : params.mKeyShiftedLetterHintInactivatedColor; + hintSize = params.mKeyShiftedLetterHintSize; } else { // key.hasHintLetter() hintColor = params.mKeyHintLetterColor; hintSize = params.mKeyHintLetterSize; @@ -644,9 +632,9 @@ public class KeyboardView extends View implements PointerTracker.DrawingProxy { hintX = positionX + getCharWidth(KEY_LABEL_REFERENCE_CHAR, paint) * 2; hintY = centerY + getCharHeight(KEY_LABEL_REFERENCE_CHAR, paint) / 2; paint.setTextAlign(Align.LEFT); - } else if (key.hasUppercaseLetter()) { + } else if (key.hasShiftedLetterHint()) { // The hint label is placed at top-right corner of the key. Used mainly on tablet. - hintX = keyWidth - params.mKeyUppercaseLetterPadding + hintX = keyWidth - params.mKeyShiftedLetterHintPadding - getCharWidth(KEY_LABEL_REFERENCE_CHAR, paint) / 2; hintY = -paint.ascent(); paint.setTextAlign(Align.CENTER); @@ -870,7 +858,7 @@ public class KeyboardView extends View implements PointerTracker.DrawingProxy { previewText.setTextSize(TypedValue.COMPLEX_UNIT_PX, params.mPreviewTextSize); previewText.setTypeface(params.mKeyTextStyle); } - previewText.setText(mKeyboard.adjustLabelCase(key.mLabel)); + previewText.setText(key.mLabel); } else { final Drawable previewIcon = mKeyboard.mIconsSet.getIconByAttrId( key.mPreviewIconAttrId); diff --git a/java/src/com/android/inputmethod/keyboard/LatinKeyboardView.java b/java/src/com/android/inputmethod/keyboard/LatinKeyboardView.java index 7e8a7180c..056aa255d 100644 --- a/java/src/com/android/inputmethod/keyboard/LatinKeyboardView.java +++ b/java/src/com/android/inputmethod/keyboard/LatinKeyboardView.java @@ -548,7 +548,6 @@ public class LatinKeyboardView extends KeyboardView implements PointerTracker.Ke mMoreKeysPanelPointerTrackerId = tracker.mPointerId; final Keyboard keyboard = getKeyboard(); - moreKeysPanel.setShifted(keyboard.isShiftedOrShiftLocked()); final int pointX = (mConfigShowMiniKeyboardAtTouchedPoint) ? tracker.getLastX() : parentKey.mX + parentKey.mWidth / 2; final int pointY = parentKey.mY - keyboard.mVerticalGap; diff --git a/java/src/com/android/inputmethod/keyboard/MiniKeyboardView.java b/java/src/com/android/inputmethod/keyboard/MiniKeyboardView.java index 1f9ed5e91..72d5b6889 100644 --- a/java/src/com/android/inputmethod/keyboard/MiniKeyboardView.java +++ b/java/src/com/android/inputmethod/keyboard/MiniKeyboardView.java @@ -131,13 +131,6 @@ public class MiniKeyboardView extends KeyboardView implements MoreKeysPanel { } @Override - public void setShifted(boolean shifted) { - final Keyboard keyboard = getKeyboard(); - keyboard.setShifted(shifted); - invalidateAllKeys(); - } - - @Override public void showMoreKeysPanel(View parentView, Controller controller, int pointX, int pointY, PopupWindow window, KeyboardActionListener listener) { mController = controller; diff --git a/java/src/com/android/inputmethod/keyboard/MoreKeysPanel.java b/java/src/com/android/inputmethod/keyboard/MoreKeysPanel.java index a3ff37269..f9a196d24 100644 --- a/java/src/com/android/inputmethod/keyboard/MoreKeysPanel.java +++ b/java/src/com/android/inputmethod/keyboard/MoreKeysPanel.java @@ -24,9 +24,6 @@ public interface MoreKeysPanel extends PointerTracker.KeyEventHandler { public boolean dismissMoreKeysPanel(); } - // TODO: Remove this method. - public void setShifted(boolean shifted); - /** * Show more keys panel. * diff --git a/java/src/com/android/inputmethod/keyboard/PointerTracker.java b/java/src/com/android/inputmethod/keyboard/PointerTracker.java index a75b8f9e6..4dac3474d 100644 --- a/java/src/com/android/inputmethod/keyboard/PointerTracker.java +++ b/java/src/com/android/inputmethod/keyboard/PointerTracker.java @@ -705,7 +705,7 @@ public class PointerTracker { if (sParams.mLongPressSpaceKeyTimeout > 0) { mTimerProxy.startLongPressTimer(sParams.mLongPressSpaceKeyTimeout, this); } - } else if (key.hasUppercaseLetter() && mKeyboard.isManualTemporaryUpperCase()) { + } else if (key.hasShiftedLetterHint() && mKeyboard.isManualShifted()) { // We need not start long press timer on the key which has manual temporary upper case // code defined and the keyboard is in manual temporary upper case mode. return; @@ -727,13 +727,6 @@ public class PointerTracker { final int[] codes = mKeyDetector.newCodeArray(); mKeyDetector.getKeyAndNearbyCodes(x, y, codes); - // If keyboard is in manual temporary upper case state and key has manual temporary - // uppercase letter as key hint letter, alternate character code should be sent. - if (mKeyboard.isManualTemporaryUpperCase() && key.hasUppercaseLetter()) { - code = key.mHintLabel.charAt(0); - codes[0] = code; - } - // Swap the first and second values in the codes array if the primary code is not the // first value but the second value in the array. This happens when key debouncing is // in effect. diff --git a/java/src/com/android/inputmethod/keyboard/internal/KeyboardShiftState.java b/java/src/com/android/inputmethod/keyboard/internal/AlphabetShiftState.java index 4608e22a5..5712df1fc 100644 --- a/java/src/com/android/inputmethod/keyboard/internal/KeyboardShiftState.java +++ b/java/src/com/android/inputmethod/keyboard/internal/AlphabetShiftState.java @@ -18,27 +18,27 @@ package com.android.inputmethod.keyboard.internal; import android.util.Log; -public class KeyboardShiftState { - private static final String TAG = KeyboardShiftState.class.getSimpleName(); +public class AlphabetShiftState { + private static final String TAG = AlphabetShiftState.class.getSimpleName(); private static final boolean DEBUG = false; - private static final int NORMAL = 0; + private static final int UNSHIFTED = 0; private static final int MANUAL_SHIFTED = 1; private static final int MANUAL_SHIFTED_FROM_AUTO = 2; - private static final int AUTO_SHIFTED = 3; + private static final int AUTOMATIC_SHIFTED = 3; private static final int SHIFT_LOCKED = 4; private static final int SHIFT_LOCK_SHIFTED = 5; - private int mState = NORMAL; + private int mState = UNSHIFTED; public void setShifted(boolean newShiftState) { final int oldState = mState; if (newShiftState) { switch (oldState) { - case NORMAL: + case UNSHIFTED: mState = MANUAL_SHIFTED; break; - case AUTO_SHIFTED: + case AUTOMATIC_SHIFTED: mState = MANUAL_SHIFTED_FROM_AUTO; break; case SHIFT_LOCKED: @@ -49,8 +49,8 @@ public class KeyboardShiftState { switch (oldState) { case MANUAL_SHIFTED: case MANUAL_SHIFTED_FROM_AUTO: - case AUTO_SHIFTED: - mState = NORMAL; + case AUTOMATIC_SHIFTED: + mState = UNSHIFTED; break; case SHIFT_LOCK_SHIFTED: mState = SHIFT_LOCKED; @@ -65,30 +65,30 @@ public class KeyboardShiftState { final int oldState = mState; if (newShiftLockState) { switch (oldState) { - case NORMAL: + case UNSHIFTED: case MANUAL_SHIFTED: case MANUAL_SHIFTED_FROM_AUTO: - case AUTO_SHIFTED: + case AUTOMATIC_SHIFTED: mState = SHIFT_LOCKED; break; } } else { - mState = NORMAL; + mState = UNSHIFTED; } if (DEBUG) Log.d(TAG, "setShiftLocked(" + newShiftLockState + "): " + toString(oldState) + " > " + this); } - public void setAutomaticTemporaryUpperCase() { + public void setAutomaticShifted() { final int oldState = mState; - mState = AUTO_SHIFTED; + mState = AUTOMATIC_SHIFTED; if (DEBUG) - Log.d(TAG, "setAutomaticTemporaryUpperCase: " + toString(oldState) + " > " + this); + Log.d(TAG, "setAutomaticShifted: " + toString(oldState) + " > " + this); } public boolean isShiftedOrShiftLocked() { - return mState != NORMAL; + return mState != UNSHIFTED; } public boolean isShiftLocked() { @@ -99,16 +99,16 @@ public class KeyboardShiftState { return mState == SHIFT_LOCK_SHIFTED; } - public boolean isAutomaticTemporaryUpperCase() { - return mState == AUTO_SHIFTED; + public boolean isAutomaticShifted() { + return mState == AUTOMATIC_SHIFTED; } - public boolean isManualTemporaryUpperCase() { + public boolean isManualShifted() { return mState == MANUAL_SHIFTED || mState == MANUAL_SHIFTED_FROM_AUTO || mState == SHIFT_LOCK_SHIFTED; } - public boolean isManualTemporaryUpperCaseFromAuto() { + public boolean isManualShiftedFromAutomaticShifted() { return mState == MANUAL_SHIFTED_FROM_AUTO; } @@ -119,13 +119,13 @@ public class KeyboardShiftState { private static String toString(int state) { switch (state) { - case NORMAL: return "NORMAL"; + case UNSHIFTED: return "UNSHIFTED"; case MANUAL_SHIFTED: return "MANUAL_SHIFTED"; case MANUAL_SHIFTED_FROM_AUTO: return "MANUAL_SHIFTED_FROM_AUTO"; - case AUTO_SHIFTED: return "AUTO_SHIFTED"; + case AUTOMATIC_SHIFTED: return "AUTOMATIC_SHIFTED"; case SHIFT_LOCKED: return "SHIFT_LOCKED"; case SHIFT_LOCK_SHIFTED: return "SHIFT_LOCK_SHIFTED"; - default: return "UKNOWN"; + default: return "UNKNOWN"; } } } diff --git a/java/src/com/android/inputmethod/keyboard/internal/KeyboardState.java b/java/src/com/android/inputmethod/keyboard/internal/KeyboardState.java index 5542bd32a..4af4e3cdf 100644 --- a/java/src/com/android/inputmethod/keyboard/internal/KeyboardState.java +++ b/java/src/com/android/inputmethod/keyboard/internal/KeyboardState.java @@ -70,7 +70,7 @@ public class KeyboardState { private String mLayoutSwitchBackSymbols; private boolean mIsAlphabetMode; - private KeyboardShiftState mAlphabetShiftState = new KeyboardShiftState(); + private AlphabetShiftState mAlphabetShiftState = new AlphabetShiftState(); private boolean mIsSymbolShifted; private boolean mPrevMainKeyboardWasShiftLocked; private boolean mPrevSymbolsKeyboardWasShifted; @@ -167,16 +167,16 @@ public class KeyboardState { } if (!mIsAlphabetMode) return; final int prevShiftMode; - if (mAlphabetShiftState.isAutomaticTemporaryUpperCase()) { + if (mAlphabetShiftState.isAutomaticShifted()) { prevShiftMode = AUTOMATIC_SHIFT; - } else if (mAlphabetShiftState.isManualTemporaryUpperCase()) { + } else if (mAlphabetShiftState.isManualShifted()) { prevShiftMode = MANUAL_SHIFT; } else { prevShiftMode = UNSHIFT; } switch (shiftMode) { case AUTOMATIC_SHIFT: - mAlphabetShiftState.setAutomaticTemporaryUpperCase(); + mAlphabetShiftState.setAutomaticShifted(); if (shiftMode != prevShiftMode) { mSwitchActions.setAlphabetAutomaticShiftedKeyboard(); } @@ -353,7 +353,7 @@ public class KeyboardState { // caps lock state and mark as if shift key pressed while normal state. setShifted(SHIFT_LOCK_SHIFTED); mShiftKeyState.onPress(); - } else if (mAlphabetShiftState.isAutomaticTemporaryUpperCase()) { + } else if (mAlphabetShiftState.isAutomaticShifted()) { // Shift key is pressed while automatic temporary upper case, we have to move to // manual temporary upper case. setShifted(MANUAL_SHIFT); @@ -400,7 +400,7 @@ public class KeyboardState { && mShiftKeyState.isPressingOnShifted() && !withSliding) { // Shift has been pressed without chording while shifted state. setShifted(UNSHIFT); - } else if (mAlphabetShiftState.isManualTemporaryUpperCaseFromAuto() + } else if (mAlphabetShiftState.isManualShiftedFromAutomaticShifted() && mShiftKeyState.isPressing() && !withSliding) { // Shift has been pressed without chording while manual temporary upper case // transited from automatic temporary upper case. diff --git a/java/src/com/android/inputmethod/latin/LatinIME.java b/java/src/com/android/inputmethod/latin/LatinIME.java index 2e7e82637..0d6395d97 100644 --- a/java/src/com/android/inputmethod/latin/LatinIME.java +++ b/java/src/com/android/inputmethod/latin/LatinIME.java @@ -1470,13 +1470,12 @@ public class LatinIME extends InputMethodServiceCompatWrapper implements Keyboar if (ic == null) return; - // True if keyboard is in either chording shift or manual temporary upper case mode. - final boolean isManualTemporaryUpperCase = mKeyboardSwitcher.isManualTemporaryUpperCase(); - if (EditorInfoCompatUtils.hasFlagNavigateNext(imeOptions) - && !isManualTemporaryUpperCase) { + final Keyboard keyboard = mKeyboardSwitcher.getKeyboard(); + // True if keyboard is in either shift chording or manual shifted state. + final boolean isManualShifted = (keyboard != null && keyboard.isManualShifted()); + if (EditorInfoCompatUtils.hasFlagNavigateNext(imeOptions) && !isManualShifted) { EditorInfoCompatUtils.performEditorActionNext(ic); - } else if (EditorInfoCompatUtils.hasFlagNavigatePrevious(imeOptions) - && isManualTemporaryUpperCase) { + } else if (EditorInfoCompatUtils.hasFlagNavigatePrevious(imeOptions) && isManualShifted) { EditorInfoCompatUtils.performEditorActionPrevious(ic); } } @@ -1518,27 +1517,6 @@ public class LatinIME extends InputMethodServiceCompatWrapper implements Keyboar mComposingStateManager.onFinishComposingText(); } } - final KeyboardSwitcher switcher = mKeyboardSwitcher; - if (switcher.isShiftedOrShiftLocked()) { - if (keyCodes == null || keyCodes[0] < Character.MIN_CODE_POINT - || keyCodes[0] > Character.MAX_CODE_POINT) { - return; - } - code = keyCodes[0]; - if (switcher.isAlphabetMode() && Character.isLowerCase(code)) { - // In some locales, such as Turkish, Character.toUpperCase() may return a wrong - // character because it doesn't take care of locale. - final String upperCaseString = new String(new int[] {code}, 0, 1) - .toUpperCase(mSubtypeSwitcher.getInputLocale()); - if (upperCaseString.codePointCount(0, upperCaseString.length()) == 1) { - code = upperCaseString.codePointAt(0); - } else { - // Some keys, such as [eszett], have upper case as multi-characters. - onTextInput(upperCaseString); - return; - } - } - } if (isComposingWord) { mWordComposer.add(code, keyCodes, x, y); if (ic != null) { diff --git a/java/src/com/android/inputmethod/latin/suggestions/MoreSuggestionsView.java b/java/src/com/android/inputmethod/latin/suggestions/MoreSuggestionsView.java index 600f14e04..cd83c3e21 100644 --- a/java/src/com/android/inputmethod/latin/suggestions/MoreSuggestionsView.java +++ b/java/src/com/android/inputmethod/latin/suggestions/MoreSuggestionsView.java @@ -141,11 +141,6 @@ public class MoreSuggestionsView extends KeyboardView implements MoreKeysPanel { } @Override - public void setShifted(boolean shifted) { - // Nothing to do with. - } - - @Override public void showMoreKeysPanel(View parentView, Controller controller, int pointX, int pointY, PopupWindow window, KeyboardActionListener listener) { mController = controller; |