Barcode Scanner Emulator
Come testare l'input del lettore di codici QR nelle applicazioni web
Molti lettori esterni in grado di leggere QR usano la modalità di emulazione tastiera e digitano il testo QR decodificato nel campo con il focus. Testa quel percorso leggendo un carico utile noto e confrontandolo con il valore che la pagina ha ricevuto. Non ogni lettore QR digita come una tastiera. I dispositivi seriali e i decodificatori da fotocamera sono integrazioni diverse, e gli eventi di tastiera del browser non identificano il lettore fisico.
Un codice QR memorizza dati. Il lettore, o un decodificatore da fotocamera, trasforma quei dati in testo. L'applicazione web deve ricevere quel testo, decidere quando la lettura è finita e validarlo. Questa guida è quel test dell'applicazione. Generare etichette, controllare il contrasto e confermare che un dispositivo può decodificare QR Code è trattato in Test dei codici QR: come testare i lettori di QR. I moduli di codici a barre in generale, cifre di controllo EAN comprese, sono trattati in Come testare i lettori di codici a barre nelle applicazioni web.
Testa l'input del lettore QR in 60 secondi
Usa un carico utile che hai scelto tu, così un carattere sbagliato è evidente. Questo percorso usa QR-INPUT-TEST-12345.
- Apri il generatore di codici QR e genera un codice QR per
QR-INPUT-TEST-12345. Il generatore gira nel browser. Non contatta il lettore. - Collega un lettore in grado di leggere QR impostato in modalità di emulazione tastiera. Un lettore solo 1D non può decodificare questo simbolo.
- Apri il tester di input dei codici a barre.
- Fai clic su Avvia test, oppure sull'area di lettura, così il campo ha il focus. Il tester non prende il focus da solo e non apre il lettore.
- Leggi il codice QR.
- Leggi il testo acquisito e il conteggio dei caratteri.
- Confronta quel testo con
QR-INPUT-TEST-12345. Il confronto include maiuscole e minuscole, trattini e lunghezza. - Leggi il suffisso. Il tester segnala ENTER, TAB o Nessuno quando il lettore invia uno di quei tasti.
Il tester registra gli eventi di tastiera che il browser può vedere. Non identifica il dispositivo USB, non legge una porta seriale e non decodifica l'immagine QR.
Modalità di input del lettore QR
Lo stesso codice QR stampato può arrivare attraverso tre integrazioni diverse. Il test di una modalità non esercita le altre.
Lettori QR in emulazione tastiera
In modalità tastiera USB HID, o in modalità tastiera Bluetooth HID, il sistema operativo tratta il lettore come una tastiera. Dopo la decodifica, il lettore digita il carico utile nel controllo che ha il focus. Un <input> o una <textarea> normale può riceverlo. La pagina non apre il dispositivo. La guida Emulazione tastiera HID descrive la sequenza di tasti, i prefissi e i suffissi.
Il focus decide la destinazione. Se l'elemento con il focus è il corpo del documento, un pulsante o un altro frame, i listener di questo campo non vedono la lettura.
Lettori QR seriali
Un lettore USB seriale o su porta COM virtuale invia il testo decodificato come byte al processo che ha aperto la porta. Il focus non sceglie quel processo. Un campo che ascolta solo i tasti resta vuoto mentre un terminale su quella porta mostra il carico utile.
I browser basati su Chromium possono aprire una porta scelta dall'utente con l'API Web Serial, in un contesto sicuro, dopo un gesto dell'utente. Firefox e Safari non forniscono quell'API. Un lettore in emulazione non compare come porta seriale. Nomi di porta, baud e inquadramento dipendono dal dispositivo e dal driver. Lettori di codici a barre USB HID e seriali confronta le due interfacce. Il tester di input dei codici a barre non può leggere una porta COM.
Lettura QR da fotocamera
Un'integrazione con fotocamera cattura un'immagine e decodifica il codice QR nel software. La pagina usa un'API della fotocamera e un decodificatore. Non riceve eventi keydown per il carico utile. Le app fotocamera del telefono, i pulsanti fotocamera nella pagina e un imager hardware che digita in un campo sono tre prodotti diversi. Superare un test in emulazione non significa che il pulsante della fotocamera funzioni, e una decodifica da fotocamera riuscita non significa che un lettore in emulazione digiterà la stessa stringa.
Acquisire l'input del lettore QR con JavaScript
La pagina sotto legge un campo con il focus. Enter invia il modulo, e il pulsante Accept usa lo stesso handler di submit, così una lettura viene elaborata una volta. Senza un suffisso ENTER, il testo resta nel campo finché qualcuno non attiva Accept. Il carico utile acquisito è scritto con textContent, così caratteri come < restano visibili come testo.
L'esempio accetta tre formati dell'applicazione: un id biglietto come QR-INPUT-TEST-12345, un URL http o https, oppure un oggetto JSON. Registra il testo letto. Non naviga verso un URL trovato nel codice QR. Un lettore che non invia Enter funziona comunque tramite il pulsante. Tab attraversa l'etichetta, il campo e il pulsante come di consueto, perché lo script non lo intrappola.
<!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>
Salva il file e aprilo in un browser desktop. Fai clic sul campo prima della lettura. autocomplete="off" riduce la possibilità che un valore salvato sostituisca la lettura. L'etichetta e il pulsante restano disponibili, così una persona può digitare un carico utile senza lettore.
Gestisci Enter solo nell'evento submit del modulo. Un secondo listener keydown per Enter registra la stessa lettura due volte. preventDefault() tiene il browser su questa pagina. Svuota il campo dopo una decisione, così la lettura successiva non si accoda al testo precedente.
Un carico utile QR può contenere un'interruzione di riga. Un lettore in emulazione spesso digita quell'interruzione come Enter. In un input di una riga, il modulo può essere inviato alla prima riga e perdere il resto. Usa una textarea, o una lettura seriale che conserva i byte, quando l'applicazione deve accettare testo su più righe. Conferma quel comportamento con un codice QR il cui carico utile include un'interruzione di riga.
Gestire i carichi utili QR
Un simbolo QR non promette un formato dell'applicazione. La stessa simbologia può trasportare uno qualunque di questi:
- Testo semplice, come
QR-INPUT-TEST-12345. - Un URL.
- Un identificatore scelto dall'applicazione.
- Un carico utile strutturato, come un numero di biglietto più un codice di sede.
- Testo JSON, quando l'applicazione ha definito quella codifica.
Il lettore trasmette i caratteri decodificati. Non controlla che corrispondano a una regola di biglietto, a un catalogo prodotti o a uno schema JSON. Valida la stringa nella pagina e validala di nuovo sul server. Il valore inviato è input ordinario dell'utente. Il browser non può provare che l'abbia prodotto un lettore.
Validare l'input QR
Non dare per scontato che un carico utile QR sia numerico. Le regole EAN-13 non si applicano. Tratta il testo come non attendibile: mostralo come testo e non assegnarlo a location, innerHTML o a un URL di script.
Valori vuoti. Un Enter da solo, o Accept su un campo vuoto, non deve creare un record. trim() rifiuta anche un carico utile fatto solo di spazi.
Caratteri imprevisti. Confronta la stringa ricevuta con il contenuto QR noto. Una differenza di layout di tastiera spesso cambia la punteggiatura mentre la lunghezza resta la stessa. Rifiuta i caratteri che il formato non consente e mostra il motivo nel testo di stato.
Lunghezza del carico utile. Imponi il massimo che la tua applicazione memorizza. maxlength sull'input tronca una lettura più lunga senza errore. Impostalo solo quando ogni carico utile accettato ci sta, e confronta il conteggio dei caratteri del tester con il campo quando un valore sembra corto.
Prefissi obbligatori. Il controllo del prefisso appartiene all'applicazione. Questa regola di biglietto accetta QR- più lettere maiuscole, cifre e trattini:
function isTicketId(value) {
return /^QR-[A-Z0-9-]{1,64}$/.test(value)
}
Togli un prefisso del lettore solo quando quel lettore è configurato per inviare un prefisso esatto e l'applicazione non lo memorizza. Un identificatore di simbologia AIM è un dato finché non decidi altrimenti.
Formati specifici dell'applicazione. Tieni la regola accanto al formato. Un modulo biglietto, un elenco di URL consentiti e un oggetto JSON richiedono controlli diversi. Un solo modello numerico rifiuterà testo QR valido.
Letture duplicate. Una lettura fisica può colpire due listener. Usa un solo percorso di completamento, come fa l'esempio. Una seconda pressione del grilletto è un evento separato. L'esempio rifiuta un carico utile che ha già accettato. Un modulo di magazzino potrebbe incrementare una quantità. Testa la regola che la tua applicazione documenta.
JSON malformato. JSON.parse lancia un'eccezione sul testo incompleto. Controlla la forma dopo un'analisi riuscita. Un array o un numero isolato possono essere JSON valido e restare comunque il tipo sbagliato:
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 imprevisti. Analizza l'URL per vedere se è utilizzabile, poi conserva la stringa letta se il test deve corrispondere esattamente al carico utile QR. URL.href può aggiungere una barra o cambiare la codifica. Accetta solo gli schemi che l'applicazione intende. Non aprire l'URL come effetto collaterale della lettura:
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 }
}
Caratteri di controllo. Rifiuta i caratteri di controllo ASCII in un carico utile da tastiera, così un prefisso nascosto resta visibile nel testo di stato. CR e LF sono caratteri di controllo. Su un lettore in emulazione, Enter e Tab sono tasti. Non sono caratteri dentro un input di testo normale. Un carico utile seriale può ancora contenere i byte 0x0D o 0x0A. Toglili al confine di inquadramento seriale e non togliere un CR che appartiene al mezzo di un carico utile su più righe.
Suffissi ENTER e TAB
Un suffisso è una configurazione facoltativa del lettore. Non fa parte del simbolo QR. Suffissi ENTER e TAB nei lettori di codici a barre mostra come distinguere i tasti. Leggi il suffisso nel tester di input, poi fai corrispondere la pagina ai lettori che distribuisci.
ENTER invia il modulo di un campo di testo di una riga nei browser attuali. Usalo quando una lettura deve confermare il valore. Chiama preventDefault() su submit quando la pagina deve restare dov'è.
TAB sposta il focus sul controllo successivo. Leggi il valore in keydown mentre il campo ha ancora il focus. Lascia l'azione predefinita al suo posto quando il campo successivo deve ricevere il focus. Ignora Shift+Tab così chi usa la tastiera può tornare indietro.
Nessun suffisso lascia il carico utile nel campo. Il pulsante Accept dell'esempio è il percorso di completamento. Un timer di inattività può supporre che una pausa significhi che la lettura è finita. Quel timer è un'euristica: una raffica Bluetooth lenta e chi digita in fretta possono attraversare lo stesso intervallo. Preferisci un suffisso configurato quando il flusso ha bisogno di una fine netta.
CR e LF sono byte. Un Enter da tastiera è event.key === "Enter". Non sono intercambiabili. Un listener che toglie solo \r da un valore di input non vede un Enter in emulazione, perché il carattere non è mai stato inserito. Un listener che osserva solo event.key non divide un buffer seriale su 0x0D. Alcuni dispositivi inviano NumPad Enter. event.key è comunque "Enter". Controlla event.key, non solo event.code === "Enter".
Il suffisso può cambiare quando qualcuno legge un codice a barre di configurazione dal manuale del dispositivo. Ritesta Enter, Tab e l'assenza di suffisso dopo ogni modifica di configurazione. Non inventare un codice a barre di programmazione. Usa il manuale di quel modello.
Eseguire il debug degli eventi di tastiera
Quando il testo memorizzato è sbagliato, ispeziona gli eventi in questo ordine.
keydown. Si attiva per ogni tasto, Enter e Tab compresi, prima che il browser inserisca un carattere o sposti il focus. Leggi il terminatore qui.
input. Si attiva dopo che un carattere stampabile modifica il campo. Non si attiva per Enter o Tab su un input di testo.
event.key. Il carattere o il nome del tasto dopo che il sistema operativo applica il layout di tastiera.
event.code. Il tasto fisico, come Digit1 o Numpad1. Può restare lo stesso quando un layout diverso cambia event.key.
Focus. Registra document.activeElement prima della lettura. Se non è il campo QR, il resto della traccia descrive il controllo sbagliato. Un iframe ha un focus proprio.
Ordine. Per una lettura in emulazione in un campo di testo, gli eventi keydown stampabili sono seguiti da aggiornamenti di input, poi da un keydown finale per Enter o Tab quando quel suffisso è configurato. change si attiva quando il campo conferma, di solito al blur. Una lettura che lascia il focus nello stesso campo non produce change alla fine. Non usare change come unico segnale di completamento.
Temporizzazione. I lettori spesso finiscono un carico utile breve ben sotto il secondo. Il tester di input confronta l'intervallo medio tra i caratteri con una soglia di 100 ms ed etichetta il risultato come temporizzazione, non come identificazione dell'hardware. Chi digita in fretta, la compilazione automatica o l'emulatore possono finire dal lato del lettore di quella soglia. Una lettura Bluetooth ritardata può sembrare digitazione. Verifica il carico utile e il suffisso. Tratta la temporizzazione come un indizio.
Il tester degli eventi tastiera elenca ogni keydown e keyup con key, code, modificatori e marche temporali. Il registro sono eventi del browser. Non è traffico USB grezzo.
Testare senza un lettore QR fisico
La logica dell'applicazione può essere testata prima che un lettore sia sulla scrivania.
- Digita
QR-INPUT-TEST-12345nel campo e attiva Accept. Questo controlla validazione e visualizzazione. Non controlla la decodifica né i suffissi. - Guida lo stesso campo da uno strumento di automazione del browser, come fa la sezione successiva.
- Usa il Barcode Scanner Emulator quando ti serve una digitazione in stile lettore. L'app desktop invia un valore che inserisci, con un ritardo di digitazione e un suffisso tra nessuno, ENTER o TAB, nell'applicazione con il focus. Riproduce il percorso da tastiera. Non fotografa un'immagine QR, non decodifica un simbolo e non crea una porta COM virtuale.
L'hardware resta necessario per il comportamento ottico e del dispositivo: se quel lettore può leggere il codice mostrato o stampato, se la simbologia QR è abilitata, il layout di tastiera, la configurazione del suffisso e le modalità seriale o SDK del produttore. L'emulatore è il controllo giusto per il percorso da tastiera. È il controllo sbagliato per dimostrare che un dispositivo legge un particolare codice QR.
Automatizzare i test dell'input QR
I test Playwright seguenti guidano la pagina di esempio. Digitano nel campo come farebbe un lettore in emulazione, poi verificano il comportamento dell'applicazione. Non aprono dispositivi USB. @playwright/test è una dipendenza di chi legge. Questo sito non la richiede.
Salva l'esempio HTML come qr-form.html accanto a questo 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 inserisce caratteri nel campo con il focus. Non è un gadget USB. Il test del carattere imprevisto usa fill perché l'obiettivo è il messaggio di validazione e l'assenza di un elemento iniettato. Estendi il file con un caso URL e un caso JSON quando quei formati sono nella build che distribuisci. Un'asserzione sull'URL deve confrontare il testo acquisito con la stringa QR originale.
Matrice di test del lettore QR
Esegui questi casi sull'applicazione sotto test. La pagina di esempio sopra copre le righe di biglietto, URL, JSON, duplicato, vuoto e carattere imprevisto. Un'applicazione solo numerica o su più righe ha bisogno del proprio risultato atteso.
| Scenario | Risultato atteso |
|---|---|
| QR di testo semplice | Valore esatto ricevuto |
| QR con URL | URL completo acquisito, e la pagina non naviga verso di esso |
| QR numerico | Cifre preservate |
| Caratteri speciali | Caratteri corretti ricevuti |
| Carico utile JSON | Dati acquisiti e validati |
| Suffisso ENTER | L'elaborazione avviene una volta |
| Suffisso TAB | Comportamento del focus gestito |
| Nessun suffisso | L'applicazione usa un meccanismo di completamento alternativo |
| Lettura duplicata | L'applicazione applica le regole di gestione dei duplicati |
| Carico utile non valido | Errore di validazione mostrato |
| Focus assente | L'applicazione gestisce in modo sicuro l'input assente |
| Carico utile lungo | Nessun troncamento indesiderato |
Leggi anche un carico utile che contiene un'interruzione di riga se il prodotto deve memorizzarne una. Annota se il campo ha ricevuto ogni riga.
Risoluzione dei problemi
Inizia con un carico utile noto nel tester di input. Se il valore del tester è già sbagliato, la pagina non è il primo guasto. Se il valore del tester è giusto e l'applicazione è sbagliata, il guasto è il focus, la validazione o la gestione degli eventi. Il lettore di codici a barre non funziona è la lista più ampia sul dispositivo. Come testare l'input di un lettore di codici a barre copre focus, layout e flussi POS oltre questo modulo.
Il lettore emette un beep ma non compare input
Un beep di solito significa che il lettore ha decodificato un simbolo. Non significa che la pagina abbia ricevuto il testo. Conferma la modalità di emulazione tastiera. Le modalità seriale e fotocamera non digitano nel campo. Fai clic sul campo così document.activeElement è quell'input, poi leggi di nuovo. Un campo disabilitato, di sola lettura o nascosto può ignorare i tasti.
Il lettore QR funziona in Notepad ma non nel browser
Il dispositivo sta digitando. La pagina non accetta quei tasti. Controlla il focus, un listener keydown che chiama preventDefault() sui tasti stampabili e un listener che gestisce solo paste. L'input in emulazione non attiva un evento paste. Confronta il risultato del tester con il campo dell'applicazione.
Il lettore legge i codici a barre ma non i codici QR
Il dispositivo può essere solo 1D, oppure la simbologia QR può essere disabilitata. La pagina non può correggerlo. Conferma il supporto 2D e abilita QR Code dal manuale del dispositivo, usando i controlli di Test dei codici QR: come testare i lettori di QR. Una lettura Code 128 riuscita prova solo il percorso da tastiera.
Caratteri errati
Leggi prima QR-INPUT-TEST-12345. Se quello corrisponde e un carico utile URL o JSON no, il layout sta cambiando la punteggiatura, come :, /, { o ". Confronta event.key con event.code nel tester degli eventi tastiera e vedi Layout di tastiera errato del lettore di codici a barre. Allinea il layout di tastiera del lettore a quello del sistema operativo.
ENTER invia il modulo due volte
Il browser invia il modulo e un listener keydown gestisce anche Enter. Tieni un solo percorso di completamento e chiama preventDefault() lì. Una seconda lettura fisica è un guasto diverso. Il testo di stato dell'esempio dice che il carico utile era già stato accettato. Se la prima lettura stessa crea due record, cerca due listener prima di modificare il lettore.
L'input QR è troncato
Confronta il conteggio dei caratteri nel tester di input con il valore nel campo. Un attributo maxlength, una maschera di input o preventDefault() sui tasti carattere possono tagliare la stringa. Un'interruzione di riga dentro il carico utile QR può inviare in anticipo un input di una riga. Alcuni lettori limitano anche quanti caratteri digitano. Alza quel limite dal manuale del dispositivo quando il tester, non solo l'applicazione, mostra un valore corto. Al lettore di codici a barre manca ENTER copre il caso correlato in cui il carico utile arriva e il modulo non conferma mai.
Il lettore non riesce a leggere un codice QR sullo schermo
Conferma che il lettore sia un imager 2D. Aumenta la luminosità dello schermo, aumenta la dimensione del codice e tieni la quiet zone libera da testo e bordi. Il riflesso, uno schermo del telefono fioco e un codice troppo denso per la distanza di lavoro sono problemi ottici. Stampa lo stesso carico utile se la lettura sullo schermo continua a fallire. Il test dell'applicazione usa comunque la stringa nota non appena una lettura produce testo.