Aller au contenu

Barcode Scanner Emulator

Comment tester la saisie d'un lecteur de QR dans les applications web

Beaucoup de lecteurs externes capables de lire le QR utilisent le mode d'émulation clavier et tapent le texte QR décodé dans le champ qui a le focus. Testez ce chemin en lisant un contenu connu et en le comparant à la valeur que la page a reçue. Tous les lecteurs de QR ne tapent pas comme un clavier. Les appareils série et les décodeurs par caméra sont des intégrations différentes, et les événements clavier du navigateur n'identifient pas le lecteur physique.

Un code QR stocke des données. Le lecteur, ou un décodeur par caméra, transforme ces données en texte. L'application web doit ensuite recevoir ce texte, décider quand la lecture est terminée et le valider. Ce guide est ce test de l'application. Produire des étiquettes, vérifier le contraste et confirmer qu'un appareil peut décoder le QR Code est traité dans Test des codes QR : comment tester les lecteurs de QR. Les formulaires de codes-barres en général, y compris les chiffres de contrôle EAN, sont traités dans Comment tester les lecteurs de codes-barres dans les applications web.

Tester la saisie d'un lecteur de QR en 60 secondes

Utilisez un contenu que vous avez choisi, pour qu'un caractère erroné saute aux yeux. Ce parcours utilise QR-INPUT-TEST-12345.

  1. Ouvrez le générateur de codes QR et générez un code QR pour QR-INPUT-TEST-12345. Le générateur s'exécute dans le navigateur. Il ne contacte pas le lecteur.
  2. Branchez un lecteur capable de lire le QR, réglé en mode d'émulation clavier. Un lecteur limité au 1D ne peut pas décoder ce symbole.
  3. Ouvrez le testeur de saisie de codes-barres.
  4. Cliquez sur Démarrer le test, ou cliquez sur la zone de lecture, pour que le champ ait le focus. Le testeur ne prend pas le focus de lui-même, et il n'ouvre pas le lecteur.
  5. Lisez le code QR.
  6. Lisez le texte capturé et le nombre de caractères.
  7. Comparez ce texte à QR-INPUT-TEST-12345. La correspondance inclut la casse, les traits d'union et la longueur.
  8. Lisez le suffixe. Le testeur signale ENTER, TAB ou Aucun lorsque le lecteur envoie l'une de ces touches.

Le testeur enregistre les événements clavier que le navigateur peut voir. Il n'identifie pas l'appareil USB, ne lit pas un port série et ne décode pas l'image QR.

Modes de saisie d'un lecteur de QR

Le même code QR imprimé peut arriver par trois intégrations différentes. Le test d'un mode n'exerce pas les autres.

Lecteurs de QR en émulation clavier

En mode clavier HID USB, ou en mode clavier HID Bluetooth, le système d'exploitation traite le lecteur comme un clavier. Après un décodage, le lecteur tape le contenu dans le contrôle qui a le focus. Un <input> ou un <textarea> ordinaire peut le recevoir. La page n'ouvre pas l'appareil. Le guide Émulation clavier HID décrit la séquence de frappes, les préfixes et les suffixes.

Le focus décide de la destination. Si l'élément focalisé est le corps du document, un bouton ou un autre cadre, les écouteurs de ce champ ne voient pas la lecture.

Lecteurs de QR série

Un lecteur série USB ou à port COM virtuel envoie le texte décodé sous forme d'octets au processus qui a ouvert le port. Le focus ne choisit pas ce processus. Un champ qui n'écoute que les frappes reste vide pendant qu'un terminal sur ce port affiche le contenu.

Les navigateurs fondés sur Chromium peuvent ouvrir un port choisi par l'utilisateur avec la Web Serial API, dans un contexte sécurisé, après un geste de l'utilisateur. Firefox et Safari ne fournissent pas cette API. Un lecteur en émulation n'apparaît pas comme un port série. Les noms de port, le débit en bauds et le cadrage dépendent de l'appareil et du pilote. Lecteurs de codes-barres USB HID et série compare les deux interfaces. Le testeur de saisie de codes-barres ne peut pas lire un port COM.

