public boolean processKey( InputConnection inputContext, KeyEvent event, boolean upperCase, boolean realAction) { if (null == inputContext || null == event) return false; int keyCode = event.getKeyCode(); CharSequence prefix = null; prefix = inputContext.getTextBeforeCursor(2, 0); int keyChar; keyChar = 0; if (keyCode >= KeyEvent.KEYCODE_A && keyCode <= KeyEvent.KEYCODE_Z) { keyChar = keyCode - KeyEvent.KEYCODE_A + 'a'; if (upperCase) { keyChar = keyChar + 'A' - 'a'; } } else if (keyCode >= KeyEvent.KEYCODE_0 && keyCode <= KeyEvent.KEYCODE_9) keyChar = keyCode - KeyEvent.KEYCODE_0 + '0'; else if (keyCode == KeyEvent.KEYCODE_COMMA) keyChar = ','; else if (keyCode == KeyEvent.KEYCODE_PERIOD) keyChar = '.'; else if (keyCode == KeyEvent.KEYCODE_APOSTROPHE) keyChar = '\''; else if (keyCode == KeyEvent.KEYCODE_AT) keyChar = '@'; else if (keyCode == KeyEvent.KEYCODE_SLASH) keyChar = '/'; if (0 == keyChar) { mLastKeyCode = keyCode; String insert = null; if (KeyEvent.KEYCODE_DEL == keyCode) { if (realAction) { inputContext.deleteSurroundingText(1, 0); } } else if (KeyEvent.KEYCODE_ENTER == keyCode) { insert = "\n"; } else if (KeyEvent.KEYCODE_SPACE == keyCode) { insert = " "; } else { return false; } if (null != insert && realAction) inputContext.commitText(insert, insert.length()); return true; } if (!realAction) return true; if (KeyEvent.KEYCODE_SHIFT_LEFT == mLastKeyCode || KeyEvent.KEYCODE_SHIFT_LEFT == mLastKeyCode) { if (keyChar >= 'a' && keyChar <= 'z') keyChar = keyChar - 'a' + 'A'; } else if (KeyEvent.KEYCODE_ALT_LEFT == mLastKeyCode) { } String result = String.valueOf((char) keyChar); inputContext.commitText(result, result.length()); mLastKeyCode = keyCode; return true; }
/** 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(); } }
public void onKey(int primaryCode, int[] keyCodes) { InputConnection ic = getCurrentInputConnection(); playClick(primaryCode); switch (primaryCode) { case Keyboard.KEYCODE_DELETE: ic.deleteSurroundingText(1, 0); break; case Keyboard.KEYCODE_SHIFT: if (caps) { keyboard = new Keyboard(this, R.xml.qwerty); kv.setKeyboard(keyboard); kv.invalidateAllKeys(); kv.setOnKeyboardActionListener(this); } else { keyboard = new Keyboard(this, R.xml.qwertytwo); kv.setKeyboard(keyboard); kv.invalidateAllKeys(); kv.setOnKeyboardActionListener(this); } caps = !caps; keyboard.setShifted(caps); kv.invalidateAllKeys(); break; case Keyboard.KEYCODE_DONE: ic.sendKeyEvent(new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_ENTER)); break; default: char code = (char) primaryCode; if (Character.isLetter(code) && caps) { code = Character.toUpperCase(code); } ic.commitText(String.valueOf(code), 1); } }
private void commitText(@NotNull InputConnection ic, @Nullable CharSequence text, int position) { ic.commitText(text, position); if (!Strings.isEmpty(text)) { history.addState( new KeyboardInputHistoryState(AndroidKeyboardUtils.getTextFromInputConnection(ic), 0)); } }
/** Commits the given text to the editing field. */ public boolean commitText(InputConnection ic, CharSequence text) { if (ic != null) { if (text.length() > 1) { // Batch edit a sequence of characters. ic.beginBatchEdit(); ic.commitText(text, 1); ic.endBatchEdit(); } else { ic.commitText(text, 1); } // Composing-text in the editor has been cleared. composingText.setLength(0); return true; } return false; }
private void restoreFromHistory(@Nullable KeyboardInputHistoryState state) { if (state != null) { final InputConnection ic = getCurrentInputConnection(); ic.deleteSurroundingText(MAX_INT, MAX_INT); ic.commitText(state.getCharSequence(), 1); } }
private void pickSuggestion(CharSequence suggestion) { InputConnection ic = mService.getCurrentInputConnection(); if (ic != null) { ic.commitText(suggestion, 1); } mService.setCommittedLength(suggestion.length()); mService.setSuggestions(null, false, false, false); }
@Override public void onText(CharSequence text) { InputConnection ic = mService.getCurrentInputConnection(); if (ic == null) return; ic.beginBatchEdit(); ic.commitText(text, 1); ic.endBatchEdit(); }
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()); }
public void commitTyped(InputConnection inputConnection) { if (mComposing.length() > 0) { if (inputConnection != null) { inputConnection.commitText(mComposing, 1); } mService.setCommittedLength(mComposing.length()); mComposing.setLength(0); mWord.reset(); updateSuggestions(); } }
public static boolean inputCharacter(char character) { InputConnection connection = getInputConnection(); if (connection != null) { if (connection.commitText(Character.toString(character), 1)) { return true; } } return false; }
boolean setText(String text) { // FIXME: need feedback if the input was lost InputConnection conn = getCurrentInputConnection(); if (conn == null) { // Debug.d("connection closed"); return false; } conn.beginBatchEdit(); // FIXME: hack conn.deleteSurroundingText(100000, 100000); conn.commitText(text, text.length()); conn.endBatchEdit(); return true; }
private void keyDel(InputConnection conn) { // if control key used -- delete word right if (pressedKeys.contains(KEY_CONTROL)) { deleteWordRight(conn); return; } if (pressedKeys.contains(KeyEvent.KEYCODE_SHIFT_LEFT)) { cut(conn); return; } conn.deleteSurroundingText(0, 1); conn.commitText("", 0); }
@Override public boolean commitText(CharSequence text, int newCursorPosition) { if (InputMethods.shouldCommitCharAsKey(mCurrentInputMethod) && text.length() == 1 && newCursorPosition > 0) { if (DEBUG) { Log.d(LOGTAG, "committing \"" + text + "\" as key"); } // mKeyInputConnection is a BaseInputConnection that commits text as keys; // but we first need to replace any composing span with a selection, // so that the new key events will generate characters to replace // text from the old composing span return replaceComposingSpanWithSelection() && mKeyInputConnection.commitText(text, newCursorPosition); } return super.commitText(text, newCursorPosition); }
void receivedChar(int code) { wakeLock.acquire(); wakeLock.release(); InputConnection conn = getCurrentInputConnection(); if (conn == null) { // Debug.d("connection closed"); return; } if (pressedKeys.contains(KEY_CONTROL)) { switch (code) { case 'a': case 'A': selectAll(conn); return; case 'x': case 'X': cut(conn); return; case 'c': case 'C': copy(conn); return; case 'v': case 'V': paste(conn); return; } } String text = null; if (code >= 0 && code <= 65535) { text = new String(new char[] {(char) code}); } else { int HI_SURROGATE_START = 0xD800; int LO_SURROGATE_START = 0xDC00; int hi = ((code >> 10) & 0x3FF) - 0x040 | HI_SURROGATE_START; int lo = LO_SURROGATE_START | (code & 0x3FF); text = new String(new char[] {(char) hi, (char) lo}); } conn.commitText(text, 1); }
@Override public void onGesturePerformed(GestureOverlayView overlay, Gesture gesture) { // Log.d(TAG, "Strokes size: " + gesture.getStrokesCount()); InputConnection ic = getCurrentInputConnection(); for (GestureStroke stroke : gesture.getStrokes()) { GesturePoint[] points = ShorthandUtils.extractGesturePointsFromStroke(stroke); String result = mRecognizer.recognize(points); if (mParameters.isDebugEnabled()) { StenoCanvas canvas = (StenoCanvas) overlay; canvas.setDebugPaths(mRecognizer.getDebugPaths()); canvas.setDebugPoints(points); } if (result != null && result.length() > 0) { ic.commitText(result, 1); } else if (mParameters.isPopupsEnabled()) { Toast.makeText(mContext, R.string.not_found, Toast.LENGTH_SHORT).show(); } } }
@Override public boolean onKey(View v, int keyCode, KeyEvent event) { // This handles the hardware keyboard input if (event.isPrintingKey()) { if (event.getAction() == KeyEvent.ACTION_DOWN) { ic.commitText(String.valueOf((char) event.getUnicodeChar()), 1); } return true; } if (event.getAction() == KeyEvent.ACTION_DOWN) { SDLActivity.onNativeKeyDown(keyCode); return true; } else if (event.getAction() == KeyEvent.ACTION_UP) { SDLActivity.onNativeKeyUp(keyCode); return true; } return false; }