Comment savoir quel clavier a été utilisé pour appuyer sur une touche?

Je travaille fréquemment sur des stations d'appairage où plusieurs claviers sont installés. Je peux utiliser setxkbmapavec -device <ID>pour définir la disposition d'un clavier spécifique (en utilisant un ID dexinput ), mais souvent, il n'est pas évident de savoir quel clavier je suis. Il serait préférable d'éviter les allers-retours d'essayer les deux claviers, donc j'aimerais écrire un outil rapide pour obtenir ces informations setxkbmap. Je m'attendrais à un cas d'utilisation typique comme le suivant:

$ setxkbmap -device "$(get-keyboard-id)" -layout gb
Press Enter to detect keyboard ID

Quelle interface fournit ces informations sur Linux? Idéalement, cela devrait fonctionner sans X, mais ce n'est pas une exigence (il ne semble pas y avoir beaucoup d'outils qui prennent en charge cela sans X).

Résultats à ce jour:

• Linux doit savoir sur quel clavier je tape pour prendre en charge différentes dispositions pour plusieurs claviers simultanément.
• xinput→ list.c → list_xi2→ XIQueryDevicefournit des ID de périphérique utilisables par setxkbmap.
• showkeyet xevn'imprimez pas les ID de clavier.
• xinput list-props $IDindique où les événements clavier sont envoyés . Cependant, en utilisant le code d'une autre réponse, il semble que cet appareil n'imprime rien pour identifier le clavier.

• Une solution presque possible consiste à exécuter xinput --test <ID> &pour chaque ID de clavier et à voir lequel renvoie quelque chose en premier. Le problème avec cela est de savoir quels "claviers" sont en fait des claviers:

  $ xinput | grep keyboard
  ⎣ Virtual core keyboard                         id=3    [master keyboard (2)]
      ↳ Virtual core XTEST keyboard               id=5    [slave  keyboard (3)]
      ↳ Power Button                              id=6    [slave  keyboard (3)]
      ↳ Video Bus                                 id=7    [slave  keyboard (3)]
      ↳ Power Button                              id=8    [slave  keyboard (3)]
      ↳ Sleep Button                              id=9    [slave  keyboard (3)]
      ↳ WebCam SC-13HDL10931N                     id=10   [slave  keyboard (3)]
      ↳ AT Translated Set 2 keyboard              id=11   [slave  keyboard (3)]
  

Désactiver l'appareil

Voici une idée pour identifier quel clavier est lequel. Vous pouvez utiliser la commande xinput pour activer et désactiver des périphériques.

Exemple

$ xinput list
⎡ Virtual core pointer                      id=2    [master pointer  (3)]
⎜   ↳ Virtual core XTEST pointer                id=4    [slave  pointer  (2)]
⎜   ↳ SynPS/2 Synaptics TouchPad                id=12   [slave  pointer  (2)]
⎜   ↳ TPPS/2 IBM TrackPoint                     id=13   [slave  pointer  (2)]
⎜   ↳ Logitech USB Receiver                     id=9    [slave  pointer  (2)]
⎜   ↳ Logitech USB Receiver                     id=10   [slave  pointer  (2)]
⎣ Virtual core keyboard                     id=3    [master keyboard (2)]
    ↳ Virtual core XTEST keyboard               id=5    [slave  keyboard (3)]
    ↳ Power Button                              id=6    [slave  keyboard (3)]
    ↳ Video Bus                                 id=7    [slave  keyboard (3)]
    ↳ Sleep Button                              id=8    [slave  keyboard (3)]
    ↳ AT Translated Set 2 keyboard              id=11   [slave  keyboard (3)]
    ↳ ThinkPad Extra Buttons                    id=14   [slave  keyboard (3)]

La sortie ci-dessus montre les différents appareils que j'ai sur mon ordinateur portable Thinkpad. Je n'ai qu'un seul clavier connecté, celui-ci:

    ↳ AT Translated Set 2 keyboard              id=11   [slave  keyboard (3)]

Jetez maintenant un œil aux propriétés disponibles via cet appareil:

