Diese Seite wurde von der Cloud Translation API übersetzt.

AutoFill-Dienste erstellen

Ein Autofill-Dienst ist eine App, die es Nutzern erleichtert, Formulare auszufüllen, indem Daten in die Ansichten anderer Apps eingefügt werden. Autofill-Dienste können auch Nutzerdaten aus den Ansichten in einer App abrufen und zur späteren Verwendung speichern. Autofill-Dienste werden in der Regel von Apps zur Verfügung gestellt, die Nutzerdaten verwalten, z. B. als Passwortmanager verwenden.

Android erleichtert das Ausfüllen von Formularen mit dem Autofill-Framework, das unter Android 8.0 (API-Level 26) und höher. Nutzer können die Funktion „Autofill“ nutzen wenn es eine App mit Autofill-Diensten gibt, .

Auf dieser Seite erfahren Sie, wie Sie einen Autofill-Dienst in Ihrer App implementieren. Ein Codebeispiel zur Implementierung eines Dienstes finden Sie im AutofillFramework-Beispiel in Java oder Kotlin. Weitere Informationen zur Funktionsweise von Autofill-Diensten finden Sie auf den Referenzseiten für die Klassen AutofillService und AutofillManager.

Manifestdeklarationen und Berechtigungen

Apps, die Autofill-Dienste anbieten, müssen eine Erklärung enthalten, in der Folgendes beschrieben wird: die Implementierung des Dienstes. Fügen Sie zum Angeben der Deklaration ein <service>-Element in das App-Manifest ein. Die <service>-Element muss enthalten die folgenden Attribute und Elemente:

Attribut android:name die auf die abgeleitete Klasse von AutofillService in der App verweist, in der für den Dienst.
android:permission Attribut, das die BIND_AUTOFILL_SERVICE deklariert Berechtigung.
<intent-filter> -Element, dessen obligatorische Untergeordnetes <action>-Element gibt die android.service.autofill.AutofillService Aktion ausführen.
Optional <meta-data> -Element, mit dem Sie zusätzliche Konfigurationsparameter für für den Dienst.

Das folgende Beispiel zeigt eine Deklaration für einen Autofill-Service:

<service
    android:name=".MyAutofillService"
    android:label="My Autofill Service"
    android:permission="android.permission.BIND_AUTOFILL_SERVICE">
    <intent-filter>
        <action android:name="android.service.autofill.AutofillService" />
    </intent-filter>
    <meta-data
        android:name="android.autofill"
        android:resource="@xml/service_configuration" />
</service>

Das Element <meta-data> enthält ein android:resource , das auf eine XML-Ressource mit weiteren Details zum Dienst verweist. Die Ressource service_configuration im vorherigen Beispiel gibt ein Aktivität, mit der Nutzer den Dienst konfigurieren können. Das folgende Beispiel zeigt die service_configuration-XML-Ressource:

<autofill-service
  xmlns:android="http://schemas.android.com/apk/res/android"
  android:settingsActivity="com.example.android.SettingsActivity" />

Weitere Informationen zu XML-Ressourcen finden Sie unter Übersicht über App-Ressourcen.

Aufforderung zum Aktivieren des Dienstes

Eine App wird als Autofill-Service verwendet, nachdem sie die Die Berechtigung BIND_AUTOFILL_SERVICE und der Nutzer aktiviert sie auf dem Gerät Einstellungen. So kann eine App prüfen, ob es sich um den derzeit aktivierten Dienst handelt: das Aufrufen der hasEnabledAutofillServices() der AutofillManager-Klasse.

Wenn die App nicht der aktuelle Autofill-Service ist, kann sie den Nutzer auffordern, ändern Sie die Autofill-Einstellungen mithilfe der ACTION_REQUEST_SET_AUTOFILL_SERVICE die Nutzerabsicht verstehen. Der Intent gibt den Wert RESULT_OK zurück, wenn der Nutzer einen Autofill-Dienst auswählt, der dem Paket des Aufrufers entspricht.

Kundenansichten ausfüllen

Der Autofill-Dienst erhält Anfragen zum Ausfüllen von Kundenansichten, wenn der Nutzer mit anderen Apps interagiert. Wenn der Autofill-Dienst Nutzerdaten hat, die der Anfrage entsprechen, werden die Daten in der Antwort gesendet. Das Android-System zeigt eine Autofill-Benutzeroberfläche mit den verfügbaren Daten, wie in Abbildung 1 dargestellt:

Autofill-UI

Abbildung 1: Autofill-Benutzeroberfläche, auf der ein Dataset angezeigt wird

Das Autofill-Framework definiert einen Workflow zum Ausfüllen von Ansichten, der die Zeit minimiert, in der das Android-System an den Autofill-Dienst gebunden ist. In bei jeder Anfrage sendet das Android-System ein AssistStructure-Objekt an den Dienst, onFillRequest() wird aufgerufen .

Der Autofill-Dienst prüft, ob der Anfrage mit Nutzerdaten entsprochen werden kann, die er die zuvor gespeichert wurden. Wenn die Anfrage erfüllt werden kann, verpackt der Dienst die Daten in Dataset-Objekten. Der Dienst ruft die Methode onSuccess() auf und übergibt ein FillResponse-Objekt, das die Dataset-Objekte enthält. Wenn der Dienst nicht Daten zur Erfüllung der Anfrage haben, wird null an die Methode onSuccess() übergeben.