Lecture QR par caméra

Une intégration caméra capture une image et décode le code QR dans le logiciel. La page utilise une API de caméra et un décodeur. Elle ne reçoit pas d'événements keydown pour le contenu. Les applications de caméra du téléphone, les boutons de caméra dans la page et un imageur matériel qui tape dans un champ sont trois produits différents. Réussir un test en émulation ne signifie pas que le bouton de caméra fonctionne, et un décodage caméra réussi ne signifie pas qu'un lecteur en émulation tapera la même chaîne.

Capturer la saisie d'un lecteur de QR avec JavaScript

La page ci-dessous lit un seul champ focalisé. Enter envoie le formulaire, et le bouton Accept utilise le même gestionnaire d'envoi, si bien qu'une lecture est traitée une fois. Sans suffixe ENTER, le texte reste dans le champ jusqu'à ce que quelqu'un active Accept. Le contenu capturé est écrit avec textContent, donc des caractères comme < restent visibles comme du texte.

L'exemple accepte trois formats d'application : un identifiant de billet tel que QR-INPUT-TEST-12345, une URL http ou https, ou un objet JSON. Il enregistre le texte lu. Il ne navigue pas vers une URL trouvée dans le code QR. Un lecteur qui n'envoie pas Enter fonctionne encore par le bouton. Tab parcourt le libellé, le champ et le bouton comme d'habitude, parce que le script ne le piège pas.

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>QR input example</title>
</head>
<body>
  <form id="qr-form">
    <label for="qr">QR payload</label>
    <input id="qr" name="qr" type="text" autocomplete="off" spellcheck="false">
    <button type="submit">Accept</button>
  </form>
  <p id="status" role="status"></p>
  <pre id="captured"></pre>
  <script>
    const form = document.querySelector('#qr-form')
    const field = document.querySelector('#qr')
    const status = document.querySelector('#status')
    const captured = document.querySelector('#captured')

    if (
      !(form instanceof HTMLFormElement) ||
      !(field instanceof HTMLInputElement) ||
      !(status instanceof HTMLElement) ||
      !(captured instanceof HTMLElement)
    ) {
      throw new Error('QR form markup is missing.')
    }

    const accepted = new Set()

    function classify(raw) {
      if (/[\u0000-\u001F\u007F]/.test(raw)) {
        return { status: 'invalid', message: 'Control character in the QR payload.' }
      }

      const value = raw.trim()
      if (!value) {
        return { status: 'empty' }
      }
      if (value.length > 2048) {
        return { status: 'invalid', message: 'QR payload is longer than this form accepts.' }
      }
      if (/^QR-[A-Z0-9-]{1,64}$/.test(value)) {
        return { status: 'ok', value }
      }
      if (value.startsWith('{')) {
        try {
          const data = JSON.parse(value)
          if (!data || typeof data !== 'object' || Array.isArray(data)) {
            return { status: 'invalid', message: 'QR JSON must be an object.' }
          }
          return { status: 'ok', value }
        } catch {
          return { status: 'invalid', message: 'QR text is not valid JSON.' }
        }
      }
      if (value.startsWith('http://') || value.startsWith('https://')) {
        try {
          const url = new URL(value)
          if (url.protocol !== 'http:' && url.protocol !== 'https:') {
            return { status: 'invalid', message: 'Only http and https URLs are accepted.' }
          }
          return { status: 'ok', value }
        } catch {
          return { status: 'invalid', message: 'The QR text is not a valid URL.' }
        }
      }
      return { status: 'invalid', message: 'Unexpected QR payload.' }
    }

    form.addEventListener('submit', (event) => {
      event.preventDefault()
      const outcome = classify(field.value)
      if (outcome.status === 'empty') {
        status.textContent = 'No QR payload received.'
        field.focus()
        return
      }
      if (outcome.status === 'invalid') {
        status.textContent = outcome.message
        captured.textContent = ''
        field.focus()
        return
      }
      if (accepted.has(outcome.value)) {
        status.textContent = 'Already accepted ' + outcome.value
        field.value = ''
        field.focus()
        return
      }
      accepted.add(outcome.value)
      captured.textContent = outcome.value
      status.textContent = 'Accepted ' + outcome.value
      field.value = ''
      field.focus()
    })
  </script>