$ xinput list-props "AT Translated Set 2 keyboard"
Device 'AT Translated Set 2 keyboard':
    Device Enabled (124):   1
    Coordinate Transformation Matrix (126): 1.000000, 0.000000, 0.000000, 0.000000, 1.000000, 0.

De ce qui précède, vous pouvez voir qu'il est activé, alors désactivons-le:

$ xinput set-prop "AT Translated Set 2 keyboard" "Device Enabled" 0

Pour l'activer:

$ xinput set-prop "AT Translated Set 2 keyboard" "Device Enabled" 1

L'idée?

Vous pouvez activer la désactivation de l'un des claviers à l'aide de cette commande pour déterminer celui sur lequel vous vous trouvez.

Les références

• deuxième clavier pour exécuter les commandes

La question semble un peu contradictoire puisque vous citez des outils X mais demandez une solution qui "devrait idéalement fonctionner sans X".

A propos de votre 4 ^ème constatation: xinputvous donnera la correspondance

$ xinput list-props 11
Device 'AT Translated Set 2 keyboard':
    Device Enabled (145):   1
    Coordinate Transformation Matrix (147): 1.000000, 0.000000, 0.000000, 0.000000, 1.000000, 0.000000, 0.000000, 0.000000, 1.000000
    Device Product ID (266):    1, 1
    Device Node (267):  "/dev/input/event0"

au moins avec la version suivante

$ xinput --version
xinput version 1.6.1
XI version on server: 2.3

Première étape: détecter le périphérique d'événements clavier en C

#include <stdio.h>
//#include <unistd.h>
#include <fcntl.h>
#include <linux/input.h>

// typical use : sudo ./a.out /dev/input/event*
int main (int argc, char *argv[])
{
  struct input_event ev[64];
  int fd[argc],rd,idev,value, size = sizeof (struct input_event);
  char name[256] = "Unknown";

  if(argc==1) return -1;

  int ndev=1;
  while(ndev<argc && (fd[ndev] = open (argv[ndev], O_RDONLY|O_NONBLOCK)) != -1){
    ndev++;
  }
  fprintf (stderr,"Found %i devices.\n", ndev);
  if(ndev==1) return -1;

  while (1){
    for(idev=1; idev<argc; idev++){
      if( (rd=read (fd[idev], ev, size * 64)) >= size){
      value = ev[0].value;
      if (value != ' ' && ev[1].value == 1 && ev[1].type == 1){
        ioctl (fd[idev], EVIOCGNAME (sizeof (name)), name);
        printf ("%s\n", name);
        return idev;
      }
      }
    }
//    sleep(1);
  }
  return -1;
}

Un grand merci à cette page . J'ai supprimé la plupart des contrôles de sécurité du code que j'y ai emprunté, pour plus de clarté, dans le vrai code, vous en avez probablement besoin.

Notez que les pressions sur les touches sont répercutées, vous pouvez donc en effet vouloir demander à l'utilisateur d'appuyer sur une touche de modification (Maj, Contrôle ...) plutôt que sur n'importe quelle touche.

Deuxième étape: utilisez xinput pour obtenir l'ID X à partir du nom de l'appareil

Compilez la source C ci-dessus et utilisez cette méthode:

xinput list --id-only "keyboard:$(sudo ./a.out /dev/input/event*)"

Plus de fouilles ont révélé une autre solution utilisant Bash ordinaire et un compte d'utilisateur normal. Script :

#!/usr/bin/env bash

set -o errexit -o nounset -o noclobber -o pipefail

# Remove leftover files and processes on exit
trap 'rm --recursive -- "$dir"; kill -- -$$' EXIT
dir="$(mktemp --directory)"
cd "$dir"

# Log key presses to file
xinput --list --id-only | while read id
do
    # Only check devices linked to an event source
    if xinput --list-props "$id" | grep --quiet --extended-regexp '^\s+Device Node.*/dev/input/event'
    then
        xinput test "$id" > "$id" &
    fi
done

# Check for key presses
while sleep 0.1
do
    for file in *
    do
        if [[ -s "$file" ]]
        then
            echo "$file"
            exit
        fi
    done
done