Wenn bei der Verarbeitung der Anfrage ein Fehler auftritt, ruft der Dienst stattdessen die Methode onFailure() auf. Eine ausführliche Beschreibung des Workflows finden Sie in der Beschreibung auf der Referenzseite zu AutofillService.

Der folgende Code zeigt ein Beispiel für die Methode onFillRequest():

Kotlin

override fun onFillRequest(
    request: FillRequest,
    cancellationSignal: CancellationSignal,
    callback: FillCallback
) {
    // Get the structure from the request
    val context: List<FillContext> = request.fillContexts
    val structure: AssistStructure = context[context.size - 1].structure

    // Traverse the structure looking for nodes to fill out
    val parsedStructure: ParsedStructure = parseStructure(structure)

    // Fetch user data that matches the fields
    val (username: String, password: String) = fetchUserData(parsedStructure)

    // Build the presentation of the datasets
    val usernamePresentation = RemoteViews(packageName, android.R.layout.simple_list_item_1)
    usernamePresentation.setTextViewText(android.R.id.text1, "my_username")
    val passwordPresentation = RemoteViews(packageName, android.R.layout.simple_list_item_1)
    passwordPresentation.setTextViewText(android.R.id.text1, "Password for my_username")

    // Add a dataset to the response
    val fillResponse: FillResponse = FillResponse.Builder()
            .addDataset(Dataset.Builder()
                    .setValue(
                            parsedStructure.usernameId,
                            AutofillValue.forText(username),
                            usernamePresentation
                    )
                    .setValue(
                            parsedStructure.passwordId,
                            AutofillValue.forText(password),
                            passwordPresentation
                    )
                    .build())
            .build()

    // If there are no errors, call onSuccess() and pass the response
    callback.onSuccess(fillResponse)
}

data class ParsedStructure(var usernameId: AutofillId, var passwordId: AutofillId)

data class UserData(var username: String, var password: String)

Java

@Override
public void onFillRequest(FillRequest request, CancellationSignal cancellationSignal, FillCallback callback) {
    // Get the structure from the request
    List<FillContext> context = request.getFillContexts();
    AssistStructure structure = context.get(context.size() - 1).getStructure();

    // Traverse the structure looking for nodes to fill out
    ParsedStructure parsedStructure = parseStructure(structure);

    // Fetch user data that matches the fields
    UserData userData = fetchUserData(parsedStructure);

    // Build the presentation of the datasets
    RemoteViews usernamePresentation = new RemoteViews(getPackageName(), android.R.layout.simple_list_item_1);
    usernamePresentation.setTextViewText(android.R.id.text1, "my_username");
    RemoteViews passwordPresentation = new RemoteViews(getPackageName(), android.R.layout.simple_list_item_1);
    passwordPresentation.setTextViewText(android.R.id.text1, "Password for my_username");

    // Add a dataset to the response
    FillResponse fillResponse = new FillResponse.Builder()
            .addDataset(new Dataset.Builder()
                    .setValue(parsedStructure.usernameId,
                            AutofillValue.forText(userData.username), usernamePresentation)
                    .setValue(parsedStructure.passwordId,
                            AutofillValue.forText(userData.password), passwordPresentation)
                    .build())
            .build();

    // If there are no errors, call onSuccess() and pass the response
    callback.onSuccess(fillResponse);
}

class ParsedStructure {
    AutofillId usernameId;
    AutofillId passwordId;
}

class UserData {
    String username;
    String password;
}

Ein Dienst kann mehr als ein Dataset haben, das die Anfrage erfüllt. In diesem Fall zeigt das Android-System in der Benutzeroberfläche für die automatische Vervollständigung mehrere Optionen an, eine für jeden Datensatz. Das folgende Codebeispiel zeigt, wie Sie mehrere Datasets in einer Antwort bereitstellen:

Kotlin

// Add multiple datasets to the response
val fillResponse: FillResponse = FillResponse.Builder()
        .addDataset(Dataset.Builder()
                .setValue(parsedStructure.usernameId,
                        AutofillValue.forText(user1Data.username), username1Presentation)
                .setValue(parsedStructure.passwordId,
                        AutofillValue.forText(user1Data.password), password1Presentation)
                .build())
        .addDataset(Dataset.Builder()
                .setValue(parsedStructure.usernameId,
                        AutofillValue.forText(user2Data.username), username2Presentation)
                .setValue(parsedStructure.passwordId,
                        AutofillValue.forText(user2Data.password), password2Presentation)
                .build())
        .build()

Java

// Add multiple datasets to the response
FillResponse fillResponse = new FillResponse.Builder()
        .addDataset(new Dataset.Builder()
                .setValue(parsedStructure.usernameId,
                        AutofillValue.forText(user1Data.username), username1Presentation)
                .setValue(parsedStructure.passwordId,
                        AutofillValue.forText(user1Data.password), password1Presentation)
                .build())
        .addDataset(new Dataset.Builder()
                .setValue(parsedStructure.usernameId,
                        AutofillValue.forText(user2Data.username), username2Presentation)
                .setValue(parsedStructure.passwordId,
                        AutofillValue.forText(user2Data.password), password2Presentation)
                .build())
        .build();

Autofill-Dienste können zwischen den ViewNode-Objekten im AssistStructure zum Abrufen der Autofill-Daten die zur Ausführung der Anfrage erforderlich sind. Ein Dienst kann Autofill-Daten mithilfe von Methoden der Klasse ViewNode abrufen, z. B. getAutofillId().

