Ein Android-App-Link ist eine spezielle Art von Deeplink, mit dem über Ihre Website-URLs sofort die entsprechenden Inhalte in Ihrer Android-App geöffnet werden können, ohne dass der Nutzer die App auswählen muss. Android-App-Links nutzen die Digital Asset Links API, um zu vertrauen, dass Ihre App von der Website als automatisches Öffnen von Links für diese Domain genehmigt wurde. Wenn das System erfolgreich bestätigt, dass Sie Inhaber der URLs sind, leitet das System diese URL-Intents automatisch an Ihre Anwendung weiter.
Führe die folgenden Schritte aus, um zu bestätigen, dass du der Inhaber der App und der Website-URLs bist:
Fügen Sie Intent-Filter hinzu, die das Attribut
autoVerifyenthalten. Dieses Attribut signalisiert dem System, dass geprüft werden 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 an folgendem Speicherort hosten:
https://domain.name/.well-known/assetlinks.json
Zugehörige Informationen finden Sie in den folgenden Ressourcen:
Intent-Filter für die Bestätigung von App-Links hinzufügen
Fügen Sie Intent-Filter mit dem folgenden Format hinzu, um die Überprüfung der Linkverarbeitung für Ihre Anwendung zu aktivieren:
<!-- 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". -->
<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 eine <intent-filter>-Deklaration für jeden Host aufzunehmen, auch wenn dieser Host in anderen nicht gekennzeichneten Deklarationen verwendet wird. Aus Konsistenzgründen sollten Sie autoVerify jedem <intent-filter>-Element hinzufügen. Außerdem wird so sichergestellt, dass Ihre Anwendung nach dem Entfernen oder Refaktorieren von Elementen in der Manifestdatei weiterhin mit allen Domains verknüpft bleibt, die Sie noch definieren.
Für die Domainbestätigung ist eine Internetverbindung erforderlich und der Vorgang kann einige Zeit in Anspruch nehmen. Zur Verbesserung der Effizienz des Prozesses überprüft das System eine Domain für eine App, die auf Android 12 oder höher ausgerichtet ist, nur dann, wenn sich die Domain in einem <intent-filter>-Element befindet, das das im vorherigen Code-Snippet angegebene Format enthält.
Unterstützung von App-Verknüpfungen für mehrere Hosts
Das System muss in der Lage sein, den in den Datenelementen der URL-Intent-Filtern der App angegebenen Host mit den Digital Asset Links-Dateien zu vergleichen, die auf den entsprechenden Webdomains in diesem Intent-Filter gehostet werden. Wenn die Überprüfung fehlschlägt, übernimmt das System standardmäßig das Standardverhalten, um den Intent aufzulösen, wie unter Deeplinks zu App-Inhalten erstellen beschrieben. Die Anwendung kann jedoch weiterhin als Standard-Handler für jedes der URL-Muster geprüft werden, die in den anderen Intent-Filtern der Anwendung definiert sind.
Hinweis:Unter Android 11 (API-Level 30) und niedriger wird deine App vom System nur dann als Standard-Handler verifiziert, wenn eine entsprechende Digital Asset Links-Datei für alle Hosts gefunden wird, die du im Manifest definiert hast.
Eine Anwendung mit den folgenden Intent-Filtern würde beispielsweise nur dann die Überprüfung 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 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="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 Varianten ihrer kombinierten Attribute zu berücksichtigen. Der erste Intent-Filter oben enthält beispielsweise ein <data>-Element, das nur das HTTPS-Schema deklariert. 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-Verknüpfung für mehrere Subdomains unterstützen
Das Digital Asset Links-Protokoll behandelt Subdomains in Ihren Intent-Filtern als eindeutige, separate Hosts. Wenn Ihr Intent-Filter also mehrere Hosts mit unterschiedlichen Subdomains auflistet, müssen Sie in jeder Domain eine gültige assetlinks.json veröffentlichen. Der folgende Intent-Filter enthält beispielsweise www.example.com und mobile.example.com als akzeptierte Intent-URL-Hosts. Daher muss ein gültiger assetlinks.json 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 wie *.example.com deklarieren, müssen Sie alternativ die Datei assetlinks.json unter dem Stammhostnamen (example.com) veröffentlichen. Eine Anwendung mit dem folgenden Intent-Filter wird beispielsweise die Überprüfung für alle Unternamen von example.com (z. B. foo.example.com) bestehen, solange 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>
Nach mehreren Apps suchen, die 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 Anwendungen jedoch exakt denselben Domainhost und Pfad auflösen können, wie es bei Lite- und Vollversionen einer Anwendung der Fall sein kann, kann nur die zuletzt installierte Anwendung Web Intents für diese Domain auflösen.
Suche in einem solchen Fall nach möglicherweise in Konflikt stehenden Apps auf dem Gerät des Nutzers, sofern du die erforderliche Paketsichtbarkeit hast. Anschließend wird in Ihrer App ein benutzerdefiniertes Auswahldialogfeld mit den Ergebnissen des Aufrufs von queryIntentActivities() eingeblendet.
Der Nutzer kann seine bevorzugte App aus der Liste übereinstimmender Apps im Dialogfeld auswählen.
Websiteverknüpfungen deklarieren
Auf deiner Website muss eine JSON-Datei für Digital Asset Links veröffentlicht werden, um die mit der Website verknüpften Android-Apps anzugeben und die URL-Intents der App zu überprüfen. In der JSON-Datei werden die folgenden Felder verwendet, um verknüpfte Apps zu identifizieren:
package_name: Die in der Dateibuild.gradleder Anwendung deklarierte Anwendungs-ID.sha256_cert_fingerprints: Die SHA256-Fingerabdrücke des Signaturzertifikats Ihrer App. Sie können den folgenden Befehl verwenden, um den Fingerabdruck über das Java-Keytool zu generieren:keytool -list -v -keystore my-release-key.keystore
Dieses Feld unterstützt mehrere Fingerabdrücke, die zur Unterstützung verschiedener Versionen Ihrer Anwendung verwendet werden können, z. B. zur Fehlerbehebung und Produktions-Builds.Wenn Sie für Ihre App die Play App-Signatur verwenden, stimmt der Zertifikat-Fingerabdruck, der beim lokalen Ausführen von
keytoolerzeugt wird, normalerweise nicht mit dem Fingerabdruck auf den Nutzergeräten überein. Sie können in Ihrem Play Console-Entwicklerkonto unterRelease > Setup > App signingprüfen, ob Sie die Play App-Signatur für Ihre App verwenden. In diesem Fall finden Sie auf derselben Seite auch das richtige Digital Asset Links-JSON-Snippet für Ihre App.
Die folgende Beispieldatei assetlinks.json gewährt Links zum Öffnen von Links an einer com.example-Android-App:
[{
"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"]
}
}]
Eine Website mit mehreren Apps verknüpfen
Eine Website kann Verknüpfungen mit mehreren Apps in derselben assetlinks.json-Datei deklarieren. Die folgende Dateiliste zeigt ein Beispiel für eine Anweisungsdatei, in der die Verknüpfung mit zwei Anwendungen separat deklariert wird und 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 unterschiedliche Ressourcen auf demselben Webhost verarbeiten. Beispielsweise kann „app1“ einen Intent-Filter für https://example.com/articles und „app2“ einen Intent-Filter für https://example.com/videos deklarieren.
Hinweis:Mehrere mit einer Domain verknüpfte Anwendungen können mit demselben oder unterschiedlichen Zertifikaten signiert sein.
Mehrere Websites mit einer einzelnen App verknüpfen
Mehrere Websites können Verknüpfungen mit derselben Anwendung in ihren jeweiligen assetlinks.json-Dateien deklarieren. Die folgenden Dateieinträge zeigen ein Beispiel dafür, wie die Verknüpfung von „beispiel.de“ und „beispiel.net“ mit „app1“ deklariert wird. Der erste Eintrag zeigt die Verknüpfung von example.com mit app1:
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"]
}
}]
Die nächste Auflistung zeigt die Verknüpfung von example.net mit 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-Bestätigungsdatei am folgenden Speicherort veröffentlichen:
https://domain.name/.well-known/assetlinks.json
Achten Sie dabei 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 Anwendung HTTPS als Datenschema deklariert ist. - Auf die Datei
assetlinks.jsonmuss ohne Weiterleitungen zugegriffen werden können (keine 301- oder 302-Weiterleitungen). - Wenn Ihre App-Links mehrere Hostdomains unterstützen, müssen Sie die Datei
assetlinks.jsonin jeder Domain veröffentlichen. Siehe Anwendungsverknü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. solche, die nur über ein VPN zugänglich sind. Als Problemumgehung können Sie in solchen Fällen Build-Varianten konfigurieren, um eine andere Manifestdatei für Entwicklungs-Builds zu generieren.
Bestätigung von Android-App-Links
Wenn android:autoVerify="true" in mindestens einem der Intent-Filter Ihrer App vorhanden ist und Ihre App auf einem Gerät mit Android 6.0 (API-Level 23) oder höher installiert wird, prüft das System automatisch die Hosts, die mit den URLs in den Intent-Filtern Ihrer App verknüpft sind. Unter Android 12 und höher können Sie den Bestätigungsprozess 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 mit einem der folgenden Elemente:
- Aktion:
android.intent.action.VIEW - Kategorien:
android.intent.category.BROWSABLEundandroid.intent.category.DEFAULT - Datenschema:
httpoderhttps
- Aktion:
- Für jeden eindeutigen Hostnamen, der in den obigen 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, die mit Ihrer App verknüpft werden sollen, überprüft und bestätigt haben, dass die gehostete JSON-Datei gültig ist, installieren Sie die App auf Ihrem Gerät. Warten Sie mindestens 20 Sekunden, bis die asynchrone Überprüfung abgeschlossen ist. Mit dem folgenden Befehl können Sie prüfen, ob das System Ihre Anwendung verifiziert und die richtigen Richtlinien für die Linkbehandlung 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 auf einem Gerät installierte App manuell aufrufen. Das funktioniert unabhängig davon, ob deine App auf Android 12 ausgerichtet ist.
Internetverbindung herstellen
Für die Domainbestätigung muss das Testgerät mit dem Internet verbunden sein.
Den aktualisierten Domainbestätigungsprozess unterstützen
Wenn Ihre App auf Android 12 oder höher ausgerichtet ist, verwendet das System automatisch den aktualisierten Domainbestätigungsprozess.
Andernfalls können Sie den aktualisierten Bestätigungsprozess manuell aktivieren. Führen Sie dazu den folgenden Befehl in einem Terminalfenster aus:
adb shell am compat enable 175408749 PACKAGE_NAME
Status von Android-App-Links auf einem Gerät zurücksetzen
Bevor Sie die Domainbestätigung auf einem Gerät manuell starten können, 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
Durch diesen Befehl wird das Gerät in den Zustand versetzt, in dem es sich befindet, bevor der Nutzer Standard-Apps für Domains auswählt.
Domainbestätigung 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 prüfen
Warten Sie einige Zeit, bis der Verifizierungs-Agent seine Anfragen abgeschlossen hat, und sehen Sie sich dann die Ergebnisse der Überprüfung an. Führen Sie dazu den folgenden Befehl aus:
adb shell pm get-app-links PACKAGE_NAME
Die Ausgabe dieses Befehls sieht in etwa 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
Die Domains, die die Überprüfung erfolgreich bestehen, haben den Status verified für die Domainbestätigung. Ein anderer Status bedeutet, dass die Domainbestätigung nicht durchgeführt werden konnte. Der Status none bedeutet insbesondere, dass der Überprüfungsagent den Bestätigungsprozess möglicherweise noch nicht abgeschlossen hat.
Die folgende Liste enthält die möglichen Rückgabewerte, die bei der Domainbestätigung für eine bestimmte Domain zurückgegeben werden können:
none- Für diese Domain wurden keine Aufnahmen aufgezeichnet. Warten Sie noch einige Minuten, bis der Verifizierungs-Agent die Anfragen zur Domainbestätigung abgeschlossen hat, und rufen Sie die Domainbestätigung dann noch einmal auf.
verified- Die Domain wurde für die deklarierende App bestätigt.
approved- Die Genehmigung der Domain wurde erzwungen, in der Regel durch Ausführung eines Shell-Befehls.
denied- Die Ablehnung der Domain wurde erzwungen, in der Regel durch Ausführung eines Shell-Befehls.
migrated- Das Ergebnis eines vorherigen Prozesses, in dem die Legacy-Domainbestätigung verwendet wurde, wurde im System beibehalten.
restored- Die Domain wurde genehmigt, nachdem der Nutzer eine Datenwiederherstellung durchgeführt hat. Es wird angenommen, dass die Domain bereits bestätigt wurde.
legacy_failure- Die Domain wurde von einem alten Prüfer abgelehnt. Der spezifische Grund für den Fehler ist unbekannt.
system_configured- Die Domain wurde von der Gerätekonfiguration automatisch genehmigt.
- Fehlercode:
1024oder höher Benutzerdefinierter Fehlercode, der für den Prüfer des Geräts spezifisch ist.
Prüfen Sie noch einmal, ob eine Netzwerkverbindung hergestellt wurde, und rufen Sie die Domainbestätigung noch einmal auf.
Nutzer bitten, Ihre App mit einer Domain zu verknüpfen
Sie können Ihre Anwendung auch für eine Domain genehmigen lassen, indem Sie den Nutzer bitten, Ihre Anwendung 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 Anwendung während der Entwicklung testen, können Sie den folgenden Befehl ausführen, um den Verifizierungsstatus der Domains Ihrer Organisation abzufragen:
adb shell pm get-app-links --user cur PACKAGE_NAME
In der folgenden Beispielausgabe hat Nutzer 0 die Anwendung manuell in den Systemeinstellungen genehmigt, obwohl kein anderes Paket für die Domain "example.org" verifiziert wurde.
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 mit Shell-Befehlen auch den Prozess simulieren, bei dem der Nutzer die Anwendung auswählt, die mit einer bestimmten Domain verknüpft ist. Eine vollständige Erläuterung dieser Befehle finden Sie in der Ausgabe von adb shell pm.
Kontext für die Anfrage angeben
Bevor Sie die Anfrage zur Domaingenehmigung stellen, geben Sie für den Nutzer etwas Kontext an. Sie können ihnen beispielsweise einen Ladebildschirm, einen Dialog oder ein ähnliches UI-Element anzeigen, das dem Nutzer erklärt, warum Ihre App der Standard-Handler für eine bestimmte Domain sein sollte.
Anfrage stellen
Wenn der Nutzer verstanden hat, worum er von Ihrer App gebeten wird, stellen Sie die Anfrage.
Rufen Sie dazu einen Intent auf, der die Intent-Aktion ACTION_APP_OPEN_BY_DEFAULT_SETTINGS enthält, und einen Datenstring, der mit package:com.example.pkg für die Ziel-App übereinstimmt, 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 das Optionsfeld Opensupported links (Unterstützte Links öffnen), wie in Abbildung 1 dargestellt.
Wenn der Nutzer Unterstützte Links öffnen aktiviert, werden unter dem Abschnitt Links zum Öffnen in dieser App mehrere Kästchen angezeigt. Hier 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 innerhalb der von ihnen hinzugefügten Domains auswählen, wird der Link automatisch in Ihrer App geöffnet.
Domains in deiner App öffnen, die von der App nicht bestätigt werden können
Die Hauptfunktion Ihrer Anwendung kann unter Umständen darin bestehen, Links als Drittanbieter zu öffnen, ohne die von ihm verwalteten Domains zu überprüfen. Wenn dies der Fall ist, erklären Sie den Nutzern, dass sie sich beim Auswählen eines Weblinks nicht zwischen einer Erstanbieter-App und Ihrer (Drittanbieter-)App entscheiden können. Nutzer müssen die Domains manuell mit Ihrer Drittanbieter-App verknüpfen.
Du kannst auch einen Dialog oder eine Trampolinaktivität einführen, über die der Nutzer den Link in der Erstanbieter-App öffnen kann, wenn er dies möchte, um als Proxy zu fungieren. Bevor Sie ein solches Dialogfeld oder eine Trampolinaktivität einrichten, richten Sie Ihre App so ein, dass sie eine Paketsichtbarkeit für die eigenen Apps hat, die dem Web Intent-Filter Ihrer App entsprechen.
App-Links testen
Wenn du die Funktion zur App-Verknüpfung implementierst, solltest du die Verknüpfungsfunktion testen, damit das System deine App mit deinen Websites verknüpfen und URL-Anfragen wie erwartet verarbeiten kann.
Zum Testen einer vorhandenen Anweisungsdatei können Sie das Tool Statement List Generator and Tester verwenden.
Liste der zu überprüfenden Hosts bestätigen
Beim Testen sollten Sie die Liste der verknüpften Hosts bestätigen, die das System für Ihre Anwendung überprüfen soll. Erstellen Sie eine Liste aller URLs, deren entsprechende Intent-Filter die folgenden Attribute und Elemente enthalten:
- Attribut
android:schememit dem Werthttpoderhttps - Attribut
android:hostmit einem Domain-URL-Muster - Aktionselement „
android.intent.action.VIEW“ android.intent.category.BROWSABLEKategorieelement
Anhand dieser Liste können Sie prüfen, ob auf jedem benannten Host und jeder Subdomain eine Digital Asset Links-JSON-Datei verfügbar ist.
Digital Asset Links-Dateien bestätigen
Prüfen Sie mit der Digital Asset Links API für jede Website, ob 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
Linkrichtlinien prüfen
Im Rahmen des Testprozesses können Sie die aktuellen Systemeinstellungen für die Linkbehandlung prüfen. Verwende den folgenden Befehl, um eine Liste der vorhandenen Richtlinien zur Linkbehandlung für alle Apps auf dem verbundenen Gerät abzurufen:
adb shell dumpsys package domain-preferred-apps
Oder das Gleiche gilt:
adb shell dumpsys package d
Hinweis: Warten Sie nach der Installation Ihrer Anwendung mindestens 20 Sekunden, damit das System den Überprüfungsvorgang abschließen kann.
Durch diesen Befehl wird eine Liste aller auf dem Gerät definierten Nutzer oder Profile zurückgegeben, denen ein Header im folgenden Format vorangestellt ist:
App linkages for user 0:
Nach diesem Header wird in der Ausgabe das folgende Format verwendet, um die Einstellungen für die Linkbehandlung für diesen Nutzer aufzulisten:
Package: com.android.vending Domains: play.google.com market.android.com Status: always : 200000002
In diesem Eintrag ist angegeben, welche Apps mit welchen Domains für diesen Nutzer 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 Anwendung verarbeitet werden. Dabei werden Leerzeichen als Trennzeichen verwendet.Status: Zeigt die aktuelle Einstellung für die Linkverarbeitung für diese Anwendung an. Eine Anwendung, die die Überprüfung bestanden hat und deren Manifestandroid:autoVerify="true"enthält, hat den Statusalways. Die Hexadezimalzahl nach diesem Status bezieht sich auf den Eintrag des Android-Systems zu den App-Verknüpfungseinstellungen des Nutzers. Dieser Wert gibt nicht an, ob die Überprüfung erfolgreich war.
Hinweis: Wenn ein Nutzer die App-Link-Einstellungen für eine Anwendung ändert, bevor die Überprüfung abgeschlossen ist, kann es zu einem Fehlalarm kommen, obwohl die Überprüfung fehlgeschlagen ist. Dieser Fehler bei der Bestätigung spielt jedoch keine Rolle, ob der Nutzer explizit aktiviert hat, dass die Anwendung unterstützte Links ohne Nachfrage öffnen darf. Das liegt daran, dass die Nutzereinstellungen Vorrang vor der programmatischen Überprüfung (oder gar nicht) haben. Der Link führt daher direkt zu Ihrer Anwendung, ohne dass ein Dialogfeld angezeigt wird, so als ob die Bestätigung erfolgreich gewesen wäre.
Testbeispiel
Damit die Überprüfung von App-Links erfolgreich ist, muss das System deine App mit jeder der Websites verifizieren können, die du in einem bestimmten Intent-Filter angibst und die Kriterien für App-Links erfüllt. Das folgende Beispiel zeigt eine Manifestkonfiguration mit mehreren definierten 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 über das obige Manifest überprüfen möchte, lautet:
www.example.com mobile.example.com www.example2.com account.example.com
Die Liste der Hosts, die die Plattform nicht über das obige Manifest überprüfen möchte, 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, suchen Sie nach den folgenden häufigen Fehlern. In diesem Abschnitt wird example.com als Platzhalterdomainname verwendet. Ersetzen Sie bei diesen Prüfungen example.com durch den tatsächlichen Domainnamen Ihres Servers.
- Falscher Intent-Filter eingerichtet
- Prüfe, ob du in einem
<intent-filter>-Element eine URL einfügst, die nicht deiner App gehört. - Falsche Serverkonfiguration
Prüfen Sie in der JSON-Konfiguration Ihres Servers, ob der SHA-Wert korrekt ist.
Prüfen Sie außerdem, ob
example.com.(mit Punkt) denselben Inhalt wieexample.combereitstellt.- 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
Dieses Verhalten schützt die Sicherheit deiner App.
- Serverstabilität
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 einfügen. Beachte, dass diese Links unter Android 11 und niedriger dazu führen, dass das System nicht alle Android-App-Links für deine App überprüft.
- Falsche Signatur in assetlinks.json
Prüfen Sie, ob Ihre Signatur korrekt ist und mit der zum Signieren Ihrer App verwendeten Signatur übereinstimmt. Häufige Fehler sind:
- Sie signieren die App mit einem Fehlerbehebungszertifikat und verwenden nur die Releasesignatur in
assetlinks.json. - Verwendung einer kleingeschriebenen Signatur in
assetlinks.json. Die Signatur sollte in Großbuchstaben angegeben werden. - Wenn du die Play App-Signatur verwendest, musst du die Signatur verwenden, mit der Google jeden deiner Releases signiert. Sie können diese Details, einschließlich eines vollständigen JSON-Snippets, überprüfen. Folgen Sie dazu der Anleitung zum Deklarieren von Websiteverknüpfungen.
- Sie signieren die App mit einem Fehlerbehebungszertifikat und verwenden nur die Releasesignatur in