</body>
</html>

Enregistrez le fichier et ouvrez-le dans un navigateur de bureau. Cliquez dans le champ avant de lire. autocomplete="off" réduit le risque qu'une valeur enregistrée remplace la lecture. Le libellé et le bouton restent disponibles, si bien qu'une personne peut taper un contenu sans lecteur.

Traitez Enter seulement dans l'événement submit du formulaire. Un second écouteur keydown pour Enter enregistre la même lecture deux fois. preventDefault() garde le navigateur sur cette page. Videz le champ après une décision pour que la lecture suivante ne s'ajoute pas au texte précédent.

Un contenu QR peut contenir un saut de ligne. Un lecteur en émulation tape souvent ce saut comme Enter. Dans un input d'une ligne, le formulaire peut s'envoyer à la première ligne et abandonner le reste. Utilisez un textarea, ou un programme qui lit le port série et conserve les octets, lorsque l'application doit accepter du texte sur plusieurs lignes. Confirmez ce comportement avec un code QR dont le contenu comprend un saut de ligne.

Traiter les contenus QR

Un symbole QR ne promet pas un format d'application. La même symbologie peut porter n'importe lequel de ceux-ci :

  • Du texte simple, tel que QR-INPUT-TEST-12345.
  • Une URL.
  • Un identifiant choisi par l'application.
  • Un contenu structuré, tel qu'un numéro de billet plus un code de lieu.
  • Du texte JSON, lorsque l'application a défini cet encodage.

Le lecteur transmet les caractères décodés. Il ne vérifie pas qu'ils correspondent à une règle de billet, à un catalogue de produits ou à un schéma JSON. Validez la chaîne dans la page, et validez-la de nouveau sur le serveur. La valeur envoyée est une saisie utilisateur ordinaire. Le navigateur ne peut pas prouver qu'un lecteur l'a produite.

Valider la saisie QR

Ne supposez pas qu'un contenu QR est numérique. Les règles EAN-13 ne s'appliquent pas. Traitez le texte comme non fiable : affichez-le comme du texte, et ne l'affectez pas à location, innerHTML ou une URL de script.

Valeurs vides. Un Enter seul, ou Accept sur un champ vide, ne doit pas créer d'enregistrement. trim() rejette aussi un contenu qui n'est que des espaces.

Caractères inattendus. Comparez la chaîne reçue au contenu QR connu. Un décalage de disposition de clavier change souvent la ponctuation alors que la longueur reste la même. Rejetez les caractères que le format n'autorise pas, et montrez la raison dans le texte de statut.

Longueur du contenu. Imposez le maximum que votre application stocke. maxlength sur l'input tronque une lecture plus longue sans erreur. Ne le posez que lorsque chaque contenu accepté tient, et comparez le nombre de caractères du testeur au champ lorsqu'une valeur paraît courte.

Préfixes exigés. Une vérification de préfixe appartient à l'application. Cette règle de billet accepte QR- plus des lettres majuscules, des chiffres et des traits d'union :

function isTicketId(value) {
  return /^QR-[A-Z0-9-]{1,64}$/.test(value)
}

Ne retirez un préfixe de lecteur que lorsque ce lecteur est configuré pour envoyer un préfixe exact et que l'application ne le stocke pas. Un identifiant de symbologie AIM reste une donnée tant que vous n'en décidez pas autrement.