Ein Dienst muss den Inhalt einer Ansicht beschreiben können, um zu prüfen, ob er die Anfrage erfüllen kann. Die Verwendung des Attributs autofillHints ist der erste Ansatz, den ein Dienst zur Beschreibung des Inhalts einer Ansicht verwenden muss. Client-Apps müssen das Attribut jedoch explizit in ihren Ansichten angeben, damit es für den Dienst verfügbar ist.

Wenn eine Client-App das autofillHints-Attribut nicht angibt, muss ein Dienst seine eigenen Heuristiken verwenden, um den Inhalt zu beschreiben. Der Dienst kann Methoden aus anderen Klassen wie getText() oder getHint() verwenden, um Informationen zum Inhalt der Ansicht abzurufen. Weitere Informationen finden Sie unter Hinweise für Autofill aus.

Das folgende Beispiel zeigt, wie Sie AssistStructure durchlaufen und abrufen können Autofill-Daten aus einem ViewNode-Objekt:

Kotlin

fun traverseStructure(structure: AssistStructure) {
    val windowNodes: List<AssistStructure.WindowNode> =
            structure.run {
                (0 until windowNodeCount).map { getWindowNodeAt(it) }
            }

    windowNodes.forEach { windowNode: AssistStructure.WindowNode ->
        val viewNode: ViewNode? = windowNode.rootViewNode
        traverseNode(viewNode)
    }
}

fun traverseNode(viewNode: ViewNode?) {
    if (viewNode?.autofillHints?.isNotEmpty() == true) {
        // If the client app provides autofill hints, you can obtain them using
        // viewNode.getAutofillHints();
    } else {
        // Or use your own heuristics to describe the contents of a view
        // using methods such as getText() or getHint()
    }

    val children: List<ViewNode>? =
            viewNode?.run {
                (0 until childCount).map { getChildAt(it) }
            }

    children?.forEach { childNode: ViewNode ->
        traverseNode(childNode)
    }
}

Java

public void traverseStructure(AssistStructure structure) {
    int nodes = structure.getWindowNodeCount();

    for (int i = 0; i < nodes; i++) {
        WindowNode windowNode = structure.getWindowNodeAt(i);
        ViewNode viewNode = windowNode.getRootViewNode();
        traverseNode(viewNode);
    }
}

public void traverseNode(ViewNode viewNode) {
    if(viewNode.getAutofillHints() != null && viewNode.getAutofillHints().length > 0) {
        // If the client app provides autofill hints, you can obtain them using
        // viewNode.getAutofillHints();
    } else {
        // Or use your own heuristics to describe the contents of a view
        // using methods such as getText() or getHint()
    }

    for(int i = 0; i < viewNode.getChildCount(); i++) {
        ViewNode childNode = viewNode.getChildAt(i);
        traverseNode(childNode);
    }
}

Nutzerdaten speichern

Ein Autofill-Dienst benötigt Nutzerdaten, um Ansichten in Apps auszufüllen. Wenn Nutzende eine Ansicht manuell ausfüllen, werden sie aufgefordert, die Daten im aktuellen Autofill-Service, wie in Abbildung 2 dargestellt.

Benutzeroberfläche zum Speichern von Autofill

Abbildung 2. Benutzeroberfläche für das Speichern von Autofill-Informationen

Um die Daten zu speichern, muss der Dienst angeben, dass er die Daten speichern möchte. Daten für die zukünftige Verwendung. Bevor das Android-System eine Anfrage zum Speichern der Daten sendet, wird eine Anfrage zum Ausfüllen gesendet, bei der der Dienst die Ansichten ausfüllen kann. Um anzugeben, dass er die Daten speichern möchte, Enthält SaveInfo -Objekt in der Antwort auf die Füllanfrage. Das SaveInfo-Objekt muss mindestens die folgenden Daten enthalten:

Der Typ der gespeicherten Nutzerdaten. Eine Liste der verfügbaren SAVE_DATA-Werte, siehe SaveInfo.
Die Mindestanzahl an Ansichten, die geändert werden müssen, um eine Speicheranfrage auszulösen. Beispielsweise muss der Nutzer bei einem Anmeldeformular normalerweise die username aktualisieren und password Ansichten, um eine Speicheranfrage auszulösen.

Ein SaveInfo-Objekt ist mit einem FillResponse-Objekt verknüpft, wie im folgenden Codebeispiel:

Kotlin

override fun onFillRequest(
    request: FillRequest,
    cancellationSignal: CancellationSignal,
    callback: FillCallback
) {
    ...
    // Builder object requires a non-null presentation
    val notUsed = RemoteViews(packageName, android.R.layout.simple_list_item_1)

    val fillResponse: FillResponse = FillResponse.Builder()
            .addDataset(
                    Dataset.Builder()
                            .setValue(parsedStructure.usernameId, null, notUsed)
                            .setValue(parsedStructure.passwordId, null, notUsed)
                            .build()
            )
            .setSaveInfo(
                    SaveInfo.Builder(
                            SaveInfo.SAVE_DATA_TYPE_USERNAME or SaveInfo.SAVE_DATA_TYPE_PASSWORD,
                            arrayOf(parsedStructure.usernameId, parsedStructure.passwordId)
                    ).build()
            )
            .build()
    ...
}

Java

