Le app che utilizzano le visualizzazioni standard funzionano con il framework di compilazione automatica senza richiedere una configurazione speciale. Puoi anche ottimizzare il funzionamento dell'app con il framework.
Configurare l'ambiente di compilazione automatica
Questa sezione descrive come configurare la funzionalità di compilazione automatica di base per la tua app.
Configurare un servizio di compilazione automatica
Per consentire all'app di utilizzare il framework di compilazione automatica, è necessario configurare un servizio di compilazione automatica sul dispositivo. Sebbene la maggior parte degli smartphone e dei tablet con Android 8.0 (livello API 26) e versioni successive sia dotata di un servizio di compilazione automatica, ti consigliamo di utilizzare un servizio di test durante il test dell'app, ad esempio il servizio di compilazione automatica nell'esempio di framework di compilazione automatica Android. Quando utilizzi un emulatore, imposta esplicitamente un servizio di compilazione automatica, perché l'emulatore potrebbe non includere un servizio predefinito.
Dopo aver installato il servizio di compilazione automatica di prova dall'app di esempio, attivalo da Impostazioni > Sistema > Lingue e immissione > Avanzate > Assistenza alla digitazione > Servizio di compilazione automatica.
Per saperne di più sulla configurazione di un emulatore per testare la compilazione automatica, consulta Testare l'app con la compilazione automatica.
Fornire suggerimenti per la compilazione automatica
Il servizio di compilazione automatica determina il tipo di ogni visualizzazione utilizzando leeuristiche. Tuttavia, se l'app si basa su queste euristiche, il comportamento di compilazione automatica potrebbe cambiare inaspettatamente mentre aggiorni l'app. Per assicurarti che il servizio di compilazione automatica identifichi correttamente i fattori di forma della tua app, fornisci suggerimenti per la compilazione automatica.
Puoi impostare i suggerimenti di compilazione automatica utilizzando l'attributo
android:autofillHints
. L'esempio seguente imposta un suggerimento "password"
su un
EditText
:
<EditText android:layout_width="match_parent" android:layout_height="wrap_content" android:autofillHints="password" />
Puoi anche impostare i suggerimenti in modo programmatico utilizzando il metodo setAutofillHints()
, come mostrato nell'esempio seguente:
Kotlin
val password = findViewById<EditText>(R.id.password) password.setAutofillHints(View.AUTOFILL_HINT_PASSWORD)
Java
EditText password = findViewById(R.id.password); password.setAutofillHints(View.AUTOFILL_HINT_PASSWORD);
Includi costanti di suggerimento predefinite
Il framework di compilazione automatica non convalida i suggerimenti, che vengono trasmessi al servizio di compilazione automatica senza modifiche o convalida. Sebbene tu possa utilizzare qualsiasi valore, le classi View
e AndroidX HintConstants
contengono elenchi di costanti di suggerimento supportate ufficialmente.
Utilizzando una combinazione di queste costanti, puoi creare layout per scenari di compilazione automatica comuni:
Credenziali dell'account
In un modulo di accesso, puoi includere suggerimenti per le credenziali dell'account, ad esempio
AUTOFILL_HINT_USERNAME
e
AUTOFILL_HINT_PASSWORD
.
Per creare un nuovo account o quando gli utenti cambiano il nome utente e la password, puoi utilizzare AUTOFILL_HINT_NEW_USERNAME
e AUTOFILL_HINT_NEW_PASSWORD
.
Informazioni sulla carta di credito
Quando richiedi i dati della carta di credito, puoi utilizzare suggerimenti come
AUTOFILL_HINT_CREDIT_CARD_NUMBER
e
AUTOFILL_HINT_CREDIT_CARD_SECURITY_CODE
.
Per le date di scadenza della carta di credito, esegui una delle seguenti operazioni:
- Se utilizzi una sola visualizzazione per la data di scadenza, usa
AUTOFILL_HINT_CREDIT_CARD_EXPIRATION_DATE
. - Se utilizzi una visualizzazione diversa per ogni parte della data di scadenza, puoi utilizzare
AUTOFILL_HINT_CREDIT_CARD_EXPIRATION_DAY
,AUTOFILL_HINT_CREDIT_CARD_EXPIRATION_MONTH
, eAUTOFILL_HINT_CREDIT_CARD_EXPIRATION_YEAR
per ogni rispettiva visualizzazione.
Indirizzo fisico
Per i campi del modulo per l'indirizzo fisico, puoi utilizzare suggerimenti come:
- Per un indirizzo in una singola visualizzazione, utilizza
AUTOFILL_HINT_POSTAL_ADDRESS
. - Quando utilizzi visualizzazioni separate per parti diverse di un indirizzo, puoi utilizzare quanto segue:
Nomi di persone
Quando chiedi i nomi delle persone, puoi utilizzare suggerimenti come i seguenti:
- Per compilare automaticamente il nome completo di una persona in una singola visualizzazione, usa
AUTOFILL_HINT_PERSON_NAME
. - Se utilizzi viste separate per parti diverse di un nome, puoi utilizzare una delle seguenti opzioni:
Numeri di telefono.
Per i numeri di telefono, puoi utilizzare quanto segue:
- Quando richiedi un numero di telefono completo in una singola visualizzazione, utilizza
AUTOFILL_HINT_PHONE_NUMBER
. - Se utilizzi visualizzazioni separate per parti diverse di un numero di telefono, puoi utilizzare una delle seguenti opzioni:
Password unica (OTP)
Per una password monouso in una singola visualizzazione, puoi utilizzare
AUTOFILL_HINT_SMS_OTP
.
Per più visualizzazioni in cui ogni visualizzazione corrisponde a una singola cifra dell'OTP,
puoi utilizzare il metodo
generateSmsOtpHintForCharacterPosition()
per generare suggerimenti per carattere.
Contrassegnare i campi come importanti per la compilazione automatica
Puoi includere i singoli campi dell'app in una struttura di visualizzazione
per la compilazione automatica. Per impostazione predefinita, le visualizzazioni utilizzano la modalità IMPORTANT_FOR_AUTOFILL_AUTO
, che consente ad Android di utilizzare le sue strategie di euristica per determinare se una visualizzazione è importante per la compilazione automatica.
Tuttavia, in alcuni casi una visualizzazione, una struttura di visualizzazione o l'intera attività non è importante per la compilazione automatica:
- Un campo
CAPTCHA
in un'attività di accesso - Una visualizzazione in cui l'utente crea contenuti, ad esempio un editor di testo o di fogli di lavoro
- Le visualizzazioni in alcune attività all'interno dei giochi, ad esempio quelle che mostrano il gameplay
Puoi impostare l'importanza di una vista per la compilazione automatica utilizzando l'attributo android:importantForAutofill
:
<TextView android:layout_width="match_parent" android:layout_height="wrap_content" android:importantForAutofill="no" />
Il valore di importantForAutofill
può essere uno dei seguenti:
auto
- Consenti al sistema Android di utilizzare le sue regole di euristica per determinare se la visualizzazione è importante per la compilazione automatica.
no
- Questa visualizzazione non è importante per la compilazione automatica.
noExcludeDescendants
- Questa visualizzazione e le relative visualizzazioni secondarie non sono importanti per la compilazione automatica.
yes
- Questa visualizzazione è importante per la compilazione automatica.
yesExcludeDescendants
- Questa visualizzazione è importante per la compilazione automatica, ma i suoi elementi secondari non lo sono.
Puoi anche utilizzare il metodo setImportantForAutofill()
:
Kotlin
val captcha = findViewById<TextView>(R.id.captcha) captcha.setImportantForAutofill(View.IMPORTANT_FOR_AUTOFILL_NO)
Java
TextView captcha = findViewById(R.id.captcha); captcha.setImportantForAutofill(View.IMPORTANT_FOR_AUTOFILL_NO);
Puoi dichiarare i casi d'uso di esempio precedenti non importanti per la compilazione automatica come segue:
- Un campo
CAPTCHA
in un'attività di accesso: utilizzaandroid:importantForAutofill="no"
oIMPORTANT_FOR_AUTOFILL_NO
per contrassegnare questa visualizzazione come non importante. - Una visualizzazione in cui l'utente crea contenuti: utilizza
android:importantForAutofill="noExcludeDescendants"
oIMPORTANT_FOR_AUTOFILL_NO_EXCLUDE_DESCENDANTS
per contrassegnare l'intera struttura della visualizzazione come non importante. - Le visualizzazioni in alcune attività all'interno dei giochi: utilizza
android:importantForAutofill="noExcludeDescendants"
oIMPORTANT_FOR_AUTOFILL_NO_EXCLUDE_DESCENDANTS
per contrassegnare l'intera struttura della visualizzazione come non importante.
Associare i dati del sito web e dell'app mobile
I servizi di compilazione automatica, come Compilazione automatica Google, possono condividere i dati di accesso degli utenti tra browser e dispositivi Android dopo che l'app e un sito web sono stati associati. Quando un utente sceglie lo stesso servizio di compilazione automatica su entrambe le piattaforme, l'accesso alla tua app web rende le sue credenziali di accesso disponibili per la compilazione automatica quando accede alla tua app per Android corrispondente.
Per associare la tua app Android al tuo sito web, ospita un Digital Asset Link con la relazione delegate_permission/common.get_login_creds
nel tuo sito. Poi,
dichiara l'associazione nel file AndroidManifest.xml
dell'app. Per istruzioni
dettagliate su come associare il tuo sito web alla tua app per Android, consulta
Attivare l'accesso automatico in app e
siti web.
Completare un flusso di lavoro di compilazione automatica
Questa sezione descrive scenari specifici in cui puoi adottare misure per migliorare la funzionalità di compilazione automatica per gli utenti della tua app.
Determinare se la compilazione automatica è attivata
Gli utenti possono attivare o disattivare la compilazione automatica, nonché cambiare il servizio di compilazione automatica, andando a Impostazioni > Sistema > Lingue e immissione > Avanzate > Assistenza immissione > Servizio di compilazione automatica. La tua app non può sostituire le impostazioni di compilazione automatica dell'utente, ma puoi implementare funzionalità di compilazione automatica aggiuntive nella tua app o in determinate visualizzazioni della tua app, se la compilazione automatica è disponibile per l'utente.
Ad esempio,
TextView
mostra una voce di compilazione automatica nel
menu overflow se la compilazione automatica è attivata per l'utente. Per verificare se la compilazione automatica è attivata per l'utente, chiama il metodo isEnabled()
dell'oggetto AutofillManager
.
Per assicurarti che l'esperienza di registrazione e accesso sia ottimizzata per gli utenti senza compilazione automatica, implementa la registrazione One Tap.
Forzare una richiesta di compilazione automatica
A volte è necessario forzare l'esecuzione di una richiesta di compilazione automatica in risposta a un'azione dell'utente. Ad esempio, TextView
offre una voce di menu di compilazione automatica
quando l'utente esegue il tocco e la pressione sulla visualizzazione.
Il seguente esempio di codice mostra come forzare una richiesta di compilazione automatica:
Kotlin
fun eventHandler(view: View) { val afm = requireContext().getSystemService(AutofillManager::class.java) afm?.requestAutofill(view) }
Java
public void eventHandler(View view) { AutofillManager afm = context.getSystemService(AutofillManager.class); if (afm != null) { afm.requestAutofill(view); } }
Puoi anche utilizzare il metodo cancel()
per annullare il contesto di compilazione automatica corrente. Questa opzione può essere utile se hai un pulsante che cancella i campi in una pagina di accesso.
Utilizza il tipo di compilazione automatica corretto per i dati nei controlli del selettore
I selettori possono essere utili con la compilazione automatica perché forniscono un'interfaccia utente che consente agli utenti di cambiare il valore di un campo che memorizza dati di data o ora. Ad esempio, in un
modulo per le carte di credito, un selettore della data consente agli utenti di inserire o modificare la data di scadenza
della carta di credito. Tuttavia, devi utilizzare un'altra vista, ad esempio EditText
, per mostrare i dati quando il selettore non è visibile.
Un oggetto EditText
prevede in modo nativo i dati di compilazione automatica di tipo
AUTOFILL_TYPE_TEXT
.
Se utilizzi un tipo di dati diverso, crea una visualizzazione personalizzata che eredita da EditText
e implementa i metodi necessari per gestire il tipo di dati corrispondente. Ad esempio, se hai un campo della data, implementa i metodi con una logica che gestisca correttamente i valori di tipo AUTOFILL_TYPE_DATE
.
Quando specifichi il tipo di dati di compilazione automatica, il servizio di compilazione automatica può creare una rappresentazione appropriata dei dati visualizzati nella visualizzazione. Per ulteriori informazioni, consulta Utilizzare i selettori con la compilazione automatica.
Completare il contesto della compilazione automatica
Il framework di compilazione automatica salva l'input dell'utente per un uso futuro mostrando una finestra di dialogo "Salva per la compilazione automatica?" al termine del contesto di compilazione automatica. In genere, il contesto di compilazione automatica termina al termine di un'attività. Tuttavia, in alcune situazioni è necessario informare esplicitamente il framework, ad esempio se utilizzi la stessa attività, ma frammenti diversi sia per la schermata di accesso sia per quella dei contenuti. In questi casi, puoi terminare esplicitamente il
contesto chiamando AutofillManager.commit()
.
Supporto per le visualizzazioni personalizzate
Le visualizzazioni personalizzate possono specificare i metadati esposti al framework di compilazione automatica utilizzando l'API di compilazione automatica. Alcune viste fungono da contenitore di elementi secondari virtuali, ad esempio quelle che contengono UI con rendering OpenGL. Queste visualizzazioni devono utilizzare l'API per specificare la struttura delle informazioni utilizzate nell'app prima di poter funzionare con il framework di compilazione automatica.
Se la tua app utilizza viste personalizzate, prendi in considerazione i seguenti scenari:
- La visualizzazione personalizzata fornisce una struttura di visualizzazione standard o una struttura di visualizzazione predefinita.
- La visualizzazione personalizzata ha una struttura virtuale o una struttura di vista che non è disponibile per il framework di compilazione automatica.
Visualizzazioni personalizzate con struttura della visualizzazione standard
Le visualizzazioni personalizzate possono definire i metadati necessari per il funzionamento della compilazione automatica. Assicurati che la visualizzazione personalizzata gestisca i metadati in modo appropriato per funzionare con il framework di compilazione automatica. La visualizzazione personalizzata deve eseguire le seguenti azioni:
- Gestisci il valore di compilazione automatica inviato dal framework alla tua app.
- Fornisci il tipo e il valore di compilazione automatica al framework.
Quando viene attivata la compilazione automatica, il framework di compilazione automatica chiama
autofill()
sulla tua vista e invia il valore che
la visualizzazione deve utilizzare. Implementa autofill()
per specificare in che modo la visualizzazione personalizzata gestisce il valore di compilazione automatica.
La vista deve specificare un tipo e un valore di compilazione automatica sostituendo rispettivamente i metodi
getAutofillType()
e
getAutofillValue()
.
Infine, la compilazione automatica non deve compilare la visualizzazione se l'utente non può fornire un valore per la visualizzazione nel suo stato corrente, ad esempio se la visualizzazione è disattivata.
In questi casi, getAutofillType()
deve restituire
AUTOFILL_TYPE_NONE
,
getAutofillValue()
deve restituire null
e autofill()
non deve fare nulla.
I seguenti casi richiedono passaggi aggiuntivi per funzionare correttamente all'interno del framework:
- La visualizzazione personalizzata è modificabile.
- La visualizzazione personalizzata contiene dati sensibili.
La visualizzazione personalizzata è modificabile
Se la visualizzazione è modificabile, comunica le modifiche al framework di compilazione automatica chiamando notifyValueChanged()
sull'oggetto AutofillManager
.
La visualizzazione personalizzata contiene dati sensibili
Se una visualizzazione contiene informazioni che consentono l'identificazione personale (PII), come indirizzi email, numeri di carte di credito e password, deve essere contrassegnata come sensibile.
In genere, le visualizzazioni i cui contenuti provengono da risorse statiche non contengono dati sensibili, mentre le visualizzazioni i cui contenuti sono impostati in modo dinamico potrebbero contenere dati sensibili. Ad esempio, un'etichetta che contiene inserisci il tuo nome utente non contiene dati sensibili, mentre un'etichetta che contiene Hello, John sì.
Il framework di compilazione automatica presuppone che tutti i dati siano sensibili per impostazione predefinita. Puoi contrassegnare i dati che non sono sensibili.
Per contrassegnare se una vista contiene dati sensibili, implementa onProvideAutofillStructure()
e chiama setDataIsSensitive()
sull'oggetto ViewStructure
.
Il seguente esempio di codice mostra come contrassegnare i dati nella struttura della visualizzazione come non sensibili:
Kotlin
override fun onProvideAutofillStructure(structure: ViewStructure, flags: Int) { super.onProvideAutofillStructure(structure, flags) structure.setDataIsSensitive(false) }
Java
@Override public void onProvideAutofillStructure(ViewStructure structure, int flags) { super.onProvideAutofillStructure(structure, flags); structure.setDataIsSensitive(false); }
Se una visualizzazione accetta solo valori predefiniti, puoi utilizzare il metodo
setAutofillOptions()
per impostare le opzioni che possono essere utilizzate per compilare automaticamente la visualizzazione. In particolare,
le viste il cui tipo di compilazione automatica è
AUTOFILL_TYPE_LIST
devono utilizzare
questo metodo, perché il servizio di compilazione automatica può svolgere un lavoro migliore se conosce
le opzioni disponibili per riempire la visualizzazione.
Anche le viste che utilizzano un adattatore, ad esempio Spinner
, Ad esempio, una rotellina che fornisce anni creati dinamicamente, in base all'anno corrente, da utilizzare nei campi di scadenza della carta di credito può implementare il metodo getAutofillOptions()
dell'interfaccia Adapter
per fornire un elenco di anni.
Le visualizzazioni che utilizzano un ArrayAdapter
possono anche fornire elenchi di valori. ArrayAdapter
imposta automaticamente le opzioni di compilazione automatica per le risorse statiche.
Se fornisci i valori in modo dinamico, sostituisci getAutofillOptions()
.
Visualizzazioni personalizzate con struttura virtuale
Il framework di compilazione automatica richiede una struttura di visualizzazione prima di poter modificare e salvare le informazioni nell'interfaccia utente dell'app. La struttura della visualizzazione non è disponibile per il framework nelle seguenti situazioni:
- L'app utilizza un motore di rendering di basso livello, come OpenGL, per eseguire il rendering dell'interfaccia utente.
- L'app utilizza un'istanza di
Canvas
per disegnare l'interfaccia utente.
In questi casi, puoi specificare una struttura della visualizzazione implementando
onProvideAutofillVirtualStructure()
e seguendo questi passaggi:
- Aumenta il conteggio dei componenti secondari della struttura della visualizzazione chiamando
addChildCount()
. - Aggiungi un bambino chiamando
newChild()
. - Imposta l'ID compilazione automatica per l'account secondario chiamando
setAutofillId()
. - Imposta le proprietà pertinenti, ad esempio il valore e il tipo di compilazione automatica.
- Se i dati nell'account secondario virtuale sono sensibili, passa
true
asetDataIsSensitive()
; in caso contrario, passafalse
.
Il seguente snippet di codice mostra come creare un nuovo elemento secondario nella struttura virtuale:
Kotlin
override fun onProvideAutofillVirtualStructure(structure: ViewStructure, flags: Int) { super.onProvideAutofillVirtualStructure(structure, flags) // Create a new child in the virtual structure. structure.addChildCount(1) val child = structure.newChild(childIndex) // Set the autofill ID for the child. child.setAutofillId(structure.autofillId!!, childVirtualId) // Populate the child by providing properties such as value and type. child.setAutofillValue(childAutofillValue) child.setAutofillType(childAutofillType) // Some children can provide a list of values, such as when the child is // a spinner. val childAutofillOptions = arrayOf<CharSequence>("option1", "option2") child.setAutofillOptions(childAutofillOptions) // Just like other types of views, mark the data as sensitive when // appropriate. val sensitive = !contentIsSetFromResources() child.setDataIsSensitive(sensitive) }
Java
@Override public void onProvideAutofillVirtualStructure(ViewStructure structure, int flags) { super.onProvideAutofillVirtualStructure(structure, flags); // Create a new child in the virtual structure. structure.addChildCount(1); ViewStructure child = structure.newChild(childIndex); // Set the autofill ID for the child. child.setAutofillId(structure.getAutofillId(), childVirtualId); // Populate the child by providing properties such as value and type. child.setAutofillValue(childAutofillValue); child.setAutofillType(childAutofillType); // Some children can provide a list of values, such as when the child is // a spinner. CharSequence childAutofillOptions[] = { "option1", "option2" }; child.setAutofillOptions(childAutofillOptions); // Just like other types of views, mark the data as sensitive when // appropriate. boolean sensitive = !contentIsSetFromResources(); child.setDataIsSensitive(sensitive); }
Quando gli elementi di una struttura virtuale cambiano, informa il framework svolgendo le seguenti attività:
- Se l'elemento attivo all'interno degli elementi secondari cambia, chiama
notifyViewEntered()
enotifyViewExited()
sull'oggettoAutofillManager
. - Se il valore di un elemento secondario cambia, chiama
notifyValueChanged()
sull'oggettoAutofillManager
. - Se la gerarchia delle visualizzazioni non è più disponibile perché l'utente ha completato un passaggio del flusso di lavoro, ad esempio quando accede utilizzando un modulo di accesso, chiama
commit()
sull'oggettoAutofillManager
. - Se la gerarchia delle visualizzazioni non è valida perché l'utente ha annullato un passaggio nel flusso di lavoro, ad esempio quando tocca un pulsante che cancella un modulo di accesso, chiama
cancel()
sull'oggettoAutofillManager
.
Utilizzare i callback per gli eventi di compilazione automatica
Se la tua app fornisce le proprie visualizzazioni di completamento automatico, hai bisogno di un meccanismo che indichi all'app di attivare o disattivare le visualizzazioni in risposta alle modifiche all'affordance di compilazione automatica dell'interfaccia utente. Il framework di compilazione automatica fornisce questo meccanismo nel formato AutofillCallback
.
Questa classe fornisce il metodo
onAutofillEvent(View, int)
, che viene chiamato dall'app dopo una modifica dello stato della compilazione automatica associata a una
visualizzazione.
È presente anche una versione sovraccarica di questo metodo che include un parametro childId
che la tua app può utilizzare con le visualizzazioni virtuali. Gli stati disponibili sono definiti come costanti nel callback.
Puoi registrare un callback utilizzando il metodo registerCallback()
della classe AutofillManager
. Il seguente esempio di codice mostra come dichiarare un callback per gli eventi di compilazione automatica:
Kotlin
val afm = context.getSystemService(AutofillManager::class.java) afm?.registerCallback(object : AutofillManager.AutofillCallback() { // For virtual structures, override // onAutofillEvent(View view, int childId, int event) instead. override fun onAutofillEvent(view: View, event: Int) { super.onAutofillEvent(view, event) when (event) { EVENT_INPUT_HIDDEN -> { // The autofill affordance associated with the view was hidden. } EVENT_INPUT_SHOWN -> { // The autofill affordance associated with the view was shown. } EVENT_INPUT_UNAVAILABLE -> { // Autofill isn't available. } } } })
Java
AutofillManager afm = getContext().getSystemService(AutofillManager.class); afm.registerCallback(new AutofillManager.AutofillCallback() { // For virtual structures, override // onAutofillEvent(View view, int childId, int event) instead. @Override public void onAutofillEvent(@NonNull View view, int event) { super.onAutofillEvent(view, event); switch (event) { case EVENT_INPUT_HIDDEN: // The autofill affordance associated with the view was hidden. break; case EVENT_INPUT_SHOWN: // The autofill affordance associated with the view was shown. break; case EVENT_INPUT_UNAVAILABLE: // Autofill isn't available. break; } } });
Quando è il momento di rimuovere il callback, utilizza il metodo
unregisterCallback()
.
Personalizzare l'elemento drawable evidenziato per la compilazione automatica
Quando una visualizzazione viene compilata automaticamente, la piattaforma la visualizza con un segno Drawable
per indicare che i contenuti della visualizzazione sono stati compilati automaticamente. Per impostazione predefinita, questo elemento Drawable è un
rettangolo pieno con un colore traslucido leggermente più scuro del colore
del tema utilizzato per disegnare gli sfondi. L'elemento drawable non deve essere modificato, ma può essere personalizzato sostituendo l'elemento android:autofilledHighlight
del tema utilizzato dall'applicazione o dall'attività, come mostrato in questo esempio:
<resources>
<style name="MyAutofilledHighlight" parent="...">
<item name="android:autofilledHighlight">@drawable/my_drawable</item>
</style>
</resources>
<shape xmlns:android="http://schemas.android.com/apk/res/android">
<solid android:color="#4DFF0000" />
</shape>
<application ...
android:theme="@style/MyAutofilledHighlight">
<!-- or -->
<activity ...
android:theme="@style/MyAutofilledHighlight">
Autenticazione per la compilazione automatica
Un servizio di compilazione automatica può richiedere all'utente di autenticarsi prima che il servizio possa completare i campi nella tua app. In questo caso, il sistema Android avvia l'attività di autenticazione del servizio nell'ambito dello stack dell'attività.
Non è necessario aggiornare l'app per supportare l'autenticazione, perché avviene all'interno del servizio. Tuttavia, devi assicurarti che la struttura della visualizzazione dell'attività venga conservata quando l'attività viene riavviata, ad esempio creando la struttura della visualizzazione in onCreate()
, non in onStart()
o onResume()
.
Puoi verificare il comportamento della tua app quando un servizio di compilazione automatica richiede l'autenticazione utilizzando HeuristicsService dall'esempio AutofillFramework e configurandolo in modo da richiedere l'autenticazione della risposta al completamento. Puoi anche utilizzare l'esempio BadViewStructureCreationSignInActivity per emulare questo problema.
Assegnare ID compilazione automatica alle visualizzazioni riutilizzate
I contenitori che riutilizzano le visualizzazioni, come la classe
RecyclerView
, sono utili per le app che devono mostrare elenchi scorrevoli di elementi in base a set di dati di grandi dimensioni. Mentre il container
scorre, il sistema riutilizza le visualizzazioni nel layout, ma queste contengono quindi nuovi
contenuti.
Se i contenuti iniziali di una visualizzazione riciclata sono compilati, il servizio di compilazione automatica conserva il significato logico delle visualizzazioni utilizzando i relativi ID di compilazione automatica. Si verifica un problema quando il sistema riutilizza le viste nel layout, gli ID logici delle viste rimangono gli stessi, causando l'associazione dei dati utente di compilazione automatica errati a un ID di compilazione automatica.
Per risolvere il problema sui dispositivi con Android 9 (livello API 28) e versioni successive, gestisci esplicitamente l'ID compilazione automatica delle visualizzazioni utilizzate daRecyclerView
utilizzando questi metodi:
- Il metodo
getNextAutofillId()
riceve un nuovo ID compilazione automatica univoco per l'attività. - Il metodo
setAutofillId()
imposta l'ID di compilazione automatica logico univoco di questa vista nell'attività.
Risolvere i problemi noti
Questa sezione presenta soluzioni alternative ai problemi noti all'interno del framework di compilazione automatica.
La compilazione automatica provoca l'arresto anomalo delle app su Android 8.0 e 8.1
In Android 8.0 (livello API 26) e 8.1 (livello API 27), la compilazione automatica può causare l'arresto anomalo dell'app in determinati scenari. Per aggirare potenziali problemi, tagga tutte le
visualizzazioni che non sono compilate automaticamente con importantForAutofill=no
. Puoi anche taggare
l'intera attività con importantForAutofill=noExcludeDescendants
.
Le finestre di dialogo ridimensionate non vengono prese in considerazione per la compilazione automatica
In Android 8.1 (livello API 27) e versioni precedenti, se una vista in un
dialogo viene ridimensionata dopo essere stata visualizzata,
la vista non viene considerata per la compilazione automatica. Queste visualizzazioni non sono incluse nell'oggetto
AssistStructure
che
il sistema Android invia
al servizio di compilazione automatica. Di conseguenza, il servizio non può compilare le visualizzazioni.
Per risolvere il problema, sostituisci la proprietà
token
dei parametri della finestra di dialogo con la proprietà token
dell'attività che crea la finestra di dialogo. Dopo aver verificato che la compilazione automatica sia attivata, salva i parametri della finestra nel metodo
onWindowAttributesChanged()
della classe che eredita da
Dialog
. Sostituisci quindi la proprietà token
dei parametri salvati con la proprietà token
dell'attività principale nel metodo onAttachedToWindow()
.
Il seguente snippet di codice mostra una classe che implementa questa soluzione alternativa:
Kotlin
class MyDialog(context: Context) : Dialog(context) { // Used to store the dialog window parameters. private var token: IBinder? = null private val isDialogResizedWorkaroundRequired: Boolean get() { if (Build.VERSION.SDK_INT != Build.VERSION_CODES.O || Build.VERSION.SDK_INT != Build.VERSION_CODES.O_MR1) { return false } val autofillManager = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) { context.getSystemService(AutofillManager::class.java) } else { null } return autofillManager?.isEnabled ?: false } override fun onWindowAttributesChanged(params: WindowManager.LayoutParams) { if (params.token == null && token != null) { params.token = token } super.onWindowAttributesChanged(params) } override fun onAttachedToWindow() { if (isDialogResizedWorkaroundRequired) { token = ownerActivity!!.window.attributes.token } super.onAttachedToWindow() } }
Java
public class MyDialog extends Dialog { public MyDialog(Context context) { super(context); } // Used to store the dialog window parameters. private IBinder token; @Override public void onWindowAttributesChanged(WindowManager.LayoutParams params) { if (params.token == null && token != null) { params.token = token; } super.onWindowAttributesChanged(params); } @Override public void onAttachedToWindow() { if (isDialogResizedWorkaroundRequired()) { token = getOwnerActivity().getWindow().getAttributes().token; } super.onAttachedToWindow(); } private boolean isDialogResizedWorkaroundRequired() { if (Build.VERSION.SDK_INT != Build.VERSION_CODES.O || Build.VERSION.SDK_INT != Build.VERSION_CODES.O_MR1) { return false; } AutofillManager autofillManager = null; if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.M) { autofillManager = getContext().getSystemService(AutofillManager.class); } return autofillManager != null && autofillManager.isEnabled(); } }
Per evitare operazioni non necessarie, il seguente snippet di codice mostra come verificare se la compilazione automatica è supportata nel dispositivo e attivata per l'utente corrente e se è necessaria questa soluzione alternativa:
Kotlin
// AutofillExtensions.kt fun Context.isDialogResizedWorkaroundRequired(): Boolean { // After the issue is resolved on Android, check whether the // workaround is still required for the current device. return isAutofillAvailable() } fun Context.isAutofillAvailable(): Boolean { if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) { // The autofill framework is available on Android 8.0 // or higher. return false } val afm = getSystemService(AutofillManager::class.java) // Return true if autofill is supported by the device and enabled // for the current user. return afm != null && afm.isEnabled }
Java
public class AutofillHelper { public static boolean isDialogResizedWorkaroundRequired(Context context) { // After the issue is resolved on Android, check whether the // workaround is still required for the current device. return isAutofillAvailable(context); } public static boolean isAutofillAvailable(Context context) { if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) { // The autofill framework is available on Android 8.0 // or higher. return false; } AutofillManager afm = context.getSystemService(AutofillManager.class); // Return true if autofill is supported by the device and enabled // for the current user. return afm != null && afm.isEnabled(); } }
Testare l'app con la compilazione automatica
Dopo aver ottimizzato l'app per il funzionamento con i servizi di compilazione automatica, verifica se funziona come previsto con questi servizi.
Utilizza un emulatore o un dispositivo fisico con Android 8.0 (livello API 26) o versioni successive per testare la tua app. Per ulteriori informazioni su come creare un emulatore, vedi Creare e gestire dispositivi virtuali.
Installare un servizio di compilazione automatica
Prima di poter testare l'app con la compilazione automatica, devi installare un'altra app che fornisca servizi di compilazione automatica. A questo scopo puoi utilizzare un'app di terze parti, ma è più facile utilizzare un servizio di compilazione automatica di esempio per non dover registrarti ai servizi di terze parti.
Puoi utilizzare l'esempio del framework di compilazione automatica Android in Java per testare la tua app con i servizi di compilazione automatica. L'app di esempio fornisce un servizio di compilazione automatica e classi Activity
client che puoi utilizzare per testare il flusso di lavoro prima di utilizzarlo con la tua app. Questa pagina fa riferimento all'app di esempio android-AutofillFramework.
Dopo aver installato l'app, attiva il servizio di compilazione automatica nelle impostazioni di sistema dell'emulatore selezionando Impostazioni > Sistema > Lingue e immissione > Avanzate > Assistenza alla digitazione > Servizio di compilazione automatica.
Analizza i requisiti dei dati
Per testare l'app con il servizio di compilazione automatica, il servizio deve avere dati che possono essere utilizzati per compilare l'app. Il servizio deve anche capire quale tipo di dati è previsto nelle visualizzazioni dell'app. Ad esempio, se la tua app ha una vista che prevede un nome utente, il servizio deve avere un set di dati che contenga un nome utente e un meccanismo per sapere che la visualizzazione prevede questi dati.
Indica al servizio il tipo di dati previsto nelle visualizzazioni impostando l'attributo
android:autofillHints
. Alcuni servizi utilizzano sofisticate euristiche
per determinare il tipo di dati, mentre altri, come l'app di esempio, si affidano
allo sviluppatore per fornire queste informazioni. L'app funziona meglio con i servizi di compilazione automatica se imposti l'attributo android:autofillHints
nelle visualizzazioni pertinenti per la compilazione automatica.
Esegui il test
Dopo aver analizzato i requisiti dei dati, puoi eseguire il test, che include il salvataggio dei dati di test nel servizio di compilazione automatica e l'attivazione della compilazione automatica nella tua app.
Salvare i dati nel servizio
Per salvare i dati nel servizio di compilazione automatica attualmente attivo:
- Apri un'app contenente una visualizzazione che prevede il tipo di dati che vuoi utilizzare durante il test. L'app di esempio android-FILLINFramework fornisce all'interfaccia utente visualizzazioni che prevedono diversi tipi di dati, come numeri di carte di credito e nomi utente.
- Tocca la visualizzazione contenente il tipo di dati di cui hai bisogno.
- Inserisci un valore nella visualizzazione.
- Tocca il pulsante di conferma, ad esempio Accedi o Invia. In genere, devi inviare il modulo prima che il servizio salvi i dati.
- Verifica la richiesta di autorizzazione dalla finestra di dialogo del sistema. La finestra di dialogo di sistema mostra il nome del servizio attualmente attivo e chiede se si tratta del servizio che vuoi utilizzare nel test. Se vuoi utilizzare il servizio, tocca Salva.
Se Android non mostra la finestra di dialogo di autorizzazione o se il servizio non è quello che vuoi utilizzare nel test, verifica che sia attualmente attivo nelle impostazioni di sistema.
Attivare la compilazione automatica nell'app
Per attivare la compilazione automatica nell'app:
- Apri l'app e vai all'attività contenente le visualizzazioni che vuoi testare.
- Tocca la visualizzazione da compilare.
- Il sistema mostra l'interfaccia utente di compilazione automatica, che contiene i set di dati che possono compilare la visualizzazione, come mostrato nella Figura 1.
- Tocca il set di dati contenente i dati che vuoi utilizzare. La vista mostra i dati precedentemente archiviati nel servizio.
Se Android non mostra l'interfaccia utente di compilazione automatica, puoi provare le seguenti opzioni di risoluzione dei problemi:
- Verifica che le visualizzazioni nella tua app utilizzino il valore corretto
nell'attributo
android:autofillHints
. Per un elenco dei possibili valori dell'attributo, consulta le costanti con prefissoAUTOFILL_HINT
nella classeView
. - Verifica che l'attributo
android:importantForAutofill
sia impostato su un valore diverso dano
nella visualizzazione che deve essere compilata o su un valore diverso danoExcludeDescendants
nella visualizzazione o in uno dei suoi elementi principali.