Formats propres à l'application. Gardez la règle à côté du format. Un formulaire de billet, une liste d'URL autorisées et un objet JSON demandent des vérifications différentes. Un seul motif numérique rejettera du texte QR valide.

Lectures en double. Une lecture physique peut toucher deux écouteurs. Utilisez un seul chemin d'achèvement, comme le fait l'exemple. Une seconde pression sur la gâchette est un événement séparé. L'exemple rejette un contenu qu'il a déjà accepté. Un formulaire d'entrepôt peut à la place incrémenter une quantité. Testez la règle que votre application documente.

JSON mal formé. JSON.parse lève une exception sur un texte incomplet. Vérifiez la forme après une analyse réussie. Un tableau ou un nombre nu peut être du JSON valide et rester le mauvais type :

function readJsonObject(value) {
  try {
    const data = JSON.parse(value)
    if (!data || typeof data !== 'object' || Array.isArray(data)) {
      return { ok: false, message: 'QR JSON must be an object.' }
    }
    return { ok: true, data }
  } catch {
    return { ok: false, message: 'QR text is not valid JSON.' }
  }
}

URL inattendues. Analysez l'URL pour voir si elle est utilisable, puis conservez la chaîne lue si le test doit correspondre exactement au contenu QR. URL.href peut ajouter une barre oblique ou changer l'encodage. N'acceptez que les schémas que l'application prévoit. N'ouvrez pas l'URL comme effet de bord de la lecture :

function readWebUrl(value) {
  let url
  try {
    url = new URL(value)
  } catch {
    return { ok: false, message: 'The QR text is not a valid URL.' }
  }
  if (url.protocol !== 'http:' && url.protocol !== 'https:') {
    return { ok: false, message: 'Only http and https URLs are accepted.' }
  }
  return { ok: true, value }
}

Caractères de contrôle. Rejetez les caractères de contrôle ASCII dans un contenu clavier pour qu'un préfixe caché reste visible dans le texte de statut. CR et LF sont des caractères de contrôle. Sur un lecteur en émulation, Enter et Tab sont des touches. Ce ne sont pas des caractères à l'intérieur d'un input texte ordinaire. Un contenu série peut encore contenir des octets 0x0D ou 0x0A. Retirez-les à la frontière de cadrage série, et ne retirez pas un CR qui appartient au milieu d'un contenu sur plusieurs lignes.

Suffixes ENTER et TAB

Un suffixe est une configuration facultative du lecteur. Il ne fait pas partie du symbole QR. Suffixes ENTER et TAB des lecteurs de codes-barres montre comment distinguer les touches. Lisez le suffixe dans le testeur de saisie, puis faites correspondre la page aux lecteurs que vous déployez.

ENTER envoie le formulaire d'un champ texte d'une ligne dans les navigateurs actuels. Utilisez-le lorsqu'une lecture doit valider la valeur. Appelez preventDefault() sur submit lorsque la page doit rester en place.

TAB déplace le focus vers le contrôle suivant. Lisez la valeur dans keydown pendant que le champ a encore le focus. Laissez l'action par défaut en place lorsque le champ suivant doit recevoir le focus. Ignorez Shift+Tab pour qu'une personne au clavier puisse reculer.

Aucun suffixe laisse le contenu dans le champ. Le bouton Accept de l'exemple est le chemin d'achèvement. Un minuteur d'inactivité peut deviner qu'une pause signifie la fin de la lecture. Ce minuteur est une heuristique : une rafale Bluetooth lente et une frappe rapide peuvent toutes deux franchir le même écart. Préférez un suffixe configuré lorsque le flux a besoin d'une fin nette.

CR et LF sont des octets. Un Enter clavier est event.key === "Enter". Les deux ne sont pas interchangeables. Un écouteur qui ne retire que \r d'une valeur d'input ne verra pas un Enter d'émulation, parce que le caractère n'a jamais été inséré. Un écouteur qui ne surveille que event.key ne découpera pas un tampon série sur 0x0D. Certains appareils envoient NumPad Enter. event.key vaut encore "Enter". Vérifiez event.key, pas seulement event.code === "Enter".

