Java Code Examples for android.view.KeyEvent#getUnicodeChar()

@Override
public boolean onKeyUp(int keyCode, KeyEvent event) {
	if (keyCode == KeyEvent.KEYCODE_SEARCH && !event.isLongPress()) {
		openSearch();
		return true;
	}
	int c = event.getUnicodeChar();
	if (c > 32) {
		if (mSearchEditText != null && !mSearchEditText.isFocused()) {
			openSearch();
			mSearchEditText.append(Character.toString((char) c));
			return true;
		}
	}
	return super.onKeyUp(keyCode, event);
}
 

@Override
public boolean dispatchKeyEvent(KeyEvent event) {
    // Determine if the key event was actual text, if so, focus the search bar and then dispatch
    // the key normally so that it can process this key event
    if (mSearchBarController != null &&
            !mSearchBarController.isSearchFieldFocused() &&
            event.getAction() == KeyEvent.ACTION_DOWN) {
        final int unicodeChar = event.getUnicodeChar();
        final boolean isKeyNotWhitespace = unicodeChar > 0 &&
                !Character.isWhitespace(unicodeChar) && !Character.isSpaceChar(unicodeChar);
        if (isKeyNotWhitespace) {
            boolean gotKey = TextKeyListener.getInstance().onKeyDown(this, mSearchQueryBuilder,
                    event.getKeyCode(), event);
            if (gotKey && mSearchQueryBuilder.length() > 0) {
                mSearchBarController.focusSearchField();
            }
        }
    }

    return super.dispatchKeyEvent(event);
}
 

/**
 * Maps shortcut keys and Android keycodes to printable characters.
 * Note that whitespace is considered printable.
 * 
 * @param event The KeyEvent to interpret
 * @return The printable character the event represents, 
 * 	or Language.NULL_CHAR if the event does not represent a printable char
 */
public static char keyEventToPrintableChar(KeyEvent event){
	char c = Language.NULL_CHAR;

   	// convert tab, backspace, newline and space keycodes to standard ASCII values
   	if (isNewline(event)){
   		c = Language.NEWLINE;
       }
   	else if (isBackspace(event)){
   		c = Language.BACKSPACE;
       }
	// This should be before the check for isSpace() because the
   	// shortcut for TAB uses the SPACE key.
   	else if (isTab(event)){
   		c = Language.TAB;
       }
   	else if (isSpace(event)){
   		c = ' ';
       }
   	else if (event.isPrintingKey()){
   		c = (char) event.getUnicodeChar(event.getMetaState());
   	}
   	
	return c;
}
 

@Override
public boolean dispatchKeyEvent(KeyEvent event) {
    // Determine if the key event was actual text, if so, focus the search bar and then dispatch
    // the key normally so that it can process this key event
    if (!mSearchBarController.isSearchFieldFocused() &&
            event.getAction() == KeyEvent.ACTION_DOWN) {
        final int unicodeChar = event.getUnicodeChar();
        final boolean isKeyNotWhitespace = unicodeChar > 0 &&
                !Character.isWhitespace(unicodeChar) && !Character.isSpaceChar(unicodeChar);
        if (isKeyNotWhitespace) {
            boolean gotKey = TextKeyListener.getInstance().onKeyDown(this, mSearchQueryBuilder,
                    event.getKeyCode(), event);
            if (gotKey && mSearchQueryBuilder.length() > 0) {
                mSearchBarController.focusSearchField();
            }
        }
    }

    return super.dispatchKeyEvent(event);
}
 

@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
    final int uniChar = event.getUnicodeChar();
    final boolean handled = super.onKeyDown(keyCode, event);
    final boolean isKeyNotWhitespace = uniChar > 0 && !Character.isWhitespace(uniChar);
    if (!handled && acceptFilter() && isKeyNotWhitespace) {
        boolean gotKey = TextKeyListener.getInstance().onKeyDown(mWorkspace, mDefaultKeySsb,
                keyCode, event);
        if (gotKey && mDefaultKeySsb != null && mDefaultKeySsb.length() > 0) {
            // something usable has been typed - start a search
            // the typed text will be retrieved and cleared by
            // showSearchDialog()
            // If there are multiple keystrokes before the search dialog takes focus,
            // onSearchRequested() will be called for every keystroke,
            // but it is idempotent, so it's fine.
            return onSearchRequested();
        }
    }

    // Eat the long press event so the keyboard doesn't come up.
    if (keyCode == KeyEvent.KEYCODE_MENU && event.isLongPress()) {
        return true;
    }

    return handled;
}
 

