Ein Android-App-Link ist ein spezieller Deeplink, mit dem Ihre Website-URLs sofort die entsprechenden Inhalte in Ihrer Android-App öffnen können, ohne dass der Nutzer die App auswählen muss. Android-App-Links verwenden die Digital Asset Links API, um zu bestätigen, dass Ihre App von der Website genehmigt wurde, Links für diese Domain automatisch zu öffnen. Wenn das System erfolgreich bestätigt, dass Sie die Inhaber der URLs sind, werden diese URL-Intents automatisch an Ihre App weitergeleitet.
So weisen Sie nach, dass Sie sowohl die App als auch die Website-URLs besitzen:
Fügen Sie Intent-Filter hinzu, die das Attribut
autoVerifyenthalten. Dieses Attribut signalisiert dem System, dass es prüfen soll, ob Ihre App zu den URL-Domains gehört, die in Ihren Intent-Filtern verwendet werden.Deklarieren Sie die Verknüpfung zwischen Ihrer Website und Ihren Intent-Filtern, indem Sie eine Digital Asset Links-JSON-Datei am folgenden Speicherort hosten:
https://domain.name/.well-known/assetlinks.json
Weitere Informationen finden Sie in den folgenden Ressourcen:
Intent-Filter für die Überprüfung von App-Links hinzufügen
Wenn Sie die Überprüfung der Linkverarbeitung für Ihre App aktivieren möchten, fügen Sie Intent-Filter hinzu, die dem folgenden Format entsprechen:
<!-- Make sure you explicitly set android:autoVerify to "true". -->
<intent-filter android:autoVerify="true">
<action android:name="android.intent.action.VIEW" />
<category android:name="android.intent.category.DEFAULT" />
<category android:name="android.intent.category.BROWSABLE" />
<!-- If a user clicks on a shared link that uses the "http" scheme, your
app should be able to delegate that traffic to "https". -->
<!-- Do not include other schemes. -->
<data android:scheme="http" />
<data android:scheme="https" />
<!-- Include one or more domains that should be verified. -->
<data android:host="..." />
</intent-filter>
Es reicht aus, autoVerify nur in einer <intent-filter>-Deklaration für jeden Host anzugeben, auch wenn dieser Host in anderen nicht markierten Deklarationen verwendet wird. Wir empfehlen jedoch, autoVerify aus Gründen der Einheitlichkeit in jedes <intent-filter>-Element aufzunehmen. So wird auch sichergestellt, dass Ihre App nach dem Entfernen oder Refaktorieren von Elementen in der Manifestdatei weiterhin mit allen Domains verknüpft ist, die Sie weiterhin definieren.
Für die Domainbestätigung ist eine Internetverbindung erforderlich. Der Vorgang kann einige Zeit in Anspruch nehmen. Um die Effizienz des Prozesses zu verbessern, wird eine Domain für eine App, die auf Android 12 oder höher ausgerichtet ist, nur dann vom System überprüft, wenn sie sich in einem <intent-filter>-Element befindet, das das im vorherigen Code-Snippet angegebene genaue Format enthält.
Wenn Sie beispielsweise andere Schemas als „http“ und „https“ verwenden, z. B. <data android:scheme="custom" />, wird die Domainbestätigung nicht durch <intent-filter> ausgelöst.
App-Links für mehrere Hosts unterstützen
Das System muss den Host, der in den Datenelementen der URL-Intent-Filter der App angegeben ist, anhand der Digital Asset Links-Dateien verifizieren können, die in diesem Intent-Filter in den jeweiligen Webdomains gehostet werden. Wenn die Überprüfung fehlschlägt, greift das System auf das Standardverhalten zurück, um die Intention aufzulösen, wie unter Deeplinks zu App-Inhalten erstellen beschrieben. Die App kann jedoch weiterhin als Standard-Handler für alle URL-Muster bestätigt werden, die in den anderen Intent-Filtern der App definiert sind.
Hinweis:Unter Android 11 (API-Level 30) und niedriger wird Ihre App vom System nur dann als Standard-Handler bestätigt, wenn eine passende Digital Asset Links-Datei für alle Hosts gefunden wird, die Sie im Manifest definieren.
Eine App mit den folgenden Intent-Filtern würde die Überprüfung beispielsweise nur für https://www.example.com bestehen, wenn eine assetlinks.json-Datei unter https://www.example.com/.well-known/assetlinks.json, aber nicht unter https://www.example.net/.well-known/assetlinks.json gefunden würde:
<application> <activity android:name=”MainActivity”> <intent-filter android:autoVerify="true"> <action android:name="android.intent.action.VIEW" /> <category android:name="android.intent.category.DEFAULT" /> <category android:name="android.intent.category.BROWSABLE" /> <data android:scheme="http" /> <data android:scheme="https" /> <data android:host="www.example.com" /> </intent-filter> </activity> <activity android:name=”SecondActivity”> <intent-filter> <action android:name="android.intent.action.VIEW" /> <category android:name="android.intent.category.DEFAULT" /> <category android:name="android.intent.category.BROWSABLE" /> <data android:scheme="https" /> <data android:host="www.example.net" /> </intent-filter> </activity> </application>
Hinweis:Alle <data>-Elemente im selben Intent-Filter werden zusammengeführt, um alle Variationen ihrer kombinierten Attribute zu berücksichtigen. Der erste Intent-Filter oben enthält beispielsweise ein <data>-Element, in dem nur das HTTPS-Schema deklariert wird. Es wird jedoch mit dem anderen <data>-Element kombiniert, sodass der Intent-Filter sowohl http://www.example.com als auch https://www.example.com unterstützt.
Daher müssen Sie separate Intent-Filter erstellen, wenn Sie bestimmte Kombinationen von URI-Schemata und Domains definieren möchten.
App-Links für mehrere Subdomains unterstützen
Im Digital Asset Links-Protokoll werden Subdomains in Ihren Intent-Filtern als eindeutige, separate Hosts behandelt. Wenn in Ihrem Intent-Filter mehrere Hosts mit unterschiedlichen Subdomains aufgeführt sind, müssen Sie also auf jeder Domain ein gültiges assetlinks.json veröffentlichen. Der folgende Intent-Filter enthält beispielsweise www.example.com und mobile.example.com als akzeptierte Intent-URL-Hosts. Ein gültiger assetlinks.json-Wert muss also sowohl unter https://www.example.com/.well-known/assetlinks.json als auch unter https://mobile.example.com/.well-known/assetlinks.json veröffentlicht werden.
<application> <activity android:name=”MainActivity”> <intent-filter android:autoVerify="true"> <action android:name="android.intent.action.VIEW" /> <category android:name="android.intent.category.DEFAULT" /> <category android:name="android.intent.category.BROWSABLE" /> <data android:scheme="https" /> <data android:scheme="https" /> <data android:host="www.example.com" /> <data android:host="mobile.example.com" /> </intent-filter> </activity> </application>
Wenn Sie Ihren Hostnamen mit einem Platzhalter deklarieren (z. B. *.example.com), müssen Sie die Datei assetlinks.json im Stamm-Hostname (example.com) veröffentlichen. Eine App mit dem folgenden Intent-Filter besteht die Überprüfung für jeden untergeordneten Namen von example.com (z. B. foo.example.com), sofern die Datei assetlinks.json unter https://example.com/.well-known/assetlinks.json veröffentlicht wird:
<application> <activity android:name=”MainActivity”> <intent-filter android:autoVerify="true"> <action android:name="android.intent.action.VIEW" /> <category android:name="android.intent.category.DEFAULT" /> <category android:name="android.intent.category.BROWSABLE" /> <data android:scheme="https" /> <data android:host="*.example.com" /> </intent-filter> </activity> </application>
Prüfen, ob mehrere Apps mit derselben Domain verknüpft sind
Wenn Sie mehrere Apps veröffentlichen, die jeweils mit derselben Domain verknüpft sind, können sie alle erfolgreich bestätigt werden. Wenn die Apps jedoch denselben Domainhost und ‑pfad auflösen können, wie es bei Lite- und Vollversionen einer App der Fall sein kann, kann nur die zuletzt installierte App Web-Intents für diese Domain auflösen.
Prüfen Sie in einem solchen Fall, ob auf dem Gerät des Nutzers möglicherweise inkompatible Apps installiert sind, sofern Sie die erforderliche Paketsichtbarkeit haben. Zeigen Sie dann in Ihrer App ein benutzerdefiniertes Auswahlfeld an, das die Ergebnisse des Aufrufs von queryIntentActivities() enthält.
Der Nutzer kann seine bevorzugte App aus der Liste der übereinstimmenden Apps auswählen, die im Dialogfeld angezeigt werden.
Websiteverknüpfungen deklarieren
Auf Ihrer Website muss eine Digital Asset Links-JSON-Datei veröffentlicht werden, um die Android-Apps anzugeben, die mit der Website verknüpft sind, und die URL-Intents der App zu verifizieren. In der JSON-Datei werden die folgenden Felder verwendet, um verknüpfte Apps zu identifizieren:
package_name: Die Anwendungs-ID, die in derbuild.gradle-Datei der App deklariert ist.sha256_cert_fingerprints: Die SHA256-Fingerabdrücke des Signaturzertifikats Ihrer App. Mit dem folgenden Befehl können Sie den Fingerabdruck über das Java-Schlüsseltool generieren:keytool -list -v -keystore my-release-key.keystore
Wenn Sie Play App Signing für Ihre App verwenden, stimmt der Zertifikatsfingerabdruck, der durch lokales Ausführen von
keytoolgeneriert wird, in der Regel nicht mit dem auf den Geräten der Nutzer überein. In Ihrem Play Console-Entwicklerkonto können Sie unterRelease > Setup > App signingnachsehen, ob Sie die Play App-Signatur für Ihre App verwenden. Wenn dies der Fall ist, finden Sie auf derselben Seite auch den richtigen JSON-Snippet für Digital Asset Links für Ihre App.
Im folgenden Beispiel wird in der assetlinks.json-Datei einer com.example-Android-App das Recht zum Öffnen von Links gewährt:
[{ "relation": ["delegate_permission/common.handle_all_urls"], "target": { "namespace": "android_app", "package_name": "com.example", "sha256_cert_fingerprints": ["14:6D:E9:83:C5:73:06:50:D8:EE:B9:95:2F:34:FC:64:16:A0:83:42:E6:1D:BE:A8:8A:04:96:B2:3F:CF:44:E5"] } }]
Website mit mehreren Apps verknüpfen
Eine Website kann in derselben assetlinks.json-Datei Verknüpfungen mit mehreren Apps deklarieren. Die folgende Dateiliste zeigt ein Beispiel für eine Erklärungsdatei, in der die Zuordnung zu zwei Apps separat deklariert wird und die sich unter https://www.example.com/.well-known/assetlinks.json befindet:
[{ "relation": ["delegate_permission/common.handle_all_urls"], "target": { "namespace": "android_app", "package_name": "com.example.puppies.app", "sha256_cert_fingerprints": ["14:6D:E9:83:C5:73:06:50:D8:EE:B9:95:2F:34:FC:64:16:A0:83:42:E6:1D:BE:A8:8A:04:96:B2:3F:CF:44:E5"] } }, { "relation": ["delegate_permission/common.handle_all_urls"], "target": { "namespace": "android_app", "package_name": "com.example.monkeys.app", "sha256_cert_fingerprints": ["14:6D:E9:83:C5:73:06:50:D8:EE:B9:95:2F:34:FC:64:16:A0:83:42:E6:1D:BE:A8:8A:04:96:B2:3F:CF:44:E5"] } }]
Verschiedene Apps können Links für verschiedene Ressourcen auf demselben Webhost verarbeiten. Beispiel: app1 deklariert möglicherweise einen Intent-Filter für https://example.com/articles und app2 einen Intent-Filter für https://example.com/videos.
Hinweis:Mehrere Apps, die mit einer Domain verknüpft sind, können mit demselben oder mit unterschiedlichen Zertifikaten signiert werden.
Mehrere Websites mit einer einzelnen App verknüpfen
Mehrere Websites können in ihren jeweiligen assetlinks.json-Dateien Verknüpfungen mit derselben App deklarieren. Die folgenden Dateiauflistungen zeigen ein Beispiel dafür, wie die Verknüpfung von example.com und example.net mit app1 deklariert wird. Im ersten Eintrag wird die Verknüpfung von example.com mit app1 gezeigt:
https://www.example.com/.well-known/assetlinks.json
[{ "relation": ["delegate_permission/common.handle_all_urls"], "target": { "namespace": "android_app", "package_name": "com.mycompany.app1", "sha256_cert_fingerprints": ["14:6D:E9:83:C5:73:06:50:D8:EE:B9:95:2F:34:FC:64:16:A0:83:42:E6:1D:BE:A8:8A:04:96:B2:3F:CF:44:E5"] } }]
In der nächsten Liste sehen Sie die Zuordnung von example.net zu app1. Nur der Speicherort dieser Dateien ist unterschiedlich (.com und .net):
https://www.example.net/.well-known/assetlinks.json
[{ "relation": ["delegate_permission/common.handle_all_urls"], "target": { "namespace": "android_app", "package_name": "com.mycompany.app1", "sha256_cert_fingerprints": ["14:6D:E9:83:C5:73:06:50:D8:EE:B9:95:2F:34:FC:64:16:A0:83:42:E6:1D:BE:A8:8A:04:96:B2:3F:CF:44:E5"] } }]
JSON-Bestätigungsdatei veröffentlichen
Sie müssen Ihre JSON-Verifizierungsdatei am folgenden Ort veröffentlichen:
https://domain.name/.well-known/assetlinks.json
Achten Sie auf Folgendes:
- Die Datei
assetlinks.jsonwird mit dem Inhaltstypapplication/jsonbereitgestellt. - Auf die Datei
assetlinks.jsonmuss über eine HTTPS-Verbindung zugegriffen werden können, unabhängig davon, ob in den Intent-Filtern Ihrer App HTTPS als Datenschema angegeben ist. - Auf die
assetlinks.json-Datei muss ohne Weiterleitungen zugegriffen werden können (keine 301- oder 302-Weiterleitungen). - Wenn Ihre App-Links mehrere Hostdomains unterstützen, müssen Sie die
assetlinks.json-Datei auf jeder Domain veröffentlichen. Weitere Informationen finden Sie unter App-Verknüpfung für mehrere Hosts unterstützen. - Veröffentlichen Sie Ihre App nicht mit Entwicklungs-/Test-URLs in der Manifestdatei, die möglicherweise nicht öffentlich zugänglich sind (z. B. URLs, auf die nur über ein VPN zugegriffen werden kann). In solchen Fällen können Sie Build-Varianten konfigurieren, um eine andere Manifestdatei für Entwickler-Builds zu generieren.
Bestätigung von Android-App-Links
Wenn android:autoVerify="true" in mindestens einem Intent-Filter Ihrer App vorhanden ist, wird beim Installieren Ihrer App auf einem Gerät mit Android 6.0 (API-Level 23) oder höher automatisch überprüft, ob die Hosts, die mit den URLs in den Intent-Filtern Ihrer App verknüpft sind, zu Ihrer Website gehören. Unter Android 12 und höher können Sie das Bestätigungsverfahren auch manuell aufrufen, um die Bestätigungslogik zu testen.
Automatische Bestätigung
Die automatische Überprüfung des Systems umfasst Folgendes:
- Das System prüft alle Intent-Filter, die Folgendes enthalten:
- Aktion:
android.intent.action.VIEW - Kategorien:
android.intent.category.BROWSABLEundandroid.intent.category.DEFAULT - Datenschema:
httpoderhttps
- Aktion:
- Für jeden eindeutigen Hostnamen, der in den oben genannten Intent-Filtern gefunden wird, fragt Android die entsprechenden Websites nach der Digital Asset Links-Datei unter
https://hostname/.well-known/assetlinks.jsonab.
Nachdem Sie die Liste der Websites bestätigt haben, die mit Ihrer App verknüpft werden sollen, und die gehostete JSON-Datei gültig ist, installieren Sie die App auf Ihrem Gerät. Warten Sie mindestens 20 Sekunden, bis die asynchrone Bestätigung abgeschlossen ist. Mit dem folgenden Befehl können Sie prüfen, ob das System Ihre App überprüft und die richtigen Richtlinien für die Linkverarbeitung festgelegt hat:
adb shell am start -a android.intent.action.VIEW \
-c android.intent.category.BROWSABLE \
-d "http://domain.name:optional_port"
Manuelle Bestätigung
Ab Android 12 können Sie die Domainbestätigung für eine App, die auf einem Gerät installiert ist, manuell aufrufen. Sie können diesen Vorgang unabhängig davon ausführen, ob Ihre App auf Android 12 ausgerichtet ist.
Internetverbindung herstellen
Für die Domainbestätigung muss Ihr Testgerät mit dem Internet verbunden sein.
Unterstützung des aktualisierten Domainbestätigungsprozesses
Wenn Ihre App auf Android 12 oder höher ausgerichtet ist, verwendet das System automatisch das aktualisierte Verfahren zur Domainbestätigung.
Andernfalls können Sie das aktualisierte Bestätigungsverfahren manuell aktivieren. Führen Sie dazu den folgenden Befehl in einem Terminalfenster aus:
adb shell am compat enable 175408749 PACKAGE_NAME
Zustand von Android-App-Links auf einem Gerät zurücksetzen
Bevor Sie die Domainbestätigung auf einem Gerät manuell aufrufen, müssen Sie den Status von Android-App-Links auf dem Testgerät zurücksetzen. Führen Sie dazu den folgenden Befehl in einem Terminalfenster aus:
adb shell pm set-app-links --package PACKAGE_NAME 0 all
Mit diesem Befehl wird das Gerät in den Zustand zurückversetzt, in dem es sich befindet, bevor der Nutzer Standard-Apps für Domains auswählt.
Domainbestätigungsprozess aufrufen
Nachdem Sie den Status von Android-App-Links auf einem Gerät zurückgesetzt haben, können Sie die Bestätigung selbst durchführen. Führen Sie dazu den folgenden Befehl in einem Terminalfenster aus:
adb shell pm verify-app-links --re-verify PACKAGE_NAME
Ergebnisse der Überprüfung ansehen
Nachdem der Bestätigungs-Agent einige Zeit hatte, seine Anfragen abzuschließen, können Sie die Bestätigungsergebnisse überprüfen. Führen Sie dazu den folgenden Befehl aus:
adb shell pm get-app-links PACKAGE_NAME
Die Ausgabe dieses Befehls sieht so aus:
com.example.pkg:
ID: 01234567-89ab-cdef-0123-456789abcdef
Signatures: [***]
Domain verification state:
example.com: verified
sub.example.com: legacy_failure
example.net: verified
example.org: 1026
Domains, die die Bestätigung bestehen, haben den Status verified. Jeder andere Status gibt an, dass die Domainbestätigung nicht durchgeführt werden konnte. Insbesondere der Status none gibt an, dass der Bestätigungsbeauftragte den Bestätigungsprozess möglicherweise noch nicht abgeschlossen hat.
In der folgenden Liste sind die möglichen Rückgabewerte aufgeführt, die bei der Domainbestätigung für eine bestimmte Domain zurückgegeben werden können:
none- Für diese Domain wurden keine Daten aufgezeichnet. Warten Sie einige Minuten, bis der Bestätigungs-Agent die Anfragen zur Domainbestätigung abgeschlossen hat, und rufen Sie den Domainbestätigungsprozess noch einmal auf.
verified- Die Domain wurde für die deklarierende App bestätigt.
approved- Die Domain wurde zwangsweise genehmigt, in der Regel durch Ausführen eines Shell-Befehls.
denied- Die Domain wurde zwangsweise abgelehnt, in der Regel durch Ausführen eines Shell-Befehls.
migrated- Das System hat das Ergebnis eines früheren Prozesses beibehalten, bei dem die alte Domainüberprüfung verwendet wurde.
restored- Die Domain wurde genehmigt, nachdem der Nutzer eine Datenwiederherstellung durchgeführt hat. Es wird davon ausgegangen, dass die Domain bereits bestätigt wurde.
legacy_failure- Die Domain wurde von einem Legacy-Bestätiger abgelehnt. Der genaue Grund für den Fehler ist unbekannt.
system_configured- Die Domain wurde automatisch durch die Gerätekonfiguration genehmigt.
- Fehlercode von
1024oder höher Benutzerdefinierter Fehlercode, der für den Prüfer des Geräts spezifisch ist.
Prüfen Sie, ob Sie eine Netzwerkverbindung hergestellt haben, und rufen Sie den Domainbestätigungsprozess noch einmal auf.
Nutzer auffordern, Ihre App mit einer Domain zu verknüpfen
Eine weitere Möglichkeit, die Genehmigung für eine Domain zu erhalten, besteht darin, den Nutzer zu bitten, Ihre App mit dieser Domain zu verknüpfen.
Prüfen, ob Ihre App bereits für die Domain genehmigt wurde
Bevor Sie den Nutzer auffordern, prüfen Sie, ob Ihre App der Standard-Handler für die Domains ist, die Sie in Ihren <intent-filter>-Elementen definieren. Sie können den Genehmigungsstatus mit einer der folgenden Methoden abfragen:
- Die
DomainVerificationManagerAPI (zur Laufzeit). - Ein Befehlszeilenprogramm (während des Tests).
DomainVerificationManager
Das folgende Code-Snippet zeigt, wie die DomainVerificationManager API verwendet wird:
Kotlin
val context: Context = TODO("Your activity or fragment's Context") val manager = context.getSystemService(DomainVerificationManager::class.java) val userState = manager.getDomainVerificationUserState(context.packageName) // Domains that have passed Android App Links verification. val verifiedDomains = userState?.hostToStateMap ?.filterValues { it == DomainVerificationUserState.DOMAIN_STATE_VERIFIED } // Domains that haven't passed Android App Links verification but that the user // has associated with an app. val selectedDomains = userState?.hostToStateMap ?.filterValues { it == DomainVerificationUserState.DOMAIN_STATE_SELECTED } // All other domains. val unapprovedDomains = userState?.hostToStateMap ?.filterValues { it == DomainVerificationUserState.DOMAIN_STATE_NONE }
Java
Context context = TODO("Your activity or fragment's Context"); DomainVerificationManager manager = context.getSystemService(DomainVerificationManager.class); DomainVerificationUserState userState = manager.getDomainVerificationUserState(context.getPackageName()); Map<String, Integer> hostToStateMap = userState.getHostToStateMap(); List<String> verifiedDomains = new ArrayList<>(); List<String> selectedDomains = new ArrayList<>(); List<String> unapprovedDomains = new ArrayList<>(); for (String key : hostToStateMap.keySet()) { Integer stateValue = hostToStateMap.get(key); if (stateValue == DomainVerificationUserState.DOMAIN_STATE_VERIFIED) { // Domain has passed Android App Links verification. verifiedDomains.add(key); } else if (stateValue == DomainVerificationUserState.DOMAIN_STATE_SELECTED) { // Domain hasn't passed Android App Links verification, but the user has // associated it with an app. selectedDomains.add(key); } else { // All other domains. unapprovedDomains.add(key); } }
Befehlszeilenprogramm
Wenn Sie Ihre App während der Entwicklung testen, können Sie mit dem folgenden Befehl den Überprüfungsstatus der Domains abfragen, die Ihrer Organisation gehören:
adb shell pm get-app-links --user cur PACKAGE_NAME
Im folgenden Beispiel wurde die App zwar nicht für die Domain „example.org“ bestätigt, Nutzer 0 hat die App aber manuell in den Systemeinstellungen genehmigt und kein anderes Paket ist für diese Domain bestätigt.
com.example.pkg:
ID: ***
Signatures: [***]
Domain verification state:
example.com: verified
example.net: verified
example.org: 1026
User 0:
Verification link handling allowed: true
Selection state:
Enabled:
example.org
Disabled:
example.com
example.net
Sie können auch Shell-Befehle verwenden, um den Prozess zu simulieren, bei dem der Nutzer auswählt, welche App mit einer bestimmten Domain verknüpft ist. Eine vollständige Beschreibung dieser Befehle finden Sie in der Ausgabe von adb shell pm.
Kontext für die Anfrage angeben
Bevor Sie diese Anfrage zur Domaingenehmigung stellen, sollten Sie dem Nutzer etwas Kontext geben. Sie können Nutzern beispielsweise einen Splash-Screen, ein Dialogfeld oder ein ähnliches UI-Element anzeigen, in dem erklärt wird, warum Ihre App der Standard-Handler für eine bestimmte Domain sein sollte.
Anfrage stellen
Nachdem der Nutzer verstanden hat, was Ihre App von ihm verlangt, können Sie die Anfrage stellen.
Rufen Sie dazu ein Intent auf, das die Intent-Aktion ACTION_APP_OPEN_BY_DEFAULT_SETTINGS und einen Datenstring enthält, der package:com.example.pkg für die Ziel-App entspricht, wie im folgenden Code-Snippet gezeigt:
Kotlin
val context: Context = TODO("Your activity or fragment's Context") val intent = Intent(Settings.ACTION_APP_OPEN_BY_DEFAULT_SETTINGS, Uri.parse("package:${context.packageName}")) context.startActivity(intent)
Java
Context context = TODO("Your activity or fragment's Context"); Intent intent = new Intent(Settings.ACTION_APP_OPEN_BY_DEFAULT_SETTINGS, Uri.parse("package:" + context.getPackageName())); context.startActivity(intent);
Wenn der Intent aufgerufen wird, sehen Nutzer einen Einstellungsbildschirm mit dem Namen Standardmäßig öffnen. Dieser Bildschirm enthält ein Optionsfeld mit dem Namen Unterstützte Links öffnen, wie in Abbildung 1 dargestellt.
Wenn der Nutzer Unterstützte Links öffnen aktiviert, wird unter dem Abschnitt In dieser App zu öffnende Links eine Reihe von Kästchen angezeigt. Dort können Nutzer die Domains auswählen, die sie mit Ihrer App verknüpfen möchten. Sie können auch Link hinzufügen auswählen, um Domains hinzuzufügen (siehe Abbildung 2). Wenn Nutzer später einen Link in den von ihnen hinzugefügten Domains auswählen, wird der Link automatisch in Ihrer App geöffnet.
Domains in Ihrer App öffnen, die nicht von Ihrer App bestätigt werden können
Die Hauptfunktion Ihrer App besteht möglicherweise darin, Links als Drittanbieter zu öffnen, ohne die Möglichkeit, die verarbeiteten Domains zu bestätigen. Wenn dies der Fall ist, erklären Sie den Nutzern, dass sie zu diesem Zeitpunkt, wenn sie einen Weblink auswählen, nicht zwischen einer selbst entwickelten App und Ihrer (Drittanbieter-)App wählen können. Nutzer müssen die Domains manuell mit Ihrer Drittanbieter-App verknüpfen.
Außerdem sollten Sie ein Dialogfeld oder eine Trampolinaktivität einführen, über die der Nutzer den Link in der eigenen App öffnen kann, wenn er dies bevorzugt. Bevor Sie ein solches Dialogfeld oder eine solche Trampolin-Aktivität einrichten, müssen Sie Ihre App so konfigurieren, dass sie Paketsichtbarkeit für die Erstanbieter-Apps hat, die dem Web-Intent-Filter Ihrer App entsprechen.
App-Links testen
Wenn Sie die App-Verknüpfungsfunktion implementieren, sollten Sie die Verknüpfungsfunktion testen, um sicherzustellen, dass das System Ihre App wie erwartet mit Ihren Websites verknüpfen und URL-Anfragen verarbeiten kann.
Wenn Sie eine vorhandene Anweisungsdatei testen möchten, können Sie das Tool Statement List Generator and Tester verwenden.
Liste der zu bestätigenden Hosts bestätigen
Beim Testen sollten Sie die Liste der zugehörigen Hosts bestätigen, die das System für Ihre App überprüfen soll. Erstellen Sie eine Liste aller URLs, deren entsprechende Intent-Filter die folgenden Attribute und Elemente enthalten:
- Attribut
android:schememit dem Werthttpoderhttps android:host-Attribut mit einem Domain-URL-Musterandroid.intent.action.VIEW-Aktionselement- Kategorieelement „
android.intent.category.BROWSABLE“
Prüfen Sie anhand dieser Liste, ob auf jedem genannten Host und jeder genannten Subdomain eine Digital Asset Links-JSON-Datei vorhanden ist.
Digital Asset Links-Dateien bestätigen
Verwenden Sie für jede Website die Digital Asset Links API, um zu bestätigen, dass die Digital Asset Links-JSON-Datei richtig gehostet und definiert ist:
https://digitalassetlinks.googleapis.com/v1/statements:list? source.web.site=https://domain.name:optional_port& relation=delegate_permission/common.handle_all_urls
Richtlinien für Links prüfen
Im Rahmen des Testverfahrens können Sie die aktuellen Systemeinstellungen für die Linkverarbeitung prüfen. Verwenden Sie den folgenden Befehl, um eine Liste der vorhandenen Richtlinien für die Linkverarbeitung für alle Apps auf Ihrem verbundenen Gerät abzurufen:
adb shell dumpsys package domain-preferred-apps
Oder Sie verwenden folgenden Code:
adb shell dumpsys package d
Hinweis:Warten Sie nach der Installation Ihrer App mindestens 20 Sekunden, damit das System den Bestätigungsprozess abschließen kann.
Der Befehl gibt eine Liste der einzelnen Nutzer oder Profile zurück, die auf dem Gerät definiert sind, vorangestellt von einer Kopfzeile im folgenden Format:
App linkages for user 0:
Nach diesem Header wird in der Ausgabe das folgende Format verwendet, um die Einstellungen für die Linkbearbeitung für diesen Nutzer aufzulisten:
Package: com.android.vending Domains: play.google.com market.android.com Status: always : 200000002
In dieser Liste sehen Sie, welche Apps für den jeweiligen Nutzer mit welchen Domains verknüpft sind:
Package: Identifiziert eine App anhand ihres Paketnamens, wie im Manifest deklariert.Domains: Zeigt die vollständige Liste der Hosts an, deren Weblinks von dieser App verarbeitet werden. Die einzelnen Einträge werden durch Leerzeichen getrennt.Status: Hier wird die aktuelle Einstellung für die Linkverarbeitung für diese App angezeigt. Bei einer App, die die Bestätigung bestanden hat und deren Manifestandroid:autoVerify="true"enthält, wird der Statusalwaysangezeigt. Die Hexadezimalzahl nach diesem Status bezieht sich auf den Eintrag des Android-Systems zu den Einstellungen des Nutzers zur App-Verknüpfung. Dieser Wert gibt nicht an, ob die Bestätigung erfolgreich war.
Hinweis:Wenn ein Nutzer die App-Link-Einstellungen für eine App ändert, bevor die Überprüfung abgeschlossen ist, wird möglicherweise ein fälschlicherweise positives Ergebnis für eine erfolgreiche Überprüfung angezeigt, obwohl die Überprüfung fehlgeschlagen ist. Dieser Bestätigungsfehler spielt jedoch keine Rolle, wenn der Nutzer die App explizit so eingestellt hat, dass unterstützte Links ohne Nachfrage geöffnet werden. Das liegt daran, dass die Nutzereinstellungen Vorrang vor der programmatischen Bestätigung (oder dem Fehlen einer solchen) haben. Der Link führt dann direkt zu Ihrer App, ohne dass ein Dialogfeld angezeigt wird, so als ob die Überprüfung erfolgreich gewesen wäre.
Testbeispiel
Damit die App-Link-Bestätigung erfolgreich ist, muss das System Ihre App mit jeder der Websites bestätigen können, die Sie in einem bestimmten Intent-Filter angeben, der die Kriterien für App-Links erfüllt. Das folgende Beispiel zeigt eine Manifestkonfiguration mit mehreren App-Links:
<application> <activity android:name=”MainActivity”> <intent-filter android:autoVerify="true"> <action android:name="android.intent.action.VIEW" /> <category android:name="android.intent.category.DEFAULT" /> <category android:name="android.intent.category.BROWSABLE" /> <data android:scheme="https" /> <data android:scheme="https" /> <data android:host="www.example.com" /> <data android:host="mobile.example.com" /> </intent-filter> <intent-filter> <action android:name="android.intent.action.VIEW" /> <category android:name="android.intent.category.BROWSABLE" /> <data android:scheme="https" /> <data android:host="www.example2.com" /> </intent-filter> </activity> <activity android:name=”SecondActivity”> <intent-filter> <action android:name="android.intent.action.VIEW" /> <category android:name="android.intent.category.DEFAULT" /> <category android:name="android.intent.category.BROWSABLE" /> <data android:scheme="https" /> <data android:host="account.example.com" /> </intent-filter> </activity> <activity android:name=”ThirdActivity”> <intent-filter> <action android:name="android.intent.action.VIEW" /> <category android:name="android.intent.category.DEFAULT" /> <data android:scheme="https" /> <data android:host="map.example.com" /> </intent-filter> <intent-filter> <action android:name="android.intent.action.VIEW" /> <category android:name="android.intent.category.BROWSABLE" /> <data android:scheme="market" /> <data android:host="example.com" /> </intent-filter> </activity> </application>
Die Liste der Hosts, die die Plattform anhand des oben genannten Manifests zu bestätigen versucht, lautet:
www.example.com mobile.example.com www.example2.com account.example.com
Die Liste der Hosts, die von der Plattform nicht versucht werden, aus dem oben genannten Manifest zu bestätigen, lautet:
map.example.com (it does not have android.intent.category.BROWSABLE) market://example.com (it does not have either an "http" or "https" scheme)
Weitere Informationen zu Anweisungslisten finden Sie unter Anweisungsliste erstellen.
Häufige Implementierungsfehler beheben
Wenn Sie Ihre Android App Links nicht bestätigen können, prüfen Sie, ob einer der folgenden häufigen Fehler vorliegt. In diesem Abschnitt wird example.com als Platzhalter für einen Domainnamen verwendet. Wenn Sie diese Prüfungen durchführen, ersetzen Sie example.com durch den tatsächlichen Domainnamen Ihres Servers.
- Falsch eingerichteter Intent-Filter
- Prüfen Sie, ob Sie in einem
<intent-filter>-Element eine URL angeben, deren Inhaber Ihre App nicht ist. - Falsche Serverkonfiguration
Prüfen Sie die JSON-Konfiguration Ihres Servers und achten Sie darauf, dass der SHA-Wert korrekt ist.
Prüfen Sie außerdem, ob unter
example.com.(mit dem abschließenden Punkt) dieselben Inhalte wie unterexample.comausgeliefert werden.- Serverseitige Weiterleitungen
Das System überprüft keine Android App Links für Ihre App, wenn Sie eine Weiterleitung wie die folgende einrichten:
http://example.combishttps://example.comexample.combiswww.example.com
Dadurch wird die Sicherheit Ihrer App geschützt.
- Serverrobustheit
Prüfen Sie, ob Ihr Server eine Verbindung zu Ihren Client-Apps herstellen kann.
- Nicht überprüfbare Links
Zu Testzwecken können Sie absichtlich nicht überprüfbare Links hinzufügen. Unter Android 11 und niedriger bewirken diese Links, dass das System nicht alle Android-App-Links für Ihre App überprüft.
- Falsche Signatur in assetlinks.json
Prüfen Sie, ob Ihre Signatur korrekt ist und mit der Signatur übereinstimmt, die zum Signieren Ihrer App verwendet wurde. Häufige Fehler sind:
- Die App wird mit einem Debug-Zertifikat signiert und die Release-Signatur ist nur in
assetlinks.jsonvorhanden. - Eine Signatur in Kleinbuchstaben in
assetlinks.json. Die Signatur sollte in Großbuchstaben angegeben werden. - Wenn Sie die Play App-Signatur verwenden, müssen Sie die Signatur verwenden, mit der Google jeden Ihrer Releases signiert. Sie können diese Details, einschließlich eines vollständigen JSON-Snippets, überprüfen, indem Sie der Anleitung zum Deklarieren von Websitezuordnungen folgen.
- Die App wird mit einem Debug-Zertifikat signiert und die Release-Signatur ist nur in