Android keyboard remapping: AltGr+IJKL as arrow keys (with Ctrl combos)

Here's the full set of bindings:

All of the above also work with Shift (for text selection) and Ctrl (for word jumping / word selection). For example:

• Shift+AltGr+J → Shift+Left (select one character left)
• Ctrl+AltGr+J → Ctrl+Left (jump one word left)
• Ctrl+Shift+AltGr+J → Ctrl+Shift+Left (select one word left)

• An Android device with a physical keyboard connected (Bluetooth or USB)
• exkeymo-server to generate the keyboard layout APK
• Key Mapper installed from the Play Store or GitHub

Android uses Key Character Map (.kcm) files to define how physical scancodes map to characters and keycodes. With exkeymo-server, you can write a custom KCM file and generate an installable APK from it. After installing the APK, you go to Settings → System → Languages & input → Physical keyboard and select the exkeymo layout for your keyboard.

The KCM format supports a replace keyword that substitutes one keycode for another. This is the foundation of the navigation layer:

key J {
    base:               'j'
    shift, capslock:    'J'
    ralt:               replace DPAD_LEFT
    shift+ralt:         replace DPAD_LEFT
}

When you press AltGr+J, Android strips the AltGr modifier and emits a clean DPAD_LEFT event. Shift survives the replacement, so Shift+AltGr+J correctly produces Shift+DPAD_LEFT — text selection works as expected.

This is where things get tricky. You might expect ctrl+ralt: replace DPAD_LEFT to produce Ctrl+DPAD_LEFT, but it doesn't. The replace keyword strips all modifiers listed in the behavior's metaState — so both Ctrl and AltGr get removed. The app sees a plain DPAD_LEFT with no Ctrl modifier.

You might also hope that omitting the ctrl+ralt rule and relying on the ralt rule to match would work. It doesn't, because the AOSP matchesMetaState() function enforces exact matching for Ctrl, Alt, and Meta modifiers. If the pressed event has Ctrl bits that the matching rule doesn't account for, the match fails entirely.

Here's the relevant AOSP source (KeyCharacterMap.cpp):

bool KeyCharacterMap::matchesMetaState(int32_t eventMetaState,
                                       int32_t behaviorMetaState) {
    if ((eventMetaState & behaviorMetaState) == behaviorMetaState) {
        const int32_t EXACT_META_STATES =
            AMETA_CTRL_ON | AMETA_CTRL_LEFT_ON | AMETA_CTRL_RIGHT_ON
            | AMETA_ALT_ON | AMETA_ALT_LEFT_ON | AMETA_ALT_RIGHT_ON
            | AMETA_META_ON | AMETA_META_LEFT_ON | AMETA_META_RIGHT_ON;
        int32_t unmatchedMetaState =
            eventMetaState & ~behaviorMetaState & EXACT_META_STATES;
        // ... cleanup logic ...
        return !unmatchedMetaState;
    }
    return false;
}

And the replace stripping logic:

if (behavior->replacementKeyCode) {
    toKeyCode = behavior->replacementKeyCode;
    toMetaState = fromMetaState & ~behavior->metaState;
    toMetaState = normalizeMetaState(toMetaState);
}

In short: the KCM format simply cannot produce Ctrl+Arrow from any AltGr-based combo. The fallback keyword doesn't help either — the original event gets consumed by the app (doing nothing), so the fallback never fires.

Since KCM files are a dead end for Ctrl combos, the workaround uses two layers:

1. KCM file: Maps Ctrl+AltGr combos to unused sentinel keycodes (F13–F24, PROG_RED, PROG_GREEN) via replace. This strips all modifiers, producing a clean sentinel keycode event.
2. Key Mapper: Catches the sentinel keycodes and emits the desired Ctrl+Arrow / Ctrl+Shift+Arrow combos.

type OVERLAY

# CapsLock → Escape
map key 58 ESCAPE

key J {
    base:                           'j'
    shift, capslock:                'J'
    ralt:                           replace DPAD_LEFT
    shift+ralt:                     replace DPAD_LEFT
    ctrl+ralt:                      replace F13
    ctrl+shift+ralt:                replace F19
}

key L {
    base:                           'l'
    shift, capslock:                'L'
    ralt:                           replace DPAD_RIGHT
    shift+ralt:                     replace DPAD_RIGHT
    ctrl+ralt:                      replace F14
    ctrl+shift+ralt:                replace F20
}

key I {
    base:                           'i'
    shift, capslock:                'I'
    ralt:                           replace DPAD_UP
    shift+ralt:                     replace DPAD_UP
    ctrl+ralt:                      replace F15
    ctrl+shift+ralt:                replace F21
}

key K {
    base:                           'k'
    shift, capslock:                'K'
    ralt:                           replace DPAD_DOWN
    shift+ralt:                     replace DPAD_DOWN
    ctrl+ralt:                      replace F16
    ctrl+shift+ralt:                replace F22
}

key O {
    base:                           'o'
    shift, capslock:                'O'
    ralt:                           replace DEL
    shift+ralt:                     replace DEL
    ctrl+ralt:                      replace PROG_RED
}

key P {
    base:                           'p'
    shift, capslock:                'P'
    ralt:                           replace FORWARD_DEL
    shift+ralt:                     replace FORWARD_DEL
    ctrl+ralt:                      replace PROG_GREEN
}

key H {
    base:                           'h'
    shift, capslock:                'H'
    ralt:                           replace MOVE_HOME
    shift+ralt:                     replace MOVE_HOME
    ctrl+ralt:                      replace F17
    ctrl+shift+ralt:                replace F23
}

key SEMICOLON {
    base:                           ';'
    shift:                          ':'
    ralt:                           replace MOVE_END
    shift+ralt:                     replace MOVE_END
    ctrl+ralt:                      replace F18
    ctrl+shift+ralt:                replace F24
}

Save this as a .kcm file and feed it to exkeymo-server to generate an APK. Install the APK, then go to Settings → System → Languages & input → Physical keyboard and select the exkeymo layout for your connected keyboard.

Install Key Mapper and grant it Accessibility Service permissions when prompted.

For each of the 14 sentinel mappings, you need to create a trigger → action pair. Here's the process:

The plain AltGr combos and Shift+AltGr combos are handled entirely by the KCM file — no extra app needed. For Ctrl and Ctrl+Shift combos, the KCM converts them to sentinel keycodes (F13–F24, PROG_RED, PROG_GREEN), and Key Mapper translates those sentinels into the final Ctrl+Arrow / Ctrl+Shift+Arrow events.

It's a two-layer workaround for a limitation in Android's KCM replace logic, but once set up, it works reliably and doesn't require root. You get a full Vim-style navigation layer on Android with proper word jumping and text selection support.