/**
 * Maps shortcut keys and Android keycodes to printable characters.
 * Note that whitespace is considered printable.
 *
 * @param event The KeyEvent to interpret
 * @return The printable character the event represents,
 * or Language.NULL_CHAR if the event does not represent a printable char
 */
public static char keyEventToPrintableChar(KeyEvent event) {
    char c = Language.NULL_CHAR;

    // convert tab, backspace, newline and space keycodes to standard ASCII values
    if (isNewline(event)) {
        c = Language.NEWLINE;
    } else if (isBackspace(event)) {
        c = Language.BACKSPACE;
    }
    // This should be before the check for isSpace() because the
    // shortcut for TAB uses the SPACE key.
    else if (isTab(event)) {
        c = Language.TAB;
    } else if (isSpace(event)) {
        c = ' ';
    } else if (event.isPrintingKey()) {
        c = (char) event.getUnicodeChar(event.getMetaState());
    }

    return c;
}
 

@Override
public boolean sendKeyEvent(KeyEvent event) {
	if (event.getAction() == KeyEvent.ACTION_UP) {
		char[] tmp = { (char)event.getUnicodeChar() };
		inputProcessor.executeCommand(tmp);
	}
	return true;
}
 

public boolean onKeyDown(int i, KeyEvent keyEvent) {
    f.b("SecureWebView", "-->onKeyDown, is device support: " + a);
    if (!a) {
        return super.onKeyDown(i, keyEvent);
    }
    if (keyEvent.getAction() != 0) {
        return super.onKeyDown(i, keyEvent);
    }
    switch (keyEvent.getKeyCode()) {
        case 4:
            return super.onKeyDown(i, keyEvent);
        case 66:
            return super.onKeyDown(i, keyEvent);
        case 67:
            a.b = true;
            return super.onKeyDown(i, keyEvent);
        default:
            if (keyEvent.getUnicodeChar() == 0) {
                return super.onKeyDown(i, keyEvent);
            }
            if (SecureJsInterface.isPWDEdit) {
                int unicodeChar = keyEvent.getUnicodeChar();
                if ((unicodeChar >= 33 && unicodeChar <= 95) || (unicodeChar >= 97 && unicodeChar <= 125)) {
                    this.b = new KeyEvent(0, 17);
                    return super.onKeyDown(this.b.getKeyCode(), this.b);
                }
            }
            return super.onKeyDown(i, keyEvent);
    }
}
 

public boolean dispatchKeyEvent(KeyEvent keyEvent) {
    f.b("SecureWebView", "-->dispatchKeyEvent, is device support: " + a);
    if (!a) {
        return super.dispatchKeyEvent(keyEvent);
    }
    if (keyEvent.getAction() != 0) {
        return super.dispatchKeyEvent(keyEvent);
    }
    switch (keyEvent.getKeyCode()) {
        case 4:
            return super.dispatchKeyEvent(keyEvent);
        case 66:
            return super.dispatchKeyEvent(keyEvent);
        case 67:
            a.b = true;
            return super.dispatchKeyEvent(keyEvent);
        default:
            if (keyEvent.getUnicodeChar() == 0) {
                return super.dispatchKeyEvent(keyEvent);
            }
            if (SecureJsInterface.isPWDEdit) {
                int unicodeChar = keyEvent.getUnicodeChar();
                if ((unicodeChar >= 33 && unicodeChar <= 95) || (unicodeChar >= 97 && unicodeChar <= 125)) {
                    this.b = new KeyEvent(0, 17);
                    return super.dispatchKeyEvent(this.b);
                }
            }
            return super.dispatchKeyEvent(keyEvent);
    }
}
 

