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