private boolean processKeyDown(int keyCode, KeyEvent event, boolean isPreIme) { if (DEBUG) { Log.d( LOGTAG, "IME: processKeyDown(keyCode=" + keyCode + ", event=" + event + ", " + isPreIme + ")"); } clampSelection(); switch (keyCode) { case KeyEvent.KEYCODE_MENU: case KeyEvent.KEYCODE_BACK: case KeyEvent.KEYCODE_VOLUME_UP: case KeyEvent.KEYCODE_VOLUME_DOWN: case KeyEvent.KEYCODE_SEARCH: return false; case KeyEvent.KEYCODE_DEL: // See comments in GeckoInputConnection.onKeyDel if (onKeyDel()) { return true; } break; case KeyEvent.KEYCODE_ENTER: if ((event.getFlags() & KeyEvent.FLAG_EDITOR_ACTION) != 0 && mIMEActionHint.equalsIgnoreCase("next")) event = new KeyEvent(event.getAction(), KeyEvent.KEYCODE_TAB); break; default: break; } if (isPreIme && mIMEState != IME_STATE_DISABLED && (event.getMetaState() & KeyEvent.META_ALT_ON) != 0) // Let active IME process pre-IME key events return false; View view = GeckoApp.mAppContext.getLayerController().getView(); KeyListener keyListener = TextKeyListener.getInstance(); // KeyListener returns true if it handled the event for us. if (mIMEState == IME_STATE_DISABLED || keyCode == KeyEvent.KEYCODE_ENTER || keyCode == KeyEvent.KEYCODE_DEL || keyCode == KeyEvent.KEYCODE_TAB || (event.getFlags() & KeyEvent.FLAG_SOFT_KEYBOARD) != 0 || !keyListener.onKeyDown(view, mEditable, keyCode, event)) { // Make sure selection in Gecko is up-to-date final Editable content = getEditable(); int a = Selection.getSelectionStart(content); int b = Selection.getSelectionEnd(content); GeckoAppShell.sendEventToGecko( GeckoEvent.createIMEEvent(GeckoEvent.IME_SET_SELECTION, a, b - a)); GeckoAppShell.sendEventToGecko(GeckoEvent.createKeyEvent(event)); } return true; }
private boolean processKeyUp(int keyCode, KeyEvent event, boolean isPreIme) { if (DEBUG) { Log.d( LOGTAG, "IME: processKeyUp(keyCode=" + keyCode + ", event=" + event + ", " + isPreIme + ")"); } switch (keyCode) { case KeyEvent.KEYCODE_BACK: case KeyEvent.KEYCODE_SEARCH: case KeyEvent.KEYCODE_MENU: return false; default: break; } if (isPreIme && mIMEState != IME_STATE_DISABLED && (event.getMetaState() & KeyEvent.META_ALT_ON) != 0) // Let active IME process pre-IME key events return false; View view = GeckoApp.mAppContext.getLayerController().getView(); KeyListener keyListener = TextKeyListener.getInstance(); if (mIMEState == IME_STATE_DISABLED || keyCode == KeyEvent.KEYCODE_ENTER || keyCode == KeyEvent.KEYCODE_DEL || (event.getFlags() & KeyEvent.FLAG_SOFT_KEYBOARD) != 0 || !keyListener.onKeyUp(view, mEditable, keyCode, event)) { GeckoAppShell.sendEventToGecko(GeckoEvent.createKeyEvent(event)); } return true; }
private void onKeyEvent( KeyEvent event, int action, int savedMetaState, boolean isSynthesizedImeKey) { // Use a separate action argument so we can override the key's original action, // e.g. change ACTION_MULTIPLE to ACTION_DOWN. That way we don't have to allocate // a new key event just to change its action field. // // Normally we expect event.getMetaState() to reflect the current meta-state; however, // some software-generated key events may not have event.getMetaState() set, e.g. key // events from Swype. Therefore, it's necessary to combine the key's meta-states // with the meta-states that we keep separately in KeyListener final int metaState = event.getMetaState() | savedMetaState; final int unmodifiedMetaState = metaState & ~(KeyEvent.META_ALT_MASK | KeyEvent.META_CTRL_MASK | KeyEvent.META_META_MASK); final int unicodeChar = event.getUnicodeChar(metaState); final int domPrintableKeyValue = unicodeChar >= ' ' ? unicodeChar : unmodifiedMetaState != metaState ? event.getUnicodeChar(unmodifiedMetaState) : 0; onKeyEvent( action, event.getKeyCode(), event.getScanCode(), metaState, event.getEventTime(), unicodeChar, // e.g. for Ctrl+A, Android returns 0 for unicodeChar, // but Gecko expects 'a', so we return that in baseUnicodeChar. event.getUnicodeChar(0), domPrintableKeyValue, event.getRepeatCount(), event.getFlags(), isSynthesizedImeKey); }
private KeyEvent translateKey(int keyCode, KeyEvent event) { switch (keyCode) { case KeyEvent.KEYCODE_ENTER: if ((event.getFlags() & KeyEvent.FLAG_EDITOR_ACTION) != 0 && mIMEActionHint.equalsIgnoreCase("next")) { return new KeyEvent(event.getAction(), KeyEvent.KEYCODE_TAB); } break; } return event; }
boolean translateAndSendNativeEvents(KeyEvent event) { if (mNativeImeAdapterAndroid == 0) return false; int action = event.getAction(); if (action != KeyEvent.ACTION_DOWN && action != KeyEvent.ACTION_UP) { // action == KeyEvent.ACTION_MULTIPLE // TODO(bulach): confirm the actual behavior. Apparently: // If event.getKeyCode() == KEYCODE_UNKNOWN, we can send a // composition key down (229) followed by a commit text with the // string from event.getUnicodeChars(). // Otherwise, we'd need to send an event with a // WebInputEvent::IsAutoRepeat modifier. We also need to verify when // we receive ACTION_MULTIPLE: we may receive it after an ACTION_DOWN, // and if that's the case, we'll need to review when to send the Char // event. return false; } // Begin add by TCL zhanghangzhi, mail: [email protected] if (event.getKeyCode() == KeyEvent.KEYCODE_DPAD_CENTER && (event.getFlags() & KeyEvent.FLAG_FROM_SYSTEM) != 0) { android.os.SystemProperties.set( "webviewchromium.tv_enterKeyFlag", String.valueOf(event.getFlags())); android.util.Log.e("ImeAdapter", "[ESTALENT] sys.tv_enterKeyFlag: " + event.getFlags()); } else { android.os.SystemProperties.set("webviewchromium.tv_enterKeyFlag", ""); android.util.Log.e("ImeAdapter", "[ESTALENT] clean sys.tv_enterKeyFlag"); } // End of TCL mViewEmbedder.onImeEvent(false); return nativeSendKeyEvent( mNativeImeAdapterAndroid, event, event.getAction(), getModifiers(event.getMetaState()), event.getEventTime(), event.getKeyCode(), event.isSystem(), event.getUnicodeChar()); }
private void initKeyEvent(KeyEvent k) { mAction = k.getAction(); mTime = k.getEventTime(); mMetaState = k.getMetaState(); mFlags = k.getFlags(); mKeyCode = k.getKeyCode(); mUnicodeChar = k.getUnicodeChar(); mRepeatCount = k.getRepeatCount(); mCharacters = k.getCharacters(); mDomKeyLocation = isJoystickButton(mKeyCode) ? DOM_KEY_LOCATION_JOYSTICK : DOM_KEY_LOCATION_MOBILE; }
@Override public boolean onKeyDown(int keyCode, KeyEvent event) { Xlog.w(TAG, "event.getFlages()" + event.getFlags()); switch (keyCode) { case KeyEvent.KEYCODE_BACK: Xlog.w(TAG, "onKeyDown, keycode is KEYCODE_BACK"); if (!mDownloadInfo.getIfNeedRefreshMenu()) { if (mDownloadInfo.getActivityID() < 0) { mGoToMainEntry = true; SdPkgInstallActivity.this.startActivity(new Intent(this, MainEntry.class)); } } break; default: break; } return super.onKeyDown(keyCode, event); }
private void logKeyEvent(int keyCode, KeyEvent event, boolean down) { String s = down ? "KeyDown event:" : "KeyUp event:"; s += " action " + event.getAction() + " keycode " + keyCode + " " + KeyEvent.keyCodeToString(keyCode); s += " unicode " + event.getUnicodeChar() + " " + event.getDisplayLabel(); s += " ScanCode " + event.getScanCode(); s += " MetaState " + event.getMetaState() + " Flags " + event.getFlags() + " modifiers " + event.getModifiers(); s += " source " + printSource(event.getSource()) + " device " + printDevice(event.getDeviceId()); pushText(s); }
@Override public boolean handleKeyEvent(KeyEvent event) { if (DEBUG_KEYEVENT) { Log.d( TAG, "KeyEvent: action=" + event.getAction() + ", flags=" + event.getFlags() + ", canceled=" + event.isCanceled() + ", keyCode=" + event.getKeyCode() + ", scanCode=" + event.getScanCode() + ", metaState=" + event.getMetaState() + ", repeatCount=" + event.getRepeatCount()); } if (event.getAction() != KeyEvent.ACTION_UP || event.getRepeatCount() != 0) { return false; } switch (event.getScanCode()) { case SCANCODE_TOGGLE_WIFI: toggleWifi(); break; case SCANCODE_TOGGLE_BT: toggleBluetooth(); break; case SCANCODE_TOGGLE_TOUCHPAD: toggleTouchpad(); break; case SCANCODE_BRIGHTNESS_DOWN: brightnessDown(); break; case SCANCODE_BRIGHTNESS_UP: brightnessUp(); break; case SCANCODE_BRIGHTNESS_AUTO: toggleAutoBrightness(); break; case SCANCODE_SCREENSHOT: takeScreenshot(); break; case SCANCODE_EXPLORER: launchExplorer(); return false; case SCANCODE_SETTINGS: launchSettings(); break; case SCANCODE_VOLUME_MUTE: // KEYCODE_VOLUME_MUTE is part of the aosp keyevent intercept handling, but // aosp uses it stop ringing in phone devices (no system volume mute toggle). // Since transformer devices doesn't have a telephony subsystem, we handle and // treat this event as a volume mute toggle action. the asusdec KeyHandler // mustn't mark the key event as consumed. toggleAudioMute(); return false; case SCANCODE_VOLUME_DOWN: volumeDown(); return false; case SCANCODE_VOLUME_UP: volumeUp(); return false; case SCANCODE_MEDIA_PLAY_PAUSE: mediaPlayPause(); return false; case SCANCODE_MEDIA_PREVIOUS: mediaPrevious(); return false; case SCANCODE_MEDIA_NEXT: mediaNext(); return false; case SCANCODE_CAPS_LOCK: capsLock(event); return false; default: return false; } return true; }