private void processKey(int keyCode, boolean doubleClick, KeyEvent event) {
    switch (keyCode) {
        case KeyEvent.KEYCODE_DPAD_UP:
            password += doubleClick ? 6 : 1;
            break;
        case KeyEvent.KEYCODE_DPAD_LEFT:
            password += doubleClick ? 7 : 2;
            break;
        case KeyEvent.KEYCODE_DPAD_RIGHT:
            password += doubleClick ? 8 : 3;
            break;
        case KeyEvent.KEYCODE_DPAD_DOWN:
            password += doubleClick ? 9 : 4;
            break;
        case KeyEvent.KEYCODE_DPAD_CENTER:
            password += doubleClick ? 5 : 0;
            break;
        case KeyEvent.KEYCODE_0:
        case KeyEvent.KEYCODE_1:
        case KeyEvent.KEYCODE_2:
        case KeyEvent.KEYCODE_3:
        case KeyEvent.KEYCODE_4:
        case KeyEvent.KEYCODE_5:
        case KeyEvent.KEYCODE_6:
        case KeyEvent.KEYCODE_7:
        case KeyEvent.KEYCODE_8:
        case KeyEvent.KEYCODE_9:
            password += (char)event.getUnicodeChar();
            break;
    }
    //TvApp.getApplication().getLogger().Debug(password);
    pwField.setText(password);
}
 

/**
     * This translates incoming hard key events in to edit operations on an
     * InputConnection.  It is only needed when using the
     * PROCESS_HARD_KEYS option.
     */
    private boolean translateKeyDown(int keyCode, KeyEvent event) {
//        Log.v("SpartacusRex","SOFT : translateKeyDown "+keyCode);

        mMetaState = MetaKeyKeyListener.handleKeyDown(mMetaState,
                keyCode, event);
        int c = event.getUnicodeChar(MetaKeyKeyListener.getMetaState(mMetaState));
        mMetaState = MetaKeyKeyListener.adjustMetaAfterKeypress(mMetaState);
        InputConnection ic = getCurrentInputConnection();
        if (c == 0 || ic == null) {
            return false;
        }

        boolean dead = false;

        if ((c & KeyCharacterMap.COMBINING_ACCENT) != 0) {
            dead = true;
            c = c & KeyCharacterMap.COMBINING_ACCENT_MASK;
        }

        if (mComposing.length() > 0) {
            char accent = mComposing.charAt(mComposing.length() - 1);
            int composed = KeyEvent.getDeadChar(accent, c);

            if (composed != 0) {
                c = composed;
                mComposing.setLength(mComposing.length() - 1);
            }
        }

        onKey(c, null);

        return true;
    }
 

@Override
public boolean onKey(View v, int keyCode, KeyEvent event) {
    if (osConfig.C_VOLUME_TO_ROTATE) {
        if (keyCode == KeyEvent.KEYCODE_VOLUME_UP) {
            mudclient.keyLeft = event.getAction() == KeyEvent.ACTION_DOWN;
            return true;
        }
        if (keyCode == KeyEvent.KEYCODE_VOLUME_DOWN) {
            mudclient.keyRight = event.getAction() == KeyEvent.ACTION_DOWN;
            return true;
        }
    }
    // If we are not volume to rotate, then we are volume to zoom...
    else {
        if (Config.S_ZOOM_VIEW_TOGGLE) {
            if (keyCode == KeyEvent.KEYCODE_VOLUME_UP) {
                mudclient.keyUp = event.getAction() == KeyEvent.ACTION_DOWN;
                return true;
            }
            if (keyCode == KeyEvent.KEYCODE_VOLUME_DOWN) {
                mudclient.keyDown = event.getAction() == KeyEvent.ACTION_DOWN;
                return true;
            }
        }
    }

    if (event.getAction() == KeyEvent.ACTION_DOWN) {
        int key = event.getUnicodeChar();
        if (keyCode == KeyEvent.KEYCODE_DEL) {
            key = 8;
        }

        boolean hitInputFilter = false;

        for (int var5 = 0; var5 < Fonts.inputFilterChars.length(); ++var5) {
            if (Fonts.inputFilterChars.charAt(var5) == key) {
                hitInputFilter = true;

                break;
            }
        }

        mudclient.handleKeyPress((byte) 126, key);
        if (hitInputFilter && mudclient.inputTextCurrent.length() < 20) {
            mudclient.inputTextCurrent = mudclient.inputTextCurrent + (char) key;
        }

        if (hitInputFilter && mudclient.chatMessageInput.length() < 80) {
            mudclient.chatMessageInput = mudclient.chatMessageInput + (char) key;
        }

        // Backspace
        if (key == '\b' && mudclient.inputTextCurrent.length() > 0) {
            mudclient.inputTextCurrent = mudclient.inputTextCurrent.substring(0,
                    mudclient.inputTextCurrent.length() - 1);
        }

        // Backspace
        if (key == '\b' && mudclient.chatMessageInput.length() > 0) {
            mudclient.chatMessageInput = mudclient.chatMessageInput.substring(0,
                    mudclient.chatMessageInput.length() - 1);
        }

        if (key == 10 || key == 13) {
            mudclient.inputTextFinal = mudclient.inputTextCurrent;
            mudclient.chatMessageInputCommit = mudclient.chatMessageInput;
        }
        return true;
    }
    return false;
}
 

