java类android.text.method.MetaKeyKeyListener的实例源码

/**
 * Use this to monitor key events being delivered to the application.
 * We get first crack at them, and can either resume them or let them
 * continue to the app.
 */
@Override public boolean onKeyUp(int keyCode, KeyEvent event) {
    // If we want to do transformations on text being entered with a hard
    // keyboard, we need to process the up events to update the meta key
    // state we are tracking.

    if (PROCESS_HARD_KEYS) {
        if (mPredictionOn) {
            mMetaState = MetaKeyKeyListener.handleKeyUp(mMetaState,
                    keyCode, event);
        }
    }

    return super.onKeyUp(keyCode, event);
}

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

    dead = false;

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

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

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

    onKey(c, null);

    return true;
}

@Override
public boolean onKeyUp(int keyCode, KeyEvent event) {
    if (PROCESS_HARD_KEYS) {
        if (PredictionOn) {
            MetaState = MetaKeyKeyListener.handleKeyUp(MetaState, keyCode, event);
        }
    }

    return super.onKeyUp(keyCode, event);
}

@Override
public boolean onKeyUp(int keyCode, KeyEvent event) {
    // Log.d(TAG, String.format("onKeyUp (%x)", keyCode));
    mMetaState = MetaKeyKeyListener.handleKeyUp(mMetaState, keyCode, event);
    return super.onKeyUp(keyCode, event);
}

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

private boolean executeDown(TextView widget, Spannable buffer, int keyCode , KeyEvent event) {
    boolean handled = false;

    if ( keyCode == KEYCODE_PAGE_UP ){
        handled |= volup(widget, buffer);
    }else if ( keyCode == KEYCODE_PAGE_DOWN){
        handled |= voldown(widget, buffer);
    }else if ( keyCode == KEYCODE_MOVE_HOME){
        handled |= movehome(widget, buffer ,event);
    }else if ( keyCode == KEYCODE_MOVE_END){
        handled |= moveend(widget, buffer , event);
    }else{
        switch (keyCode) {
        case KeyEvent.KEYCODE_DPAD_UP:
            handled |= up(widget, buffer);
            break;

        case KeyEvent.KEYCODE_DPAD_DOWN:
            handled |= down(widget, buffer);
            break;

        case KeyEvent.KEYCODE_DPAD_LEFT:
            handled |= left(widget, buffer);
            break;

        case KeyEvent.KEYCODE_DPAD_RIGHT:
            handled |= right(widget, buffer);
            break;

        case KeyEvent.KEYCODE_DPAD_CENTER:
            if (JotaTextKeyListener.getMetaStateSelecting(buffer) != 0) {
                if (widget.showContextMenu()) {
                    handled = true;
                }
            }
            break;
        case KeyEvent.KEYCODE_VOLUME_UP:
            if ( sUseVolumeKey ){
                handled |= volup(widget, buffer);
            }
            break;
        case KeyEvent.KEYCODE_VOLUME_DOWN:
            if ( sUseVolumeKey ){
                handled |= voldown(widget, buffer);
            }
            break;
        }
    }
    if (handled) {
        MetaKeyKeyListener.adjustMetaAfterKeypress(buffer);
        resetLockedMeta(buffer);
    }

    return handled;
}

public static final int getMetaStateSelecting(CharSequence text) {
    return MetaKeyKeyListener.getMetaState(text, META_SELECTING);
}

@Override
public boolean onKeyUp(int keyCode, KeyEvent event) {
    Log.i(TAG, "onKeyUp (keyCode='" + keyCode + "', event.keyCode='" + event.getKeyCode() + "', metaState='" + event.getMetaState() + "')");
    metaState = MetaKeyKeyListener.handleKeyUp(metaState, keyCode, event);
    return super.onKeyUp(keyCode, event);
}

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

@Override
public boolean onKeyUp(int keyCode, KeyEvent event) {
    // Log.d(TAG, String.format("onKeyUp (%x)", keyCode));
    mMetaState = MetaKeyKeyListener.handleKeyUp(mMetaState, keyCode, event);
    return super.onKeyUp(keyCode, event);
}