@Override
public void onFillRequest(FillRequest request, CancellationSignal cancellationSignal, FillCallback callback) {
    ...
    // Builder object requires a non-null presentation
    RemoteViews notUsed = new RemoteViews(getPackageName(), android.R.layout.simple_list_item_1);

    FillResponse fillResponse = new FillResponse.Builder()
            .addDataset(new Dataset.Builder()
                    .setValue(parsedStructure.usernameId, null, notUsed)
                    .setValue(parsedStructure.passwordId, null, notUsed)
                    .build())
            .setSaveInfo(new SaveInfo.Builder(
                    SaveInfo.SAVE_DATA_TYPE_USERNAME | SaveInfo.SAVE_DATA_TYPE_PASSWORD,
                    new AutofillId[] {parsedStructure.usernameId, parsedStructure.passwordId})
                    .build())
            .build();
    ...
}

Der Autofill-Service kann eine Logik implementieren, um die Nutzerdaten im onSaveRequest() , die normalerweise aufgerufen wird, nachdem die Client-Aktivität beendet ist, oder wenn die Client-App-Aufrufe commit(). Der folgende Code zeigt ein Beispiel für die Methode onSaveRequest():

Kotlin

override fun onSaveRequest(request: SaveRequest, callback: SaveCallback) {
    // Get the structure from the request
    val context: List<FillContext> = request.fillContexts
    val structure: AssistStructure = context[context.size - 1].structure

    // Traverse the structure looking for data to save
    traverseStructure(structure)

    // Persist the data - if there are no errors, call onSuccess()
    callback.onSuccess()
}

Java

@Override
public void onSaveRequest(SaveRequest request, SaveCallback callback) {
    // Get the structure from the request
    List<FillContext> context = request.getFillContexts();
    AssistStructure structure = context.get(context.size() - 1).getStructure();

    // Traverse the structure looking for data to save
    traverseStructure(structure);

    // Persist the data - if there are no errors, call onSuccess()
    callback.onSuccess();
}

Autofill-Dienste müssen sensible Daten verschlüsseln, bevor sie gespeichert werden. Sie können jedoch Nutzerdaten können Labels oder nicht vertrauliche Daten enthalten. Ein Nutzerkonto kann beispielsweise ein Label enthalten, das die Daten als Arbeitskonto oder privates Konto kennzeichnet. Dienste dürfen keine Labels verschlüsseln. Wenn Labels nicht verschlüsselt werden, können Dienste die Labels in Präsentationsansichten verwenden, auch wenn sich der Nutzer nicht authentifiziert hat. Anschließend können Dienste die Labels nach der Authentifizierung des Nutzers durch die tatsächlichen Daten ersetzen.

Benutzeroberfläche zum Speichern von Autofill-Daten verschieben

Wenn Sie ab Android 10 mehrere Bildschirme für die Implementierung eines Autofill-Workflows verwenden, z. B. einen Bildschirm für das Feld „Nutzername“ und einen anderen für das Passwort, können Sie die Benutzeroberfläche zum Speichern von Autofill mit dem Flag SaveInfo.FLAG_DELAY_SAVE verschieben.

Wenn dieses Flag gesetzt ist, wird die Benutzeroberfläche zum Speichern von Autofill-Daten nicht ausgelöst, wenn der Autofill-Kontext, der mit der SaveInfo-Antwort verknüpft ist, verbindlich gemacht wird. Stattdessen können Sie eine separate Aktivität innerhalb derselben Aufgabe verwenden, um zukünftige Ausfüllanfragen zu senden und dann die Benutzeroberfläche über eine Speicheranfrage anzuzeigen. Weitere Informationen finden Sie unter SaveInfo.FLAG_DELAY_SAVE.

Nutzerauthentifizierung erforderlich machen

Die Autofill-Services bieten eine zusätzliche Sicherheitsstufe, indem vorschreiben, dass Nutzer müssen sich authentifizieren, bevor sie Aufrufe ausfüllen kann. Folgende Szenarien sind gute Kandidaten für die Implementierung der Nutzerauthentifizierung:

Die Nutzerdaten in der App müssen mit einem primären Passwort oder einem Fingerabdruck gescannt werden, um entsperrt zu werden.
Ein bestimmter Datensatz muss entsperrt werden, z. B. Kreditkartendetails mithilfe eines Kartenprüfcodes (CVC).

In einem Szenario, in dem der Dienst vor dem Entsperren eine Nutzerauthentifizierung erfordert kann der Dienst Textbausteindaten oder eine Beschriftung anzeigen und den Intent, die sich um Authentifizierung. Wenn Sie nach dem Authentifizierungsvorgang abgeschlossen ist, können Sie diese Daten dem Intent hinzufügen. Ihre Authentifizierungsaktivitäten können die Daten dann an die AutofillService-Klasse in Ihrer App zurückgeben.

Das folgende Codebeispiel zeigt, wie angegeben wird, dass die Anfrage Authentifizierung erforderlich:

Kotlin

val authPresentation = RemoteViews(packageName, android.R.layout.simple_list_item_1).apply {
    setTextViewText(android.R.id.text1, "requires authentication")
}
val authIntent = Intent(this, AuthActivity::class.java).apply {
    // Send any additional data required to complete the request
    putExtra(MY_EXTRA_DATASET_NAME, "my_dataset")
}

val intentSender: IntentSender = PendingIntent.getActivity(
        this,
        1001,
        authIntent,
        PendingIntent.FLAG_CANCEL_CURRENT
).intentSender