@Override
public Event decodeHardwareKey(final KeyEvent keyEvent) {
    // KeyEvent#getUnicodeChar() does not exactly returns a unicode char, but rather a value
    // that includes both the unicode char in the lower 21 bits and flags in the upper bits,
    // hence the name "codePointAndFlags". {@see KeyEvent#getUnicodeChar()} for more info.
    final int codePointAndFlags = keyEvent.getUnicodeChar();
    // The keyCode is the abstraction used by the KeyEvent to represent different keys that
    // do not necessarily map to a unicode character. This represents a physical key, like
    // the key for 'A' or Space, but also Backspace or Ctrl or Caps Lock.
    final int keyCode = keyEvent.getKeyCode();
    final boolean isKeyRepeat = (0 != keyEvent.getRepeatCount());
    if (KeyEvent.KEYCODE_DEL == keyCode) {
        return Event.createHardwareKeypressEvent(Event.NOT_A_CODE_POINT, Constants.CODE_DELETE,
                null /* next */, isKeyRepeat);
    }
    if (keyEvent.isPrintingKey() || KeyEvent.KEYCODE_SPACE == keyCode
            || KeyEvent.KEYCODE_ENTER == keyCode) {
        if (0 != (codePointAndFlags & KeyCharacterMap.COMBINING_ACCENT)) {
            // A dead key.
            return Event.createDeadEvent(
                    codePointAndFlags & KeyCharacterMap.COMBINING_ACCENT_MASK, keyCode,
                    null /* next */);
        }
        if (KeyEvent.KEYCODE_ENTER == keyCode) {
            // The Enter key. If the Shift key is not being pressed, this should send a
            // CODE_ENTER to trigger the action if any, or a carriage return otherwise. If the
            // Shift key is being pressed, this should send a CODE_SHIFT_ENTER and let
            // Latin IME decide what to do with it.
            if (keyEvent.isShiftPressed()) {
                return Event.createHardwareKeypressEvent(Event.NOT_A_CODE_POINT,
                        Constants.CODE_SHIFT_ENTER, null /* next */, isKeyRepeat);
            }
            return Event.createHardwareKeypressEvent(Constants.CODE_ENTER, keyCode,
                    null /* next */, isKeyRepeat);
        }
        // If not Enter, then this is just a regular keypress event for a normal character
        // that can be committed right away, taking into account the current state.
        return Event.createHardwareKeypressEvent(codePointAndFlags, keyCode, null /* next */,
                isKeyRepeat);
    }
    return Event.createNotHandledEvent();
}
 

