| /* |
| * Copyright (C) 2009 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package com.android.inputmethod.pinyin; |
| |
| import com.android.inputmethod.pinyin.SoftKeyboard.KeyRow; |
| |
| import android.content.res.Resources; |
| import android.view.inputmethod.EditorInfo; |
| |
| /** |
| * Switcher used to switching input mode between Chinese, English, symbol,etc. |
| */ |
| public class InputModeSwitcher { |
| /** |
| * User defined key code, used by soft keyboard. |
| */ |
| private static final int USERDEF_KEYCODE_SHIFT_1 = -1; |
| |
| /** |
| * User defined key code, used by soft keyboard. |
| */ |
| private static final int USERDEF_KEYCODE_LANG_2 = -2; |
| |
| /** |
| * User defined key code, used by soft keyboard. |
| */ |
| private static final int USERDEF_KEYCODE_SYM_3 = -3; |
| |
| /** |
| * User defined key code, used by soft keyboard. |
| */ |
| public static final int USERDEF_KEYCODE_PHONE_SYM_4 = -4; |
| |
| /** |
| * User defined key code, used by soft keyboard. |
| */ |
| private static final int USERDEF_KEYCODE_MORE_SYM_5 = -5; |
| |
| /** |
| * User defined key code, used by soft keyboard. |
| */ |
| private static final int USERDEF_KEYCODE_SMILEY_6 = -6; |
| |
| |
| /** |
| * Bits used to indicate soft keyboard layout. If none bit is set, the |
| * current input mode does not require a soft keyboard. |
| **/ |
| private static final int MASK_SKB_LAYOUT = 0xf0000000; |
| |
| /** |
| * A kind of soft keyboard layout. An input mode should be anded with |
| * {@link #MASK_SKB_LAYOUT} to get its soft keyboard layout. |
| */ |
| private static final int MASK_SKB_LAYOUT_QWERTY = 0x10000000; |
| |
| /** |
| * A kind of soft keyboard layout. An input mode should be anded with |
| * {@link #MASK_SKB_LAYOUT} to get its soft keyboard layout. |
| */ |
| private static final int MASK_SKB_LAYOUT_SYMBOL1 = 0x20000000; |
| |
| /** |
| * A kind of soft keyboard layout. An input mode should be anded with |
| * {@link #MASK_SKB_LAYOUT} to get its soft keyboard layout. |
| */ |
| private static final int MASK_SKB_LAYOUT_SYMBOL2 = 0x30000000; |
| |
| /** |
| * A kind of soft keyboard layout. An input mode should be anded with |
| * {@link #MASK_SKB_LAYOUT} to get its soft keyboard layout. |
| */ |
| private static final int MASK_SKB_LAYOUT_SMILEY = 0x40000000; |
| |
| /** |
| * A kind of soft keyboard layout. An input mode should be anded with |
| * {@link #MASK_SKB_LAYOUT} to get its soft keyboard layout. |
| */ |
| private static final int MASK_SKB_LAYOUT_PHONE = 0x50000000; |
| |
| /** |
| * Used to indicate which language the current input mode is in. If the |
| * current input mode works with a none-QWERTY soft keyboard, these bits are |
| * also used to get language information. For example, a Chinese symbol soft |
| * keyboard and an English one are different in an icon which is used to |
| * tell user the language information. BTW, the smiley soft keyboard mode |
| * should be set with {@link #MASK_LANGUAGE_CN} because it can only be |
| * launched from Chinese QWERTY soft keyboard, and it has Chinese icon on |
| * soft keyboard. |
| */ |
| private static final int MASK_LANGUAGE = 0x0f000000; |
| |
| /** |
| * Used to indicate the current language. An input mode should be anded with |
| * {@link #MASK_LANGUAGE} to get this information. |
| */ |
| private static final int MASK_LANGUAGE_CN = 0x01000000; |
| |
| /** |
| * Used to indicate the current language. An input mode should be anded with |
| * {@link #MASK_LANGUAGE} to get this information. |
| */ |
| private static final int MASK_LANGUAGE_EN = 0x02000000; |
| |
| /** |
| * Used to indicate which case the current input mode is in. For example, |
| * English QWERTY has lowercase and uppercase. For the Chinese QWERTY, these |
| * bits are ignored. For phone keyboard layout, these bits can be |
| * {@link #MASK_CASE_UPPER} to request symbol page for phone soft keyboard. |
| */ |
| private static final int MASK_CASE = 0x00f00000; |
| |
| /** |
| * Used to indicate the current case information. An input mode should be |
| * anded with {@link #MASK_CASE} to get this information. |
| */ |
| private static final int MASK_CASE_LOWER = 0x00100000; |
| |
| /** |
| * Used to indicate the current case information. An input mode should be |
| * anded with {@link #MASK_CASE} to get this information. |
| */ |
| private static final int MASK_CASE_UPPER = 0x00200000; |
| |
| /** |
| * Mode for inputing Chinese with soft keyboard. |
| */ |
| public static final int MODE_SKB_CHINESE = (MASK_SKB_LAYOUT_QWERTY | MASK_LANGUAGE_CN); |
| |
| /** |
| * Mode for inputing basic symbols for Chinese mode with soft keyboard. |
| */ |
| public static final int MODE_SKB_SYMBOL1_CN = (MASK_SKB_LAYOUT_SYMBOL1 | MASK_LANGUAGE_CN); |
| |
| /** |
| * Mode for inputing more symbols for Chinese mode with soft keyboard. |
| */ |
| public static final int MODE_SKB_SYMBOL2_CN = (MASK_SKB_LAYOUT_SYMBOL2 | MASK_LANGUAGE_CN); |
| |
| /** |
| * Mode for inputing English lower characters with soft keyboard. |
| */ |
| public static final int MODE_SKB_ENGLISH_LOWER = (MASK_SKB_LAYOUT_QWERTY |
| | MASK_LANGUAGE_EN | MASK_CASE_LOWER); |
| |
| /** |
| * Mode for inputing English upper characters with soft keyboard. |
| */ |
| public static final int MODE_SKB_ENGLISH_UPPER = (MASK_SKB_LAYOUT_QWERTY |
| | MASK_LANGUAGE_EN | MASK_CASE_UPPER); |
| |
| /** |
| * Mode for inputing basic symbols for English mode with soft keyboard. |
| */ |
| public static final int MODE_SKB_SYMBOL1_EN = (MASK_SKB_LAYOUT_SYMBOL1 | MASK_LANGUAGE_EN); |
| |
| /** |
| * Mode for inputing more symbols for English mode with soft keyboard. |
| */ |
| public static final int MODE_SKB_SYMBOL2_EN = (MASK_SKB_LAYOUT_SYMBOL2 | MASK_LANGUAGE_EN); |
| |
| /** |
| * Mode for inputing smileys with soft keyboard. |
| */ |
| public static final int MODE_SKB_SMILEY = (MASK_SKB_LAYOUT_SMILEY | MASK_LANGUAGE_CN); |
| |
| /** |
| * Mode for inputing phone numbers. |
| */ |
| public static final int MODE_SKB_PHONE_NUM = (MASK_SKB_LAYOUT_PHONE); |
| |
| /** |
| * Mode for inputing phone numbers. |
| */ |
| public static final int MODE_SKB_PHONE_SYM = (MASK_SKB_LAYOUT_PHONE | MASK_CASE_UPPER); |
| |
| /** |
| * Mode for inputing Chinese with a hardware keyboard. |
| */ |
| public static final int MODE_HKB_CHINESE = (MASK_LANGUAGE_CN); |
| |
| /** |
| * Mode for inputing English with a hardware keyboard |
| */ |
| public static final int MODE_HKB_ENGLISH = (MASK_LANGUAGE_EN); |
| |
| /** |
| * Unset mode. |
| */ |
| public static final int MODE_UNSET = 0; |
| |
| /** |
| * Maximum toggle states for a soft keyboard. |
| */ |
| public static final int MAX_TOGGLE_STATES = 4; |
| |
| /** |
| * The input mode for the current edit box. |
| */ |
| private int mInputMode = MODE_UNSET; |
| |
| /** |
| * Used to remember previous input mode. When user enters an edit field, the |
| * previous input mode will be tried. If the previous mode can not be used |
| * for the current situation (For example, previous mode is a soft keyboard |
| * mode to input symbols, and we have a hardware keyboard for the current |
| * situation), {@link #mRecentLauageInputMode} will be tried. |
| **/ |
| private int mPreviousInputMode = MODE_SKB_CHINESE; |
| |
| /** |
| * Used to remember recent mode to input language. |
| */ |
| private int mRecentLauageInputMode = MODE_SKB_CHINESE; |
| |
| /** |
| * Editor information of the current edit box. |
| */ |
| private EditorInfo mEditorInfo; |
| |
| /** |
| * Used to indicate required toggling operations. |
| */ |
| private ToggleStates mToggleStates = new ToggleStates(); |
| |
| /** |
| * The current field is a short message field? |
| */ |
| private boolean mShortMessageField; |
| |
| /** |
| * Is return key in normal state? |
| */ |
| private boolean mEnterKeyNormal = true; |
| |
| /** |
| * Current icon. 0 for none icon. |
| */ |
| int mInputIcon = R.drawable.ime_pinyin; |
| |
| /** |
| * IME service. |
| */ |
| private PinyinIME mImeService; |
| |
| /** |
| * Key toggling state for Chinese mode. |
| */ |
| private int mToggleStateCn; |
| |
| /** |
| * Key toggling state for Chinese mode with candidates. |
| */ |
| private int mToggleStateCnCand; |
| |
| /** |
| * Key toggling state for English lowwercase mode. |
| */ |
| private int mToggleStateEnLower; |
| |
| /** |
| * Key toggling state for English upppercase mode. |
| */ |
| private int mToggleStateEnUpper; |
| |
| /** |
| * Key toggling state for English symbol mode for the first page. |
| */ |
| private int mToggleStateEnSym1; |
| |
| /** |
| * Key toggling state for English symbol mode for the second page. |
| */ |
| private int mToggleStateEnSym2; |
| |
| /** |
| * Key toggling state for smiley mode. |
| */ |
| private int mToggleStateSmiley; |
| |
| /** |
| * Key toggling state for phone symbol mode. |
| */ |
| private int mToggleStatePhoneSym; |
| |
| /** |
| * Key toggling state for GO action of ENTER key. |
| */ |
| private int mToggleStateGo; |
| |
| /** |
| * Key toggling state for SEARCH action of ENTER key. |
| */ |
| private int mToggleStateSearch; |
| |
| /** |
| * Key toggling state for SEND action of ENTER key. |
| */ |
| private int mToggleStateSend; |
| |
| /** |
| * Key toggling state for NEXT action of ENTER key. |
| */ |
| private int mToggleStateNext; |
| |
| /** |
| * Key toggling state for SEND action of ENTER key. |
| */ |
| private int mToggleStateDone; |
| |
| /** |
| * QWERTY row toggling state for Chinese input. |
| */ |
| private int mToggleRowCn; |
| |
| /** |
| * QWERTY row toggling state for English input. |
| */ |
| private int mToggleRowEn; |
| |
| /** |
| * QWERTY row toggling state for URI input. |
| */ |
| private int mToggleRowUri; |
| |
| /** |
| * QWERTY row toggling state for email address input. |
| */ |
| private int mToggleRowEmailAddress; |
| |
| class ToggleStates { |
| /** |
| * If it is true, this soft keyboard is a QWERTY one. |
| */ |
| boolean mQwerty; |
| |
| /** |
| * If {@link #mQwerty} is true, this variable is used to decide the |
| * letter case of the QWERTY keyboard. |
| */ |
| boolean mQwertyUpperCase; |
| |
| /** |
| * The id of enabled row in the soft keyboard. Refer to |
| * {@link com.android.inputmethod.pinyin.SoftKeyboard.KeyRow} for |
| * details. |
| */ |
| public int mRowIdToEnable; |
| |
| /** |
| * Used to store all other toggle states for the current input mode. |
| */ |
| public int mKeyStates[] = new int[MAX_TOGGLE_STATES]; |
| |
| /** |
| * Number of states to toggle. |
| */ |
| public int mKeyStatesNum; |
| } |
| |
| public InputModeSwitcher(PinyinIME imeService) { |
| mImeService = imeService; |
| Resources r = mImeService.getResources(); |
| mToggleStateCn = Integer.parseInt(r.getString(R.string.toggle_cn)); |
| mToggleStateCnCand = Integer.parseInt(r |
| .getString(R.string.toggle_cn_cand)); |
| mToggleStateEnLower = Integer.parseInt(r |
| .getString(R.string.toggle_en_lower)); |
| mToggleStateEnUpper = Integer.parseInt(r |
| .getString(R.string.toggle_en_upper)); |
| mToggleStateEnSym1 = Integer.parseInt(r |
| .getString(R.string.toggle_en_sym1)); |
| mToggleStateEnSym2 = Integer.parseInt(r |
| .getString(R.string.toggle_en_sym2)); |
| mToggleStateSmiley = Integer.parseInt(r |
| .getString(R.string.toggle_smiley)); |
| mToggleStatePhoneSym = Integer.parseInt(r |
| .getString(R.string.toggle_phone_sym)); |
| |
| mToggleStateGo = Integer |
| .parseInt(r.getString(R.string.toggle_enter_go)); |
| mToggleStateSearch = Integer.parseInt(r |
| .getString(R.string.toggle_enter_search)); |
| mToggleStateSend = Integer.parseInt(r |
| .getString(R.string.toggle_enter_send)); |
| mToggleStateNext = Integer.parseInt(r |
| .getString(R.string.toggle_enter_next)); |
| mToggleStateDone = Integer.parseInt(r |
| .getString(R.string.toggle_enter_done)); |
| |
| mToggleRowCn = Integer.parseInt(r.getString(R.string.toggle_row_cn)); |
| mToggleRowEn = Integer.parseInt(r.getString(R.string.toggle_row_en)); |
| mToggleRowUri = Integer.parseInt(r.getString(R.string.toggle_row_uri)); |
| mToggleRowEmailAddress = Integer.parseInt(r |
| .getString(R.string.toggle_row_emailaddress)); |
| } |
| |
| public int getInputMode() { |
| return mInputMode; |
| } |
| |
| public ToggleStates getToggleStates() { |
| return mToggleStates; |
| } |
| |
| public int getSkbLayout() { |
| int layout = (mInputMode & MASK_SKB_LAYOUT); |
| |
| switch (layout) { |
| case MASK_SKB_LAYOUT_QWERTY: |
| return R.xml.skb_qwerty; |
| case MASK_SKB_LAYOUT_SYMBOL1: |
| return R.xml.skb_sym1; |
| case MASK_SKB_LAYOUT_SYMBOL2: |
| return R.xml.skb_sym2; |
| case MASK_SKB_LAYOUT_SMILEY: |
| return R.xml.skb_smiley; |
| case MASK_SKB_LAYOUT_PHONE: |
| return R.xml.skb_phone; |
| } |
| return 0; |
| } |
| |
| // Return the icon to update. |
| public int switchLanguageWithHkb() { |
| int newInputMode = MODE_HKB_CHINESE; |
| mInputIcon = R.drawable.ime_pinyin; |
| |
| if (MODE_HKB_CHINESE == mInputMode) { |
| newInputMode = MODE_HKB_ENGLISH; |
| mInputIcon = R.drawable.ime_en; |
| } |
| |
| saveInputMode(newInputMode); |
| return mInputIcon; |
| } |
| |
| // Return the icon to update. |
| public int switchModeForUserKey(int userKey) { |
| int newInputMode = MODE_UNSET; |
| |
| if (USERDEF_KEYCODE_LANG_2 == userKey) { |
| if (MODE_SKB_CHINESE == mInputMode) { |
| newInputMode = MODE_SKB_ENGLISH_LOWER; |
| } else if (MODE_SKB_ENGLISH_LOWER == mInputMode |
| || MODE_SKB_ENGLISH_UPPER == mInputMode) { |
| newInputMode = MODE_SKB_CHINESE; |
| } else if (MODE_SKB_SYMBOL1_CN == mInputMode) { |
| newInputMode = MODE_SKB_SYMBOL1_EN; |
| } else if (MODE_SKB_SYMBOL1_EN == mInputMode) { |
| newInputMode = MODE_SKB_SYMBOL1_CN; |
| } else if (MODE_SKB_SYMBOL2_CN == mInputMode) { |
| newInputMode = MODE_SKB_SYMBOL2_EN; |
| } else if (MODE_SKB_SYMBOL2_EN == mInputMode) { |
| newInputMode = MODE_SKB_SYMBOL2_CN; |
| } else if (MODE_SKB_SMILEY == mInputMode) { |
| newInputMode = MODE_SKB_CHINESE; |
| } |
| } else if (USERDEF_KEYCODE_SYM_3 == userKey) { |
| if (MODE_SKB_CHINESE == mInputMode) { |
| newInputMode = MODE_SKB_SYMBOL1_CN; |
| } else if (MODE_SKB_ENGLISH_UPPER == mInputMode |
| || MODE_SKB_ENGLISH_LOWER == mInputMode) { |
| newInputMode = MODE_SKB_SYMBOL1_EN; |
| } else if (MODE_SKB_SYMBOL1_EN == mInputMode |
| || MODE_SKB_SYMBOL2_EN == mInputMode) { |
| newInputMode = MODE_SKB_ENGLISH_LOWER; |
| } else if (MODE_SKB_SYMBOL1_CN == mInputMode |
| || MODE_SKB_SYMBOL2_CN == mInputMode) { |
| newInputMode = MODE_SKB_CHINESE; |
| } else if (MODE_SKB_SMILEY == mInputMode) { |
| newInputMode = MODE_SKB_SYMBOL1_CN; |
| } |
| } else if (USERDEF_KEYCODE_SHIFT_1 == userKey) { |
| if (MODE_SKB_ENGLISH_LOWER == mInputMode) { |
| newInputMode = MODE_SKB_ENGLISH_UPPER; |
| } else if (MODE_SKB_ENGLISH_UPPER == mInputMode) { |
| newInputMode = MODE_SKB_ENGLISH_LOWER; |
| } |
| } else if (USERDEF_KEYCODE_MORE_SYM_5 == userKey) { |
| int sym = (MASK_SKB_LAYOUT & mInputMode); |
| if (MASK_SKB_LAYOUT_SYMBOL1 == sym) { |
| sym = MASK_SKB_LAYOUT_SYMBOL2; |
| } else { |
| sym = MASK_SKB_LAYOUT_SYMBOL1; |
| } |
| newInputMode = ((mInputMode & (~MASK_SKB_LAYOUT)) | sym); |
| } else if (USERDEF_KEYCODE_SMILEY_6 == userKey) { |
| if (MODE_SKB_CHINESE == mInputMode) { |
| newInputMode = MODE_SKB_SMILEY; |
| } else { |
| newInputMode = MODE_SKB_CHINESE; |
| } |
| } else if (USERDEF_KEYCODE_PHONE_SYM_4 == userKey) { |
| if (MODE_SKB_PHONE_NUM == mInputMode) { |
| newInputMode = MODE_SKB_PHONE_SYM; |
| } else { |
| newInputMode = MODE_SKB_PHONE_NUM; |
| } |
| } |
| |
| if (newInputMode == mInputMode || MODE_UNSET == newInputMode) { |
| return mInputIcon; |
| } |
| |
| saveInputMode(newInputMode); |
| prepareToggleStates(true); |
| return mInputIcon; |
| } |
| |
| // Return the icon to update. |
| public int requestInputWithHkb(EditorInfo editorInfo) { |
| mShortMessageField = false; |
| boolean english = false; |
| int newInputMode = MODE_HKB_CHINESE; |
| |
| switch (editorInfo.inputType & EditorInfo.TYPE_MASK_CLASS) { |
| case EditorInfo.TYPE_CLASS_NUMBER: |
| case EditorInfo.TYPE_CLASS_PHONE: |
| case EditorInfo.TYPE_CLASS_DATETIME: |
| english = true; |
| break; |
| case EditorInfo.TYPE_CLASS_TEXT: |
| int v = editorInfo.inputType & EditorInfo.TYPE_MASK_VARIATION; |
| if (v == EditorInfo.TYPE_TEXT_VARIATION_EMAIL_ADDRESS |
| || v == EditorInfo.TYPE_TEXT_VARIATION_PASSWORD |
| || v == EditorInfo.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD |
| || v == EditorInfo.TYPE_TEXT_VARIATION_URI) { |
| english = true; |
| } else if (v == EditorInfo.TYPE_TEXT_VARIATION_SHORT_MESSAGE) { |
| mShortMessageField = true; |
| } |
| break; |
| default: |
| } |
| |
| if (english) { |
| // If the application request English mode, we switch to it. |
| newInputMode = MODE_HKB_ENGLISH; |
| } else { |
| // If the application do not request English mode, we will |
| // try to keep the previous mode to input language text. |
| // Because there is not soft keyboard, we need discard all |
| // soft keyboard related information from the previous language |
| // mode. |
| if ((mRecentLauageInputMode & MASK_LANGUAGE) == MASK_LANGUAGE_CN) { |
| newInputMode = MODE_HKB_CHINESE; |
| } else { |
| newInputMode = MODE_HKB_ENGLISH; |
| } |
| } |
| mEditorInfo = editorInfo; |
| saveInputMode(newInputMode); |
| prepareToggleStates(false); |
| return mInputIcon; |
| } |
| |
| // Return the icon to update. |
| public int requestInputWithSkb(EditorInfo editorInfo) { |
| mShortMessageField = false; |
| |
| int newInputMode = MODE_SKB_CHINESE; |
| |
| switch (editorInfo.inputType & EditorInfo.TYPE_MASK_CLASS) { |
| case EditorInfo.TYPE_CLASS_NUMBER: |
| case EditorInfo.TYPE_CLASS_DATETIME: |
| newInputMode = MODE_SKB_SYMBOL1_EN; |
| break; |
| case EditorInfo.TYPE_CLASS_PHONE: |
| newInputMode = MODE_SKB_PHONE_NUM; |
| break; |
| case EditorInfo.TYPE_CLASS_TEXT: |
| int v = editorInfo.inputType & EditorInfo.TYPE_MASK_VARIATION; |
| if (v == EditorInfo.TYPE_TEXT_VARIATION_EMAIL_ADDRESS |
| || v == EditorInfo.TYPE_TEXT_VARIATION_PASSWORD |
| || v == EditorInfo.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD |
| || v == EditorInfo.TYPE_TEXT_VARIATION_URI) { |
| // If the application request English mode, we switch to it. |
| newInputMode = MODE_SKB_ENGLISH_LOWER; |
| } else { |
| if (v == EditorInfo.TYPE_TEXT_VARIATION_SHORT_MESSAGE) { |
| mShortMessageField = true; |
| } |
| // If the application do not request English mode, we will |
| // try to keep the previous mode. |
| int skbLayout = (mInputMode & MASK_SKB_LAYOUT); |
| newInputMode = mInputMode; |
| if (0 == skbLayout) { |
| if ((mInputMode & MASK_LANGUAGE) == MASK_LANGUAGE_CN) { |
| newInputMode = MODE_SKB_CHINESE; |
| } else { |
| newInputMode = MODE_SKB_ENGLISH_LOWER; |
| } |
| } |
| } |
| break; |
| default: |
| // Try to keep the previous mode. |
| int skbLayout = (mInputMode & MASK_SKB_LAYOUT); |
| newInputMode = mInputMode; |
| if (0 == skbLayout) { |
| if ((mInputMode & MASK_LANGUAGE) == MASK_LANGUAGE_CN) { |
| newInputMode = MODE_SKB_CHINESE; |
| } else { |
| newInputMode = MODE_SKB_ENGLISH_LOWER; |
| } |
| } |
| break; |
| } |
| |
| mEditorInfo = editorInfo; |
| saveInputMode(newInputMode); |
| prepareToggleStates(true); |
| return mInputIcon; |
| } |
| |
| // Return the icon to update. |
| public int requestBackToPreviousSkb() { |
| int layout = (mInputMode & MASK_SKB_LAYOUT); |
| int lastLayout = (mPreviousInputMode & MASK_SKB_LAYOUT); |
| if (0 != layout && 0 != lastLayout) { |
| mInputMode = mPreviousInputMode; |
| saveInputMode(mInputMode); |
| prepareToggleStates(true); |
| return mInputIcon; |
| } |
| return 0; |
| } |
| |
| public int getTooggleStateForCnCand() { |
| return mToggleStateCnCand; |
| } |
| |
| public boolean isEnglishWithHkb() { |
| return MODE_HKB_ENGLISH == mInputMode; |
| } |
| |
| public boolean isEnglishWithSkb() { |
| return MODE_SKB_ENGLISH_LOWER == mInputMode |
| || MODE_SKB_ENGLISH_UPPER == mInputMode; |
| } |
| |
| public boolean isEnglishUpperCaseWithSkb() { |
| return MODE_SKB_ENGLISH_UPPER == mInputMode; |
| } |
| |
| public boolean isChineseText() { |
| int skbLayout = (mInputMode & MASK_SKB_LAYOUT); |
| if (MASK_SKB_LAYOUT_QWERTY == skbLayout || 0 == skbLayout) { |
| int language = (mInputMode & MASK_LANGUAGE); |
| if (MASK_LANGUAGE_CN == language) return true; |
| } |
| return false; |
| } |
| |
| public boolean isChineseTextWithHkb() { |
| int skbLayout = (mInputMode & MASK_SKB_LAYOUT); |
| if (0 == skbLayout) { |
| int language = (mInputMode & MASK_LANGUAGE); |
| if (MASK_LANGUAGE_CN == language) return true; |
| } |
| return false; |
| } |
| |
| public boolean isChineseTextWithSkb() { |
| int skbLayout = (mInputMode & MASK_SKB_LAYOUT); |
| if (MASK_SKB_LAYOUT_QWERTY == skbLayout) { |
| int language = (mInputMode & MASK_LANGUAGE); |
| if (MASK_LANGUAGE_CN == language) return true; |
| } |
| return false; |
| } |
| |
| public boolean isSymbolWithSkb() { |
| int skbLayout = (mInputMode & MASK_SKB_LAYOUT); |
| if (MASK_SKB_LAYOUT_SYMBOL1 == skbLayout |
| || MASK_SKB_LAYOUT_SYMBOL2 == skbLayout) { |
| return true; |
| } |
| return false; |
| } |
| |
| public boolean isEnterNoramlState() { |
| return mEnterKeyNormal; |
| } |
| |
| public boolean tryHandleLongPressSwitch(int keyCode) { |
| if (USERDEF_KEYCODE_LANG_2 == keyCode |
| || USERDEF_KEYCODE_PHONE_SYM_4 == keyCode) { |
| mImeService.showOptionsMenu(); |
| return true; |
| } |
| return false; |
| } |
| |
| private void saveInputMode(int newInputMode) { |
| mPreviousInputMode = mInputMode; |
| mInputMode = newInputMode; |
| |
| int skbLayout = (mInputMode & MASK_SKB_LAYOUT); |
| if (MASK_SKB_LAYOUT_QWERTY == skbLayout || 0 == skbLayout) { |
| mRecentLauageInputMode = mInputMode; |
| } |
| |
| mInputIcon = R.drawable.ime_pinyin; |
| if (isEnglishWithHkb()) { |
| mInputIcon = R.drawable.ime_en; |
| } else if (isChineseTextWithHkb()) { |
| mInputIcon = R.drawable.ime_pinyin; |
| } |
| |
| if (!Environment.getInstance().hasHardKeyboard()) { |
| mInputIcon = 0; |
| } |
| } |
| |
| private void prepareToggleStates(boolean needSkb) { |
| mEnterKeyNormal = true; |
| if (!needSkb) return; |
| |
| mToggleStates.mQwerty = false; |
| mToggleStates.mKeyStatesNum = 0; |
| |
| int states[] = mToggleStates.mKeyStates; |
| int statesNum = 0; |
| // Toggle state for language. |
| int language = (mInputMode & MASK_LANGUAGE); |
| int layout = (mInputMode & MASK_SKB_LAYOUT); |
| int charcase = (mInputMode & MASK_CASE); |
| int variation = mEditorInfo.inputType & EditorInfo.TYPE_MASK_VARIATION; |
| |
| if (MASK_SKB_LAYOUT_PHONE != layout) { |
| if (MASK_LANGUAGE_CN == language) { |
| // Chinese and Chinese symbol are always the default states, |
| // do not add a toggling operation. |
| if (MASK_SKB_LAYOUT_QWERTY == layout) { |
| mToggleStates.mQwerty = true; |
| mToggleStates.mQwertyUpperCase = true; |
| if (mShortMessageField) { |
| states[statesNum] = mToggleStateSmiley; |
| statesNum++; |
| } |
| } |
| } else if (MASK_LANGUAGE_EN == language) { |
| if (MASK_SKB_LAYOUT_QWERTY == layout) { |
| mToggleStates.mQwerty = true; |
| mToggleStates.mQwertyUpperCase = false; |
| states[statesNum] = mToggleStateEnLower; |
| if (MASK_CASE_UPPER == charcase) { |
| mToggleStates.mQwertyUpperCase = true; |
| states[statesNum] = mToggleStateEnUpper; |
| } |
| statesNum++; |
| } else if (MASK_SKB_LAYOUT_SYMBOL1 == layout) { |
| states[statesNum] = mToggleStateEnSym1; |
| statesNum++; |
| } else if (MASK_SKB_LAYOUT_SYMBOL2 == layout) { |
| states[statesNum] = mToggleStateEnSym2; |
| statesNum++; |
| } |
| } |
| |
| // Toggle rows for QWERTY. |
| mToggleStates.mRowIdToEnable = KeyRow.DEFAULT_ROW_ID; |
| if (variation == EditorInfo.TYPE_TEXT_VARIATION_EMAIL_ADDRESS) { |
| mToggleStates.mRowIdToEnable = mToggleRowEmailAddress; |
| } else if (variation == EditorInfo.TYPE_TEXT_VARIATION_URI) { |
| mToggleStates.mRowIdToEnable = mToggleRowUri; |
| } else if (MASK_LANGUAGE_CN == language) { |
| mToggleStates.mRowIdToEnable = mToggleRowCn; |
| } else if (MASK_LANGUAGE_EN == language) { |
| mToggleStates.mRowIdToEnable = mToggleRowEn; |
| } |
| } else { |
| if (MASK_CASE_UPPER == charcase) { |
| states[statesNum] = mToggleStatePhoneSym; |
| statesNum++; |
| } |
| } |
| |
| // Toggle state for enter key. |
| int action = mEditorInfo.imeOptions |
| & (EditorInfo.IME_MASK_ACTION | EditorInfo.IME_FLAG_NO_ENTER_ACTION); |
| |
| if (action == EditorInfo.IME_ACTION_GO) { |
| states[statesNum] = mToggleStateGo; |
| statesNum++; |
| mEnterKeyNormal = false; |
| } else if (action == EditorInfo.IME_ACTION_SEARCH) { |
| states[statesNum] = mToggleStateSearch; |
| statesNum++; |
| mEnterKeyNormal = false; |
| } else if (action == EditorInfo.IME_ACTION_SEND) { |
| states[statesNum] = mToggleStateSend; |
| statesNum++; |
| mEnterKeyNormal = false; |
| } else if (action == EditorInfo.IME_ACTION_NEXT) { |
| int f = mEditorInfo.inputType & EditorInfo.TYPE_MASK_FLAGS; |
| if (f != EditorInfo.TYPE_TEXT_FLAG_MULTI_LINE) { |
| states[statesNum] = mToggleStateNext; |
| statesNum++; |
| mEnterKeyNormal = false; |
| } |
| } else if (action == EditorInfo.IME_ACTION_DONE) { |
| states[statesNum] = mToggleStateDone; |
| statesNum++; |
| mEnterKeyNormal = false; |
| } |
| mToggleStates.mKeyStatesNum = statesNum; |
| } |
| } |