// Build a FillResponse object that requires authentication
val fillResponse: FillResponse = FillResponse.Builder()
        .setAuthentication(autofillIds, intentSender, authPresentation)
        .build()

Java

RemoteViews authPresentation = new RemoteViews(getPackageName(), android.R.layout.simple_list_item_1);
authPresentation.setTextViewText(android.R.id.text1, "requires authentication");
Intent authIntent = new Intent(this, AuthActivity.class);

// Send any additional data required to complete the request
authIntent.putExtra(MY_EXTRA_DATASET_NAME, "my_dataset");
IntentSender intentSender = PendingIntent.getActivity(
                this,
                1001,
                authIntent,
                PendingIntent.FLAG_CANCEL_CURRENT
        ).getIntentSender();

// Build a FillResponse object that requires authentication
FillResponse fillResponse = new FillResponse.Builder()
        .setAuthentication(autofillIds, intentSender, authPresentation)
        .build();

Sobald die Aktivität den Authentifizierungsvorgang abgeschlossen hat, muss sie die Methode setResult()-Methode, Übergeben Sie einen RESULT_OK-Wert und legen Sie die EXTRA_AUTHENTICATION_RESULT fest. zum FillResponse-Objekt hinzu, das das gefüllte Dataset enthält. Die Der folgende Code zeigt ein Beispiel für die Rückgabe des Ergebnisses Authentifizierungsabläufe abgeschlossen:

Kotlin

// The data sent by the service and the structure are included in the intent
val datasetName: String? = intent.getStringExtra(MY_EXTRA_DATASET_NAME)
val structure: AssistStructure = intent.getParcelableExtra(EXTRA_ASSIST_STRUCTURE)
val parsedStructure: ParsedStructure = parseStructure(structure)
val (username, password) = fetchUserData(parsedStructure)

// Build the presentation of the datasets
val usernamePresentation =
        RemoteViews(packageName, android.R.layout.simple_list_item_1).apply {
            setTextViewText(android.R.id.text1, "my_username")
        }
val passwordPresentation =
        RemoteViews(packageName, android.R.layout.simple_list_item_1).apply {
            setTextViewText(android.R.id.text1, "Password for my_username")
        }

// Add the dataset to the response
val fillResponse: FillResponse = FillResponse.Builder()
        .addDataset(Dataset.Builder()
                .setValue(
                        parsedStructure.usernameId,
                        AutofillValue.forText(username),
                        usernamePresentation
                )
                .setValue(
                        parsedStructure.passwordId,
                        AutofillValue.forText(password),
                        passwordPresentation
                )
                .build()
        ).build()

val replyIntent = Intent().apply {
    // Send the data back to the service
    putExtra(MY_EXTRA_DATASET_NAME, datasetName)
    putExtra(EXTRA_AUTHENTICATION_RESULT, fillResponse)
}

setResult(Activity.RESULT_OK, replyIntent)

Java

Intent intent = getIntent();

// The data sent by the service and the structure are included in the intent
String datasetName = intent.getStringExtra(MY_EXTRA_DATASET_NAME);
AssistStructure structure = intent.getParcelableExtra(EXTRA_ASSIST_STRUCTURE);
ParsedStructure parsedStructure = parseStructure(structure);
UserData userData = fetchUserData(parsedStructure);

// Build the presentation of the datasets
RemoteViews usernamePresentation = new RemoteViews(getPackageName(), android.R.layout.simple_list_item_1);
usernamePresentation.setTextViewText(android.R.id.text1, "my_username");
RemoteViews passwordPresentation = new RemoteViews(getPackageName(), android.R.layout.simple_list_item_1);
passwordPresentation.setTextViewText(android.R.id.text1, "Password for my_username");

// Add the dataset to the response
FillResponse fillResponse = new FillResponse.Builder()
        .addDataset(new Dataset.Builder()
                .setValue(parsedStructure.usernameId,
                        AutofillValue.forText(userData.username), usernamePresentation)
                .setValue(parsedStructure.passwordId,
                        AutofillValue.forText(userData.password), passwordPresentation)
                .build())
        .build();

Intent replyIntent = new Intent();

// Send the data back to the service
replyIntent.putExtra(MY_EXTRA_DATASET_NAME, datasetName);
replyIntent.putExtra(EXTRA_AUTHENTICATION_RESULT, fillResponse);

setResult(RESULT_OK, replyIntent);

Wenn ein Kreditkartendatensatz entsperrt werden muss, kann der Dienst eine Benutzeroberfläche anzeigen, auf der nach der CVC gefragt wird. Sie können die Daten ausblenden, bis das Dataset Textbausteine wie den Namen der Bank und die die letzten vier Ziffern Ihrer Kreditkartennummer. Im folgenden Beispiel wird gezeigt, wie eine Authentifizierung für einen Datensatz erforderlich gemacht und die Daten ausgeblendet werden, bis der Nutzer die CVC angegeben hat:

Kotlin

// Parse the structure and fetch payment data
val parsedStructure: ParsedStructure = parseStructure(structure)
val paymentData: Payment = fetchPaymentData(parsedStructure)

// Build the presentation that shows the bank and the last four digits of the
// credit card number, such as 'Bank-1234'
val maskedPresentation: String = "${paymentData.bank}-" +
        paymentData.creditCardNumber.substring(paymentData.creditCardNumber.length - 4)