@Override
public boolean dispatchKeyEvent(final KeyEvent event) {
    final int keyCode = event.getKeyCode();
    final InputConnection connection = mInputConnection;
    if (connection != null) {
        if (isAttachToWindowWidget()) {
            if (event.getKeyCode() == KeyEvent.KEYCODE_BACK) {
                return false;
            } else {
                connection.sendKeyEvent(event);
                hide(UIWidget.KEEP_WIDGET);
            }
            return true;
        }
        // Android Components do not support InputConnection.sendKeyEvent()
        if (event.getAction() == KeyEvent.ACTION_DOWN) {
            Log.e("reb", "key = " + KeyEvent.keyCodeToString(keyCode));

            switch (keyCode) {
                case KeyEvent.KEYCODE_DEL:
                    handleBackspace();
                    return true;
                case KeyEvent.KEYCODE_ENTER:
                case KeyEvent.KEYCODE_NUMPAD_ENTER:
                    handleDone();
                    return true;
                case KeyEvent.KEYCODE_DPAD_LEFT:
                    moveCursor(-1);
                    return true;
                case KeyEvent.KEYCODE_DPAD_RIGHT:
                    moveCursor(1);
                    return true;
                default:
                    break;
            }
            if (event.getUnicodeChar() != 0) {
                KeyCharacterMap map = event.getKeyCharacterMap();
                String value = String.valueOf((char) map.get(keyCode, event.getMetaState()));
                connection.commitText(value, 1);
                return true;
            }
        }
    }
    return false;
}
 

@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
    int c = event.getUnicodeChar();
    if (keyCode == KeyEvent.KEYCODE_VOLUME_UP) {
        if (mVolumeLevel != VOLUME_LEVEL_UNKNOWN) {
            setVolume(mVolumeLevel + 20);
        } else {
            mMediaServer.status().command.volumeUp();
        }
        return true;
    } else if (keyCode == KeyEvent.KEYCODE_VOLUME_DOWN) {
        if (mVolumeLevel != VOLUME_LEVEL_UNKNOWN) {
            setVolume(mVolumeLevel - 20);
        } else {
            mMediaServer.status().command.volumeDown();
        }
        return true;
    } else if (keyCode == KeyEvent.KEYCODE_DPAD_LEFT) {
        if (event.isAltPressed()) {
            mMediaServer.status().command.seek(Uri.encode("-".concat(Preferences.get(this).getSeekTime())));
            return true;
        } else if (event.isShiftPressed()) {
            mMediaServer.status().command.seek(Uri.encode("-3"));
            return true;
        } else {
            mMediaServer.status().command.key("nav-left");
            return true;
        }
    } else if (keyCode == KeyEvent.KEYCODE_DPAD_RIGHT) {
        if (event.isAltPressed()) {
            mMediaServer.status().command.seek(Uri.encode("+".concat(Preferences.get(this).getSeekTime())));
            return true;
        } else if (event.isShiftPressed()) {
            mMediaServer.status().command.seek(Uri.encode("+3"));
            return true;
        } else {
            mMediaServer.status().command.key("nav-right");
            return true;
        }
    } else if (keyCode == KeyEvent.KEYCODE_DPAD_UP) {
        mMediaServer.status().command.key("nav-up");
        return true;
    } else if (keyCode == KeyEvent.KEYCODE_DPAD_DOWN) {
        mMediaServer.status().command.key("nav-down");
        return true;
    } else if (keyCode == KeyEvent.KEYCODE_DPAD_CENTER) {
        mMediaServer.status().command.key("nav-activate");
        return true;
    } else if (c == ' ') {
        mMediaServer.status().command.playback.pause();
        return true;
    } else if (c == 's') {
        mMediaServer.status().command.playback.stop();
        return true;
    } else if (c == 'p') {
        mMediaServer.status().command.playback.previous();
        return true;
    } else if (c == 'n') {
        mMediaServer.status().command.playback.next();
        return true;
    } else if (c == '+') {
        // TODO: Play faster
        return super.onKeyDown(keyCode, event);
    } else if (c == '-') {
        // TODO: Play slower
        return super.onKeyDown(keyCode, event);
    } else if (c == 'f') {
        mMediaServer.status().command.fullscreen();
        return true;
    } else if (c == 'm') {
        mute();
        return true;
    } else {
        return super.onKeyDown(keyCode, event);
    }
}
 

