@Override
public boolean dispatchKeyEvent(KeyEvent ev) {
Log.i(LOG_STRING, "key event: " + ev.toString());
int code = ev.getKeyCode();
int action = ev.getAction();
if (code == 80 && action == 1) {
// Log.i(LOG_STRING, "CAMERA CAMERA CAMERA CAMERA" + ev.toString());
super.dispatchKeyEvent(ev);
// Parcel reply = Parcel.obtain();
// boolean record = false;
// try {
// mBinder.transact(DemonstrationService.GET_TOGGLE_CODE, null, reply, 0);
// record = (Boolean) reply.readValue(Boolean.class.getClassLoader());
// } catch (RemoteException e) {
// Log.e(LOG_STRING, "Problems transacting with demonstration service: " +
// e.toString());
// }
// onRecord(record);
return true;
}
// I/AcessibleFrameLayout( 2081): key event: KeyEvent{action=0 code=80 repeat=0 meta=0
// scancode=211 mFlags=8}
// I/AcessibleFrameLayout( 2081): key event: KeyEvent{action=1 code=80 repeat=0 meta=0
// scancode=211 mFlags=8}
return super.dispatchKeyEvent(ev);
}
@Override
public boolean onKeyUp(int keyCode, KeyEvent keyEvent) {
SYSLOG("onKeyUp: " + keyEvent.toString());
int[] event = new int[3];
event[0] = EVENT_TYPE_KEY_RELEASED;
event[1] = convertToMoSyncKeyCode(keyCode, keyEvent);
event[2] = keyCode;
mMoSyncThread.postEvent(event);
// We need to intercept the back key otherwise the
// activity will be terminated.
if (keyCode == KeyEvent.KEYCODE_BACK) {
// Pass on the back event in case we want to handle it.
mMoSyncThread.handleBack();
return true;
} else {
return super.onKeyUp(keyCode, keyEvent);
}
}
@Override
public boolean onKeyDown(int keyCode, KeyEvent keyEvent) {
SYSLOG("onKeyDown: " + keyEvent.toString());
// If the key is being held down we shouldn't send any more events.
if (keyEvent.getRepeatCount() != 0) return true;
int[] event = new int[3];
event[0] = EVENT_TYPE_KEY_PRESSED;
event[1] = convertToMoSyncKeyCode(keyCode, keyEvent);
event[2] = keyCode;
mMoSyncThread.postEvent(event);
// We need to intercept the back key otherwise the
// activity will be terminated.
if (keyCode == KeyEvent.KEYCODE_BACK) {
return true;
} else {
return super.onKeyDown(keyCode, keyEvent);
}
}
private void handleGoogTvKeyPress(KeyEvent event, int keyCode) {
int hash;
String charLabel = "";
if (event.getKeyCode() == KeyEvent.KEYCODE_DPAD_DOWN
|| event.getKeyCode() == KeyEvent.KEYCODE_DPAD_UP
|| event.getKeyCode() == KeyEvent.KEYCODE_DPAD_LEFT
|| event.getKeyCode() == KeyEvent.KEYCODE_DPAD_RIGHT) {
// ---Navigate with DPad---
Log.i("KeyBindings", event.toString());
} else {
if (event.getKeyCode()
== KeyEvent.KEYCODE_UNKNOWN) { // key was pressed on soft (on-screen) keyboard
hash = BasicOnKeyboardActionListener.KEY_PRESSED;
SearchFragmentTab.PHYSICAL_KEY = false;
} else { // key was pressed on physical keyboard for Goog TV
SearchFragmentTab.PHYSICAL_KEY = true;
hash = event.getKeyCode();
if (event.isLongPress() && event.getKeyCode() == KeyEvent.KEYCODE_DEL) {
SearchFragmentTab.backSpaceLong();
}
}
switch (hash) {
case 0: // A letter was pressed on the English keyboard
SearchFragmentTab.retainSearch();
break;
}
ApplicationContext.getInstance().readyToSearch = true;
// Russian Keyboard
if (ApplicationContext.getInstance().keyboardType.equals("Russian")) {
if (event.getKeyCode()
== KeyEvent.KEYCODE_UNKNOWN) { // key was pressed on soft (on-screen) keyboard
charLabel = sparseArrRussian.get(hash);
} else { // key was pressed on the physical keyboard (for GoogTV)
charLabel = sparseArrRussian_GoogTV.get(hash);
}
// Hybrid Keyboard
} else if (ApplicationContext.getInstance()
.keyboardType
.equals("Hybrid")) { // Hybrid keyboard
if (ApplicationContext.getInstance()
.getHybridKeyboardMode()
.equals("Hybrid_English_To_Russ")) {
if (event.getKeyCode()
!= KeyEvent
.KEYCODE_UNKNOWN) { // key was pressed on the physical keyboard (for GoogTV)
charLabel = sparseArrHybridEngToRuss_GoogTV.get(hash);
} else { // key was pressed on the soft (on-screen) keyboard (for GoogTV)
ApplicationContext.getInstance().readyToSearch = true;
charLabel = sparseArrHybrid_EngToRuss.get(hash);
}
} else if (ApplicationContext.getInstance()
.getHybridKeyboardMode()
.equals("Hybrid_Russian_To_Eng")) {
if (event.getKeyCode()
!= KeyEvent
.KEYCODE_UNKNOWN) { // key was pressed on the physical keyboard (for GoogTV)
charLabel = sparseArrHybrid_RussToEng_GoogTV.get(hash);
} else { // key was pressed on the soft (on-screen) keyboard (for GoogTV)
ApplicationContext.getInstance().readyToSearch = true;
charLabel = sparseArrHybrid_RussToEng.get(hash);
}
}
}
// English Keyboard
else if (ApplicationContext.getInstance().keyboardType.equals("English")) {
try {
charLabel = sparseArrEnglish.get(hash);
} catch (Exception e) {
BugSenseHandler.addCrashExtraData(
"KeyBindings", "Exception in dispatchKeyEvent: " + e.getMessage());
BugSenseHandler.leaveBreadcrumb("KeyBindings.keyboardType.equals(\"English\")");
BugSenseHandler.sendException(e);
Crashlytics.setString("KeyBindings", "keyboardType.equals(\"English\")");
Crashlytics.logException(e);
}
}
if (event.getKeyCode()
!= KeyEvent.KEYCODE_UNKNOWN) { // physical key was pressed on physical GoogTV keyboard
if (event.getAction() == KeyEvent.ACTION_UP) {
if (keyCode == KeyEvent.KEYCODE_DEL) {
SearchFragmentTab.backSpace(true);
} else {
if (event.getAction() == KeyEvent.ACTION_UP)
if (event.getKeyCode() == KeyEvent.KEYCODE_BACK) {
Intent intent = new Intent("key_bindings_event");
intent.putExtra("message", "onBackPressed");
LocalBroadcastManager.getInstance(ApplicationContext.getInstance())
.sendBroadcast(intent);
} else {
SearchFragmentTab.typeText(charLabel);
// ---keep track of key presses to avoid double-typing on Goog TV---
SearchFragmentTab.ENGLISH_KBD_BACKSPACE = false;
}
}
}
} else { // soft input key was pressed on IMM keyboard
SearchFragmentTab.typeText(charLabel);
SearchFragmentTab.ENGLISH_KBD_BACKSPACE = false;
}
}
}
public boolean processLocalKeyEvent(int keyCode, KeyEvent evt) {
android.util.Log.e(TAG, evt.toString() + " " + keyCode);
if (rfb != null && rfb.isInNormalProtocol()) {
RemotePointer pointer = vncCanvas.getPointer();
boolean down =
(evt.getAction() == KeyEvent.ACTION_DOWN)
|| (evt.getAction() == KeyEvent.ACTION_MULTIPLE);
boolean unicode = false;
int metaState = 0, numchars = 1;
int keyboardMetaState = evt.getMetaState();
// Add shift to metaState if necessary.
if ((keyboardMetaState & 0x000000c1) != 0) metaState |= SHIFT_MASK;
// If the keyboardMetaState contains any hint of CTRL, add CTRL_MASK to metaState
if ((keyboardMetaState & 0x00007000) != 0) metaState |= CTRL_MASK;
// If the keyboardMetaState contains left ALT, add ALT_MASK to metaState.
// Leaving KeyEvent.KEYCODE_ALT_LEFT for symbol input on hardware keyboards.
if ((keyboardMetaState & KeyEvent.META_ALT_RIGHT_ON) != 0) metaState |= ALT_MASK;
if ((keyboardMetaState & (RemoteKeyboard.SUPER_MASK | 0x00010000)) != 0)
metaState |= SUPER_MASK;
if (keyCode == KeyEvent.KEYCODE_MENU) return true; // Ignore menu key
if (pointer.handleHardwareButtons(
keyCode, evt, metaState | onScreenMetaState | hardwareMetaState)) return true;
int key = 0, keysym = 0;
if (!down) {
switch (evt.getScanCode()) {
case SCAN_ESC:
key = 0xff1b;
break;
case SCAN_LEFTCTRL:
case SCAN_RIGHTCTRL:
hardwareMetaState &= ~CTRL_MASK;
break;
case SCAN_F1:
keysym = 0xffbe;
break;
case SCAN_F2:
keysym = 0xffbf;
break;
case SCAN_F3:
keysym = 0xffc0;
break;
case SCAN_F4:
keysym = 0xffc1;
break;
case SCAN_F5:
keysym = 0xffc2;
break;
case SCAN_F6:
keysym = 0xffc3;
break;
case SCAN_F7:
keysym = 0xffc4;
break;
case SCAN_F8:
keysym = 0xffc5;
break;
case SCAN_F9:
keysym = 0xffc6;
break;
case SCAN_F10:
keysym = 0xffc7;
break;
}
switch (keyCode) {
case KeyEvent.KEYCODE_DPAD_CENTER:
hardwareMetaState &= ~CTRL_MASK;
break;
// Leaving KeyEvent.KEYCODE_ALT_LEFT for symbol input on hardware keyboards.
case KeyEvent.KEYCODE_ALT_RIGHT:
hardwareMetaState &= ~ALT_MASK;
break;
}
}
switch (keyCode) {
// case KeyEvent.KEYCODE_BACK: keysym = 0xff1b; break;
case KeyEvent.KEYCODE_DPAD_LEFT:
keysym = 0xff51;
break;
case KeyEvent.KEYCODE_DPAD_UP:
keysym = 0xff52;
break;
case KeyEvent.KEYCODE_DPAD_RIGHT:
keysym = 0xff53;
break;
case KeyEvent.KEYCODE_DPAD_DOWN:
keysym = 0xff54;
break;
case KeyEvent.KEYCODE_DEL:
keysym = 0xff08;
break;
case KeyEvent.KEYCODE_ENTER:
keysym = 0xff0d;
break;
case KeyEvent.KEYCODE_TAB:
keysym = 0xff09;
break;
case 92 /* KEYCODE_PAGE_UP */:
keysym = 0xff55;
break;
case 93 /* KEYCODE_PAGE_DOWN */:
keysym = 0xff56;
break;
case 111 /* KEYCODE_ESCAPE */:
keysym = 0xff1b;
break;
case 112 /* KEYCODE_FORWARD_DEL */:
keysym = 0xffff;
break;
case 113 /* KEYCODE_CTRL_LEFT */:
keysym = 0xffe3;
break;
case 114 /* KEYCODE_CTRL_RIGHT */:
keysym = 0xffe4;
break;
case 115 /* KEYCODE_CAPS_LOCK */:
keysym = 0xffe5;
break;
case 116 /* KEYCODE_SCROLL_LOCK */:
keysym = 0xff14;
break;
case 117 /* KEYCODE_META_LEFT */:
keysym = 0xffeb;
break;
case 118 /* KEYCODE_META_RIGHT */:
keysym = 0xffec;
break;
case 120 /* KEYCODE_SYSRQ */:
keysym = 0xff61;
break;
case 121 /* KEYCODE_BREAK */:
keysym = 0xff6b;
break;
case 122 /* KEYCODE_MOVE_HOME */:
keysym = 0xff50;
break;
case 123 /* KEYCODE_MOVE_END */:
keysym = 0xff57;
break;
case 124 /* KEYCODE_INSERT */:
keysym = 0xff63;
break;
case 131 /* KEYCODE_F1 */:
keysym = 0xffbe;
break;
case 132 /* KEYCODE_F2 */:
keysym = 0xffbf;
break;
case 133 /* KEYCODE_F3 */:
keysym = 0xffc0;
break;
case 134 /* KEYCODE_F4 */:
keysym = 0xffc1;
break;
case 135 /* KEYCODE_F5 */:
keysym = 0xffc2;
break;
case 136 /* KEYCODE_F6 */:
keysym = 0xffc3;
break;
case 137 /* KEYCODE_F7 */:
keysym = 0xffc4;
break;
case 138 /* KEYCODE_F8 */:
keysym = 0xffc5;
break;
case 139 /* KEYCODE_F9 */:
keysym = 0xffc6;
break;
case 140 /* KEYCODE_F10 */:
keysym = 0xffc7;
break;
case 141 /* KEYCODE_F11 */:
keysym = 0xffc8;
break;
case 142 /* KEYCODE_F12 */:
keysym = 0xffc9;
break;
case 143 /* KEYCODE_NUM_LOCK */:
keysym = 0xff7f;
break;
case 0 /* KEYCODE_UNKNOWN */:
if (evt.getCharacters() != null) {
key = evt.getCharacters().charAt(0);
keysym = UnicodeToKeysym.translate(key);
numchars = evt.getCharacters().length();
unicode = true;
}
break;
default:
// Modifier handling is a bit tricky. Alt, Ctrl, and Super should be passed
// through to the VNC server so that they get handled there, but strip
// them from the character before retrieving the Unicode char from it.
// Don't clear Shift, we still want uppercase characters.
int metaMask =
(0x00007000 | 0x00070000); // KeyEvent.META_CTRL_MASK | KeyEvent.META_META_MASK
// We still want alt-key combinations to give us symbols, so we only strip out
// KeyEvent.META_ALT_MASK
// if we've decided to send out ALT as a separate key modifier over.
if ((metaState & ALT_MASK) != 0) metaMask |= 0x00000032;
KeyEvent copy =
new KeyEvent(
evt.getDownTime(),
evt.getEventTime(),
evt.getAction(),
evt.getKeyCode(),
evt.getRepeatCount(),
keyboardMetaState & ~metaMask,
evt.getDeviceId(),
evt.getScanCode());
key = copy.getUnicodeChar();
keysym = UnicodeToKeysym.translate(key);
break;
}
if (down) {
// Look for standard scan-codes from external keyboards
switch (evt.getScanCode()) {
case SCAN_ESC:
keysym = 0xff1b;
break;
case SCAN_LEFTCTRL:
case SCAN_RIGHTCTRL:
hardwareMetaState |= CTRL_MASK;
break;
case SCAN_F1:
keysym = 0xffbe;
break;
case SCAN_F2:
keysym = 0xffbf;
break;
case SCAN_F3:
keysym = 0xffc0;
break;
case SCAN_F4:
keysym = 0xffc1;
break;
case SCAN_F5:
keysym = 0xffc2;
break;
case SCAN_F6:
keysym = 0xffc3;
break;
case SCAN_F7:
keysym = 0xffc4;
break;
case SCAN_F8:
keysym = 0xffc5;
break;
case SCAN_F9:
keysym = 0xffc6;
break;
case SCAN_F10:
keysym = 0xffc7;
break;
}
switch (keyCode) {
case KeyEvent.KEYCODE_DPAD_CENTER:
hardwareMetaState |= CTRL_MASK;
break;
// Leaving KeyEvent.KEYCODE_ALT_LEFT for symbol input on hardware keyboards.
case KeyEvent.KEYCODE_ALT_RIGHT:
hardwareMetaState |= ALT_MASK;
break;
}
}
try {
if (afterMenu) {
afterMenu = false;
if (!down && keysym != lastKeyDown) return true;
}
if (down) lastKeyDown = keysym;
if (numchars == 1) {
android.util.Log.e(
TAG,
"action down? = "
+ down
+ " key = "
+ key
+ " keysym = "
+ keysym
+ " onscreen metastate = "
+ onScreenMetaState
+ " keyboard metastate = "
+ keyboardMetaState
+ " RFB metastate = "
+ metaState
+ " keycode = "
+ keyCode
+ " unicode = "
+ evt.getUnicodeChar());
// TODO: UGLY HACK for Z10 devices running 10.1 which never send the down-event
// for backspace... so we send it instead. Remove as soon as possible!
if (backspaceWorkaround && keyCode == KeyEvent.KEYCODE_DEL)
rfb.writeKeyEvent(keysym, (onScreenMetaState | hardwareMetaState | metaState), true);
rfb.writeKeyEvent(keysym, (onScreenMetaState | hardwareMetaState | metaState), down);
// If this is a unicode key, the up event will never come, so we artificially insert it.
if (unicode)
rfb.writeKeyEvent(keysym, (onScreenMetaState | hardwareMetaState | metaState), false);
// TODO: UGLY HACK for BB10 devices which never send the up-event
// for space, backspace and enter... so we send it instead. Remove as soon as possible!
if (bb10
&& (keyCode == KeyEvent.KEYCODE_SPACE
|| keyCode == KeyEvent.KEYCODE_DEL
|| keyCode == KeyEvent.KEYCODE_ENTER))
rfb.writeKeyEvent(keysym, (onScreenMetaState | hardwareMetaState | metaState), false);
} else if (numchars > 1) {
for (int i = 0; i < numchars; i++) {
key = evt.getCharacters().charAt(i);
// Log.e(TAG,"action down? = " + down + " key = " + key + " keysym = " + keysym + "
// onscreen metastate = " + onScreenMetaState + " keyboard metastate = " +
// keyboardMetaState + " RFB metastate = " + metaState + " keycode = " + keyCode + "
// unicode = " + evt.getUnicodeChar());
keysym = UnicodeToKeysym.translate(key);
rfb.writeKeyEvent(keysym, (onScreenMetaState | hardwareMetaState | metaState), true);
rfb.writeKeyEvent(keysym, (onScreenMetaState | hardwareMetaState | metaState), false);
}
}
} catch (Exception e) {
e.printStackTrace();
}
return true;
}
return false;
}