Le suffixe peut changer lorsque quelqu'un lit un code-barres de configuration du manuel de l'appareil. Retestez Enter, Tab et l'absence de suffixe après tout changement de configuration. N'inventez pas de code-barres de programmation. Utilisez le manuel de ce modèle.

Examiner les événements clavier

Lorsque le texte stocké est faux, examinez les événements dans cet ordre.

keydown. Se déclenche pour chaque touche, y compris Enter et Tab, avant que le navigateur insère un caractère ou déplace le focus. Lisez le terminateur ici.

input. Se déclenche après qu'un caractère imprimable a modifié le champ. Il ne se déclenche pas pour Enter ou Tab sur un input texte.

event.key. Le caractère ou le nom de touche après que le système d'exploitation a appliqué la disposition de clavier.

event.code. La touche physique, telle que Digit1 ou Numpad1. Elle peut rester la même lorsqu'un décalage de disposition change event.key.

Focus. Journalisez document.activeElement avant la lecture. Si ce n'est pas le champ QR, le reste de la trace décrit le mauvais contrôle. Un iframe a son propre focus.

Ordre. Pour une lecture en émulation dans un champ texte, les événements keydown imprimables sont suivis de mises à jour input, puis d'un keydown final pour Enter ou Tab lorsque ce suffixe est configuré. change se déclenche lorsque le champ valide la valeur, en général au blur. Une lecture qui laisse le focus dans le même champ ne produit pas change à la fin. N'utilisez pas change comme seul signal d'achèvement.

Minutage. Les lecteurs terminent souvent un contenu court bien en dessous d'une seconde. Le testeur de saisie compare l'écart moyen entre les caractères à un seuil de 100 ms et étiquette le résultat comme un minutage, pas comme une identification du matériel. Une frappe rapide, le remplissage automatique ou l'émulateur peuvent se retrouver du côté lecteur de ce seuil. Une lecture Bluetooth retardée peut ressembler à de la frappe. Vérifiez le contenu et le suffixe. Traitez le minutage comme un indice.

Le testeur d'événements clavier liste chaque keydown et keyup avec key, code, les modificateurs et les horodatages. Le journal contient des événements du navigateur. Ce n'est pas du trafic USB brut.

Tester sans lecteur de QR physique

La logique de l'application peut être testée avant qu'un lecteur soit sur le bureau.

  • Tapez QR-INPUT-TEST-12345 dans le champ et activez Accept. Cela vérifie la validation et l'affichage. Cela ne vérifie pas le décodage ni les suffixes.
  • Pilotez le même champ depuis un outil d'automatisation de navigateur, comme le fait la section suivante.
  • Utilisez Barcode Scanner Emulator lorsque vous avez besoin d'une frappe de type lecteur. L'application de bureau envoie une valeur que vous saisissez, avec un délai de frappe et un suffixe parmi aucun, ENTER ou TAB, dans l'application qui a le focus. Elle reproduit le chemin clavier. Elle ne photographie pas une image QR, ne décode pas un symbole et ne crée pas de port COM virtuel.

Le matériel reste nécessaire pour le comportement optique et l'appareil : si ce lecteur peut lire le code affiché ou imprimé, si la symbologie QR est activée, la disposition de clavier, la configuration du suffixe, et les modes série ou SDK du fabricant. L'émulateur est la bonne vérification pour le chemin clavier. C'est la mauvaise vérification pour prouver qu'un appareil lit un code QR particulier.

Automatiser les tests de saisie QR

Les tests Playwright suivants pilotent la page d'exemple. Ils tapent dans le champ comme le ferait un lecteur en émulation, puis vérifient le comportement de l'application. Ils n'ouvrent pas d'appareils USB. @playwright/test est une dépendance pour la personne qui exécute le test. Ce site ne l'exige pas.