val authPresentation = RemoteViews(packageName, android.R.layout.simple_list_item_1).apply {
    setTextViewText(android.R.id.text1, maskedPresentation)
}

// Prepare an intent that displays the UI that asks for the CVC
val cvcIntent = Intent(this, CvcActivity::class.java)
val cvcIntentSender: IntentSender = PendingIntent.getActivity(
        this,
        1001,
        cvcIntent,
        PendingIntent.FLAG_CANCEL_CURRENT
).intentSender

// Build a FillResponse object that includes a Dataset that requires authentication
val fillResponse: FillResponse = FillResponse.Builder()
        .addDataset(
                Dataset.Builder()
                        // The values in the dataset are replaced by the actual
                        // data once the user provides the CVC
                        .setValue(parsedStructure.creditCardId, null, authPresentation)
                        .setValue(parsedStructure.expDateId, null, authPresentation)
                        .setAuthentication(cvcIntentSender)
                        .build()
        ).build()

Java

// Parse the structure and fetch payment data
ParsedStructure parsedStructure = parseStructure(structure);
Payment paymentData = fetchPaymentData(parsedStructure);

// Build the presentation that shows the bank and the last four digits of the
// credit card number, such as 'Bank-1234'
String maskedPresentation = paymentData.bank + "-" +
    paymentData.creditCardNumber.subString(paymentData.creditCardNumber.length - 4);
RemoteViews authPresentation = new RemoteViews(getPackageName(), android.R.layout.simple_list_item_1);
authPresentation.setTextViewText(android.R.id.text1, maskedPresentation);

// Prepare an intent that displays the UI that asks for the CVC
Intent cvcIntent = new Intent(this, CvcActivity.class);
IntentSender cvcIntentSender = PendingIntent.getActivity(
        this,
        1001,
        cvcIntent,
        PendingIntent.FLAG_CANCEL_CURRENT
).getIntentSender();

// Build a FillResponse object that includes a Dataset that requires authentication
FillResponse fillResponse = new FillResponse.Builder()
        .addDataset(new Dataset.Builder()
                // The values in the dataset are replaced by the actual
                // data once the user provides the CVC
                .setValue(parsedStructure.creditCardId, null, authPresentation)
                .setValue(parsedStructure.expDateId, null, authPresentation)
                .setAuthentication(cvcIntentSender)
                .build())
        .build();

Sobald die Aktivität den CVC validiert hat, sollte die Methode setResult() aufgerufen werden. übergeben Sie einen RESULT_OK-Wert und legen Sie die zusätzliche EXTRA_AUTHENTICATION_RESULT auf Ein Dataset-Objekt, das die Kreditkartennummer und das Ablaufdatum enthält. Der neue Datensatz ersetzt den Datensatz, für den eine Authentifizierung erforderlich ist, und die Ansichten werden sofort ausgefüllt. Im folgenden Code wird gezeigt, wie der Datensatz zurückgegeben wird, sobald der Nutzer die CVC angegeben hat:

Kotlin

// Parse the structure and fetch payment data.
val parsedStructure: ParsedStructure = parseStructure(structure)
val paymentData: Payment = fetchPaymentData(parsedStructure)

// Build a non-null RemoteViews object to use as the presentation when
// creating the Dataset object. This presentation isn't actually used, but the
// Builder object requires a non-null presentation.
val notUsed = RemoteViews(packageName, android.R.layout.simple_list_item_1)

// Create a dataset with the credit card number and expiration date.
val responseDataset: Dataset = Dataset.Builder()
        .setValue(
                parsedStructure.creditCardId,
                AutofillValue.forText(paymentData.creditCardNumber),
                notUsed
        )
        .setValue(
                parsedStructure.expDateId,
                AutofillValue.forText(paymentData.expirationDate),
                notUsed
        )
        .build()

val replyIntent = Intent().apply {
    putExtra(EXTRA_AUTHENTICATION_RESULT, responseDataset)
}

Java

// Parse the structure and fetch payment data.
ParsedStructure parsedStructure = parseStructure(structure);
Payment paymentData = fetchPaymentData(parsedStructure);

// Build a non-null RemoteViews object to use as the presentation when
// creating the Dataset object. This presentation isn't actually used, but the
// Builder object requires a non-null presentation.
RemoteViews notUsed = new RemoteViews(getPackageName(), android.R.layout.simple_list_item_1);

// Create a dataset with the credit card number and expiration date.
Dataset responseDataset = new Dataset.Builder()
        .setValue(parsedStructure.creditCardId,
                AutofillValue.forText(paymentData.creditCardNumber), notUsed)
        .setValue(parsedStructure.expDateId,
                AutofillValue.forText(paymentData.expirationDate), notUsed)
        .build();

Intent replyIntent = new Intent();
replyIntent.putExtra(EXTRA_AUTHENTICATION_RESULT, responseDataset);

Daten in logischen Gruppen organisieren

Autofill-Dienste müssen die Daten in logischen Gruppen organisieren, die Konzepte aus verschiedenen Domains voneinander abgrenzen. Auf dieser Seite wird auf diese logischen Gruppen als Partitionen bezeichnet. Die folgende Liste zeigt typische Beispiele für Partitionen und Felder:

Anmeldedaten, einschließlich der Felder für Nutzername und Passwort.
Adresse, einschließlich der Felder „Straße“, „Ort“, „Bundesland“ und „Postleitzahl“.
Zahlungsinformationen, einschließlich Kreditkartennummer, Ablaufdatum und Sicherheitscode

