Ein Autofill-Dienst ist eine App, mit der Nutzer Formulare ausfüllen können, 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 bereitgestellt, die Nutzerdaten verwalten, z. B. Passwortmanager.
Android erleichtert das Ausfüllen von Formularen mit dem ab Android 8.0 (API-Level 26) verfügbaren Autofill-Framework. Nutzer können die Autofill-Funktionen nur verwenden, wenn es eine App gibt, die Autofill-Dienste auf ihrem Gerät bereitstellt.
Auf dieser Seite wird beschrieben, wie Sie einen Autofill-Dienst in Ihrer App implementieren. Ein Codebeispiel, das zeigt, wie ein Dienst implementiert wird, finden Sie im AutofillFramework-Beispiel in Java oder Kotlin.
Weitere Informationen zur Funktionsweise von Autofill-Diensten finden Sie auf den Referenzseiten der Klassen AutofillService
und AutofillManager
.
Manifestdeklarationen und Berechtigungen
Apps, die AutoFill-Dienste anbieten, müssen eine Erklärung enthalten, in der die Implementierung des Dienstes beschrieben wird. Fügen Sie dazu ein <service>
-Element in das App-Manifest ein. Das Element <service>
muss die folgenden Attribute und Elemente enthalten:
android:name
-Attribut, das auf die abgeleitete Klasse vonAutofillService
in der Anwendung verweist, die den Dienst implementiert.android:permission
-Attribut, das die BerechtigungBIND_AUTOFILL_SERVICE
angibt.<intent-filter>
-Element, dessen obligatorisches untergeordnetes<action>
-Element die Aktionandroid.service.autofill.AutofillService
angibt.- Optionales Element
<meta-data>
, mit dem Sie zusätzliche Konfigurationsparameter für den Dienst angeben können
Das folgende Beispiel zeigt eine Erklärung 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 <meta-data>
-Element enthält das Attribut android:resource
, das auf eine XML-Ressource mit weiteren Details zum Dienst verweist.
Die Ressource service_configuration
im vorherigen Beispiel gibt eine Aktivität an, mit der Nutzer den Dienst konfigurieren können. Das folgende Beispiel zeigt die XML-Ressource service_configuration
:
<autofill-service
xmlns:android="http://schemas.android.com/apk/res/android"
android:settingsActivity="com.example.android.SettingsActivity" />
Weitere Informationen zu XML-Ressourcen finden Sie in der Übersicht über Anwendungsressourcen.
Aufforderung zum Aktivieren des Dienstes
Eine App wird als Autofill-Dienst verwendet, nachdem sie die Berechtigung BIND_AUTOFILL_SERVICE
deklariert und der Nutzer sie in den Geräteeinstellungen aktiviert hat. Eine Anwendung kann durch Aufrufen der Methode hasEnabledAutofillServices()
der Klasse AutofillManager
prüfen, ob es der derzeit aktivierte Dienst ist.
Wenn die App nicht der aktuelle Autofill-Service ist, kann sie den Nutzer auffordern, die Autofill-Einstellungen mithilfe des Intents ACTION_REQUEST_SET_AUTOFILL_SERVICE
zu ändern. Der Intent gibt den Wert RESULT_OK
zurück, wenn der Nutzer einen Autofill-Dienst auswählt, der mit dem Paket des Aufrufers übereinstimmt.
Kundenansichten ausfüllen
Der Autofill-Dienst empfängt Anfragen zum Ausfüllen von Clientansichten, wenn der Nutzer mit anderen Apps interagiert. Wenn der Autofill-Dienst Nutzerdaten hat, die der Anfrage entsprechen, sendet er die Daten in der Antwort. Das Android-System zeigt eine Autofill-UI mit den verfügbaren Daten an, wie in Abbildung 1 dargestellt:
Das Autofill-Framework definiert einen Workflow zum Ausfüllen von Ansichten, mit dem die Zeit minimiert wird, die das Android-System an den Autofill-Dienst gebunden ist. Bei jeder Anfrage sendet das Android-System durch Aufrufen der Methode onFillRequest()
ein AssistStructure
-Objekt an den Dienst.
Der Autofill-Dienst prüft, ob die Anfrage mit zuvor gespeicherten Nutzerdaten erfüllt werden kann. Wenn die Anfrage erfüllt werden kann, erstellt der Dienst ein Paket für die Daten in den Dataset
-Objekten. Der Dienst ruft die Methode onSuccess()
auf und übergibt ein FillResponse
-Objekt, das die Dataset
-Objekte enthält. Wenn der Dienst keine Daten hat, um die Anfrage zu erfüllen, übergibt er null
an die Methode onSuccess()
.
Wenn bei der Verarbeitung der Anfrage ein Fehler auftritt, ruft der Dienst stattdessen die Methode onFailure()
auf. Eine detaillierte Erläuterung des Workflows finden Sie in der Beschreibung auf der AutofillService
-Referenzseite.
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 mehrere Datasets haben, die der Anfrage entsprechen. In diesem Fall zeigt das Android-System mehrere Optionen – eine für jedes Dataset – in der Autofill-UI an. 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 die ViewNode
-Objekte in der AssistStructure
aufrufen, um die Autofill-Daten abzurufen, die zur Ausführung der Anfrage erforderlich sind. Ein Dienst kann Autofill-Daten mit Methoden der ViewNode
-Klasse wie getAutofillId()
abrufen.
Ein Dienst muss den Inhalt einer Ansicht beschreiben können, um zu prüfen, ob die Anfrage erfüllt werden kann. Die Verwendung des Attributs autofillHints
ist der erste Ansatz, mit dem ein Dienst den Inhalt einer Ansicht beschreiben muss. Clientanwendungen müssen das Attribut jedoch explizit in ihren Ansichten angeben, bevor es für den Dienst verfügbar ist.
Wenn eine Clientanwendung das Attribut autofillHints
nicht bereitstellt, muss ein Dienst seine eigene Heuristik zur Beschreibung der Inhalte verwenden.
Der Dienst kann Methoden aus anderen Klassen verwenden, z. B. getText()
oder getHint()
, um Informationen zum Inhalt der Ansicht abzurufen.
Weitere Informationen finden Sie unter Hinweise für Autofill bereitstellen.
Das folgende Beispiel zeigt, wie AssistStructure
durchlaufen und AutoFill-Daten aus einem ViewNode
-Objekt abgerufen werden:
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-Service benötigt Nutzerdaten, um Datenansichten in Apps auszufüllen. Wenn Nutzer eine Ansicht manuell ausfüllen, werden sie aufgefordert, die Daten im aktuellen AutoFill-Dienst zu speichern (siehe Abbildung 2).
Zum Speichern der Daten muss der Dienst angeben, dass er die Daten für eine zukünftige Verwendung speichern möchte. Bevor das Android-System eine Anfrage zum Speichern der Daten sendet, gibt es eine Ausführungsanfrage, bei der der Dienst die Möglichkeit hat, die Ansichten auszufüllen. Um anzugeben, dass er die Daten speichern möchte, fügt der Dienst ein SaveInfo
-Objekt in die Antwort auf die Ausführungsanfrage ein. Das SaveInfo
-Objekt enthält mindestens die folgenden Daten:
- Der Typ der gespeicherten Nutzerdaten. Eine Liste der verfügbaren
SAVE_DATA
-Werte finden Sie unterSaveInfo
. - Die Mindestanzahl von Ansichten, die geändert werden müssen, um eine Speicheranfrage auszulösen.
Beispielsweise muss der Nutzer in einem Anmeldeformular normalerweise die Ansichten
username
undpassword
aktualisieren, um eine Speicheranfrage auszulösen.
Ein SaveInfo
-Objekt ist einem FillResponse
-Objekt zugeordnet, wie im folgenden Codebeispiel gezeigt:
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-Dienst kann eine Logik zur Beibehaltung der Nutzerdaten in der onSaveRequest()
-Methode implementieren. Diese wird normalerweise nach Abschluss der Clientaktivität oder wenn die Client-App commit()
aufruft, aufgerufen.
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. Nutzerdaten können jedoch auch Labels oder nicht vertrauliche Daten enthalten. Beispielsweise kann ein Nutzerkonto ein Label enthalten, das die Daten als Arbeitskonto oder als 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, 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.
UI zum Speichern von Autofill verschieben
Wenn Sie ab Android 10 mehrere Bildschirme zum Implementieren eines Autofill-Workflows verwenden – z. B. einen Bildschirm für das Feld für den Nutzernamen und einen anderen für das Passwort –, können Sie die Benutzeroberfläche zum Speichern von Autofill-Daten mit dem Flag SaveInfo.FLAG_DELAY_SAVE
verschieben.
Wenn dieses Flag gesetzt ist, wird die UI zum Speichern von Autofill-Daten nicht ausgelöst, wenn der mit der SaveInfo
-Antwort verknüpfte Autofill-Kontext festgeschrieben wird. Stattdessen können Sie eine separate Aktivität innerhalb derselben Aufgabe verwenden, um zukünftige Ausführungsanfragen zu senden, und dann die UI über eine Speicheranfrage anzeigen. Weitere Informationen findest du unter SaveInfo.FLAG_DELAY_SAVE
.
Nutzerauthentifizierung verlangen
Autofill-Dienste können eine zusätzliche Sicherheitsstufe bieten, da der Nutzer sich authentifizieren muss, bevor Ansichten ausgefüllt werden können. Die folgenden Szenarien eignen sich gut für die Implementierung der Nutzerauthentifizierung:
- Die Nutzerdaten in der App müssen mit einem primären Passwort oder einem Fingerabdruck entsperrt werden.
- Ein bestimmtes Dataset, z. B. Kreditkartendetails, muss mit einer Kartenprüfnummer (CVC) entsperrt werden.
In einem Szenario, in dem der Dienst vor dem Entsperren der Daten eine Nutzerauthentifizierung erfordert, kann der Dienst Boilerplate-Daten oder ein Label angeben und den Intent
angeben, der die Authentifizierung übernimmt. Wenn Sie zusätzliche Daten benötigen, um die Anfrage nach Abschluss des Authentifizierungsvorgangs zu verarbeiten, können Sie diese Daten dem Intent hinzufügen. Über Ihre Authentifizierungsaktivität können die Daten dann an die AutofillService
-Klasse in Ihrer Anwendung zurückgegeben werden.
Das folgende Codebeispiel zeigt, wie Sie angeben, dass die Anfrage eine Authentifizierung erfordert:
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()
aufrufen, einen RESULT_OK
-Wert übergeben und das zusätzliche EXTRA_AUTHENTICATION_RESULT
auf das FillResponse
-Objekt festlegen, das das ausgefüllte Dataset enthält. Der folgende Code zeigt ein Beispiel für die Rückgabe des Ergebnisses nach Abschluss der Authentifizierung:
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);
In dem Szenario, in dem ein Kreditkarten-Dataset entsperrt werden muss, kann der Dienst eine UI anzeigen, in der die CVC-Nummer angefordert wird. Sie können die Daten ausblenden, bis der Datensatz entriegelt ist. Dazu geben Sie Textbausteindaten wie den Namen der Bank und die letzten vier Ziffern der Kreditkartennummer ein. Das folgende Beispiel zeigt, wie eine Authentifizierung für ein Dataset erforderlich ist und die Daten ausgeblendet werden, bis der Nutzer den CVC angibt:
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 sie die Methode setResult()
aufrufen, einen RESULT_OK
-Wert übergeben und das EXTRA_AUTHENTICATION_RESULT
-Extra auf ein Dataset
-Objekt setzen, das die Kreditkartennummer und das Ablaufdatum enthält. Das neue Dataset ersetzt das Dataset, das eine Authentifizierung erfordert, und die Ansichten werden sofort ausgefüllt. Der folgende Code zeigt ein Beispiel für die Rückgabe des Datasets, nachdem der Nutzer den 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);
Die Daten in logischen Gruppen organisieren
Autofill-Dienste müssen die Daten in logische Gruppen organisieren, die Konzepte von verschiedenen Domains isolieren. Auf dieser Seite werden diese logischen Gruppen als Partitionen bezeichnet. Die folgende Liste enthält typische Beispiele für Partitionen und Felder:
- Anmeldedaten, die Felder für Nutzername und Passwort enthalten.
- Adresse, einschließlich der Felder für Straße, Stadt, Bundesland und Postleitzahl
- Zahlungsinformationen, z. B. die Kreditkartennummer, das Ablaufdatum und die Felder mit dem Bestätigungscode
Ein Autofill-Dienst, der Daten korrekt partitioniert, kann die Daten seiner Nutzer besser schützen, da er keine Daten aus mehr als einer Partition in einem Dataset verfügbar macht. Beispielsweise muss ein Dataset mit Anmeldedaten keine Zahlungsinformationen enthalten. Durch das Organisieren von Daten in Partitionen kann Ihr Dienst nur die für die Erfüllung einer Anfrage erforderliche Mindestmenge an relevanten Informationen bereitstellen.
Durch das Organisieren von Daten in Partitionen können Dienste Aktivitäten ausführen, die Ansichten aus mehreren Partitionen enthalten, und gleichzeitig die minimale Menge relevanter Daten an die Client-App senden. Angenommen, eine Aktivität umfasst Ansichten für Nutzername, Passwort, Straße und Stadt sowie einen Autofill-Service mit den folgenden Daten:
Partition | Feld 1 | Feld 2 |
---|---|---|
Anmeldedaten | Arbeitsnutzername | Arbeitspasswort |
persönlicher_Nutzername | privates_Passwort | |
Adresse | Arbeitsstraße | Arbeitsort |
Privatstraße | persönlicher_Stadt |
Der Dienst kann ein Dataset vorbereiten, das die Partition mit Anmeldedaten für die Arbeits- und persönlichen Konten enthält. Wenn der Nutzer einen Datensatz auswählt, kann eine nachfolgende Autofill-Antwort entweder die Arbeits- oder die private Adresse enthalten, je nach erster Wahl des Nutzers.
Ein Dienst kann das Feld identifizieren, von dem die Anfrage stammt. Dazu ruft die Methode isFocused()
beim Durchlaufen des AssistStructure
-Objekts auf. Dadurch kann der Dienst ein FillResponse
mit den entsprechenden Partitionsdaten vorbereiten.
SMS mit einmaligem Code automatisch ausfüllen
Ihr Autofill-Dienst kann den Nutzer beim Ausfüllen von einmaligen Codes, die per SMS gesendet werden, mithilfe der SMS Retriever API unterstützen.
Für die Verwendung dieser Funktion müssen die folgenden Voraussetzungen erfüllt sein:
- Der Autofill-Service läuft unter Android 9 (API-Level 28) oder höher.
- Der Nutzer erteilt die Einwilligung, dass dein Autofill-Dienst Einmalcodes von SMS liest.
- Die Anwendung, für die du Autofill bereitstellt, verwendet nicht bereits die SMS Retriever API zum Lesen von Einmalcodes.
Ihr Autofill-Dienst kann SmsCodeAutofillClient
verwenden, das über SmsCodeRetriever.getAutofillClient()
über die Google Play-Dienste ab Version 19.0.56 verfügbar ist.
Die wichtigsten Schritte zur Verwendung dieser API in einem Autofill-Service sind:
- Verwenden Sie im Autofill-Dienst
hasOngoingSmsRequest
ausSmsCodeAutofillClient
, um festzustellen, ob für den Paketnamen der App, die Sie automatisch ausfüllen möchten, aktive Anfragen vorhanden sind. Der Autofill-Dienst darf nur dann eine Vorschlagsaufforderung anzeigen, wenn die Meldungfalse
zurückgegeben wird. - Verwenden Sie im Autofill-Dienst
checkPermissionState
ausSmsCodeAutofillClient
, um zu prüfen, ob der Autofill-Dienst die Berechtigung zum automatischen Ausfüllen einmaliger Codes hat. Dieser Berechtigungsstatus kannNONE
,GRANTED
oderDENIED
sein. Der Autofill-Dienst muss eine Eingabeaufforderung für Vorschläge für die StatusNONE
undGRANTED
anzeigen. - Verwenden Sie in der Autofill-Authentifizierungsaktivität die Berechtigung
SmsRetriever.SEND_PERMISSION
, um einBroadcastReceiver
zu registrieren, das aufSmsCodeRetriever.SMS_CODE_RETRIEVED_ACTION
wartet, um das Ergebnis des SMS-Codes zu erhalten, wenn es verfügbar ist. Rufen Sie
startSmsCodeRetriever
unterSmsCodeAutofillClient
auf, um auf einmalige Codes zu warten, die per SMS gesendet werden. Wenn der Nutzer Ihrem Autofill-Dienst die Berechtigung erteilt, einmalige Codes aus SMS abzurufen, wird nach SMS gesucht, die in den letzten ein bis fünf Minuten empfangen wurden.Wenn Ihr Autofill-Dienst die Nutzerberechtigung zum Lesen von Einmalcodes anfordern muss, schlägt das von
startSmsCodeRetriever
zurückgegebeneTask
möglicherweise fehl und wirdResolvableApiException
zurückgegeben. In diesem Fall müssen Sie die MethodeResolvableApiException.startResolutionForResult()
aufrufen, um ein Einwilligungsdialogfeld für die Berechtigungsanfrage einzublenden.Sie erhalten das SMS-Codeergebnis vom Intent und geben dann den SMS-Code als Autofill-Antwort zurück.
Erweiterte Autofill-Szenarien
- In Tastatur einbinden
- Ab Android 11 können Tastaturen und andere IMEs für Eingabemethoden Autofill-Vorschläge inline anzeigen lassen, anstatt ein Drop-down-Menü zu verwenden. Weitere Informationen dazu, wie der Autofill-Dienst diese Funktion unterstützt, finden Sie unter Autofill in Tastaturen einbinden.
- Datasets paginieren
- Eine große Autofill-Antwort kann die zulässige Transaktionsgröße des Objekts
Binder
überschreiten, das das für die Verarbeitung der Anfrage erforderliche entfernbare Objekt darstellt. Um zu verhindern, dass das Android-System in diesen Szenarien eine Ausnahme ausgibt, kannst du dieFillResponse
klein halten. Füge dazu nicht mehr als 20Dataset
-Objekte gleichzeitig hinzu. Falls für Ihre Antwort mehr Datasets erforderlich sind, können Sie ein Dataset hinzufügen, das die Nutzer über weitere Informationen informiert und die nächste Gruppe von Datasets bei Auswahl abruft. Weitere Informationen finden Sie unteraddDataset(Dataset)
. - Auf mehrere Bildschirme aufgeteilte Daten speichern
Apps teilen Nutzerdaten oft in einer Aktivität auf mehreren Bildschirmen auf, insbesondere bei Aktivitäten, die zum Erstellen eines neuen Nutzerkontos verwendet werden. Auf dem ersten Bildschirm wird beispielsweise nach einem Nutzernamen gefragt. Wenn der Nutzername verfügbar ist, wird auf einem zweiten Bildschirm nach einem Passwort gefragt. In diesen Fällen muss der Autofill-Dienst warten, bis der Nutzer beide Felder ausgefüllt hat, bevor die UI zum Speichern von AutoFill angezeigt werden kann. Gehen Sie in solchen Fällen so vor:
- Fügen Sie der Antwort in der ersten Ausfüllanfrage ein Clientstatus-Bundle hinzu, das die Autofill-IDs der Teilfelder auf dem Bildschirm enthält.
- Rufen Sie in der zweiten Ausführungsanfrage das Clientstatus-Bundle und die in der vorherigen Anfrage festgelegten Autofill-IDs aus dem Clientstatus ab. Fügen Sie diese IDs sowie das Flag
FLAG_SAVE_ON_ALL_VIEWS_INVISIBLE
dem in der zweiten Antwort verwendetenSaveInfo
-Objekt hinzu. - Verwenden Sie in der Speicheranfrage die richtigen
FillContext
-Objekte, um den Wert der einzelnen Felder zu erhalten. Pro Ausführungsanfrage gibt es einen Füllkontext.
Weitere Informationen finden Sie unter Speichern, wenn Daten auf mehrere Bildschirme aufgeteilt werden.
- Initialisierungs- und Teardown-Logik für jede Anfrage bereitstellen
Jedes Mal, wenn eine Autofill-Anfrage eingeht, stellt das Android-System eine Verbindung zum Dienst her und ruft die Methode
onConnected()
auf. Sobald der Dienst die Anfrage verarbeitet, ruft das Android-System die MethodeonDisconnected()
auf und hebt die Bindung zum Dienst auf. Sie könnenonConnected()
implementieren, um Code bereitzustellen, der vor der Verarbeitung einer Anfrage ausgeführt wird, undonDisconnected()
, 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 anpassen, damit Nutzer entscheiden können, ob der Dienst ihre Daten speichern darf. Dienste können zusätzliche Informationen darüber liefern, was gespeichert wird, entweder in einem einfachen Text oder über eine benutzerdefinierte Ansicht. Dienste können auch das Aussehen der Schaltfläche ändern, mit der die Speicheranfrage abgebrochen wird. Sie erhalten dann eine Benachrichtigung, wenn der Nutzer auf diese Schaltfläche tippt. Weitere Informationen finden Sie auf der Referenzseite zu
SaveInfo
.- Kompatibilitätsmodus
Im Kompatibilitätsmodus können Autofill-Dienste die virtuelle Struktur der Bedienungshilfen für Autofill-Zwecke verwenden. Sie ist besonders nützlich, um die Autofill-Funktion in Browsern bereitzustellen, in denen die Autofill-APIs nicht explizit implementiert sind.
Wenn Sie den Autofill-Dienst im Kompatibilitätsmodus testen möchten, setzen Sie den Browser oder die Anwendung, für die der Kompatibilitätsmodus erforderlich ist, explizit auf die Zulassungsliste. Mit dem folgenden Befehl können Sie prüfen, welche Pakete bereits auf der Zulassungsliste stehen:
$ adb shell settings get global autofill_compat_mode_allowed_packages
Wenn das zu testende Paket nicht aufgeführt ist, fügen Sie es mit dem folgenden Befehl hinzu, wobei
pkgX
das Paket der Anwendung ist:$ adb shell settings put global autofill_compat_mode_allowed_packages pkg1[resId1]:pkg2[resId1,resId2]
Wenn die Anwendung ein Browser ist, geben Sie mit
resIdx
die Ressourcen-ID des Eingabefelds an, das die URL der gerenderten Seite enthält.
Für den Kompatibilitätsmodus gelten folgende Einschränkungen:
- Eine Speicheranfrage wird ausgelöst, wenn der Dienst das Flag
FLAG_SAVE_ON_ALL_VIEWS_INVISIBLE
verwendet oder die MethodesetTrigger()
aufgerufen wird.FLAG_SAVE_ON_ALL_VIEWS_INVISIBLE
ist bei Verwendung des Kompatibilitätsmodus standardmäßig festgelegt. - Der Textwert der Knoten ist in der Methode
onSaveRequest(SaveRequest, SaveCallback)
möglicherweise nicht verfügbar.
Weitere Informationen zum Kompatibilitätsmodus, einschließlich der damit verbundenen Einschränkungen, finden Sie in der Referenz zur Klasse AutofillService
.