Ottimizza la compilazione automatica dell'app

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:

val password = findViewById<EditText>(R.id.password)
password.setAutofillHints(View.AUTOFILL_HINT_PASSWORD)

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 e AUTOFILL_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:
  • AUTOFILL_HINT_POSTAL_ADDRESS_STREET_ADDRESS
  • AUTOFILL_HINT_POSTAL_ADDRESS_EXTENDED_ADDRESS
  • AUTOFILL_HINT_POSTAL_ADDRESS_LOCALITY
  • AUTOFILL_HINT_POSTAL_ADDRESS_REGION
  • AUTOFILL_HINT_POSTAL_ADDRESS_COUNTRY
  • AUTOFILL_HINT_POSTAL_CODE
  • AUTOFILL_HINT_POSTAL_ADDRESS_EXTENDED_POSTAL_CODE

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:
  • AUTOFILL_HINT_PERSON_NAME_PREFIX
  • AUTOFILL_HINT_PERSON_NAME_GIVEN
  • AUTOFILL_HINT_PERSON_NAME_MIDDLE
  • AUTOFILL_HINT_PERSON_NAME_MIDDLE_INITIAL
  • AUTOFILL_HINT_PERSON_NAME_FAMILY
  • AUTOFILL_HINT_PERSON_NAME_SUFFIX

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:
  • AUTOFILL_HINT_PHONE_COUNTRY_CODE
  • AUTOFILL_HINT_PHONE_NATIONAL
  • AUTOFILL_HINT_PHONE_NUMBER_DEVICE

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():

val captcha = findViewById<TextView>(R.id.captcha)
captcha.setImportantForAutofill(View.IMPORTANT_FOR_AUTOFILL_NO)

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: usa android:importantForAutofill="no" o IMPORTANT_FOR_AUTOFILL_NO per contrassegnare questa visualizzazione come non importante.
• Una vista in cui l'utente crea contenuti: utilizza android:importantForAutofill="noExcludeDescendants" o IMPORTANT_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" o IMPORTANT_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:

fun eventHandler(view: View) {
    val afm = requireContext().getSystemService(AutofillManager::class.java)
    afm?.requestAutofill(view)
}

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:

override fun onProvideAutofillStructure(structure: ViewStructure, flags: Int) {
    super.onProvideAutofillStructure(structure, flags)

    structure.setDataIsSensitive(false)
}

@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:

1. Aumenta il numero di elementi secondari della struttura delle visualizzazioni chiamando addChildCount().
2. Aggiungi un bambino chiamando newChild().
3. Imposta l'ID di compilazione automatica per il bambino chiamando setAutofillId().
4. Imposta le proprietà pertinenti, come il tipo e il valore di compilazione automatica.
5. Se i dati nel bambino virtuale sono sensibili, passa true a setDataIsSensitive(); in caso contrario, passa false.

Il seguente snippet di codice mostra come creare un nuovo asset secondario nella struttura virtuale:

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)
}

@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() e notifyViewExited() sull'oggetto AutofillManager.
• Se il valore di un asset secondario cambia, chiama notifyValueChanged() sull'oggetto AutofillManager.
• 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'oggetto AutofillManager.
• 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'oggetto AutofillManager.

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:

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.
            }
        }

    }
})

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:

res/values/styles.xml

<resources>
    <style name="MyAutofilledHighlight" parent="...">
        <item name="android:autofilledHighlight">@drawable/my_drawable</item>
    </style>
</resources>

res/drawable/my_drawable.xml

<shape xmlns:android="http://schemas.android.com/apk/res/android">
    <solid android:color="#4DFF0000" />
</shape>

File AndroidManifest.xml

<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:

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()
    }

}

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:

// 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
}

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:

1. 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.
2. Tocca la vista che contiene il tipo di dati di cui hai bisogno.
3. Inserisci un valore nella visualizzazione.
4. Tocca il pulsante di conferma, ad esempio Accedi o Invia. In genere è necessario inviare il modulo prima che il servizio salvi i dati.
5. 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:

1. Apri l'app e vai all'attività con le visualizzazioni che vuoi testare.
2. Tocca la visualizzazione da compilare.
3. 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.
4. 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 prefisso AUTOFILL_HINT nella classe View.
• Verifica che l'attributo android:importantForAutofill sia impostato su un valore diverso da no nella vista che deve essere compilato oppure su un valore diverso da noExcludeDescendants nella vista o in uno dei relativi elementi principali.