@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; }