@Override
public Event decodeHardwareKey(final KeyEvent keyEvent) {
    // KeyEvent#getUnicodeChar() does not exactly returns a unicode char, but rather a value
    // that includes both the unicode char in the lower 21 bits and flags in the upper bits,
    // hence the name "codePointAndFlags". {@see KeyEvent#getUnicodeChar()} for more info.
    final int codePointAndFlags = keyEvent.getUnicodeChar();
    // The keyCode is the abstraction used by the KeyEvent to represent different keys that
    // do not necessarily map to a unicode character. This represents a physical key, like
    // the key for 'A' or Space, but also Backspace or Ctrl or Caps Lock.
    final int keyCode = keyEvent.getKeyCode();
    final boolean isKeyRepeat = (0 != keyEvent.getRepeatCount());
    if (KeyEvent.KEYCODE_DEL == keyCode) {
        return Event.createHardwareKeypressEvent(Event.NOT_A_CODE_POINT, Constants.CODE_DELETE,
                null /* next */, isKeyRepeat);
    }
    if (keyEvent.isPrintingKey() || KeyEvent.KEYCODE_SPACE == keyCode
            || KeyEvent.KEYCODE_ENTER == keyCode) {
        if (0 != (codePointAndFlags & KeyCharacterMap.COMBINING_ACCENT)) {
            // A dead key.
            return Event.createDeadEvent(
                    codePointAndFlags & KeyCharacterMap.COMBINING_ACCENT_MASK, keyCode,
                    null /* next */);
        }
        if (KeyEvent.KEYCODE_ENTER == keyCode) {
            // The Enter key. If the Shift key is not being pressed, this should send a
            // CODE_ENTER to trigger the action if any, or a carriage return otherwise. If the
            // Shift key is being pressed, this should send a CODE_SHIFT_ENTER and let
            // Latin IME decide what to do with it.
            if (keyEvent.isShiftPressed()) {
                return Event.createHardwareKeypressEvent(Event.NOT_A_CODE_POINT,
                        Constants.CODE_SHIFT_ENTER, null /* next */, isKeyRepeat);
            }
            return Event.createHardwareKeypressEvent(Constants.CODE_ENTER, keyCode,
                    null /* next */, isKeyRepeat);
        }
        // If not Enter, then this is just a regular keypress event for a normal character
        // that can be committed right away, taking into account the current state.
        return Event.createHardwareKeypressEvent(codePointAndFlags, keyCode, null /* next */,
                isKeyRepeat);
    }
    return Event.createNotHandledEvent();
}
 

private int getUnicodeChar(int keyCode, KeyEvent event) {
    metaState = MetaKeyKeyListener.handleKeyDown(metaState, keyCode, event);
    int c = event.getUnicodeChar(event.getMetaState());
    metaState = MetaKeyKeyListener.adjustMetaAfterKeypress(metaState);
    return c;
}
 

private int getUnicodeChar(int keyCode, KeyEvent event) {
    metaState = MetaKeyKeyListener.handleKeyDown(metaState, keyCode, event);
    int c = event.getUnicodeChar(event.getMetaState());
    metaState = MetaKeyKeyListener.adjustMetaAfterKeypress(metaState);
    return c;
}
 

/**
 * @see BaseInputConnection#sendKeyEvent(android.view.KeyEvent)
 */
