@Override
public boolean onKey(View v, int keyCode, KeyEvent event) {
if (event != null && v.getId() == R.id.edittext_note_editor) {
// if shift key is down, then we want to insert the '\n' char in the
// TextView;
// otherwise, the default action is to send the message.
if (event.getAction() == KeyEvent.ACTION_DOWN) {
Log.d(TAG, "keyCode is " + keyCode);
if (keyCode == KeyEvent.KEYCODE_ENTER) {
if (!event.isShiftPressed()) {
performSubmitClick();
return true;
}
}
if (keyCode == KeyEvent.KEYCODE_DPAD_RIGHT) {
if (event.isShiftPressed() && event.isCtrlPressed()) {
mCallbacks.onKeyNextTalk();
return true;
}
}
if (keyCode == KeyEvent.KEYCODE_DPAD_LEFT) {
if (event.isShiftPressed() && event.isCtrlPressed()) {
mCallbacks.onKeyPreviousTalk();
return true;
}
}
}
}
return false;
}
/**
* Convert a KeyEvent into a long which can be kept in settings and compared to key presses when
* the service is in use.
*
* @param keyEvent The key event to convert. The (non-extended) keycode must not be a modifier.
* @return An extended key code that includes modifier information
*/
public static long keyEventToExtendedKeyCode(KeyEvent keyEvent) {
long returnValue = keyEvent.getKeyCode();
returnValue |= (keyEvent.isShiftPressed()) ? (((long) KeyEvent.META_SHIFT_ON) << 32) : 0;
returnValue |= (keyEvent.isCtrlPressed()) ? (((long) KeyEvent.META_CTRL_ON) << 32) : 0;
returnValue |= (keyEvent.isAltPressed()) ? (((long) KeyEvent.META_ALT_ON) << 32) : 0;
return returnValue;
}
@Override
public boolean onKey(View v, int keyCode, KeyEvent event) {
KeyModifiers m = new KeyModifiers();
m.shift = event.isShiftPressed();
m.alt = event.isAltPressed();
final char k = TranslateKey(keyCode, m);
if (k == 0) return false;
if (event.getAction() == KeyEvent.ACTION_DOWN) Emulator.the.OnKey(k, true, m.shift, m.alt);
else Emulator.the.OnKey(k, false, false, false);
return true;
}
@Override
public boolean onKeyUp(int keyCode, KeyEvent event) {
if (keyCode == KeyEvent.KEYCODE_BACK) {
// We don't want to swallow the back button press
return false;
}
// NOTE: Most keyboards, and specifically the Android default keyboard when
// entering non-ascii characters, will not trigger KeyEvent events as documented
// here: http://developer.android.com/reference/android/view/KeyEvent.html
// Log.e("KeyDown", "------------");
// Log.e("KeyDown", "keyChar:" + (int) event.getDisplayLabel());
// Log.e("KeyDown", "utfChar:" + (char)event.getUnicodeChar());
// Log.e("KeyDown", "intUtfChar:" + event.getUnicodeChar());
final NetworkPackage np = new NetworkPackage(MousePadPlugin.PACKAGE_TYPE_MOUSEPAD_REQUEST);
boolean modifier = false;
if (event.isAltPressed()) {
np.set("alt", true);
modifier = true;
}
if (Build.VERSION.SDK_INT >= 11) {
if (event.isCtrlPressed()) {
np.set("ctrl", true);
modifier = true;
}
}
if (event.isShiftPressed()) {
np.set("shift", true);
}
int specialKey = SpecialKeysMap.get(keyCode, -1);
if (specialKey != -1) {
np.set("specialKey", specialKey);
} else if (event.getDisplayLabel() != 0 && modifier) {
// Alt will change the utf symbol to non-ascii characters, we want the plain original letter
// Since getDisplayLabel will always have a value, we have to check for special keys before
char keyCharacter = event.getDisplayLabel();
np.set("key", new String(new char[] {keyCharacter}).toLowerCase());
} else {
// A normal key, but still not handled by the KeyInputConnection (happens with numbers)
np.set("key", new String(new char[] {(char) event.getUnicodeChar()}));
}
sendKeyPressPackage(np);
return true;
}
/**
* You can call this function yourself to have the scroll view perform scrolling from a key event,
* just as if the event had been dispatched to it by the view hierarchy.
*
* @param event The key event to execute.
* @return Return true if the event was handled, else false.
*/
public boolean executeKeyEvent(KeyEvent event) {
mTempRect.setEmpty();
if (!canScroll()) {
if (isFocused() && event.getKeyCode() != KeyEvent.KEYCODE_BACK) {
View currentFocused = findFocus();
if (currentFocused == this) currentFocused = null;
View nextFocused =
FocusFinder.getInstance().findNextFocus(this, currentFocused, View.FOCUS_DOWN);
return nextFocused != null
&& nextFocused != this
&& nextFocused.requestFocus(View.FOCUS_DOWN);
}
return false;
}
boolean handled = false;
if (event.getAction() == KeyEvent.ACTION_DOWN) {
switch (event.getKeyCode()) {
case KeyEvent.KEYCODE_DPAD_UP:
if (!event.isAltPressed()) {
handled = arrowScroll(View.FOCUS_UP);
} else {
handled = fullScroll(View.FOCUS_UP);
}
break;
case KeyEvent.KEYCODE_DPAD_DOWN:
if (!event.isAltPressed()) {
handled = arrowScroll(View.FOCUS_DOWN);
} else {
handled = fullScroll(View.FOCUS_DOWN);
}
break;
case KeyEvent.KEYCODE_SPACE:
pageScroll(event.isShiftPressed() ? View.FOCUS_UP : View.FOCUS_DOWN);
break;
}
}
return handled;
}
@SmallTest
@Feature({"TextInput", "Main"})
public void testGuessedKeyCodeFromTyping() throws Throwable {
assertEquals(-1, getTypedKeycodeGuess(null, ""));
assertEquals(KeyEvent.KEYCODE_X, getTypedKeycodeGuess(null, "x"));
assertEquals(-1, getTypedKeycodeGuess(null, "xyz"));
assertEquals(-1, getTypedKeycodeGuess("abc", "abc"));
assertEquals(KeyEvent.KEYCODE_DEL, getTypedKeycodeGuess("abc", ""));
assertEquals(KeyEvent.KEYCODE_H, getTypedKeycodeGuess("", "h"));
assertEquals(KeyEvent.KEYCODE_DEL, getTypedKeycodeGuess("h", ""));
assertEquals(KeyEvent.KEYCODE_E, getTypedKeycodeGuess("h", "he"));
assertEquals(KeyEvent.KEYCODE_L, getTypedKeycodeGuess("he", "hel"));
assertEquals(KeyEvent.KEYCODE_O, getTypedKeycodeGuess("hel", "helo"));
assertEquals(KeyEvent.KEYCODE_DEL, getTypedKeycodeGuess("helo", "hel"));
assertEquals(KeyEvent.KEYCODE_L, getTypedKeycodeGuess("hel", "hell"));
assertEquals(KeyEvent.KEYCODE_L, getTypedKeycodeGuess("hell", "helll"));
assertEquals(KeyEvent.KEYCODE_DEL, getTypedKeycodeGuess("helll", "hell"));
assertEquals(KeyEvent.KEYCODE_O, getTypedKeycodeGuess("hell", "hello"));
assertEquals(KeyEvent.KEYCODE_X, getTypedKeycodeGuess("xxx", "xxxx"));
assertEquals(KeyEvent.KEYCODE_X, getTypedKeycodeGuess("xxx", "xxxxx"));
assertEquals(KeyEvent.KEYCODE_DEL, getTypedKeycodeGuess("xxx", "xx"));
assertEquals(KeyEvent.KEYCODE_DEL, getTypedKeycodeGuess("xxx", "x"));
assertEquals(KeyEvent.KEYCODE_Y, getTypedKeycodeGuess("xxx", "xxxy"));
assertEquals(KeyEvent.KEYCODE_Y, getTypedKeycodeGuess("xxx", "xxxxy"));
assertEquals(-1, getTypedKeycodeGuess("xxx", "xy"));
assertEquals(-1, getTypedKeycodeGuess("xxx", "y"));
assertEquals(-1, getTypedKeycodeGuess("foo", "bar"));
assertEquals(-1, getTypedKeycodeGuess("foo", "bars"));
assertEquals(-1, getTypedKeycodeGuess("foo", "ba"));
// Some characters also require modifiers so we have to check the full event.
KeyEvent ev = ImeAdapter.getTypedKeyEventGuess(null, "!");
assertEquals(KeyEvent.KEYCODE_1, ev.getKeyCode());
assertTrue(ev.isShiftPressed());
}
private static int getMetaState(KeyEvent event) {
return (event.isCtrlPressed() ? CTRL : 0)
| (event.isAltPressed() ? ALT : 0)
| (event.isShiftPressed() ? SHIFT : 0);
}
/**
* Overrides default directional pad behavior:
*
* <ul>
* <li>Up/down: Increases/decreases text navigation granularity
* <li>Left/right: Moves to previous/next unit of text
* </ul>
*
* <p>If one of the following conditions is met, default behavior is preserved:
*
* <ul>
* <li>No input connection available
* <li>Input view is hidden
* <li>Not currently editing text
* <li>Cannot move in the specified direction
* </ul>
*/
@Override
public boolean onKeyUp(int keyCode, KeyEvent event) {
if (mUserCommandHandler.onKeyUp(event)) {
return true;
}
final AccessibleInputConnection aic = getCurrentInputConnection();
if (aic == null || !aic.hasExtractedText()) {
return super.onKeyUp(keyCode, event);
}
final KeyEvent downEvent = mPreviousDpadDownEvent;
mPreviousDpadDownEvent = null;
final KeyEvent metaDownEvent = mPreviousMetaDownEvent;
mPreviousMetaDownEvent = null;
if (downEvent != null) {
boolean captureEvent = false;
switch (downEvent.getKeyCode()) {
case KeyEvent.KEYCODE_DPAD_LEFT:
if (!event.isAltPressed()) {
captureEvent = previousUnit(mGranularity, 1, event.isShiftPressed());
} else {
mWasUpDownPressed = true;
}
break;
case KeyEvent.KEYCODE_DPAD_RIGHT:
if (!event.isAltPressed()) {
captureEvent = nextUnit(mGranularity, 1, event.isShiftPressed());
} else {
mWasUpDownPressed = true;
}
break;
case KeyEvent.KEYCODE_DPAD_UP:
if (event.isAltPressed()) {
adjustGranularity(1);
captureEvent = true;
} else {
mWasUpDownPressed = true;
}
break;
case KeyEvent.KEYCODE_DPAD_DOWN:
if (event.isAltPressed()) {
adjustGranularity(-1);
captureEvent = true;
} else {
mWasUpDownPressed = true;
}
break;
}
if (captureEvent) {
return true;
}
}
// If we didn't capture the meta event, attempt to send the previous
// meta down event and then preserve default behavior.
if (metaDownEvent != null) {
if (!super.onKeyDown(metaDownEvent.getKeyCode(), metaDownEvent)) {
aic.sendKeyEvent(metaDownEvent);
}
}
// If we didn't capture the event, attempt to send the previous down
// event and then preserve default behavior.
if (downEvent != null) {
if (!super.onKeyDown(downEvent.getKeyCode(), downEvent)) {
aic.sendKeyEvent(downEvent);
}
}
if (!super.onKeyUp(keyCode, event)) {
aic.sendKeyEvent(event);
}
return true;
}
public boolean executeKeyEvent(KeyEvent var1) {
boolean var4 = false;
this.mTempRect.setEmpty();
boolean var3;
if (!this.canScroll()) {
var3 = var4;
if (this.isFocused()) {
var3 = var4;
if (var1.getKeyCode() != 4) {
View var5 = this.findFocus();
View var6 = var5;
if (var5 == this) {
var6 = null;
}
var6 = FocusFinder.getInstance().findNextFocus(this, var6, 130);
var3 = var4;
if (var6 != null) {
var3 = var4;
if (var6 != this) {
var3 = var4;
if (var6.requestFocus(130)) {
var3 = true;
}
}
}
}
}
return var3;
} else {
var4 = false;
var3 = var4;
if (var1.getAction() == 0) {
switch (var1.getKeyCode()) {
case 19:
if (!var1.isAltPressed()) {
var3 = this.arrowScroll(33);
} else {
var3 = this.fullScroll(33);
}
break;
case 20:
if (!var1.isAltPressed()) {
var3 = this.arrowScroll(130);
} else {
var3 = this.fullScroll(130);
}
break;
case 62:
short var2;
if (var1.isShiftPressed()) {
var2 = 33;
} else {
var2 = 130;
}
this.pageScroll(var2);
var3 = var4;
break;
default:
var3 = var4;
}
}
return var3;
}
}