Ein Autofill-Service, der Daten korrekt partitioniert, kann den der Daten seiner Nutzer, indem sie keine Daten aus mehr als einer Partition in einer Dataset. Beispielsweise muss ein Dataset mit Anmeldedaten Zahlungsinformationen enthalten. Wenn Sie Daten in Partitionen organisieren, können Sie -Dienst, um die Mindestmenge an relevanten Informationen bereitzustellen, die für eine Anfrage erfüllen.

Durch die Organisation von Daten in Partitionen können Dienste Aktivitäten mit Ansichten aus mehreren Partitionen ausfüllen und gleichzeitig die minimale Menge an relevanten Daten an die Client-App senden. Angenommen, eine Aktivität enthält Ansichten für Nutzername, Passwort, Straße und Ort und einen Autofill-Dienst mit den folgenden Daten:

Partition	Feld 1	Feld 2
Anmeldedaten	work_username	Geschäftliches Passwort
Anmeldedaten	personal_username	persönliches_passwort
Adresse	Arbeitsstraße	work_city
Adresse	personal_street	personal_city

Der Dienst kann einen Datensatz mit der Anmeldedatenpartition für das geschäftliche und das private Konto vorbereiten. Wenn der Nutzer ein Dataset auswählt, Eine nachfolgende Autofill-Antwort kann entweder die berufliche oder die persönliche Adresse, je nach der ersten Wahl des Nutzers.

Ein Dienst kann das Feld identifizieren, von dem die Anfrage stammt, indem er Folgendes aufruft: isFocused() beim Durchlaufen des AssistStructure-Objekts. Dadurch können die -Dienst, um eine FillResponse mit den entsprechenden Partitionsdaten vorzubereiten.

SMS-Einmalcodes automatisch ausfüllen

Ihr Autofill-Dienst kann Nutzern mithilfe der SMS Retriever API dabei helfen, per SMS gesendete Einmalcodes einzugeben.

Für die Nutzung dieser Funktion müssen die folgenden Voraussetzungen erfüllt sein:

Der Autofill-Dienst wird unter Android 9 (API-Level 28) oder höher ausgeführt.
Der Nutzer willigt ein, dass Ihr Autofill-Service Einmalcodes auslesen darf SMS.
Die Anwendung, für die Sie Autofill bereitstellen, verwendet nicht bereits das SMS Retriever API zum Lesen von Einmalcodes.

Ihr Autofill-Dienst kann SmsCodeAutofillClient verwenden. Diese Funktion ist verfügbar, wenn Sie SmsCodeRetriever.getAutofillClient() über Google Play-Dienste 19.0.56 oder höher aufrufen.

Die wichtigsten Schritte zur Verwendung dieser API in einem Autofill-Dienst sind:

Im Autofill-Service hasOngoingSmsRequest verwenden von SmsCodeAutofillClient, um zu ermitteln, ob es Anfragen gibt für den Paketnamen der App, die automatisch ausgefüllt wird. Mein Autofill Der Dienst darf nur dann eine Vorschlagsaufforderung anzeigen, wenn dies false zurückgibt.
Im Autofill-Service checkPermissionState verwenden von SmsCodeAutofillClient, um zu prüfen, ob der Autofill-Service Berechtigung zum automatischen Ausfüllen von Einmalcodes. Dieser Berechtigungsstatus kann NONE sein, GRANTED oder DENIED. Der Autofill-Dienst muss für die Bundesstaaten NONE und GRANTED einen Vorschlag anzeigen.
Verwende in der Autofill-Authentifizierungsaktivität die Berechtigung SmsRetriever.SEND_PERMISSION, um BroadcastReceiver zu registrieren Warten auf SmsCodeRetriever.SMS_CODE_RETRIEVED_ACTION, um die SMS zu erhalten wenn es verfügbar ist.
startSmsCodeRetriever anrufen am SmsCodeAutofillClient, um Einmalcodes zu erfassen, die per SMS gesendet werden. Wenn der Nutzer dem Autofill-Dienst die Berechtigung zum Abrufen einmaliger Daten Codes von SMS erhalten, sucht diese nach SMS-Nachrichten, die in den letzten ein bis fünf Minuten ab jetzt.

Wenn der Autofill-Dienst die Nutzerberechtigung zum einmaligen Lesen anfordern muss fehl, wird für die von startSmsCodeRetriever zurückgegebene Task möglicherweise der Fehler ResolvableApiException zurückgegeben. In diesem Fall müssen Sie die Methode ResolvableApiException.startResolutionForResult() aufrufen, um ein Einwilligungsdialogfeld für die Berechtigungsanfrage anzuzeigen.
Das Ergebnis des SMS-Codes des Intents empfangen und dann die SMS zurückgeben als Autofill-Antwort.

Erweiterte Autofill-Szenarien

In Tastatur einbinden

Ab Android 11 unterstützt die Plattform Tastaturen und andere Eingabemethoden-Editoren (IMEs) um Autofill-Vorschläge inline anzuzeigen, anstatt ein Pulldown-Menü zu verwenden. Weitere Informationen dazu, wie Ihr Autofill-Dienst diese Funktion unterstützen kann, finden Sie unter Autofill in Tastaturen einbinden.

Datasets paginieren

