auto import from //depot/cupcake/@135843
This commit is contained in:
The Android Open Source Project
@@ -0,0 +1,674 @@
|
||||
/*
|
||||
* Copyright (C) 2008-2009 Google Inc.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
|
||||
* use this file except in compliance with the License. You may obtain a copy of
|
||||
* the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
||||
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
||||
* License for the specific language governing permissions and limitations under
|
||||
* the License.
|
||||
*/
|
||||
|
||||
package com.example.android.softkeyboard;
|
||||
|
||||
import android.inputmethodservice.InputMethodService;
|
||||
import android.inputmethodservice.Keyboard;
|
||||
import android.inputmethodservice.KeyboardView;
|
||||
import android.text.method.MetaKeyKeyListener;
|
||||
import android.util.Log;
|
||||
import android.view.KeyCharacterMap;
|
||||
import android.view.KeyEvent;
|
||||
import android.view.View;
|
||||
import android.view.inputmethod.CompletionInfo;
|
||||
import android.view.inputmethod.EditorInfo;
|
||||
import android.view.inputmethod.InputConnection;
|
||||
import android.view.inputmethod.InputMethodManager;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* Example of writing an input method for a soft keyboard. This code is
|
||||
* focused on simplicity over completeness, so it should in no way be considered
|
||||
* to be a complete soft keyboard implementation. Its purpose is to provide
|
||||
* a basic example for how you would get started writing an input method, to
|
||||
* be fleshed out as appropriate.
|
||||
*/
|
||||
public class SoftKeyboard extends InputMethodService
|
||||
implements KeyboardView.OnKeyboardActionListener {
|
||||
static final boolean DEBUG = false;
|
||||
|
||||
/**
|
||||
* This boolean indicates the optional example code for performing
|
||||
* processing of hard keys in addition to regular text generation
|
||||
* from on-screen interaction. It would be used for input methods that
|
||||
* perform language translations (such as converting text entered on
|
||||
* a QWERTY keyboard to Chinese), but may not be used for input methods
|
||||
* that are primarily intended to be used for on-screen text entry.
|
||||
*/
|
||||
static final boolean PROCESS_HARD_KEYS = true;
|
||||
|
||||
private KeyboardView mInputView;
|
||||
private CandidateView mCandidateView;
|
||||
private CompletionInfo[] mCompletions;
|
||||
|
||||
private StringBuilder mComposing = new StringBuilder();
|
||||
private boolean mPredictionOn;
|
||||
private boolean mCompletionOn;
|
||||
private int mLastDisplayWidth;
|
||||
private boolean mCapsLock;
|
||||
private long mLastShiftTime;
|
||||
private long mMetaState;
|
||||
|
||||
private LatinKeyboard mSymbolsKeyboard;
|
||||
private LatinKeyboard mSymbolsShiftedKeyboard;
|
||||
private LatinKeyboard mQwertyKeyboard;
|
||||
|
||||
private LatinKeyboard mCurKeyboard;
|
||||
|
||||
private String mWordSeparators;
|
||||
|
||||
/**
|
||||
* Main initialization of the input method component. Be sure to call
|
||||
* to super class.
|
||||
*/
|
||||
@Override public void onCreate() {
|
||||
super.onCreate();
|
||||
mWordSeparators = getResources().getString(R.string.word_separators);
|
||||
}
|
||||
|
||||
/**
|
||||
* This is the point where you can do all of your UI initialization. It
|
||||
* is called after creation and any configuration change.
|
||||
*/
|
||||
@Override public void onInitializeInterface() {
|
||||
if (mQwertyKeyboard != null) {
|
||||
// Configuration changes can happen after the keyboard gets recreated,
|
||||
// so we need to be able to re-build the keyboards if the available
|
||||
// space has changed.
|
||||
int displayWidth = getMaxWidth();
|
||||
if (displayWidth == mLastDisplayWidth) return;
|
||||
mLastDisplayWidth = displayWidth;
|
||||
}
|
||||
mQwertyKeyboard = new LatinKeyboard(this, R.xml.qwerty);
|
||||
mSymbolsKeyboard = new LatinKeyboard(this, R.xml.symbols);
|
||||
mSymbolsShiftedKeyboard = new LatinKeyboard(this, R.xml.symbols_shift);
|
||||
}
|
||||
|
||||
/**
|
||||
* Called by the framework when your view for creating input needs to
|
||||
* be generated. This will be called the first time your input method
|
||||
* is displayed, and every time it needs to be re-created such as due to
|
||||
* a configuration change.
|
||||
*/
|
||||
@Override public View onCreateInputView() {
|
||||
mInputView = (KeyboardView) getLayoutInflater().inflate(
|
||||
R.layout.input, null);
|
||||
mInputView.setOnKeyboardActionListener(this);
|
||||
mInputView.setKeyboard(mQwertyKeyboard);
|
||||
return mInputView;
|
||||
}
|
||||
|
||||
/**
|
||||
* Called by the framework when your view for showing candidates needs to
|
||||
* be generated, like {@link #onCreateInputView}.
|
||||
*/
|
||||
@Override public View onCreateCandidatesView() {
|
||||
mCandidateView = new CandidateView(this);
|
||||
mCandidateView.setService(this);
|
||||
return mCandidateView;
|
||||
}
|
||||
|
||||
/**
|
||||
* This is the main point where we do our initialization of the input method
|
||||
* to begin operating on an application. At this point we have been
|
||||
* bound to the client, and are now receiving all of the detailed information
|
||||
* about the target of our edits.
|
||||
*/
|
||||
@Override public void onStartInput(EditorInfo attribute, boolean restarting) {
|
||||
super.onStartInput(attribute, restarting);
|
||||
|
||||
// Reset our state. We want to do this even if restarting, because
|
||||
// the underlying state of the text editor could have changed in any way.
|
||||
mComposing.setLength(0);
|
||||
updateCandidates();
|
||||
|
||||
if (!restarting) {
|
||||
// Clear shift states.
|
||||
mMetaState = 0;
|
||||
}
|
||||
|
||||
mPredictionOn = false;
|
||||
mCompletionOn = false;
|
||||
mCompletions = null;
|
||||
|
||||
// We are now going to initialize our state based on the type of
|
||||
// text being edited.
|
||||
switch (attribute.inputType&EditorInfo.TYPE_MASK_CLASS) {
|
||||
case EditorInfo.TYPE_CLASS_NUMBER:
|
||||
case EditorInfo.TYPE_CLASS_DATETIME:
|
||||
// Numbers and dates default to the symbols keyboard, with
|
||||
// no extra features.
|
||||
mCurKeyboard = mSymbolsKeyboard;
|
||||
break;
|
||||
|
||||
case EditorInfo.TYPE_CLASS_PHONE:
|
||||
// Phones will also default to the symbols keyboard, though
|
||||
// often you will want to have a dedicated phone keyboard.
|
||||
mCurKeyboard = mSymbolsKeyboard;
|
||||
break;
|
||||
|
||||
case EditorInfo.TYPE_CLASS_TEXT:
|
||||
// This is general text editing. We will default to the
|
||||
// normal alphabetic keyboard, and assume that we should
|
||||
// be doing predictive text (showing candidates as the
|
||||
// user types).
|
||||
mCurKeyboard = mQwertyKeyboard;
|
||||
mPredictionOn = true;
|
||||
|
||||
// We now look for a few special variations of text that will
|
||||
// modify our behavior.
|
||||
int variation = attribute.inputType & EditorInfo.TYPE_MASK_VARIATION;
|
||||
if (variation == EditorInfo.TYPE_TEXT_VARIATION_PASSWORD) {
|
||||
// Do not display predictions / what the user is typing
|
||||
// when they are entering a password.
|
||||
mPredictionOn = false;
|
||||
}
|
||||
|
||||
if (variation == EditorInfo.TYPE_TEXT_VARIATION_EMAIL_ADDRESS
|
||||
|| variation == EditorInfo.TYPE_TEXT_VARIATION_URI) {
|
||||
// Our predictions are not useful for e-mail addresses
|
||||
// or URIs.
|
||||
mPredictionOn = false;
|
||||
}
|
||||
|
||||
if ((attribute.inputType&EditorInfo.TYPE_TEXT_FLAG_AUTO_COMPLETE) != 0) {
|
||||
// If this is an auto-complete text view, then our predictions
|
||||
// will not be shown and instead we will allow the editor
|
||||
// to supply their own. We only show the editor's
|
||||
// candidates when in fullscreen mode, otherwise relying
|
||||
// own it displaying its own UI.
|
||||
mPredictionOn = false;
|
||||
mCompletionOn = isFullscreenMode();
|
||||
}
|
||||
|
||||
// We also want to look at the current state of the editor
|
||||
// to decide whether our alphabetic keyboard should start out
|
||||
// shifted.
|
||||
updateShiftKeyState(attribute);
|
||||
break;
|
||||
|
||||
default:
|
||||
// For all unknown input types, default to the alphabetic
|
||||
// keyboard with no special features.
|
||||
mCurKeyboard = mQwertyKeyboard;
|
||||
}
|
||||
|
||||
// Update the label on the enter key, depending on what the application
|
||||
// says it will do.
|
||||
mCurKeyboard.setImeOptions(getResources(), attribute.imeOptions);
|
||||
}
|
||||
|
||||
/**
|
||||
* This is called when the user is done editing a field. We can use
|
||||
* this to reset our state.
|
||||
*/
|
||||
@Override public void onFinishInput() {
|
||||
super.onFinishInput();
|
||||
|
||||
// Clear current composing text and candidates.
|
||||
mComposing.setLength(0);
|
||||
updateCandidates();
|
||||
|
||||
// We only hide the candidates window when finishing input on
|
||||
// a particular editor, to avoid popping the underlying application
|
||||
// up and down if the user is entering text into the bottom of
|
||||
// its window.
|
||||
setCandidatesViewShown(false);
|
||||
|
||||
mCurKeyboard = mQwertyKeyboard;
|
||||
if (mInputView != null) {
|
||||
mInputView.closing();
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void onStartInputView(EditorInfo attribute, boolean restarting) {
|
||||
super.onStartInputView(attribute, restarting);
|
||||
// Apply the selected keyboard to the input view.
|
||||
mInputView.setKeyboard(mCurKeyboard);
|
||||
mInputView.closing();
|
||||
}
|
||||
|
||||
/**
|
||||
* Deal with the editor reporting movement of its cursor.
|
||||
*/
|
||||
@Override public void onUpdateSelection(int oldSelStart, int oldSelEnd,
|
||||
int newSelStart, int newSelEnd,
|
||||
int candidatesStart, int candidatesEnd) {
|
||||
|
||||
// If the current selection in the text view changes, we should
|
||||
// clear whatever candidate text we have.
|
||||
if (mComposing.length() > 0 && (newSelStart != candidatesEnd
|
||||
|| newSelEnd != candidatesEnd)) {
|
||||
mComposing.setLength(0);
|
||||
updateCandidates();
|
||||
InputConnection ic = getCurrentInputConnection();
|
||||
if (ic != null) {
|
||||
ic.finishComposingText();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* This tells us about completions that the editor has determined based
|
||||
* on the current text in it. We want to use this in fullscreen mode
|
||||
* to show the completions ourself, since the editor can not be seen
|
||||
* in that situation.
|
||||
*/
|
||||
@Override public void onDisplayCompletions(CompletionInfo[] completions) {
|
||||
if (mCompletionOn) {
|
||||
mCompletions = completions;
|
||||
if (completions == null) {
|
||||
setSuggestions(null, false, false);
|
||||
return;
|
||||
}
|
||||
|
||||
List<String> stringList = new ArrayList<String>();
|
||||
for (int i=0; i<(completions != null ? completions.length : 0); i++) {
|
||||
CompletionInfo ci = completions[i];
|
||||
if (ci != null) stringList.add(ci.getText().toString());
|
||||
}
|
||||
setSuggestions(stringList, true, true);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* This translates incoming hard key events in to edit operations on an
|
||||
* InputConnection. It is only needed when using the
|
||||
* PROCESS_HARD_KEYS option.
|
||||
*/
|
||||
private boolean translateKeyDown(int keyCode, KeyEvent event) {
|
||||
mMetaState = MetaKeyKeyListener.handleKeyDown(mMetaState,
|
||||
keyCode, event);
|
||||
int c = event.getUnicodeChar(MetaKeyKeyListener.getMetaState(mMetaState));
|
||||
mMetaState = MetaKeyKeyListener.adjustMetaAfterKeypress(mMetaState);
|
||||
InputConnection ic = getCurrentInputConnection();
|
||||
if (c == 0 || ic == null) {
|
||||
return false;
|
||||
}
|
||||
|
||||
boolean dead = false;
|
||||
|
||||
if ((c & KeyCharacterMap.COMBINING_ACCENT) != 0) {
|
||||
dead = true;
|
||||
c = c & KeyCharacterMap.COMBINING_ACCENT_MASK;
|
||||
}
|
||||
|
||||
if (mComposing.length() > 0) {
|
||||
char accent = mComposing.charAt(mComposing.length() -1 );
|
||||
int composed = KeyEvent.getDeadChar(accent, c);
|
||||
|
||||
if (composed != 0) {
|
||||
c = composed;
|
||||
mComposing.setLength(mComposing.length()-1);
|
||||
}
|
||||
}
|
||||
|
||||
onKey(c, null);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Use this to monitor key events being delivered to the application.
|
||||
* We get first crack at them, and can either resume them or let them
|
||||
* continue to the app.
|
||||
*/
|
||||
@Override public boolean onKeyDown(int keyCode, KeyEvent event) {
|
||||
switch (keyCode) {
|
||||
case KeyEvent.KEYCODE_BACK:
|
||||
// The InputMethodService already takes care of the back
|
||||
// key for us, to dismiss the input method if it is shown.
|
||||
// However, our keyboard could be showing a pop-up window
|
||||
// that back should dismiss, so we first allow it to do that.
|
||||
if (event.getRepeatCount() == 0 && mInputView != null) {
|
||||
if (mInputView.handleBack()) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case KeyEvent.KEYCODE_DEL:
|
||||
// Special handling of the delete key: if we currently are
|
||||
// composing text for the user, we want to modify that instead
|
||||
// of let the application to the delete itself.
|
||||
if (mComposing.length() > 0) {
|
||||
onKey(Keyboard.KEYCODE_DELETE, null);
|
||||
return true;
|
||||
}
|
||||
break;
|
||||
|
||||
case KeyEvent.KEYCODE_ENTER:
|
||||
// Let the underlying text editor always handle these.
|
||||
return false;
|
||||
|
||||
default:
|
||||
// For all other keys, if we want to do transformations on
|
||||
// text being entered with a hard keyboard, we need to process
|
||||
// it and do the appropriate action.
|
||||
if (PROCESS_HARD_KEYS) {
|
||||
if (keyCode == KeyEvent.KEYCODE_SPACE
|
||||
&& (event.getMetaState()&KeyEvent.META_ALT_ON) != 0) {
|
||||
// A silly example: in our input method, Alt+Space
|
||||
// is a shortcut for 'android' in lower case.
|
||||
InputConnection ic = getCurrentInputConnection();
|
||||
if (ic != null) {
|
||||
// First, tell the editor that it is no longer in the
|
||||
// shift state, since we are consuming this.
|
||||
ic.clearMetaKeyStates(KeyEvent.META_ALT_ON);
|
||||
keyDownUp(KeyEvent.KEYCODE_A);
|
||||
keyDownUp(KeyEvent.KEYCODE_N);
|
||||
keyDownUp(KeyEvent.KEYCODE_D);
|
||||
keyDownUp(KeyEvent.KEYCODE_R);
|
||||
keyDownUp(KeyEvent.KEYCODE_O);
|
||||
keyDownUp(KeyEvent.KEYCODE_I);
|
||||
keyDownUp(KeyEvent.KEYCODE_D);
|
||||
// And we consume this event.
|
||||
return true;
|
||||
}
|
||||
}
|
||||
if (mPredictionOn && translateKeyDown(keyCode, event)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return super.onKeyDown(keyCode, event);
|
||||
}
|
||||
|
||||
/**
|
||||
* Use this to monitor key events being delivered to the application.
|
||||
* We get first crack at them, and can either resume them or let them
|
||||
* continue to the app.
|
||||
*/
|
||||
@Override public boolean onKeyUp(int keyCode, KeyEvent event) {
|
||||
// If we want to do transformations on text being entered with a hard
|
||||
// keyboard, we need to process the up events to update the meta key
|
||||
// state we are tracking.
|
||||
if (PROCESS_HARD_KEYS) {
|
||||
if (mPredictionOn) {
|
||||
mMetaState = MetaKeyKeyListener.handleKeyUp(mMetaState,
|
||||
keyCode, event);
|
||||
}
|
||||
}
|
||||
|
||||
return super.onKeyUp(keyCode, event);
|
||||
}
|
||||
|
||||
/**
|
||||
* Helper function to commit any text being composed in to the editor.
|
||||
*/
|
||||
private void commitTyped(InputConnection inputConnection) {
|
||||
if (mComposing.length() > 0) {
|
||||
inputConnection.commitText(mComposing, mComposing.length());
|
||||
mComposing.setLength(0);
|
||||
updateCandidates();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Helper to update the shift state of our keyboard based on the initial
|
||||
* editor state.
|
||||
*/
|
||||
private void updateShiftKeyState(EditorInfo attr) {
|
||||
if (attr != null
|
||||
&& mInputView != null && mQwertyKeyboard == mInputView.getKeyboard()) {
|
||||
int caps = getCurrentInputConnection().getCursorCapsMode(attr.inputType);
|
||||
mInputView.setShifted(mCapsLock || caps != 0);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Helper to determine if a given character code is alphabetic.
|
||||
*/
|
||||
private boolean isAlphabet(int code) {
|
||||
if (Character.isLetter(code)) {
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Helper to send a key down / key up pair to the current editor.
|
||||
*/
|
||||
private void keyDownUp(int keyEventCode) {
|
||||
getCurrentInputConnection().sendKeyEvent(
|
||||
new KeyEvent(KeyEvent.ACTION_DOWN, keyEventCode));
|
||||
getCurrentInputConnection().sendKeyEvent(
|
||||
new KeyEvent(KeyEvent.ACTION_UP, keyEventCode));
|
||||
}
|
||||
|
||||
/**
|
||||
* Helper to send a character to the editor as raw key events.
|
||||
*/
|
||||
private void sendKey(int keyCode) {
|
||||
switch (keyCode) {
|
||||
case '\n':
|
||||
keyDownUp(KeyEvent.KEYCODE_ENTER);
|
||||
break;
|
||||
default:
|
||||
if (keyCode >= '0' && keyCode <= '9') {
|
||||
keyDownUp(keyCode - '0' + KeyEvent.KEYCODE_0);
|
||||
} else {
|
||||
getCurrentInputConnection().commitText(String.valueOf((char) keyCode), 1);
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// Implementation of KeyboardViewListener
|
||||
|
||||
public void onKey(int primaryCode, int[] keyCodes) {
|
||||
if (isWordSeparator(primaryCode)) {
|
||||
// Handle separator
|
||||
if (mComposing.length() > 0) {
|
||||
commitTyped(getCurrentInputConnection());
|
||||
}
|
||||
sendKey(primaryCode);
|
||||
updateShiftKeyState(getCurrentInputEditorInfo());
|
||||
} else if (primaryCode == Keyboard.KEYCODE_DELETE) {
|
||||
handleBackspace();
|
||||
} else if (primaryCode == Keyboard.KEYCODE_SHIFT) {
|
||||
handleShift();
|
||||
} else if (primaryCode == Keyboard.KEYCODE_CANCEL) {
|
||||
handleClose();
|
||||
return;
|
||||
} else if (primaryCode == LatinKeyboardView.KEYCODE_OPTIONS) {
|
||||
// Show a menu or somethin'
|
||||
} else if (primaryCode == Keyboard.KEYCODE_MODE_CHANGE
|
||||
&& mInputView != null) {
|
||||
Keyboard current = mInputView.getKeyboard();
|
||||
if (current == mSymbolsKeyboard || current == mSymbolsShiftedKeyboard) {
|
||||
current = mQwertyKeyboard;
|
||||
} else {
|
||||
current = mSymbolsKeyboard;
|
||||
}
|
||||
mInputView.setKeyboard(current);
|
||||
if (current == mSymbolsKeyboard) {
|
||||
current.setShifted(false);
|
||||
}
|
||||
} else {
|
||||
handleCharacter(primaryCode, keyCodes);
|
||||
}
|
||||
}
|
||||
|
||||
public void onText(CharSequence text) {
|
||||
InputConnection ic = getCurrentInputConnection();
|
||||
if (ic == null) return;
|
||||
ic.beginBatchEdit();
|
||||
if (mComposing.length() > 0) {
|
||||
commitTyped(ic);
|
||||
}
|
||||
ic.commitText(text, 0);
|
||||
ic.endBatchEdit();
|
||||
updateShiftKeyState(getCurrentInputEditorInfo());
|
||||
}
|
||||
|
||||
/**
|
||||
* Update the list of available candidates from the current composing
|
||||
* text. This will need to be filled in by however you are determining
|
||||
* candidates.
|
||||
*/
|
||||
private void updateCandidates() {
|
||||
if (!mCompletionOn) {
|
||||
if (mComposing.length() > 0) {
|
||||
ArrayList<String> list = new ArrayList<String>();
|
||||
list.add(mComposing.toString());
|
||||
setSuggestions(list, true, true);
|
||||
} else {
|
||||
setSuggestions(null, false, false);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public void setSuggestions(List<String> suggestions, boolean completions,
|
||||
boolean typedWordValid) {
|
||||
if (suggestions != null && suggestions.size() > 0) {
|
||||
setCandidatesViewShown(true);
|
||||
} else if (isFullscreenMode()) {
|
||||
setCandidatesViewShown(true);
|
||||
}
|
||||
if (mCandidateView != null) {
|
||||
mCandidateView.setSuggestions(suggestions, completions, typedWordValid);
|
||||
}
|
||||
}
|
||||
|
||||
private void handleBackspace() {
|
||||
final int length = mComposing.length();
|
||||
if (length > 1) {
|
||||
mComposing.delete(length - 1, length);
|
||||
getCurrentInputConnection().setComposingText(mComposing, mComposing.length());
|
||||
updateCandidates();
|
||||
} else if (length > 0) {
|
||||
mComposing.setLength(0);
|
||||
getCurrentInputConnection().commitText("", 0);
|
||||
updateCandidates();
|
||||
} else {
|
||||
keyDownUp(KeyEvent.KEYCODE_DEL);
|
||||
}
|
||||
updateShiftKeyState(getCurrentInputEditorInfo());
|
||||
}
|
||||
|
||||
private void handleShift() {
|
||||
if (mInputView == null) {
|
||||
return;
|
||||
}
|
||||
|
||||
Keyboard currentKeyboard = mInputView.getKeyboard();
|
||||
if (mQwertyKeyboard == currentKeyboard) {
|
||||
// Alphabet keyboard
|
||||
checkToggleCapsLock();
|
||||
mInputView.setShifted(mCapsLock || !mInputView.isShifted());
|
||||
} else if (currentKeyboard == mSymbolsKeyboard) {
|
||||
mSymbolsKeyboard.setShifted(true);
|
||||
mInputView.setKeyboard(mSymbolsShiftedKeyboard);
|
||||
mSymbolsShiftedKeyboard.setShifted(true);
|
||||
} else if (currentKeyboard == mSymbolsShiftedKeyboard) {
|
||||
mSymbolsShiftedKeyboard.setShifted(false);
|
||||
mInputView.setKeyboard(mSymbolsKeyboard);
|
||||
mSymbolsKeyboard.setShifted(false);
|
||||
}
|
||||
}
|
||||
|
||||
private void handleCharacter(int primaryCode, int[] keyCodes) {
|
||||
if (isInputViewShown()) {
|
||||
if (mInputView.isShifted()) {
|
||||
primaryCode = Character.toUpperCase(primaryCode);
|
||||
}
|
||||
}
|
||||
if (isAlphabet(primaryCode) && mPredictionOn) {
|
||||
mComposing.append((char) primaryCode);
|
||||
getCurrentInputConnection().setComposingText(mComposing, mComposing.length());
|
||||
updateShiftKeyState(getCurrentInputEditorInfo());
|
||||
updateCandidates();
|
||||
} else {
|
||||
getCurrentInputConnection().commitText(
|
||||
String.valueOf((char) primaryCode), 1);
|
||||
}
|
||||
}
|
||||
|
||||
private void handleClose() {
|
||||
commitTyped(getCurrentInputConnection());
|
||||
dismissSoftInput(0);
|
||||
mInputView.closing();
|
||||
}
|
||||
|
||||
private void checkToggleCapsLock() {
|
||||
long now = System.currentTimeMillis();
|
||||
if (mLastShiftTime + 800 > now) {
|
||||
mCapsLock = !mCapsLock;
|
||||
mLastShiftTime = 0;
|
||||
} else {
|
||||
mLastShiftTime = now;
|
||||
}
|
||||
}
|
||||
|
||||
private String getWordSeparators() {
|
||||
return mWordSeparators;
|
||||
}
|
||||
|
||||
public boolean isWordSeparator(int code) {
|
||||
String separators = getWordSeparators();
|
||||
return separators.contains(String.valueOf((char)code));
|
||||
}
|
||||
|
||||
public void pickDefaultCandidate() {
|
||||
pickSuggestionManually(0);
|
||||
}
|
||||
|
||||
public void pickSuggestionManually(int index) {
|
||||
if (mCompletionOn && mCompletions != null && index >= 0
|
||||
&& index < mCompletions.length) {
|
||||
CompletionInfo ci = mCompletions[index];
|
||||
getCurrentInputConnection().commitCompletion(ci);
|
||||
if (mCandidateView != null) {
|
||||
mCandidateView.clear();
|
||||
}
|
||||
updateShiftKeyState(getCurrentInputEditorInfo());
|
||||
} else if (mComposing.length() > 0) {
|
||||
// If we were generating candidate suggestions for the current
|
||||
// text, we would commit one of them here. But for this sample,
|
||||
// we will just commit the current text.
|
||||
commitTyped(getCurrentInputConnection());
|
||||
}
|
||||
}
|
||||
|
||||
public void swipeRight() {
|
||||
if (mCompletionOn) {
|
||||
pickDefaultCandidate();
|
||||
}
|
||||
}
|
||||
|
||||
public void swipeLeft() {
|
||||
handleBackspace();
|
||||
}
|
||||
|
||||
public void swipeDown() {
|
||||
handleClose();
|
||||
}
|
||||
|
||||
public void swipeUp() {
|
||||
}
|
||||
|
||||
public void onPress(int primaryCode) {
|
||||
}
|
||||
|
||||
public void onRelease(int primaryCode) {
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user