Enregistrez l'exemple HTML sous le nom qr-form.html à côté de ce test.

import { readFileSync } from 'node:fs'
import { expect, test } from '@playwright/test'

const html = readFileSync(new URL('./qr-form.html', import.meta.url), 'utf8')

async function openForm(page) {
  await page.setContent(html)
}

test('accepts a known QR payload once', async ({ page }) => {
  await openForm(page)
  const field = page.getByLabel('QR payload')
  await field.pressSequentially('QR-INPUT-TEST-12345')
  await field.press('Enter')
  await expect(page.getByRole('status')).toHaveText('Accepted QR-INPUT-TEST-12345')
  await expect(page.locator('#captured')).toHaveText('QR-INPUT-TEST-12345')
})

test('rejects an unexpected payload', async ({ page }) => {
  await openForm(page)
  const field = page.getByLabel('QR payload')
  await field.pressSequentially('not-a-ticket')
  await field.press('Enter')
  await expect(page.getByRole('status')).toHaveText('Unexpected QR payload.')
  await expect(page.locator('#captured')).toBeEmpty()
})

test('commits on ENTER and rejects a duplicate scan', async ({ page }) => {
  await openForm(page)
  const field = page.getByLabel('QR payload')
  await field.pressSequentially('QR-INPUT-TEST-12345')
  await field.press('Enter')
  await field.pressSequentially('QR-INPUT-TEST-12345')
  await field.press('Enter')
  await expect(page.getByRole('status')).toHaveText('Already accepted QR-INPUT-TEST-12345')
  await expect(page.locator('#captured')).toHaveText('QR-INPUT-TEST-12345')
})

test('does not capture keys while the field is unfocused', async ({ page }) => {
  await openForm(page)
  await page.getByRole('button', { name: 'Accept' }).focus()
  await page.keyboard.type('QR-INPUT-TEST-12345')
  await expect(page.getByLabel('QR payload')).toHaveValue('')
  await expect(page.locator('#captured')).toBeEmpty()
  await expect(page.getByRole('status')).toHaveText('')
})

test('shows unexpected characters as text', async ({ page }) => {
  await openForm(page)
  const payload = '<img src=x onerror=alert(1)>'
  const field = page.getByLabel('QR payload')
  await field.fill(payload)
  await page.getByRole('button', { name: 'Accept' }).click()
  await expect(page.getByRole('status')).toHaveText('Unexpected QR payload.')
  await expect(page.locator('#captured img')).toHaveCount(0)
  await expect(page.locator('img')).toHaveCount(0)
})

pressSequentially insère des caractères dans le champ focalisé. Ce n'est pas un périphérique USB. Le test des caractères inattendus utilise fill, parce que le but est le message de validation et l'absence d'un élément injecté. Étendez le fichier avec un cas d'URL et un cas JSON lorsque ces formats sont dans la version que vous livrez. Une assertion d'URL doit comparer le texte capturé à la chaîne QR d'origine.

Matrice de test du lecteur de QR

Exécutez-les contre l'application sous test. La page d'exemple ci-dessus couvre les lignes billet, URL, JSON, doublon, vide et caractères inattendus. Une application uniquement numérique ou sur plusieurs lignes a besoin de son propre résultat attendu.

Scénario Résultat attendu
QR en texte simple Valeur exacte reçue
QR d'URL URL complète capturée, et la page n'y navigue pas
QR numérique Chiffres conservés
Caractères spéciaux Caractères corrects reçus
Contenu JSON Données capturées et validées
Suffixe ENTER Le traitement a lieu une fois
Suffixe TAB Comportement du focus traité
Aucun suffixe L'application utilise un autre mécanisme d'achèvement
Lecture en double L'application applique les règles de gestion des doublons
Contenu invalide Erreur de validation affichée
Focus absent L'application gère l'absence de saisie sans risque
Contenu long Pas de troncature involontaire