Eine große Autofill-Antwort kann die zulässige Transaktionsgröße des Objekt Binder, das den Wechselobjekt, das für die Verarbeitung der Anfrage erforderlich ist. Um zu verhindern, dass das Android-System in diesen Szenarien keine Ausnahme auslöst, können Sie die FillResponse durch Hinzufügen von nicht mehr als 20 Dataset-Objekten auf einmal ansehen. Wenn für Ihre Antwort weitere Datensätze erforderlich sind, können Sie einen Datensatz hinzufügen, der Nutzer darüber informiert, dass es weitere Informationen gibt, und die nächste Gruppe von Datensätzen abruft, wenn er ausgewählt wird. Weitere Informationen finden Sie unter addDataset(Dataset).

Daten auf mehreren Bildschirmen speichern

In Apps werden Nutzerdaten häufig in mehreren Bildschirmen derselben Aktivität aufgeteilt, insbesondere bei Aktivitäten, mit denen ein neues Nutzerkonto erstellt wird. Auf dem ersten Bildschirm wird beispielsweise nach einem Nutzernamen gefragt. Wenn der Nutzername verfügbar ist, wird auf dem zweiten Bildschirm nach einem Passwort gefragt. In diesen Fällen muss der Autofill-Service warten, bis der Nutzer sowohl bevor die Benutzeroberfläche zum Speichern von Autofill-Daten angezeigt werden kann. Gehen Sie so vor, um mit solchen Szenarien umzugehen:

Geben Sie in der ersten Anfrage ausfüllen Clientstatus-Bundle hinzufügen in der Antwort, die die Autofill-IDs der Teilfelder enthält auf dem Bildschirm angezeigt wird.
In der zweiten Ausführungsanfrage Client-Status-Bundle abrufen, Autofill-IDs abrufen in der vorherigen Anfrage aus dem Clientstatus aus und fügen Sie diese IDs und den FLAG_SAVE_ON_ALL_VIEWS_INVISIBLE für das SaveInfo-Objekt, das in der zweiten Antwort verwendet wird.
In der Speicheranfrage die richtige FillContext -Objekte, um den Wert jedes Felds zu erhalten. Es gibt einen Füllkontext pro Füllanfrage.

Weitere Informationen finden Sie unter Speichern, wenn Daten auf mehrere Bildschirme verteilt sind.

Initialisierungs- und Teardown-Logik für jede Anfrage angeben

Bei jeder Autofill-Anfrage stellt das Android-System eine Verbindung zum und ruft die zugehörige onConnected()-Methode auf. Sobald der Dienst die Anfrage verarbeitet, ruft das Android-System die onDisconnected() und hebt die Bindung an den Dienst auf. Sie können onConnected() implementieren, um Code bereitzustellen, der vor der Verarbeitung einer Anfrage ausgeführt wird, und onDisconnected(), um Code bereitzustellen, der nach der Verarbeitung einer Anfrage ausgeführt wird.

Benutzeroberfläche zum Speichern von Autofill-Daten anpassen

Autofill-Dienste können die Benutzeroberfläche zum Speichern von Autofill-Daten anpassen, damit Nutzer besser entscheiden können, möchten, dass der Dienst ihre Daten speichert. Dienste können zusätzliche Informationen dazu bereitstellen, was gespeichert wird, entweder durch einfachen Text oder durch eine benutzerdefinierte Ansicht. Auch die Darstellung der Schaltfläche kann von Diensten geändert werden. bricht die Anfrage zum Speichern ab und erhält eine Benachrichtigung, Schaltfläche. Weitere Informationen finden Sie auf der Referenzseite zu SaveInfo.

Kompatibilitätsmodus

Im Kompatibilitätsmodus können Autofill-Dienste die Bedienungshilfen virtuelle Struktur für Autofill-Zwecke. Sie ist besonders nützlich, um Autofill-Funktionen in Browsern bereitzustellen, die die Autofill APIs nicht explizit implementieren.

Wenn Sie den Autofill-Dienst im Kompatibilitätsmodus testen möchten, müssen Sie Setzen Sie den Browser oder die App, für die der Kompatibilitätsmodus erforderlich ist, auf die Zulassungsliste. Sie können die welche Pakete bereits auf die Zulassungsliste gesetzt wurden, indem Sie den folgenden Befehl ausführen:

$ adb shell settings get global autofill_compat_mode_allowed_packages

Wenn das Paket, das Sie testen, nicht aufgeführt ist, fügen Sie es mit dem folgenden Befehl hinzu. Dabei steht pkgX für das Paket der App:

$ adb shell settings put global autofill_compat_mode_allowed_packages pkg1[resId1]:pkg2[resId1,resId2]

Wenn es sich bei der App um einen Browser handelt, geben Sie mit resIdx die Ressourcen-ID des Eingabefelds an, das die URL der gerenderten Seite enthält.

Der Kompatibilitätsmodus hat folgende Einschränkungen:

Eine Speicheranfrage wird ausgelöst, wenn der Dienst die FLAG_SAVE_ON_ALL_VIEWS_INVISIBLE oder der setTrigger() aufgerufen wird. FLAG_SAVE_ON_ALL_VIEWS_INVISIBLE ist standardmäßig bei Verwendung des Kompatibilitätsmodus festgelegt.
Der Textwert der Knoten ist möglicherweise nicht in der Methode onSaveRequest(SaveRequest, SaveCallback) verfügbar.

Weitere Informationen zum Kompatibilitätsmodus, einschließlich der Einschränkungen finden Sie in der AutofillService Klassenreferenz.