Le app che utilizzano le viste 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
In questa sezione viene descritto come impostare la funzionalità di compilazione automatica di base per la tua app.
Configurare un servizio di compilazione automatica
Affinché l'app possa usare il framework di compilazione automatica, sul dispositivo deve essere configurato un servizio di compilazione automatica. Anche se la maggior parte dei telefoni e tablet con Android 8.0 (livello API 26) e versioni successive è dotata di un servizio di compilazione automatica, ti consigliamo di utilizzare un servizio di test per testare la tua app, ad esempio il servizio di compilazione automatica nell'esempio di framework di compilazione automatica per Android. Se 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 andando su Impostazioni > Sistema > Lingue e immissione > Avanzate > Assistenza per l'inserimento > Servizio di compilazione automatica.
Per saperne di più su come configurare un emulatore per testare la compilazione automatica, consulta Testare l'app con la compilazione automatica.
Fornisci suggerimenti per la compilazione automatica
Il servizio di compilazione automatica determina il tipo di ogni vista mediante l'euristica. Tuttavia, se la tua app si basa su queste euristiche, il comportamento di compilazione automatica potrebbe cambiare inaspettatamente quando aggiorni l'app. Per assicurarti che il servizio di compilazione automatica identifichi correttamente i fattori di forma dell'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 dei suggerimenti predefinite
Il framework di compilazione automatica non convalida i suggerimenti, che vengono trasmessi senza modifiche o convalida al servizio di compilazione automatica. Sebbene sia possibile 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 gli scenari di compilazione automatica comuni:
Credenziali account
In un modulo di accesso puoi includere suggerimenti delle credenziali dell'account come AUTOFILL_HINT_USERNAME
e AUTOFILL_HINT_PASSWORD
.
Per creare un nuovo account o quando gli utenti cambiano nome utente e 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, procedi in uno dei seguenti modi:
- Se utilizzi un'unica visualizzazione per la data di scadenza, utilizza
AUTOFILL_HINT_CREDIT_CARD_EXPIRATION_DATE
. - Se utilizzi una vista 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 ciascuna vista corrispondente.
Indirizzo fisico
Per i campi del modulo dell'indirizzo fisico, puoi utilizzare suggerimenti come i seguenti:
- Per un indirizzo in un'unica visualizzazione, utilizza
AUTOFILL_HINT_POSTAL_ADDRESS
. - Quando utilizzi viste distinte per parti diverse di un indirizzo, puoi utilizzare quanto segue:
Nomi di persone
Quando richiedi i nomi delle persone, puoi utilizzare suggerimenti come i seguenti:
- Per compilare automaticamente il nome completo di una persona in un'unica visualizzazione, utilizza
AUTOFILL_HINT_PERSON_NAME
. - Se utilizzi viste distinte per parti diverse di un nome, puoi utilizzare una qualsiasi delle seguenti opzioni:
Numeri di telefono.
Per i numeri di telefono, puoi utilizzare:
- Quando richiedi un numero di telefono completo in un'unica visualizzazione, utilizza
AUTOFILL_HINT_PHONE_NUMBER
. - Se utilizzi viste distinte per parti diverse di un numero di telefono, puoi utilizzare una delle seguenti opzioni:
Password unica (OTP)
Per una password monouso in un'unica visualizzazione, puoi utilizzare
AUTOFILL_HINT_SMS_OTP
.
Per più viste in cui ogni visualizzazione è mappata a una singola cifra dell'OTP, puoi utilizzare il metodo generateSmsOtpHintForCharacterPosition()
per generare suggerimenti per carattere.
Contrassegna 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 viste utilizzano la modalità IMPORTANT_FOR_AUTOFILL_AUTO
, che consente ad Android di utilizzare la sua euristica per determinare se una visualizzazione è importante per la compilazione automatica.
Tuttavia, in alcuni casi una vista, una struttura di visualizzazione o l'intera attività non sono importanti 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 foglio di lavoro
- Le visualizzazioni di 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 la sua euristica per determinare se la visualizzazione è importante per la compilazione automatica.
no
- Questa visualizzazione non è importante per la compilazione automatica.
noExcludeDescendants
- Questa vista e i relativi elementi secondari non sono importanti per la compilazione automatica.
yes
- Questa visualizzazione è importante per la compilazione automatica.
yesExcludeDescendants
- Questa visualizzazione è importante per la compilazione automatica, ma le relative visualizzazioni secondarie non sono importanti per la compilazione automatica.
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 degli esempi precedenti non importanti per la compilazione automatica come segue:
- Un campo
CAPTCHA
in un'attività di accesso: usaandroid:importantForAutofill="no"
oIMPORTANT_FOR_AUTOFILL_NO
per contrassegnare questa visualizzazione come non importante. - Una vista in cui l'utente crea contenuti: utilizza
android:importantForAutofill="noExcludeDescendants"
oIMPORTANT_FOR_AUTOFILL_NO_EXCLUDE_DESCENDANTS
per contrassegnare l'intera struttura di visualizzazione come non importante. - Le visualizzazioni in alcune attività all'interno dei giochi: usa
android:importantForAutofill="noExcludeDescendants"
oIMPORTANT_FOR_AUTOFILL_NO_EXCLUDE_DESCENDANTS
per contrassegnare l'intera struttura delle visualizzazioni come non importante.
Associa i dati del sito web e dell'app mobile
I servizi di compilazione automatica come la Compilazione automatica Google possono condividere i dati di accesso degli utenti tra browser e dispositivi Android dopo l'associazione dell'app e di un sito web. Quando un utente sceglie lo stesso servizio di compilazione automatica su entrambe le piattaforme, accedendo all'app web, le sue credenziali di accesso saranno disponibili per la compilazione automatica quando accede all'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
sul tuo sito. Dopodiché, dichiara l'associazione nel file AndroidManifest.xml
dell'app. Per istruzioni dettagliate su come associare il tuo sito web alla tua app Android, consulta la pagina Attivare l'accesso automatico per più app e siti web.
Completa 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.
Stabilire se la compilazione automatica è abilitata
Gli utenti possono attivare o disattivare la compilazione automatica e modificare il servizio di compilazione automatica andando su Impostazioni > Sistema > Lingue e immissione > Avanzate > Assistenza per l'inserimento > Servizio di compilazione automatica. La tua app non può eseguire l'override delle impostazioni di compilazione automatica dell'utente, ma puoi implementare funzionalità di compilazione automatica aggiuntive nell'app o in determinate visualizzazioni dell'app, se questa funzionalità è disponibile per l'utente.
Ad esempio, TextView
mostra una voce di compilazione automatica nel menu extra se la compilazione automatica è abilitata per l'utente. Per verificare se la compilazione automatica è abilitata per l'utente, chiama il metodo isEnabled()
dell'oggetto AutofillManager
.
Per assicurarti che la tua esperienza di registrazione e accesso sia ottimizzata per gli utenti senza compilazione automatica, implementa l'accesso 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 per
la compilazione automatica quando l'utente esegue un tocco e una pressione sulla vista.
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 l'attuale contesto di compilazione automatica. Questo può essere utile se è disponibile
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 nella compilazione automatica, in quanto forniscono una UI che consente agli utenti di modificare il valore di un campo in cui sono memorizzati i dati relativi a data e ora. Ad esempio, in un modulo della carta 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 dati di compilazione automatica di tipo
AUTOFILL_TYPE_TEXT
.
Se utilizzi un tipo di dati diverso, crea una vista personalizzata che erediti da EditText
e implementi i metodi necessari per gestire il tipo di dati corrispondente. Ad esempio, se hai un campo data, implementa i metodi con una logica che gestisce 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 vista. Per ulteriori informazioni, consulta Utilizzare i selettori con la compilazione automatica.
Completa il contesto della compilazione automatica
Il framework di compilazione automatica salva l'input utente per un utilizzo futuro, mostrando la finestra di dialogo "Salva per
compilazione automatica?" al termine del contesto di compilazione automatica. In genere, il contesto di compilazione automatica termina al termine di un'attività. Tuttavia, in alcuni casi è necessario inviare una notifica esplicita al framework, ad esempio se stai utilizzando la stessa attività ma frammenti diversi sia per la schermata di accesso che per quella dei contenuti. In queste situazioni, puoi terminare esplicitamente
il contesto chiamando AutofillManager.commit()
.
Supporto per le visualizzazioni personalizzate
Le viste personalizzate possono specificare i metadati esposti al framework di compilazione automatica utilizzando l'API di compilazione automatica. Alcune visualizzazioni fungono da container di elementi secondari virtuali, come quelle che contengono un'interfaccia utente sottoposta a rendering OpenGL. Queste viste 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 visualizzazioni personalizzate, prendi in considerazione i seguenti scenari:
- La visualizzazione personalizzata fornisce una struttura di visualizzazione standard o una struttura di visualizzazione predefinita.
- La vista personalizzata ha una struttura virtuale o una struttura che non è disponibile per il framework di compilazione automatica.
Visualizzazioni personalizzate con struttura di visualizzazione standard
Le viste 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 intraprendere le seguenti azioni:
- Gestisci il valore di compilazione automatica che il framework invia alla tua app.
- Indica il valore e il tipo di compilazione automatica al framework.
Quando viene attivata la compilazione automatica, il framework di compilazione automatica richiama
autofill()
sulla tua visualizzazione e invia il valore
che deve essere utilizzato dalla visualizzazione. Implementa autofill()
per specificare in che modo la visualizzazione personalizzata gestisce il valore di compilazione automatica.
La visualizzazione deve specificare un tipo e un valore di compilazione automatica eseguendo l'override rispettivamente dei metodi getAutofillType()
e getAutofillValue()
.
Infine, la compilazione automatica non deve riempire la vista se l'utente non può fornire un valore per la vista nello stato attuale, ad esempio se è disabilitata.
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, invia una notifica al framework di compilazione automatica in caso di modifiche chiamando
notifyValueChanged()
sull'oggetto AutofillManager
.
La visualizzazione personalizzata contiene dati sensibili
Se una vista contiene informazioni che consentono l'identificazione personale (PII), ad esempio indirizzi email, numeri di carte di credito e password, deve essere contrassegnata come sensibile.
In generale, le viste i cui contenuti provengono da risorse statiche non contengono dati sensibili, mentre le viste 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, a differenza di un'etichetta che contiene Ciao, Mario.
Per impostazione predefinita, il framework di compilazione automatica presuppone che tutti i dati siano sensibili. Puoi contrassegnare i dati che non sono sensibili.
Per contrassegnare una vista se contiene dati sensibili, implementa onProvideAutofillStructure()
e chiama setDataIsSensitive()
sull'oggetto ViewStructure
.
Il seguente esempio di codice mostra come contrassegnare i dati nella struttura della vista 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 vista accetta solo valori predefiniti, puoi utilizzare il metodo
setAutofillOptions()
per impostare le opzioni che possono essere utilizzate per la compilazione automatica della visualizzazione. In particolare, le viste il cui tipo di compilazione automatica è AUTOFILL_TYPE_LIST
devono utilizzare questo metodo, in quanto il servizio di compilazione automatica può svolgere un lavoro migliore se conosce le opzioni disponibili per riempire la visualizzazione.
Le viste che utilizzano un adattatore, ad esempio Spinner
, sono un caso simile. Ad esempio,
una rotellina che fornisce anni creati dinamicamente, in base all'anno corrente, da utilizzare nei campi relativi alla scadenza della carta di credito può
implementare il metodo
getAutofillOptions()
dell'interfaccia
Adapter
per fornire un elenco di
anni.
Le viste che utilizzano un elemento 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()
.
Viste 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 vista 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 la UI.
In questi casi, puoi specificare una struttura di visualizzazione implementando onProvideAutofillVirtualStructure()
e seguendo questi passaggi:
- Aumenta il numero di elementi secondari della struttura delle visualizzazioni chiamando
addChildCount()
. - Aggiungi un bambino chiamando
newChild()
. - Imposta l'ID di compilazione automatica per il bambino chiamando
setAutofillId()
. - Imposta le proprietà pertinenti, come il tipo e il valore di compilazione automatica.
- Se i dati nel bambino virtuale sono sensibili, passa
true
asetDataIsSensitive()
; in caso contrario, passafalse
.
Il seguente snippet di codice mostra come creare un nuovo asset 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, invia una notifica al framework eseguendo le seguenti attività:
- Se lo stato attivo all'interno degli oggetti secondari cambia, chiama
notifyViewEntered()
enotifyViewExited()
sull'oggettoAutofillManager
. - Se il valore di un asset 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()
nell'oggettoAutofillManager
. - Se la gerarchia delle visualizzazioni non è valida perché l'utente ha annullato un passaggio del 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 visualizzazioni con completamento automatico, devi avere un meccanismo che indichi all'app di attivare o disattivare le viste in risposta alle modifiche nell'affordità della compilazione automatica dell'interfaccia utente. Il framework di compilazione automatica fornisce questo meccanismo sotto forma di AutofillCallback
.
Questa classe fornisce il metodo onAutofillEvent(View, int)
, che l'app chiama dopo una modifica dello stato di compilazione automatica associato a una vista.
Esiste anche una versione sovraccaricata di questo metodo che include un parametro childId
che la tua app può utilizzare con le viste 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, usa il metodo unregisterCallback()
.
Personalizza il disegno da disegnare con compilazione automatica evidenziata
Quando una visualizzazione viene compilata automaticamente, la piattaforma mostra un elemento Drawable
sopra la visualizzazione per indicare che i contenuti della visualizzazione vengono compilati automaticamente. Per impostazione predefinita, questo disegno è un rettangolo pieno con un colore traslucido leggermente più scuro del colore del tema utilizzato per disegnare gli sfondi. Il disegno 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 compilazione automatica
Un servizio di compilazione automatica può richiedere all'utente di eseguire l'autenticazione prima che possa completare i campi nella tua app. In questo caso il sistema Android avvia l'attività di autenticazione del servizio come parte dello stack dell'attività.
Non è necessario aggiornare l'app per supportare l'autenticazione perché l'autenticazione avviene all'interno del servizio. Tuttavia, devi assicurarti che la struttura della visualizzazione dell'attività venga mantenuta quando viene riavviata, ad esempio creando la struttura 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 di AutofillFramework e configurandolo in modo che richieda l'autenticazione della risposta di riempimento. Puoi anche utilizzare l'esempio BadViewStrutturaCreationSignInActivity per emulare questo problema.
Assegna gli ID compilazione automatica alle visualizzazioni riciclate
I container che riciclano le visualizzazioni, come la classe RecyclerView
, sono utili per le app che devono visualizzare elenchi a scorrimento di elementi basati su set di dati di grandi dimensioni. Mentre il container scorre, il sistema riutilizza le visualizzazioni nel layout, che però contengono nuovi contenuti.
Se i contenuti iniziali di una visualizzazione riciclata vengono compilati, il servizio di compilazione automatica conserva il significato logico delle visualizzazioni utilizzando i relativi ID di compilazione automatica. Si verifica un problema quando, poiché il sistema riutilizza le viste nel layout, gli ID logici delle viste rimangono invariati, causando l'associazione di dati utente di compilazione automatica sbagliati 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 di compilazione automatica delle viste utilizzate da RecyclerView
utilizzando questi metodi:
- Il metodo
getNextAutofillId()
riceve un nuovo ID di compilazione automatica univoco per l'attività. - Il metodo
setAutofillId()
imposta l'ID di compilazione automatica univoco e logico di questa vista nell'attività.
Risolvere i problemi noti
Questa sezione presenta soluzioni alternative per problemi noti all'interno del framework di compilazione automatica.
La compilazione automatica causa l'arresto anomalo delle app su Android 8.0, 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 i potenziali problemi, tagga le visualizzazioni
che non vengono 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 una finestra di dialogo viene ridimensionata dopo essere stata già visualizzata, non viene considerata per la compilazione automatica. Queste viste non sono incluse nell'oggetto AssistStructure
inviato dal sistema Android al servizio di compilazione automatica. Di conseguenza, il servizio non è in grado di compilare le viste.
Per risolvere questo 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 l'attivazione della compilazione automatica, salva i parametri della finestra nel metodo onWindowAttributesChanged()
della classe che eredita da Dialog
. Poi, sostituisci 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, lo snippet di codice riportato di seguito 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 in modo che funzioni con i servizi di compilazione automatica, verifica se funziona come previsto con i servizi di compilazione automatica.
Utilizza un emulatore o un dispositivo fisico con Android 8.0 (livello API 26) o versioni successive per testare la tua app. Per saperne di più su come creare un emulatore, consulta Creare e gestire dispositivi virtuali.
Installa un servizio di compilazione automatica
Prima di poter testare la tua app con la compilazione automatica, devi installare un'altra app che offra servizi di compilazione automatica. A questo scopo, puoi utilizzare un'app di terze parti, ma è più semplice utilizzare un servizio di compilazione automatica di esempio, in modo da non dover registrarti a servizi di terze parti.
Puoi usare l'esempio di framework di compilazione automatica di 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
del client che puoi utilizzare per testare il flusso di lavoro prima di utilizzarla 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: vai a Impostazioni > Sistema > Lingue e immissione > Avanzate > Assistenza per l'inserimento > Servizio di compilazione automatica.
Analizza i requisiti dei dati
Per testare la tua app con il servizio di compilazione automatica, il servizio deve disporre di dati che possa utilizzare per compilare l'app. Il servizio deve anche capire quale tipo di dati è previsto nelle viste 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 vista prevede questi dati.
Indica al servizio quale tipo di dati è previsto nelle tue viste impostando l'attributo android:autofillHints
. Alcuni servizi utilizzano sofisticate euristiche
per determinare il tipo di dati, mentre altri, come l'app di esempio, si basano sullo
sviluppatore per fornire queste informazioni. La tua app funziona meglio con i servizi di compilazione automatica se imposti l'attributo android:autofillHints
nelle viste 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 nell'app.
Salva i dati nel servizio
Per salvare i dati nel servizio di compilazione automatica attualmente attivo:
- Apri un'app contenente una vista che prevede il tipo di dati che vuoi utilizzare durante il test. L'app di esempio android-AutofillFramework fornisce l'interfaccia utente con visualizzazioni che prevedono diversi tipi di dati, ad esempio numeri di carte di credito e nomi utente.
- Tocca la vista che contiene 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 è necessario inviare il modulo prima che il servizio salvi i dati.
- Verifica la richiesta di autorizzazione nella 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 delle autorizzazioni o se il servizio non è quello che vuoi utilizzare nel test, verifica che il servizio sia attualmente attivo nelle impostazioni di sistema.
Attiva la compilazione automatica nell'app
Per attivare la compilazione automatica nella tua app:
- Apri l'app e vai all'attività con 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 riempire la visualizzazione, come mostrato nella Figura 1.
- Tocca il set di dati che contiene 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 per la risoluzione dei problemi:
- Verifica che le visualizzazioni nella tua app utilizzino il valore corretto nell'attributo
android:autofillHints
. Per un elenco dei possibili valori per l'attributo, consulta le costanti precedute dal prefissoAUTOFILL_HINT
nella classeView
. - Verifica che l'attributo
android:importantForAutofill
sia impostato su un valore diverso dano
nella vista che deve essere compilato oppure su un valore diverso danoExcludeDescendants
nella vista o in uno dei relativi elementi principali.