Lisez aussi un contenu qui contient un saut de ligne si le produit doit en stocker un. Notez si le champ a reçu chaque ligne.

Dépannage

Commencez par un contenu connu dans le testeur de saisie. Si la valeur du testeur est déjà fausse, la page n'est pas la première faute. Si la valeur du testeur est juste et que l'application a tort, la faute est le focus, la validation ou le traitement des événements. Le lecteur de codes-barres ne fonctionne pas est la liste de contrôle plus large de l'appareil. Comment tester la saisie d'un lecteur de codes-barres couvre le focus, la disposition et les flux POS au-delà de ce formulaire.

Le lecteur émet un bip, mais aucune saisie n'apparaît

Un bip signifie en général que le lecteur a décodé un symbole. Il ne signifie pas que la page a reçu le texte. Confirmez le mode d'émulation clavier. Les modes série et caméra ne tapent pas dans le champ. Cliquez dans le champ pour que document.activeElement soit cet input, puis lisez de nouveau. Un champ désactivé, en lecture seule ou masqué peut ignorer les touches.

Le lecteur de QR fonctionne dans Notepad, mais pas dans le navigateur

L'appareil tape. La page n'accepte pas ces touches. Vérifiez le focus, un écouteur keydown qui appelle preventDefault() sur les touches imprimables, et un écouteur qui ne gère que paste. La saisie en émulation ne déclenche pas d'événement paste. Comparez le résultat du testeur au champ de l'application.

Le lecteur lit les codes-barres, mais pas les codes QR

L'appareil peut être limité au 1D, ou la symbologie QR peut être désactivée. La page ne peut pas corriger cela. Confirmez la prise en charge 2D et activez QR Code depuis le manuel de l'appareil, avec les vérifications de Test des codes QR : comment tester les lecteurs de QR. Une lecture Code 128 réussie ne prouve que le chemin clavier.

Caractères incorrects

Lisez d'abord QR-INPUT-TEST-12345. Si cela correspond et qu'un contenu URL ou JSON ne correspond pas, la disposition change la ponctuation telle que :, /, { ou ". Comparez event.key à event.code dans le testeur d'événements clavier, et voyez Mauvaise disposition de clavier du lecteur de codes-barres. Faites correspondre la disposition de clavier du lecteur à celle du système d'exploitation.

ENTER envoie le formulaire deux fois

Le navigateur envoie le formulaire, et un écouteur keydown gère aussi Enter. Gardez un seul chemin d'achèvement et appelez preventDefault() là. Une seconde lecture physique est une autre panne. Le texte de statut de l'exemple dit que le contenu a déjà été accepté. Si la première lecture elle-même crée deux enregistrements, cherchez deux écouteurs avant de changer le lecteur.

La saisie QR est tronquée

Comparez le nombre de caractères dans le testeur de saisie à la valeur dans le champ. Un attribut maxlength, un masque de saisie ou preventDefault() sur les touches de caractères peut couper la chaîne. Un saut de ligne dans le contenu QR peut envoyer trop tôt un input d'une ligne. Certains lecteurs limitent aussi le nombre de caractères qu'ils tapent. Relevez cette limite depuis le manuel de l'appareil lorsque le testeur, et pas seulement l'application, montre une valeur courte. Le lecteur de codes-barres n'envoie pas ENTER couvre le cas voisin où le contenu arrive et où le formulaire ne valide jamais.

Le lecteur ne peut pas lire un code QR à l'écran

Confirmez que le lecteur est un imageur 2D. Augmentez la luminosité de l'affichage, agrandissez le code et gardez la zone de silence libre de texte et de bordures. Un reflet, un écran de téléphone sombre et un code trop dense pour la distance de travail sont des problèmes optiques. Imprimez le même contenu si la lecture à l'écran continue d'échouer. Le test d'application utilise encore la chaîne connue dès qu'une lecture produit du texte.