La lecture USB HID scanner de code à barres d'entrée sans savoir VID&PID

Cela ne répond pas à votre question spécifique, mais de toute façon...

Plus d'un an, j'ai mis en œuvre lecteur de code à barres de soutien et même dans les plus mauvaises conditions. C'était pour un formulaire de demande de déclaration auprès de l'association logistiques de données en Java pur (cross platform client riche, principalement sous Windows).
J'ai trouvé la même chose que vous dites sur le pilote du clavier, ce qui empêche la distinction réelle des périphériques USB en mode utilisateur, au moins au premier coup d'œil. Il y a des dispositifs plus coûteux avec des pilotes et des fonctionnalités avancées, ce qui permettrait une sorte de distinction.
Tous les lecteurs de codes-barres que j'ai rencontré dans ce milieu étaient visibles que les claviers et utilisé pour simplement remplir un SAP champ de formulaire, puis appuyez sur la touche entrée, qui est un cas commun. La résiliation peut être configurable à l'aide de la "magie codes-barres" ou d'un autre fabricant de la méthode spécifique.

De sorte que la décision a été contre toute JNI base, plate-forme de mise en œuvre spécifiques.
Au lieu de cela, j'ai mis en place également une interception approche (version étendue de la vôtre) en évaluant générique keyoard d'entrée dans certaines Swing/AWT formes à l'aide de ces critères:

• touche fréquence déterminée par les deux premiers caractères (au départ /après la temporisation)
• gigue (fréquence/de changement de taux)
• ensemble de caractères valides
• la résiliation de saut de ligne.

L'entrée est consommé par un tampon jusqu'à ce que les critères pour la machine généré d'entrée ne sont pas remplies, ou la validation a été passé, où les codes à barres les auditeurs seront avisés. Dans les deux cas, l'entrée peut être transmis comme si rien ne se passait.

Ce qui s'est avéré pour être très précis, car pour un homme, c'est tout, mais impossible d'entrer dans une séquence valide au lecteur de code-barres du taux de (presque) zéro de la gigue.

EDIT:

Juste creusé le source Java; je peux vous donner le code d'une première révision de la mise en œuvre ci-dessus comme un exemple (pas de garantie, pensez également à mettre en œuvre CR):

import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* A {@link KeyListener} implementation for barcode readers. This implementation
* checks for input rate and jitter to distinguish human and scanner
* input sequences by 'precision'. A barcode input sequence from a scanner is
* typically terminated with a line break.
* 
* @author Me
*/
public abstract class AbstractBarcodeInputListener implements KeyListener {
public static final int DEFAULT_MIN_PAUSE = 300;//[ms]
public static final int DEFAULT_MAX_TIME_DELTA = 200;//[ms]
public static final int DEFAULT_MAX_TIME_JITTER = 50;//[ms]
public static Integer parseInt(Pattern pattern, int group, String line) {
final Matcher matcher = pattern.matcher(line);
if (matcher.matches())
return Integer.parseInt(matcher.group(group));
return null;
}
private String input;
private final long minPause;
private long maxTimeDelta;
private final long maxTimeJitter;
private long firstTime;
private long firstTimeDelta;
private long lastTimeDelta;
private long lastTime;
public AbstractBarcodeInputListener(long maxTimeDelta, long maxTimeJitter) {
this.input = new String();
this.minPause = AbstractBarcodeInputListener.DEFAULT_MIN_PAUSE;
this.maxTimeDelta = maxTimeDelta;
this.maxTimeJitter = maxTimeJitter;
this.firstTime = 0;
this.firstTimeDelta = 0;
this.lastTimeDelta = 0;
this.lastTime = 0;
}
public AbstractBarcodeInputListener() {
this(AbstractBarcodeInputListener.DEFAULT_MAX_TIME_DELTA,
AbstractBarcodeInputListener.DEFAULT_MAX_TIME_JITTER);
}
private boolean checkTiming(KeyEvent e) {
final int inputLength = this.input.length();
final long time = e.getWhen();
long timeDelta = time - this.lastTime;
long absJitter = 0;
long relJitter = 0;
boolean inputOK = true;
switch (inputLength) {
case 0: //pause check
inputOK &= (timeDelta > this.minPause);
this.firstTime = time;
this.firstTimeDelta = timeDelta = 0;
break;
case 1: //delta check
this.firstTimeDelta = timeDelta;
inputOK &= (timeDelta < this.maxTimeDelta);
break;
default://jitter check & delta check
absJitter = Math.abs(timeDelta - this.firstTimeDelta);
relJitter = Math.abs(timeDelta - this.lastTimeDelta);
inputOK &= (absJitter < this.maxTimeJitter);
inputOK &= (relJitter < this.maxTimeJitter);
inputOK &= (timeDelta < this.maxTimeDelta);
break;
}
this.lastTime = time;
this.lastTimeDelta = timeDelta;
return inputOK;
}
@Override
public void keyPressed(KeyEvent e) {
}
private void clearInput() {
this.input = new String();
}
private void commitInput(KeyEvent e) {
final String code = this.input;
if (!code.isEmpty()) {
final long avgIntervalTime = e.getWhen() - this.firstTime;
this.maxTimeDelta = (avgIntervalTime * 15) / 10;
this.clearInput();
this.codeRead(code);
}
}
@Override
public void keyReleased(KeyEvent e) {
}
@Override
public void keyTyped(KeyEvent e) {
if (this.checkTiming(e)) {
final char c = e.getKeyChar();
switch (c) {
case '\b':
this.clearInput();
break;
case '\n':
this.commitInput(e);
break;
default:
this.input += c;
break;
}
} else {
this.clearInput();
}
}
public abstract void codeRead(String line);
}

OriginalL'auteur Sam