A partire dal 27 marzo 2025, ti consigliamo di utilizzare android-latest-release anziché aosp-main per compilare e contribuire ad AOSP. Per ulteriori informazioni, vedi Modifiche ad AOSP.

Questa pagina è stata tradotta dall'API Cloud Translation.

Dispositivi touch
Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Android supporta una serie di touchscreen e pad tattili, tra cui tablet con digitalizzatore basati su stilo.

I touchscreen sono dispositivi touch associati a un display che l'utente ha l'impressione di manipolare direttamente gli elementi sullo schermo.

I touch pad sono dispositivi touch non associati a un display, ad esempio una tablet digitalizzatore. I touch pad sono in genere usati per puntare o per posizionamento indiretto assoluto o controllo basato su gesti di un'interfaccia utente.

I dispositivi touch possono avere pulsanti le cui funzioni sono simili a quelle dei pulsanti del mouse.

A volte i dispositivi touch possono essere manipolati utilizzando una serie di strumenti diversi, come le dita o uno stilo, a seconda della tecnologia del sensore touch sottostante.

A volte vengono utilizzati dispositivi touch per implementare tasti virtuali. Ad esempio, su alcuni dispositivi Android, l'area del sensore del touchscreen si estende oltre il bordo del display e ha una doppia funzione come parte di un tastierino sensibile al tocco.

A causa della grande varietà di dispositivi touch, Android si basa su un gran numero di proprietà di configurazione per descrivere le caratteristiche e il comportamento desiderato di ciascun dispositivo.

Classificazione dei dispositivi touch

Un dispositivo di input è classificato come dispositivo multi-touch se entrambi sussistono le seguenti condizioni:

Il dispositivo di input segnala la presenza degli assi assoluti ABS_MT_POSITION_X e ABS_MT_POSITION_Y.
Il dispositivo di input non ha pulsanti del gamepad. Questa condizione risolve un'ambiguità con alcuni gamepad che segnalano assi con codici che si sovrappongono a quelli degli assi MT.

Un dispositivo di input è classificato come dispositivo single-touch se entrambi i dispositivi le seguenti condizioni:

Il dispositivo di input non è classificato come dispositivo multi-touch. Un dispositivo di input è classificato come dispositivo single-touch o multi-touch, mai entrambi.
Il dispositivo di input segnala la presenza dell'assoluta ABS_X e ABS_Y e la presenza del codice chiave BTN_TOUCH.