@Override
public boolean sendKeyEvent(KeyEvent event) {
    if (DEBUG) {
        Log.w(TAG, "sendKeyEvent [" + event.getAction() + "] [" + event.getKeyCode() + "]");
    }
    // If this is a key-up, and backspace/del or if the key has a character representation,
    // need to update the underlying Editable (i.e. the local representation of the text
    // being edited).
    if (event.getAction() == KeyEvent.ACTION_UP) {
        if (event.getKeyCode() == KeyEvent.KEYCODE_DEL) {
            deleteSurroundingText(1, 0);
            return true;
        } else if (event.getKeyCode() == KeyEvent.KEYCODE_FORWARD_DEL) {
            deleteSurroundingText(0, 1);
            return true;
        } else {
            int unicodeChar = event.getUnicodeChar();
            if (unicodeChar != 0) {
                Editable editable = getEditable();
                int selectionStart = Selection.getSelectionStart(editable);
                int selectionEnd = Selection.getSelectionEnd(editable);
                if (selectionStart > selectionEnd) {
                    int temp = selectionStart;
                    selectionStart = selectionEnd;
                    selectionEnd = temp;
                }
                editable.replace(selectionStart, selectionEnd,
                        Character.toString((char)unicodeChar));
            }
        }
    } else if (event.getAction() == KeyEvent.ACTION_DOWN) {
        // TODO(aurimas): remove this workaround when crbug.com/278584 is fixed.
        if (event.getKeyCode() == KeyEvent.KEYCODE_ENTER) {
            beginBatchEdit();
            finishComposingText();
            mImeAdapter.translateAndSendNativeEvents(event);
            endBatchEdit();
            return true;
        } else if (event.getKeyCode() == KeyEvent.KEYCODE_DEL) {
            return true;
        } else if (event.getKeyCode() == KeyEvent.KEYCODE_FORWARD_DEL) {
            return true;
        }
    }
    mImeAdapter.translateAndSendNativeEvents(event);
    return true;
}
 

void onKeyEvent(KeyEvent event) {
    int action = event.getAction();
    int keyCode = event.getKeyCode();
    switch (action) {
        case KeyEvent.ACTION_DOWN: {

            //输入模式
            int unicodeChar = event.getUnicodeChar();
            if (unicodeChar != 0) {

                input((char) unicodeChar);
                event.cancel();
            }
            if (!event.isCanceled() && !event.isCtrlPressed() && !event.isAltPressed()
                    && !event.isShiftPressed()) {
                switch (keyCode) {
                    case KeyEvent.KEYCODE_TAB:
                        //tab
                        input(tabText);
                        event.cancel();
                        break;
                    case KeyEvent.KEYCODE_SPACE:
                        //空格
                        input(' ');
                        event.cancel();
                        break;
                    case KeyEvent.KEYCODE_ENTER:
                        //enter
                        onKeyCodeEnter(event);
                        event.cancel();
                        break;
                    case KeyEvent.KEYCODE_DEL:
                        //del
                        onKeyCodeDel(event);
                        event.cancel();
                        break;
                    case KeyEvent.KEYCODE_FORWARD_DEL:
                        //del
                        onKeyCodeForwardDel(event);
                        event.cancel();
                        break;
                    case KeyEvent.KEYCODE_DPAD_LEFT:
                        //left
                        onKeyCodeDpadLeft(event);
                        event.cancel();
                        break;
                    case KeyEvent.KEYCODE_DPAD_RIGHT:
                        //right
                        onKeyCodeDpadRight(event);
                        event.cancel();
                        break;
                    case KeyEvent.KEYCODE_DPAD_UP:
                        //up
                        onKeyCodeDpadUp(event);
                        event.cancel();
                        break;
                    case KeyEvent.KEYCODE_DPAD_DOWN:
                        //down
                        onKeyCodeDpadDown(event);
                        event.cancel();
                        break;
                    case KeyEvent.KEYCODE_VOLUME_DOWN:

                    case KeyEvent.KEYCODE_PAGE_DOWN:
                        //page down
                        onKeyCodePageDown(event);
                        event.cancel();
                        break;
                    case KeyEvent.KEYCODE_VOLUME_UP:

                    case KeyEvent.KEYCODE_PAGE_UP:
                        //page up
                        onKeyCodePageUp(event);
                        event.cancel();
                        break;
                    case KeyEvent.KEYCODE_MOVE_HOME:
                        onKeyCodeMoveHome(event);
                        event.cancel();
                        break;
                    case KeyEvent.KEYCODE_MOVE_END:
                        onKeyCodeMoveEnd(event);
                        event.cancel();
                        break;
                }
            }
            if (!event.isCanceled()) {
                //快捷键模式
                if (onShortKey(event.isCtrlPressed(), event.isAltPressed(), event.isShiftPressed(), keyCode)) {
                    event.cancel();
                }
            }

            break;
        }

    }
}