Is there a way to get the evdev keycode from a string?

Question

I'd like to read button mappings from a text file that contains data like this:

DPAD_LEFT = 105
DPAD_RIGHT = 106
DPAD_UP = 103
DPAD_DOWN = 108

The right part is actually the evdev keycode (as defined in <linux/input.h>).

This is quite hard to read, so I'd like to be able have files like this:

DPAD_LEFT = KEY_LEFT
DPAD_RIGHT = KEY_RIGHT
DPAD_UP = KEY_UP
DPAD_DOWN = KEY_DOWN

But I'm currently not able to convert them back:

char[256] keyname;
some_method_to_read(&keyname, "DPAD_LEFT");
//keyname now contains "KEY_LEFT"

How do I get the corresponding keycode (e.g. 105)? Is there a standard way to do this?

EDIT: The only way I can think of right now is by duplicating all the keycodes in my source and putting them in an array or map, like the evtest utility does. But there are a lot of keycodes and this seems quite a bit of overkill to me. Also, this might get out-of-sync with the keycodes defined in <input/linux.h> at some point.

std::map<string, int> keynames;
#define MAP_KEYCODE(keycode) keynames[#keycode] = keycode

MAP_KEYCODE(KEY_LEFT);
MAP_KEYCODE(KEY_RIGHT);
MAP_KEYCODE(KEY_UP);
MAP_KEYCODE(KEY_DOWN);
// [...]

No there's no standard method (that I know of), but you can build a name-to-keycode map yourself from `linux/input.h`. — n. m. could be an AI, Aug 17 '15 at 21:00
Yeah, I had that idea too, but this seems a lot of work to me. Anyhow, if there's no other way, I'll have to do it like this. Thanks! — Jan Holthuis, Aug 17 '15 at 21:03
You can transform linux/input.h into a sequence of calls to MAP_KEYCODE with a simple sed script. — n. m. could be an AI, Aug 17 '15 at 21:08

score 0 · Answer 1 · answered Aug 18 '15 at 00:02

Have your program read the name-to-code mapping from a configuration file(s), say /usr/share/yourprogram/keycodes and/or $HOME/.yourprogram/keycodes.

Document that anyone can regenerate that file from their /usr/include/linux/input.h -- and regenerate the initial file yourself -- using for example

awk '$2 ~ /^KEY_/ { code[$2] = $3 }
     END {
       for (name in code)
         if (code[name] ~ /^KEY_/)
           code[name] = code[code[name]];
       for (name in code)
         if (code[name] !~ /KEY_/)
           printf "%-24s %s\n", name, code[name]
     }' /usr/include/linux/input.h | sort

You might have to add KEY_CNT youself (it's value is one more than KEY_MAX), as the above script does not do math, only direct aliases.

To describing the name-to-code mappings, I'd use

struct keycode {
    struct keycode *next;
    unsigned int    code;
    unsigned int    hash;
    unsigned char   namelen;
    char            name[];
};

where the hash is a simple hash, say djb2,

unsigned int djb2(const char *const str, const size_t len)
{
    unsigned int result = 5831U;
    size_t       i;
    for (i = 0; i < len; i++)
        result = result * 33U ^ (unsigned int)str[i];
    return result;
}

Of currently defined key codes, only KEY_CUT and KEY_F15 map to the same djb2 hash, 1857856141. (If you used 31U instead of 33U, the current set would have no collisions, but that's no proof against future collisions. Better have one collision already, so you can test it is handled correctly.)

The function that reads the configuration file could just return the codes by prepending new ones to a singly-linked list, perhaps

int read_keycodes(const char *const filename,
                  struct keycode **list);

If you prepend to the list, you should later on ignore redefinitions of the same name. This way, if you read the system-wide configuration first, then the user-specific one, the user-specific one can override the system-wide ones.

After all keycode mappings are read, you construct a hash table, something like

struct keytab {
    unsigned int     size; /* index = hash % size */
    struct keycode **slot;
};

(When building the hash table, discard keycodes whose exact names are already in the keytab. This way later definitions override earlier ones.)

This way you only need to calculate the hash of the name you want to look up, then probe the linked list in your keytab structure. Compare hashes first, then lengths; if both match, finally do a strcmp(). This way the lookup will be very fast, and relatively simple to implement, too. With current key codes, you'll only do the slow strcmp() twice for KEY_F15 and KEY_CUT; for all others, a single strcmp() will suffice.

Questions?

score 0 · Accepted Answer · answered Aug 30 '15 at 20:54

I found a way to do this properly: By using libevdev's libevdev_event_code_from_name function.

unsigned int event_type = EV_KEY;
const char* name = "BTN_A";
int code = libevdev_event_code_from_name(event_type, name);
if(code < 0)
{
  puts("There was an error!");
}

Is there a way to get the evdev keycode from a string?

2 Answers2