Quando un dispositivo di input è classificato come dispositivo touch, la presenza di tasti virtuali viene determinata tentando di caricare il file della mappa dei tasti virtuali per il dispositivo. Se è disponibile una mappa dei tasti virtuali, viene usato il layout dei tasti. viene caricato anche il file del dispositivo. Consulta [File mappa delle chiavi virtuali](#virtual-key-map-files) per informazioni sulla posizione e sul formato di questi file.

Il sistema carica quindi il file di configurazione del dispositivo di input per il dispositivo touch.

Tutti i dispositivi touch integrati devono avere file di configurazione del dispositivo di input. Se non è presente alcun file di configurazione del dispositivo di input, il sistema sceglie una configurazione predefinita appropriata per le periferiche touch di uso generale, come touchscreen o touchpad HID USB o Bluetooth esterni. Queste impostazioni predefinite non sono progettate per i touchscreen e può causare un comportamento errato.

Una volta caricata la configurazione del dispositivo di input, il sistema classifica dispositivo di input come touchscreen, touch pad o dispositivo di puntatore.

Un dispositivo touchscreen viene utilizzato per manipolare direttamente gli oggetti presenti sulla schermo. L'utente tocca direttamente lo schermo, quindi il sistema non richiede eventuali inviti aggiuntivi per indicare che gli oggetti manipolato.
Viene utilizzato un touch pad per fornire informazioni sul posizionamento assoluto. a un'app sul tocco di una determinata area del sensore. Può essere utile per tablet con digitalizzatore.
Un dispositivo pointer viene utilizzato per la manipolazione indiretta degli oggetti sulla schermo usando un cursore. Le dita vengono interpretate come gesti del cursore multi-touch. Altri strumenti, come gli stili, vengono interpretati utilizzando posizioni assolute. Per ulteriori informazioni, consulta la sezione Gesti indiretti del cursore multi-touch.

Le seguenti regole vengono usate per classificare il dispositivo di input come touchscreen, touchpad o dispositivo di puntamento.

Se la proprietà touch.deviceType è impostata, il tipo di dispositivo è impostato come indicato.
Se il dispositivo di input segnala la presenza della proprietà di input INPUT_PROP_DIRECT (tramite l'ioctl EVIOCGPROP), il tipo di dispositivo è impostato su touchscreen. Questa condizione presuppone che i dispositivi touch con input diretto siano collegati a un display che è anche connesso.
Se il dispositivo di input segnala la presenza della proprietà INPUT_PROP_POINTER input (tramite l'ioctl EVIOCGPROP), il tipo di dispositivo viene impostato su pointer.
Se il dispositivo di input segnala la presenza di REL_X o REL_Y assi relativi, il tipo di dispositivo è impostato su touch pad. Questa condizione risolve un'ambiguità per i dispositivi di input costituiti sia da un mouse sia da un touchpad. In questo caso, il touchpad non viene usato per controllare del puntatore, perché è già il mouse.
In caso contrario, il tipo di dispositivo è impostato su cursor. Questa impostazione predefinita garantisce I touch pad non sono stati designati per altri scopi speciali. controlla il puntatore.

Pulsanti

I pulsanti sono controlli facoltative che le app possono utilizzare per eseguire funzioni aggiuntive. I pulsanti dei dispositivi touch si comportano in modo simile al mouse e vengono utilizzati principalmente con dispositivi touch di tipo pointer o con una stilo.

Sono supportati i seguenti pulsanti:

BTN_LEFT: mappato a MotionEvent.BUTTON_PRIMARY.
BTN_RIGHT: mappato a MotionEvent.BUTTON_SECONDARY.
BTN_MIDDLE: mappato a MotionEvent.BUTTON_MIDDLE.
BTN_BACK e BTN_SIDE: mappati a MotionEvent.BUTTON_BACK. Se premi questo pulsante, viene sintetizzata anche la pressione di un tasto con il codice del tasto KeyEvent.KEYCODE_BACK.
BTN_FORWARD e BTN_EXTRA: mappati a MotionEvent.BUTTON_FORWARD. Se premi questo pulsante viene sintetizzata anche la pressione di un tasto con il codice chiave KeyEvent.KEYCODE_FORWARD.
BTN_STYLUS: mappato a MotionEvent.BUTTON_SECONDARY.
BTN_STYLUS2: mappato a MotionEvent.BUTTON_TERTIARY.

Strumenti e tipi di strumenti

Uno strumento è un dito, uno stilo o un altro apparato utilizzato per interagire con il dispositivo touch. Alcuni dispositivi touch possono distinguere tra tipi di strumenti.

In altre parti di Android, come nell'API MotionEvent, uno strumento è spesso indicato come cursore.

Sono supportati i seguenti tipi di strumenti:

BTN_TOOL_FINGER e MT_TOOL_FINGER: mappati a MotionEvent.TOOL_TYPE_FINGER.
BTN_TOOL_PEN e MT_TOOL_PEN: mappati a MotionEvent.TOOL_TYPE_STYLUS.
BTN_TOOL_RUBBER: mappato a MotionEvent.TOOL_TYPE_ERASER.
BTN_TOOL_BRUSH: mappato a MotionEvent.TOOL_TYPE_STYLUS.
BTN_TOOL_PENCIL: mappato a MotionEvent.TOOL_TYPE_STYLUS.
BTN_TOOL_AIRBRUSH: mappato a MotionEvent.TOOL_TYPE_STYLUS.
BTN_TOOL_MOUSE: mappato a MotionEvent.TOOL_TYPE_MOUSE.
BTN_TOOL_LENS: mappato a MotionEvent.TOOL_TYPE_MOUSE.
BTN_TOOL_DOUBLETAP, BTN_TOOL_TRIPLETAP e BTN_TOOL_QUADTAP: mappati a MotionEvent.TOOL_TYPE_FINGER.

Strumenti passandoci sopra al tocco

Gli strumenti possono essere a contatto con il dispositivo touch o essere nel raggio d'azione e passare sopra il dispositivo. Non tutti i dispositivi touch possono rilevare la presenza di uno strumento visualizzato sopra il dispositivo. Quelli che lo supportano, come i digitalizzatori con stilo a RF, spesso sono in grado di rilevare quando lo strumento si trova entro un raggio d'azione limitato del digitalizzatore.

Il componente InputReader distingue gli strumenti che toccano dal passaggio del mouse i nostri strumenti. Analogamente, gli strumenti di tocco e di passaggio del mouse vengono segnalati alle app in modi diversi.

Gli strumenti di tocco vengono segnalati alle app come eventi di tocco utilizzando MotionEvent.ACTION_DOWN, MotionEvent.ACTION_MOVE, MotionEvent.ACTION_DOWN, MotionEvent.ACTION_POINTER_DOWN e MotionEvent.ACTION_POINTER_UP.

Gli strumenti di passaggio del mouse vengono segnalati alle app come eventi di movimento generici utilizzando MotionEvent.ACTION_HOVER_ENTER, MotionEvent.ACTION_HOVER_MOVE e MotionEvent.ACTION_HOVER_EXIT.

Requisiti del driver del dispositivo touch

I driver dei dispositivi touch devono registrare solo gli assi e i codici chiave degli assi e i pulsanti supportati. La registrazione di assi o codici chiave non supportati può confondere l'algoritmo di classificazione del dispositivo o causare il rilevamento errato delle funzionalità del dispositivo da parte del sistema. Ad esempio, se il dispositivo segnala il codice chiave BTN_TOUCH, il sistema presume che BTN_TOUCH venga sempre utilizzato per indicare se lo strumento tocca lo schermo. Pertanto, BTN_TOUCH non deve essere utilizzato per indicare che lo strumento si trova semplicemente nell'intervallo e viene visualizzato in modalità di passaggio del mouse.
I dispositivi con un solo tocco utilizzano i seguenti eventi di input Linux:
- ABS_X: (OBBLIGATORIO) indica la coordinata X dello strumento.
- ABS_Y: (OBBLIGATORIO) indica la coordinata Y dello strumento.
- ABS_PRESSURE: (facoltativo) indica la pressione fisica applicata alla punta dello strumento o l'intensità del segnale del contatto touch.
- ABS_TOOL_WIDTH: (facoltativo) indica l'area della sezione trasversale o la larghezza di del contatto o dello strumento stesso.
- ABS_DISTANCE: (facoltativo) indica la distanza dello strumento dalla superficie del dispositivo touch.
- ABS_TILT_X: (facoltativo) indica l'inclinazione dello strumento dalla superficie del il dispositivo touch lungo l'asse X.
- ABS_TILT_Y: (facoltativo) indica l'inclinazione dello strumento dalla superficie del il dispositivo touch lungo l'asse Y.
- BTN_TOUCH: (OBBLIGATORIO) indica se lo strumento tocca il dispositivo.
- BTN_LEFT, BTN_RIGHT, BTN_MIDDLE e BTN_BACK BTN_SIDE, BTN_FORWARD, BTN_EXTRA, BTN_STYLUS e BTN_STYLUS2: (Facoltativo) Stati del pulsante Report.
- BTN_TOOL_FINGER, BTN_TOOL_PEN, BTN_TOOL_RUBBER BTN_TOOL_BRUSH, BTN_TOOL_PENCIL, BTN_TOOL_AIRBRUSH BTN_TOOL_MOUSE, BTN_TOOL_LENS, BTN_TOOL_DOUBLETAP, BTN_TOOL_TRIPLETAP, BTN_TOOL_QUADTAP: (facoltativo) Segnala il tipo di strumento.
I dispositivi multi-touch utilizzano i seguenti eventi di input Linux:
- ABS_MT_POSITION_X: (OBBLIGATORIO) indica la coordinata X dello strumento.
- ABS_MT_POSITION_Y: (OBBLIGATORIO) indica la coordinata Y dello strumento.
- ABS_MT_PRESSURE: (facoltativo) indica la pressione fisica applicata al punta dello strumento o l'intensità del segnale del contatto touch.
- ABS_MT_TOUCH_MAJOR: (facoltativo) indica l'area della sezione trasversale della contatto touch o la lunghezza della dimensione più lunga del contatto touch.
- ABS_MT_TOUCH_MINOR: (facoltativo) indica la lunghezza della dimensione più breve del contatto di tocco. Questo asse non deve essere utilizzato se ABS_MT_TOUCH_MAJOR è registrando una misurazione dell'area.
- ABS_MT_WIDTH_MAJOR: (facoltativo) indica l'area della sezione trasversale dello strumento stesso o la lunghezza della dimensione più lunga dello strumento stesso. Non utilizzare questo asse a meno che tu non conosca le dimensioni dello strumento stesso.
- ABS_MT_WIDTH_MINOR: (facoltativo) indica la lunghezza della dimensione più corta dello strumento stesso. Questo asse non deve essere utilizzato se ABS_MT_WIDTH_MAJOR sta generando un report misurazione di un'area o se le dimensioni dello strumento stesso sono sconosciute.
- ABS_MT_ORIENTATION: (facoltativo) indica l'orientamento dello strumento.
- ABS_MT_DISTANCE: (facoltativo) indica la distanza dello strumento dal superficie del dispositivo touch.
- ABS_MT_TOOL_TYPE: (facoltativo) indica il tipo di strumento come MT_TOOL_FINGER o MT_TOOL_PEN.
- ABS_MT_TRACKING_ID: (facoltativo) indica l'ID monitoraggio dello strumento. L'ID monitoraggio è un numero intero non negativo arbitrario che viene utilizzato per identificare e monitorare ogni strumento in modo indipendente quando sono attivi più strumenti. Ad esempio, quando più dita toccano il dispositivo, a ogni dito deve essere assegnato un ID di monitoraggio distinto che viene utilizzato finché il dito rimane in contatto. Gli ID monitoraggio possono essere riutilizzati quando gli strumenti associati non sono più nel raggio d'azione.
- ABS_MT_SLOT: (facoltativo) indica l'ID slot dello strumento, se si utilizza il protocollo multi-touch "B" di Linux. Consulta la documentazione sul protocollo multi-touch Linux per ulteriori dettagli.
- BTN_TOUCH: (OBBLIGATORIO) indica se lo strumento tocca il dispositivo.
- BTN_LEFT, BTN_RIGHT, BTN_MIDDLE, BTN_BACK, BTN_SIDE, BTN_FORWARD, BTN_EXTRA, BTN_STYLUS, BTN_STYLUS2: (facoltativo) Stati del pulsante Report.
- BTN_TOOL_FINGER, BTN_TOOL_PEN, BTN_TOOL_RUBBER, BTN_TOOL_BRUSH, BTN_TOOL_PENCIL, BTN_TOOL_AIRBRUSH, BTN_TOOL_MOUSE, BTN_TOOL_LENS, BTN_TOOL_DOUBLETAP, BTN_TOOL_TRIPLETAP, BTN_TOOL_QUADTAP: (facoltativo) Indica il tipo di strumento.
Se sono definiti gli assi sia per il protocollo single-touch sia per quello multi-touch, vengono utilizzati solo gli assi multi-touch e gli assi single-touch vengono ignorati.
I valori minimo e massimo di ABS_X, ABS_Y, ABS_MT_POSITION_X, e ABS_MT_POSITION_Y assi definiscono i limiti dell'area attiva del dispositivo in unità di superficie specifiche per dispositivo. Nel caso di un touchscreen, l'area attiva descrive la parte del dispositivo touch che copre effettivamente il display.

Per un touchscreen, il sistema interpola automaticamente le posizioni tocco registrate in unità di superficie per ottenere le posizioni tocco in pixel del display in base al seguente calcolo:
```
    displayX = (x - minX) * displayWidth / (maxX - minX + 1)
    displayY = (y - minY) * displayHeight / (maxY - minY + 1)
    
```
Un touchscreen potrebbe segnalare tocchi al di fuori dell'area attiva segnalata.

I tocchi avviati al di fuori dell'area attiva non vengono inviati alle app, ma possono essere utilizzati per i tasti virtuali.

Tocchi avviati all'interno dell'area attiva o che entrano ed escono dal display vengono pubblicati nelle app. Di conseguenza, se un tocco inizia all'interno dei confini di un'app e poi si sposta all'esterno dell'area attiva, l'app potrebbe ricevere eventi tocco con coordinate del display negative o oltre i confini del display. Si tratta di un comportamento previsto.

Un dispositivo touch non deve mai bloccare le coordinate di tocco ai limiti del piano in ogni area. Se un tocco esce dall'area attiva, deve essere segnalato come esterno all'area attiva o non deve essere segnalato affatto.

Ad esempio, se il dito dell'utente si tocca vicino all'angolo in alto a sinistra della touch screen, potrebbe riportare una coordinata di (minX, minY). Se il dito continua a spostarsi ulteriormente all'esterno dell'area attiva, il touchscreen deve iniziare a registrare coordinate con componenti inferiori a minX e minY, ad esempio (minX - 2, minY - 3) oppure deve smettere di registrare il tocco del tutto. In altre parole, il touchscreen non dovrebbe indicare (minX, minY) quando il dito dell'utente si tocca davvero al di fuori dell'area attiva.

Il blocco delle coordinate tocco al bordo del display crea un confine artificiale rigido intorno al bordo dello schermo che impedisce al sistema di monitorare senza problemi i movimenti che entrano o escono dai limiti dell'area di visualizzazione.
I valori segnalati da ABS_PRESSURE o ABS_MT_PRESSURE, se vengono segnalati, devono essere diversi da zero quando lo strumento tocca il dispositivo e zero in caso contrario per indicare che lo strumento è in stato di passaggio.

La segnalazione delle informazioni sulla pressione è facoltativa, ma vivamente consigliata. Le app possono usare le informazioni sulla pressione per implementare il disegno sensibile alla pressione e altri effetti.
I valori riportati da ABS_TOOL_WIDTH, ABS_MT_TOUCH_MAJOR, ABS_MT_TOUCH_MINOR, ABS_MT_WIDTH_MAJOR o ABS_MT_WIDTH_MINOR devono essere diversi da zero quando lo strumento tocca il dispositivo e zero in caso contrario, ma non è obbligatorio. Ad esempio, il dispositivo touch potrebbe essere in grado di misurare la dimensione del tocco del dito ma non con lo stilo.

Le informazioni sulle dimensioni dei report sono facoltative ma vivamente consigliate. Le app possono utilizzare le informazioni sulla pressione per implementare il disegno sensibile alle dimensioni e altri effetti.
I valori riportati da ABS_DISTANCE o ABS_MT_DISTANCE devono si avvicinano allo zero quando lo strumento tocca il dispositivo. La distanza può rimanere diversa da zero anche quando lo strumento è a contatto diretto. I valori esatti riportati dipendono sul modo in cui l'hardware misura la distanza.

La segnalazione delle informazioni sulla distanza è facoltativa ma consigliata per dispositivi stilo.
I valori riportati da ABS_TILT_X e ABS_TILT_Y devono essere zero quando lo strumento è perpendicolare al dispositivo. Un'inclinazione diversa da zero indica che lo strumento è inclinato.

Si presume che gli angoli di inclinazione lungo gli assi X e Y siano specificati in gradi rispetto alla perpendicolare. Viene dato il punto centrale (perfettamente perpendicolare) di (max + min) / 2 per ogni asse. I valori inferiori al punto centrale rappresentano un'inclinazione verso l'alto o verso sinistra, mentre i valori superiori al punto centrale rappresentano un'inclinazione verso il basso o verso destra.

InputReader converte i componenti di inclinazione X e Y in un angolo di inclinazione perpendiculare che va da 0 a PI / 2 radianti e un angolo di orientamento planare che va da -PI a PI radianti. Questa rappresentazione genera una descrizione dell'orientamento compatibile con quella utilizzata per descrivere i tocchi delle dita.

La segnalazione delle informazioni sull'inclinazione è facoltativa, ma consigliata per i dispositivi stilo.
Se il tipo di strumento viene segnalato da ABS_MT_TOOL_TYPE, sostituisce le informazioni sul tipo di strumento segnalate da BTN_TOOL_*. Se non sono disponibili informazioni sul tipo di strumento, per impostazione predefinita il tipo di strumento viene impostato su MotionEvent.TOOL_TYPE_FINGER.
Uno strumento viene considerato attivo in base alle seguenti condizioni:
- Quando utilizzi il protocollo single-touch, lo strumento è attivo se BTN_TOUCH, o BTN_TOOL_* è 1.
  
  Questa condizione implica che InputReader debba avere almeno alcune informazioni sulla natura dello strumento, ad esempio se è in contatto o almeno il tipo di strumento. Se non sono disponibili informazioni, si presume che lo strumento sia inattivo (fuori intervallo).
- Quando utilizzi il protocollo multi-touch "A", lo strumento è attivo ogni volta che viene visualizzato nel report di sincronizzazione più recente. Quando lo strumento non viene più visualizzato in sincronizza i rapporti, cessa di esistere.
- Quando si utilizza il protocollo multi-touch "B", lo strumento è attivo purché ha uno slot attivo. Quando lo spazio viene cancellato, lo strumento non esiste più.
Viene determinato che uno strumento passa il mouse sopra in base alle seguenti condizioni:
- Se lo strumento è BTN_TOOL_MOUSE o BTN_TOOL_LENS, significa che non è visualizzato in modalità di passaggio del mouse, anche se una delle seguenti condizioni è vera.
- Se lo strumento è attivo e il conducente segnala le informazioni sulla pressione, e la pressione segnalata è pari a zero, significa che lo strumento sta passando il cursore del mouse.
- Se lo strumento è attivo e il driver supporta il codice chiave BTN_TOUCH e BTN_TOUCH ha un valore pari a zero, lo strumento è in stato di passaggio del mouse.
InputReader supporta sia il protocollo multi-touch "A" sia "B". Nuovi conducenti dovresti usare la lettera "B" ma entrambe funzionano.
A partire da Android 4.0, potrebbe essere necessario modificare i driver del touchscreen per conformarsi alla specifica del protocollo di input di Linux.

Potrebbero essere necessarie le seguenti modifiche:
- Quando uno strumento diventa inattivo (il dito si solleva), non dovrebbe più essere visualizzato nei report sulla sincronizzazione multi-touch successivi. Quando tutti gli strumenti diventano inattivi (tutte le dita sono "in alto"), il driver deve inviare un pacchetto di report di sincronizzazione vuoto, ad esempio SYN_MT_REPORT seguito da SYN_REPORT.
  
  Le versioni precedenti di Android previste "up" eventi da segnalare inviando con un valore di pressione pari a 0. Il comportamento precedente non era compatibile con Specifica del protocollo di input Linux e non è più supportato.
- Le informazioni sulla pressione fisica o sull'intensità del segnale devono essere registrate utilizzando ABS_MT_PRESSURE.
  
  Le versioni precedenti di Android recuperavano le informazioni sulla pressione da ABS_MT_TOUCH_MAJOR. Il comportamento precedente non era compatibile con Specifica del protocollo di input Linux e non è più supportato.
- Le informazioni sulle dimensioni del tocco devono essere registrate utilizzando ABS_MT_TOUCH_MAJOR.
  
  Le versioni precedenti di Android recuperavano le informazioni sulle dimensioni da ABS_MT_TOOL_MAJOR. Il vecchio comportamento non era compatibile con la specifica del protocollo di input di Linux e non è più supportato.
I driver dei dispositivi touch non richiedono più personalizzazioni specifiche per Android. Basandosi sul protocollo di input Linux standard, Android può supportare una gamma più ampia di periferiche touch, come gli schermi touch multi-touch HID esterni, utilizzando driver non modificati.

Operazione con dispositivo touch

Di seguito è riportato un breve riepilogo del funzionamento dei dispositivi touch su Android.

EventHub legge gli eventi non elaborati dal driver evdev.
InputReader utilizza gli eventi non elaborati e aggiorna lo stato interno su la posizione e altre caratteristiche di ogni strumento. Monitora anche gli stati dei pulsanti.
Se BACK o FORWARD è stato premuto o rilasciato, InputReader invia una notifica a InputDispatcher sull'evento chiave.
InputReader determina se è stata eseguita la pressione di un tasto virtuale. Se sì, invia una notifica a InputDispatcher dell'evento chiave.
InputReader determina se il tocco è stato avviato all'interno del limiti del display. In questo caso, invia una notifica a InputDispatcher l'evento touch.
Se non sono presenti strumenti di tocco, ma è presente almeno uno strumento di passaggio del mouse, InputReader invia una notifica a InputDispatcher sull'evento di passaggio del mouse.
Se il tipo di dispositivo touch è pointer, InputReader esegue il puntatore il rilevamento dei gesti, sposta il puntatore e si posiziona di conseguenza e invia una notifica InputDispatcher sull'evento puntatore.
InputDispatcher utilizza WindowManagerPolicy per determinare se devono essere inviati gli eventi e se devono riattivare il dispositivo. Quindi, InputDispatcher invia gli eventi alle app appropriate.

Configurazione dispositivo touch

Il comportamento del dispositivo touch è determinato dagli assi, dai pulsanti e dalle proprietà di input del dispositivo configurazione del dispositivo di input, mappa dei tasti virtuali e layout dei tasti.

Per ulteriori dettagli sui file che contribuiscono alla configurazione della tastiera:

Proprietà

Il sistema si basa su molte proprietà di configurazione del dispositivo di input per configurare e calibrare il comportamento del dispositivo touch.

Uno dei motivi è che i driver dei dispositivi touch spesso segnalano le caratteristiche del tocco usando unità specifiche per dispositivo.

Ad esempio, molti dispositivi touch misurano l'area di contatto utilizzando una bilancia specifica per dispositivo interna, come il numero totale nodi dei sensori attivati dal tocco. Questo valore di dimensione non elaborato non avrebbe significato per le app perché queste dovrebbero conoscere le dimensioni fisiche e altre caratteristiche dei nodi del sensore del dispositivo touch.

Il sistema utilizza i parametri di calibrazione codificati nei file di configurazione del dispositivo di input per decodificare, trasformare e normalizzare i valori registrati dal dispositivo touch in una rappresentazione standard più semplice che le app possono comprendere.

Convenzioni sulla documentazione

A scopo di documentazione, utilizziamo le seguenti convenzioni per descrivere i valori utilizzati dal sistema durante il processo di calibrazione.

Valori asse non elaborati

Le seguenti espressioni indicano i valori non elaborati registrati dal driver del dispositivo touch come eventi EV_ABS.

raw.x: Il valore dell'asse ABS_X o ABS_MT_POSITION_X.
raw.y: Il valore dell'asse ABS_Y o ABS_MT_POSITION_Y.
raw.pressure: Il valore dell'asse ABS_PRESSURE o ABS_MT_PRESSURE oppure 0 se non disponibile.
raw.touchMajor: Il valore dell'asse ABS_MT_TOUCH_MAJOR o 0 se non disponibile.
raw.touchMinor: Il valore dell'asse ABS_MT_TOUCH_MINOR o raw.touchMajor se non disponibile.
raw.toolMajor: Il valore dell'asse ABS_TOOL_WIDTH o ABS_MT_WIDTH_MAJOR oppure 0 se non disponibile.
raw.toolMinor: Il valore dell'asse ABS_MT_WIDTH_MINOR o raw.toolMajor in caso contrario disponibili.
raw.orientation: Il valore dell'asse ABS_MT_ORIENTATION o 0 se non disponibile.
raw.distance: Il valore dell'asse ABS_DISTANCE o ABS_MT_DISTANCE oppure 0 se non disponibile.
raw.tiltX: Il valore dell'asse ABS_TILT_X o 0 se non disponibile.
raw.tiltY: Il valore dell'asse ABS_TILT_Y o 0 se non disponibile.

Intervalli dell'asse non elaborati

Le seguenti espressioni indicano i limiti dei valori non elaborati. Si ottengono chiamando EVIOCGABS ioctl per ogni asse.

raw.*.min: Il valore minimo incluso dell'asse non elaborato.
raw.*.max: Il valore massimo inclusivo dell'asse non elaborato.
raw.*.range: Equivalente a raw.*.max - raw.*.min.
raw.*.fuzz: L'accuratezza dell'asse non elaborato. Ad es. fuzz = 1 implica che i valori sono precisi con un'approssimazione di +/- 1 unità.
raw.width: La larghezza inclusiva dell'area tocco, equivalente a raw.x.range + 1.
raw.height: L'altezza inclusiva dell'area tocco, equivalente a raw.y.range + 1.

Intervalli di output

Le seguenti espressioni indicano le caratteristiche del sistema di coordinate di output. Il sistema utilizza l'interpolazione lineare per tradurre le informazioni sulla posizione del tocco le unità di superficie utilizzate dal dispositivo touch nelle unità di output segnalati ad app come i pixel di visualizzazione.

output.width: La larghezza dell'output. Per i touchscreen (associati a un display), si tratta della larghezza del display in pixel. Per i touchpad (non associati a un display), la larghezza in uscita è pari a raw.width, a indicare che non viene eseguita alcuna interpolazione.
output.height: L'altezza dell'output. Per i touchscreen (associati a un display), si tratta dell'altezza del display in pixel. Per i touchpad (non associati a un display), l'altezza in uscita è pari a raw.height, il che indica che non viene eseguita alcuna interpolazione.
output.diag: La lunghezza diagonale del sistema di coordinate di output, equivalente a sqrt(output.width ^2 + output.height ^2).

Configurazione di base

Il mapper dell'input tocco utilizza molte proprietà di configurazione nel file di configurazione del dispositivo di input per specificare i valori di calibrazione. La tabella seguente descrive alcune proprietà di configurazione per uso generico. Tutte le altre proprietà sono descritte nelle sezioni seguenti insieme ai campi utilizzati per la calibrazione.

touch.deviceType

Definizione: touch.deviceType = touchScreen | touchPad | pointer | default

Specifica il tipo di dispositivo touch.

Se il valore è touchScreen, il dispositivo touch è un touchscreen associato con un display.
Se il valore è touchPad, il dispositivo tocco è un touchpad non associato a un display.
Se il valore è pointer, il dispositivo touch è un touchpad non associato a un display e i relativi movimenti vengono utilizzati per gesti del cursore multi-touch indiretti.
Se il valore è default, il sistema rileva automaticamente il tipo di dispositivo in base all'algoritmo di classificazione.

Per ulteriori dettagli, consulta la sezione Classificazione su come il tipo di dispositivo influenza il comportamento del dispositivo touch.

In Android 3 e versioni precedenti, si presumeva che tutti i dispositivi touch fossero touchscreen.

touch.orientationAware

Definizione: touch.orientationAware = 0 | 1

Consente di specificare se il dispositivo touch deve reagire ai cambiamenti di orientamento del display.

Se il valore è 1, le posizioni touch riportate dal dispositivo touch vengono ruotate ogni volta che cambia l'orientamento del display.
Se il valore è 0, le posizioni tocco registrate dal dispositivo touch sono immuni alle modifiche dell'orientamento del display.

Il valore predefinito è 1 se il dispositivo è un touchscreen, 0 negli altri casi.

Il sistema distingue tra display e touchscreen interni ed esterni. Un touch screen interno sensibile all'orientamento viene ruotato in base all'orientamento del display interno. Un touch screen esterno ruotato che tiene conto dell'orientamento in base all'orientamento del display esterno.

Il rilevamento dell'orientamento viene utilizzato per supportare la rotazione dei touch screen sui dispositivi come Nexus One. Ad esempio, quando il dispositivo viene ruotato in senso orario di 90 gradi dal suo orientamento naturale, le posizioni assolute dei tocchi vengono rimappate in modo che un tocco nell'angolo in alto a sinistra del sistema di coordinate assoluto del touchscreen viene segnalata come un tocco nell'angolo in alto a sinistra del sistema di coordinate ruotato del display. Questo avviene in modo che i tocchi vengano registrati con lo stesso sistema di coordinate che le app usano per disegnare i propri elementi visivi.

Prima di Honeycomb, si pensava che tutti i dispositivi touch fossero orientati in modo consapevole.

touch.gestureMode

Definizione: touch.gestureMode = pointer | spots | default

Consente di specificare la modalità di presentazione per i gesti del puntatore. Questa proprietà di configurazione è pertinente solo quando il dispositivo touch è di tipo pointer.

Se il valore è pointer, i gesti del touchpad vengono presentati tramite un cursore in modo simile a un puntatore del mouse.
Se il valore è spots, i gesti del touchpad vengono presentati da un ancoraggio che rappresenta il baricentro del gesto e un insieme di macchie circolari che rappresentano la posizione delle singole dita.

Il valore predefinito è pointer quando la proprietà di input INPUT_PROP_SEMI_MT se il criterio viene impostato su spots.

Campi X e Y

I campi X e Y forniscono informazioni sulla posizione del centro dell'area di contatto.

Calcolo

Il calcolo è semplice: le informazioni sulla posizione del driver tocco vengono interpolate linearmente nel sistema di coordinate di output.

xScale = output.width / raw.width
yScale = output.height / raw.height

If not orientation aware or screen rotation is 0 degrees:
output.x = (raw.x - raw.x.min) * xScale
output.y = (raw.y - raw.y.min) * yScale
Else If rotation is 90 degrees:
    output.x = (raw.y - raw.y.min) * yScale
    output.y = (raw.x.max - raw.x) * xScale
Else If rotation is 180 degrees:
    output.x = (raw.x.max - raw.x) * xScale
    output.y = (raw.y.max - raw.y) * yScale
Else If rotation is 270 degrees:
    output.x = (raw.y.max - raw.y) * yScale
    output.y = (raw.x - raw.x.min) * xScale
End If

touchMajor, touchMinor, toolMajor, toolMinor, dimensione dei campi

I campi touchMajor e touchMinor descrivono le dimensioni approssimative dell'area di contatto in unità di output (pixel).

I campi toolMajor e toolMinor descrivono le dimensioni approssimative dell'strumento stesso nelle unità di output (pixel).

Il campo size descrive le dimensioni normalizzate del tocco in relazione a il tocco più grande possibile che il dispositivo touch sia in grado di rilevare. La dimensione normalizzata minima è 0,0 (nessun contatto o misurazione impossibile) e la dimensione normalizzata massima è 1,0 (l'area del sensore è satura).

Quando è possibile misurare sia la lunghezza che la larghezza approssimative, il campo touchMajor specifica la dimensione più lunga e il campo touchMinor specifica la dimensione più corta dell'area di contatto. Quando è possibile misurare solo il diametro approssimativo dell'area di contatto, i campi touchMajor e touchMinor sono uguali.

Analogamente, il campo toolMajor specifica la dimensione più lunga e il campo toolMinor specifica la dimensione più corta dell'area della sezione trasversale dello strumento.

Se le dimensioni del tocco non sono disponibili, ma le dimensioni dello strumento sono disponibili, allora la dimensione dello strumento è impostato in modo uguale alle dimensioni del tocco. Al contrario, se la dimensione dello strumento non è disponibile, ma è disponibile la dimensione tocco, quest'ultima viene impostata in modo che corrisponda a quella dello strumento.

I dispositivi touch misurano o segnalano le dimensioni del tocco e degli strumenti in vari modi. L'implementazione attuale supporta tre diversi tipi di misurazioni: diametro, area e riquadro di delimitazione geometrico in unità di superficie.

Definizione: touch.size.calibration = none | geometric | diameter | area | default

Specifica il tipo di misurazione utilizzato dal driver tocco per segnalare le dimensioni del tocco e dello strumento.

Se il valore è none, la dimensione è impostata su zero.
Se il valore è geometric, si presume che la dimensione sia specificata nello stesso le unità di superficie come la posizione, in modo che venga ridimensionato nello stesso modo.
Se il valore è diameter, si presume che la dimensione sia proporzionale a il diametro (larghezza) del tocco o dello strumento.
Se il valore è area, si presume che la dimensione sia proporzionale al area del tocco o dello strumento.
Se il valore è default, il sistema utilizza la calibrazione geometric se il valore L'asse raw.touchMajor o raw.toolMajor è disponibile, altrimenti utilizza la calibrazione di none.

touch.size.scale

Definizione: touch.size.scale = <un numero a virgola mobile non negativo>

Specifica un fattore di scala costante utilizzato nella calibrazione.

Il valore predefinito è 1.0.

touch.size.bias

Definizione: touch.size.bias = <un numero a virgola mobile non negativo>

Specifica un valore di bias costante utilizzato nella calibrazione.

Il valore predefinito è 0.0.

touch.size.isSommato

Definizione: touch.size.isSummed = 0 | 1

Specifica se la dimensione viene riportata come somma delle dimensioni di tutti contatti attivi oppure viene riportato singolarmente per ciascun contatto.

Se il valore è 1, le dimensioni registrate vengono divise per il numero di contatti prima dell'utilizzo.
Se il valore è 0, le dimensioni registrate vengono utilizzate così come sono.

Il valore predefinito è 0.

Alcuni dispositivi touch, in particolare i dispositivi "Semi-MT", non sono in grado di distinguere le singole dimensioni di più contatti, pertanto registrano una misurazione delle dimensioni che rappresenta la loro area o larghezza totale. Questa proprietà deve essere impostata su 1 solo per questi dispositivi. In caso di dubbi, imposta questo valore su 0.

Calcolo

Il calcolo dei campi touchMajor, touchMinor, toolMajor, toolMinor, e size dipende dai parametri di calibrazione specificati.

If raw.touchMajor and raw.toolMajor are available:
    touchMajor = raw.touchMajor
    touchMinor = raw.touchMinor
    toolMajor = raw.toolMajor
    toolMinor = raw.toolMinor
Else If raw.touchMajor is available:
    toolMajor = touchMajor = raw.touchMajor
    toolMinor = touchMinor = raw.touchMinor
Else If raw.toolMajor is available:
    touchMajor = toolMajor = raw.toolMajor
    touchMinor = toolMinor = raw.toolMinor
Else
    touchMajor = toolMajor = 0
    touchMinor = toolMinor = 0
    size = 0
End If

size = avg(touchMajor, touchMinor)

If touch.size.isSummed == 1:
    touchMajor = touchMajor / numberOfActiveContacts
    touchMinor = touchMinor / numberOfActiveContacts
    toolMajor = toolMajor / numberOfActiveContacts
    toolMinor = toolMinor / numberOfActiveContacts
    size = size / numberOfActiveContacts
End If

If touch.size.calibration == "none":
    touchMajor = toolMajor = 0
    touchMinor = toolMinor = 0
    size = 0
Else If touch.size.calibration == "geometric":
    outputScale = average(output.width / raw.width, output.height / raw.height)
    touchMajor = touchMajor * outputScale
    touchMinor = touchMinor * outputScale
    toolMajor = toolMajor * outputScale
    toolMinor = toolMinor * outputScale
Else If touch.size.calibration == "area":
    touchMajor = sqrt(touchMajor)
    touchMinor = touchMajor
    toolMajor = sqrt(toolMajor)
    toolMinor = toolMajor
Else If touch.size.calibration == "diameter":
    touchMinor = touchMajor
    toolMinor = toolMajor
End If

If touchMajor != 0:
    output.touchMajor = touchMajor * touch.size.scale + touch.size.bias
Else
    output.touchMajor = 0
End If

If touchMinor != 0:
    output.touchMinor = touchMinor * touch.size.scale + touch.size.bias
Else
    output.touchMinor = 0
End If

If toolMajor != 0:
    output.toolMajor = toolMajor * touch.size.scale + touch.size.bias
Else
    output.toolMajor = 0
End If

If toolMinor != 0:
    output.toolMinor = toolMinor * touch.size.scale + touch.size.bias
Else
    output.toolMinor = 0
End If

output.size = size

campo di pressione

Il campo pressure descrive la pressione fisica approssimativa applicata al dispositivo touch come valore normalizzato compreso tra 0,0 (nessun tocco) e 1,0 (pressione normale).

Una pressione pari a zero indica che lo strumento è in stato di attesa.

touch.pressure.calibration

Definizione: touch.pressure.calibration = none | physical | amplitude | default

Specifica il tipo di misurazione utilizzato dal conducente touch per registrare la pressione.

Se il valore è none, la pressione è sconosciuta, quindi viene impostata su 1,0 quando si tocca e su 0,0 quando si passa il mouse sopra.
Se il valore è physical, si presume che l'asse di pressione misuri l'intensità fisica effettiva della pressione applicata al touchpad.
Se il valore è amplitude, si presume che l'asse di pressione misuri l'ampiezza del segnale, correlata alle dimensioni del contatto e alla pressione applicata.
Se il valore è default, il sistema utilizza la calibrazione physical se l'asse di pressione è disponibile, altrimenti utilizza none.

tocca.pressione.scala

Definizione: touch.pressure.scale = <un numero a virgola mobile non negativo>

Specifica un fattore di scala costante utilizzato nella calibrazione.

Il valore predefinito è 1.0 / raw.pressure.max.

Calcolo

Il calcolo del campo pressure dipende dai parametri di calibrazione specificati.

If touch.pressure.calibration == "physical" or "amplitude":
    output.pressure = raw.pressure * touch.pressure.scale
Else
    If hovering:
        output.pressure = 0
    Else
        output.pressure = 1
    End If
End If

campi di orientamento e inclinazione

Il campo orientation descrive l'orientamento del tocco e dello strumento come misura angolare. L'orientamento 0 indica che l'asse principale è orientato verticalmente, -PI/2 indica che l'asse principale è orientato a sinistra, PI/2 indica che l'asse principale è orientato a destra. Quando uno stilo strumento è presente, l'intervallo di orientamento può essere descritto come da -PI o PI.

Il campo tilt descrive l'inclinazione dello strumento come misurazione angolare. Un'inclinazione di 0 indica che lo strumento è perpendicolare alla superficie. Un'inclinazione di PI/2 indica che lo strumento è a contatto con la superficie.

touch.orientation.calibration

Definizione: touch.orientation.calibration = none | interpolated | vector | default

Specifica il tipo di misurazione usato dal driver touch per segnalare l'orientamento.

Se il valore è none, l'orientamento è sconosciuto, quindi viene impostato su 0.
Se il valore è interpolated, l'orientamento viene interpolato linearmente in modo che un valore non elaborato di raw.orientation.min venga mappato a -PI/2 e un valore non elaborato di raw.orientation.max venga mappato a PI/2. Il valore centrale di (raw.orientation.min + raw.orientation.max) / 2 mappa a 0.
Se il valore è vector, l'orientamento viene interpretato come un vettore pacchettizzato costituito da due campi a 4 bit con segno. Questa rappresentazione viene utilizzata nel protocollo Atmel basato su oggetti parti. Quando decodificato, il vettore fornisce un angolo di orientamento e una confidenza magnitudo. La grandezza di confidenza viene utilizzata per scalare le informazioni sulle dimensioni, a meno che non sia geometrica.
Se il valore è default, il sistema utilizza la calibrazione interpolated se l'asse di orientamento è disponibile, altrimenti utilizza none.

Calcolo

Il calcolo dei campi orientation e tilt dipende dai parametri di calibrazione specificati e dagli input disponibili.

If touch.tiltX and touch.tiltY are available:
    tiltXCenter = average(raw.tiltX.min, raw.tiltX.max)
    tiltYCenter = average(raw.tiltY.min, raw.tiltY.max)
    tiltXAngle = (raw.tiltX - tiltXCenter) * PI / 180
    tiltYAngle = (raw.tiltY - tiltYCenter) * PI / 180
    output.orientation = atan2(-sin(tiltXAngle), sinf(tiltYAngle))
    output.tilt = acos(cos(tiltXAngle) * cos(tiltYAngle))
Else If touch.orientation.calibration == "interpolated":
    center = average(raw.orientation.min, raw.orientation.max)
    output.orientation = PI / (raw.orientation.max - raw.orientation.min)
    output.tilt = 0
Else If touch.orientation.calibration == "vector":
    c1 = (raw.orientation & 0xF0) >> 4
    c2 = raw.orientation & 0x0F

    If c1 != 0 or c2 != 0:
        If c1 >= 8 Then c1 = c1 - 16
        If c2 >= 8 Then c2 = c2 - 16
        angle = atan2(c1, c2) / 2
        confidence = sqrt(c1*c1 + c2*c2)

        output.orientation = angle

        If touch.size.calibration == "diameter" or "area":
            scale = 1.0 + confidence / 16
            output.touchMajor *= scale
            output.touchMinor /= scale
            output.toolMajor *= scale
            output.toolMinor /= scale
        End If
    Else
        output.orientation = 0
    End If
    output.tilt = 0
Else
    output.orientation = 0
    output.tilt = 0
End If

If orientation aware:
    If screen rotation is 90 degrees:
        output.orientation = output.orientation - PI / 2
    Else If screen rotation is 270 degrees:
        output.orientation = output.orientation + PI / 2
    End If
End If

campo distanza

Il campo distance descrive la distanza tra lo strumento e la superficie del dispositivo touch. Un valore pari a 0,0 indica il contatto diretto, mentre valori più elevati indicano una distanza crescente dalla superficie.

touch.distance.calibration

Definizione: touch.distance.calibration = none | scaled | default

Specifica il tipo di misurazione utilizzata dal driver tocco per segnalare la distanza.

Se il valore è none, la distanza è sconosciuta, quindi viene impostata su 0.
Se il valore è scaled, la distanza registrata viene moltiplicata per fattore di scala costante.
Se il valore è default, il sistema utilizza la calibrazione scaled se il valore asse di distanza disponibile, altrimenti utilizza none.

touch.distance.scale

Definizione: touch.distance.scale = <un numero a virgola mobile non negativo>

Specifica un fattore di scala costante utilizzato nella calibrazione.

Il valore predefinito è 1.0.

Calcolo

Il calcolo del campo distance dipende dai parametri di calibrazione specificati.

If touch.distance.calibration == "scaled":
    output.distance = raw.distance * touch.distance.scale
Else
    output.distance = 0
End If

Esempio

# Input device configuration file for a touch screen that supports pressure,
# size and orientation. The pressure and size scale factors were obtained
# by measuring the characteristics of the device itself and deriving
# useful approximations based on the resolution of the touch sensor and the
# display.
#
# Note that these parameters are specific to a particular device model.
# Different parameters need to be used for other devices.

# Basic Parameters
touch.deviceType = touchScreen
touch.orientationAware = 1

# Size
# Based on empirical measurements, we estimate the size of the contact
# using size = sqrt(area) * 28 + 0.
touch.size.calibration = area
touch.size.scale = 28
touch.size.bias = 0
touch.size.isSummed = 0

# Pressure
# Driver reports signal strength as pressure.
#
# A normal index finger touch typically registers about 80 signal strength
# units although we don't expect these values to be accurate.
touch.pressure.calibration = amplitude
touch.pressure.scale = 0.0125

# Orientation
touch.orientation.calibration = vector

Note sulla compatibilità

Le proprietà di configurazione dei dispositivi touch sono cambiate in modo significativo nel Android Ice Cream Sandwich 4.0. Tutti i file di configurazione dei dispositivi di input per i dispositivi touch devono essere aggiornati per utilizzare le nuove proprietà di configurazione.

Anche i driver più vecchi dei dispositivi touch potrebbero dover aggiornato.

File di mappe delle chiavi virtuali

I dispositivi touch possono essere utilizzati per implementare i tasti virtuali.

Esistono diversi modi per farlo, a seconda delle funzionalità del controller touch. Alcuni controller touch possono essere configurati direttamente per implementare i tasti virtuali impostando i registri del firmware. Altre volte è preferibile eseguire la mappatura dalle coordinate del tocco ai codici chiave nel software.

Se nel software vengono implementate chiavi virtuali, il kernel deve esportare una mappa delle chiavi virtuali denominato virtualkeys.<devicename> come proprietà board. Ad esempio, se i driver del dispositivo touchscreen riportano il nome "touchyfeely", il file della mappa dei tasti virtuali deve avere il percorso/sys/board_properties/virtualkeys.touchyfeely.

Un file di mappe delle chiavi virtuali descrive le coordinate e i codici chiave Linux delle chiavi virtuali. sul touchscreen.

Oltre al file della mappa delle chiavi virtuali, deve esistere un layout delle chiavi corrispondente e un file di mappe dei caratteri delle chiavi per mappare i codici chiave Linux ai codici chiave Android e per specificare il tipo di tastiera (di solito SPECIAL_FUNCTION).

Sintassi

Un file di mappa delle chiavi virtuali è un file di testo normale costituito da una sequenza di chiavi virtuali le descrizioni dei layout separate da ritorni a capo o da due punti.

Le righe dei commenti iniziano con "#" e prosegui fino alla fine della riga.

Ogni chiave virtuale è descritta da sei componenti delimitati da due punti:

0x01: un codice di versione. Deve essere sempre 0x01.
<Linux key code>: il codice chiave Linux della chiave virtuale.
<centerX>: la coordinata dei pixel X del centro della chiave virtuale.
<centerY>: la coordinata dei pixel Y del centro della chiave virtuale.
<width>: la larghezza della chiave virtuale in pixel.
<height>: l'altezza del tasto virtuale in pixel.

Tutte le coordinate e le dimensioni sono specificate in termini del sistema di coordinate del display.

Ecco un file di mappa delle chiavi virtuali scritto su una sola riga.

# All on one line
0x01:158:55:835:90:55:0x01:139:172:835:125:55:0x01:102:298:835:115:55:0x01:217:412:835:95:55

Lo stesso file di mappatura delle chiavi virtuali può essere scritto anche su più righe.

# One key per line
0x01:158:55:835:90:55
0x01:139:172:835:125:55
0x01:102:298:835:115:55
0x01:217:412:835:95:55

Nell'esempio precedente, il touchscreen ha una risoluzione di 480x800. Di conseguenza, tutti i tasti virtuali hanno una coordinata <centerY> pari a 835, che è leggermente al di sotto dell'area visibile del touchscreen.

La prima chiave ha un codice di scansione Linux di 158 (KEY_BACK), centerX di 55, centerY di 835, larghezza di 90 e altezza di 55.

Esempio

File di mappa delle chiavi virtuali: /sys/board_properties/virtualkeys.touchyfeely.

0x01:158:55:835:90:55
0x01:139:172:835:125:55
0x01:102:298:835:115:55
0x01:217:412:835:95:55

File di layout della chiave: /system/usr/keylayout/touchyfeely.kl.

key 158 BACK
key 139 MENU
key 172 HOME
key 217 SEARCH

File della mappa dei caratteri chiave: /system/usr/keychars/touchyfeely.kcm.

type SPECIAL_FUNCTION

Gesti del cursore multi-touch indiretti

In modalità cursore, il sistema interpreta i seguenti gesti:

Tocca con un dito: fai clic.
Movimento di un dito: sposta il cursore.
Movimento di un dito più pressioni di pulsanti: trascina il puntatore.
Movimento di due dita con entrambe le dita che si spostano nella stessa direzione: trascina l'area sotto il puntatore in quella direzione. Il cursore stesso non si sposta.
Movimento di due dita che si avvicinano o si allontanano in direzioni diverse: scorri/modifica la scala/ruota l'area intorno al cursore. Il cursore stesso non si sposta.
Movimento di più dita: gesto in formato libero.

Rifiuto della palma

A partire da Android 13, il sistema può rifiutare automaticamente gli input dai palmi delle mani se è abilitato il framework integrato. Le soluzioni interne personalizzate sono ancora supportate, anche se potrebbero dover essere modificate per restituire il flag TOOL_TYPE_PALM quando viene rilevato un palmo. Il framework integrato funziona anche in combinazione con soluzioni personalizzate.

Il modello effettivo esamina i primi 90 ms di dati sui gesti, il cursore corrente e i cursori circostanti, quindi prende in considerazione la distanza dei tocchi dal bordo del display. Determina quindi, in base ai puntatori, quali sono i palmi delle mani. Inoltre, vengono prese in considerazione le dimensioni di ciascun contatto, come indicato da touchMajor e touchMinor. Il framework Android rimuove quindi gli indicatori contrassegnati come palme dallo stream di tocco.

Se un puntatore è già stato inviato alle app, il sistema:

(Se sono presenti altri cursori attivi) Annulla il cursore con ACTION_POINTER_UP e FLAG_CANCELED impostati.
(Se è l'unico cursore) Annullalo con ACTION_CANCEL.

Un'API pubblica, MotionEvent.FLAG_CANCELED, indica che l'attuale non deve attivare un'azione dell'utente. Questo flag è impostato sia per ACTION_CANCEL sia per ACTION_POINTER_UP.

Se il cursore con il palmo non è stato inviato alle app, il sistema lo ignora semplicemente.

Attiva il rifiuto della palma

Nel driver touch, utilizza Macro input_abs_set_res per impostare le risoluzioni per i seguenti campi (le unità sono pixel per mm):
- ABS_MT_POSITION_X
- ABS_MT_POSITION_Y
- ABS_MT_TOUCH_MAJOR
- ABS_MT_TOUCH_MINOR
Il supporto per ABS_MT_TOUCH_MINOR è facoltativo. Tuttavia, se il tuo dispositivo che la supportano, assicurati che la risoluzione sia impostata correttamente.
Per verificare che i campi siano impostati correttamente, esegui:
```
    $ adb shell getevent -li
```

Per abilitare la funzionalità durante il runtime, esegui:

    $ adb shell device_config put input_native_boot palm_rejection_enabled 1

Riavvia il processo system_server.

     $ adb shell stop && adb shell start

Conferma che adb shell dumpsys input mostri la presenza di respintori del palmo della mano all'interno UnwantedInteractionBlocker. In caso contrario, controlla i log relativi all'input per trovare tracce su ciò che potrebbe essere configurato in modo errato.

Vedi l'esempio seguente come riferimento:

UnwantedInteractionBlocker:
  mEnablePalmRejection: true
  isPalmRejectionEnabled (flag value): true
  mPalmRejectors:
    deviceId = 3:
      mDeviceInfo:
        max_x = 
        max_y = 
        x_res = 11.00
        y_res = 11.00
        major_radius_res = 1.00
        minor_radius_res = 1.00
        minor_radius_supported = true
        touch_major_res = 1
        touch_minor_res = 1
      mSlotState:
        mSlotsByPointerId:

        mPointerIdsBySlot:

      mSuppressedPointerIds: {}

Per attivare definitivamente la funzionalità, aggiungi il comando sysprop corrispondente nel file init**rc:
```
setprop persist.device_config.input_native_boot.palm_rejection_enabled 1
```

Continua a leggere

Protocollo multi-touch Linux

Dispositivi touch Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Classificazione dei dispositivi touch

Pulsanti

Strumenti e tipi di strumenti

Strumenti passandoci sopra al tocco

Requisiti del driver del dispositivo touch

Operazione con dispositivo touch

Configurazione dispositivo touch

Proprietà

Convenzioni sulla documentazione

Valori asse non elaborati

Intervalli dell'asse non elaborati

Intervalli di output

Configurazione di base

touch.deviceType

touch.orientationAware

touch.gestureMode

Campi X e Y

Calcolo

touchMajor, touchMinor, toolMajor, toolMinor, dimensione dei campi

touch.size.scale

touch.size.bias

touch.size.isSommato

Calcolo

campo di pressione

touch.pressure.calibration

tocca.pressione.scala

Calcolo

campi di orientamento e inclinazione

touch.orientation.calibration

Calcolo

campo distanza

touch.distance.calibration

touch.distance.scale

Calcolo

Esempio

Note sulla compatibilità

File di mappe delle chiavi virtuali

Sintassi

Esempio

Gesti del cursore multi-touch indiretti

Rifiuto della palma

Attiva il rifiuto della palma

Continua a leggere

Dispositivi touch
Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.