Android-App-Links sind ein spezieller Deeplink, mit dem über Ihre Website-URLs die entsprechenden Inhalte sofort in Ihrer Android-App geöffnet werden können, ohne dass der Nutzer die App auswählen muss. Bei Android-App-Links wird die Digital Asset Links API verwendet, um die Gewissheit zu schaffen, dass Ihre App von der Website für das automatische Öffnen von Links für diese Domain genehmigt wurde. Wenn das System erfolgreich bestätigt, dass Sie der 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 deiner App- und Website-URLs bist:
Fügen Sie Intent-Filter hinzu, die das Attribut
autoVerifyenthalten. Dieses Attribut signalisiert dem System, dass es prüfen soll, ob Ihre Anwendung zu den URL-Domains gehört, die in Ihren Intent-Filtern verwendet werden.Deklariere die Verknüpfung zwischen deiner Website und den Intent-Filtern, indem du an folgendem Speicherort eine Digital Asset Links-JSON-Datei hostet:
https://domain.name/.well-known/assetlinks.json
Weitere Informationen finden Sie in den folgenden Ressourcen:
Intent-Filter für die Bestätigung von App-Links hinzufügen
Um die Prüfung der Linkverarbeitung für Ihre Anwendung zu aktivieren, fügen Sie Intent-Filter im folgenden Format hinzu:
<!-- 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 ist zwar ausreichend, autoVerify nur in einer <intent-filter>-Deklaration für jeden Host anzugeben, auch wenn dieser Host in anderen nicht markierten Deklarationen verwendet wird. Aus Konsistenzgründen ist es jedoch empfehlenswert, autoVerify jedem <intent-filter>-Element hinzuzufügen. Dadurch wird auch sichergestellt, dass Ihre Anwendung nach dem Entfernen oder Refaktorieren von Elementen in der Manifestdatei mit allen Domains verknüpft bleibt, die Sie noch definieren.
Für die Domainbestätigung ist eine Internetverbindung erforderlich und kann einige Zeit in Anspruch nehmen. Zur Steigerung 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 diese Domain in einem <intent-filter>-Element befindet, das genau das im vorherigen Code-Snippet angegebene Format enthält.
App-Verknüpfung für mehrere Hosts unterstützen
Das System muss in der Lage sein, den in den Datenelementen der App-URL-Intent-Filter 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, verwendet 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 überprüft werden, die in den anderen Intent-Filtern der Anwendung definiert sind.
Hinweis:Unter Android 11 (API-Level 30) und niedriger bestätigt das System deine App nur dann als Standard-Handler, wenn es eine entsprechende Digital Asset Links-Datei für alle Hosts findet, die du im Manifest definiert hast.
Beispielsweise würde eine Anwendung mit den folgenden Intent-Filtern die Überprüfung nur für https://www.example.com bestehen, wenn die Datei assetlinks.json 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 aber mit dem anderen <data>-Element kombiniert, damit 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-Schemas und Domains definieren möchten.
Anwendungsverknüpfungen 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 für jede 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 eine gültige 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 den Hostnamen alternativ mit einem Platzhalter wie *.example.com angeben, müssen Sie die Datei assetlinks.json beim Stamm-Hostnamen (example.com) veröffentlichen. Eine Anwendung mit dem folgenden Intent-Filter durchläuft beispielsweise die Überprüfung für jeden beliebigen Unternamen von example.com (z. B. foo.example.com), solange die Datei assetlinks.json unter https://example.com/.well-known/assetlinks.json veröffentlicht ist:
<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 Anwendungen 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 ist, kann nur die zuletzt installierte Anwendung Web Intents für diese Domain auflösen.
Prüfe in einem solchen Fall, ob auf dem Gerät des Nutzers möglicherweise in Konflikt stehende Apps vorhanden sind, sofern du die erforderliche Paketsichtbarkeit hast. Rufen Sie dann in Ihrer App ein Dialogfeld für die benutzerdefinierte Auswahl auf, das die Ergebnisse des Aufrufs von queryIntentActivities() enthält.
Der Nutzer kann seine bevorzugte App aus der Liste passender Apps auswählen, die im Dialogfeld angezeigt werden.
Websiteverknüpfungen deklarieren
Auf deiner Website muss eine Digital Asset Links-JSON-Datei veröffentlicht werden, um die mit der Website verknüpften Android-Apps anzugeben und die URL-Intents der App zu bestätigen. In der JSON-Datei werden die folgenden Felder verwendet, um zugehörige Anwendungen zu identifizieren:
package_name: Die in der Dateibuild.gradleder Anwendung deklarierte Anwendungs-ID.sha256_cert_fingerprints: Die SHA256-Fingerabdrücke des Signaturzertifikats Ihrer App. Mit dem folgenden Befehl können Sie den Fingerabdruck über das Java-Keytool generieren:keytool -list -v -keystore my-release-key.keystore
Dieses Feld unterstützt mehrere Fingerabdrücke zur Unterstützung verschiedener Versionen Ihrer App, z. B. Debug- und Produktions-Builds.Wenn du die Play App-Signatur für deine App verwendest, stimmt der durch das lokale Ausführen von
keytoolerstellte Zertifikat-Fingerabdruck normalerweise nicht mit dem Fingerabdruck auf den Geräten der Nutzer ü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.
In der folgenden Beispieldatei assetlinks.json werden einer com.example-Android-App die Rechte 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"]
}
}]
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, die die Verknüpfung mit zwei Anwendungen separat deklariert und unter https://www.example.com/.well-known/assetlinks.json gespeichert ist:
[{
"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 unter 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 einer Domain zugeordnete 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 App in den jeweiligen assetlinks.json-Dateien deklarieren. Die folgende Datei enthält ein Beispiel für die Deklaration der Verknüpfung von „beispiel.de“ und „beispiel.net“ mit „app1“. Der erste Eintrag zeigt die Verknüpfung von „beispiel.de“ 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"]
}
}]
Der nächste Eintrag zeigt die Verknüpfung von beispiel.net mit app1. Nur der Ort, an dem diese Dateien gehostet werden, unterscheidet sich (.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 an folgendem Speicherort veröffentlichen:
https://domain.name/.well-known/assetlinks.json
Achten Sie dabei auf Folgendes:
- Die Datei
assetlinks.jsonwird mit dem Inhaltstypapplication/jsonbereitgestellt. - Die Datei
assetlinks.jsonmuss über eine HTTPS-Verbindung zugänglich sein, unabhängig davon, ob in den Intent-Filtern Ihrer App 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. Weitere Informationen finden Sie unter Unterstützung von Anwendungsverknüpfungen für mehrere Hosts. - 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 VPN zugänglich sind). In solchen Fällen können Sie das Problem umgehen, indem Sie 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 Intent-Filter Ihrer App vorhanden ist, führt das Installieren der App auf einem Gerät mit Android 6.0 (API-Level 23) oder höher dazu, dass das System automatisch die Hosts überprüft, die mit den URLs in den Intent-Filtern Ihrer App verknüpft sind. Unter Android 12 und höher kannst du den Überprüfungsprozess auch manuell aufrufen, um die Verifizierungslogik zu testen.
Automatische Bestätigung
Die automatische Überprüfung des Systems umfasst Folgendes:
- Das System prüft alle Intent-Filter, die eines der folgenden Elemente 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 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 Anwendung verknüpft werden sollen, und die Gültigkeit der gehosteten JSON-Datei überprüft haben, installieren Sie die App auf Ihrem Gerät. Warten Sie mindestens 20 Sekunden, bis die asynchrone Überprüfung abgeschlossen ist. Prüfen Sie mit dem folgenden Befehl, ob Ihre Anwendung vom System verifiziert und die richtigen Richtlinien für die Linkverarbeitung festgelegt wurden:
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 Anwendung manuell aufrufen. Das ist unabhängig davon möglich, 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 aufrufen, müssen Sie den Status der 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 Standardanwendungen 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 prüfen
Warten Sie einige Zeit, bis der Überprüfungs-Agent seine Anfragen abgeschlossen hat, und prüfen Sie dann die Ergebnisse der Überprüfung. 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 Bestätigung bestehen, haben den Domainbestätigungsstatus verified. Jeder andere Status weist darauf hin, dass die Domainbestätigung nicht durchgeführt werden konnte. Der Status none weist insbesondere darauf hin, dass der Überprüfungs-Agent den Bestätigungsvorgang möglicherweise noch nicht abgeschlossen hat.
In der folgenden Liste sind die möglichen Rückgabewerte aufgeführt, die von der Domainbestätigung für eine bestimmte Domain zurückgegeben werden können:
none- Für diese Domain wurden keine Aufzeichnungen aufgezeichnet. Warten Sie noch einige Minuten, bis der Verifizierungs-Agent die Anfragen zur Domainbestätigung abgeschlossen hat, und rufen Sie dann den Domainbestätigungsprozess 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ühren eines Shell-Befehls.
denied- Die Domain wurde erzwungen, in der Regel durch Ausführen eines Shell-Befehls.
migrated- Das Ergebnis eines vorherigen Prozesses, bei dem die Legacy-Domainbestätigung verwendet wurde, wurde 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. Die spezifische Fehlerursache 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, ob Sie eine Netzwerkverbindung hergestellt haben, und rufen Sie den Domainbestätigungsprozess noch einmal auf.
Nutzer auffordern, Ihre Anwendung mit einer Domain zu verknüpfen
Eine weitere Möglichkeit zur Genehmigung Ihrer Anwendung für eine Domain besteht darin, den Nutzer zu 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 Anwendung der Standard-Handler für die Domains ist, die Sie in den <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 mit dem folgenden Befehl den Bestätigungsstatus der Domains abfragen, die Ihrer Organisation gehören:
adb shell pm get-app-links --user cur PACKAGE_NAME
In der folgenden Beispielausgabe hat der Nutzer 0 die Anwendung manuell in den Systemeinstellungen genehmigt, obwohl die Prüfung der Anwendung für die Domain „example.org“ fehlgeschlagen ist. Es wird kein anderes Paket für diese Domain verifiziert.
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 Anwendung mit einer bestimmten Domain verknüpft ist. Eine vollständige Erläuterung dieser Befehle finden Sie in der Ausgabe von adb shell pm.
Geben Sie den Kontext für die Anfrage an
Bevor Sie die Domaingenehmigung anfordern, geben Sie etwas Kontext für den Nutzer an. Du könntest ihnen beispielsweise einen Ladebildschirm, ein Dialogfeld oder ein ähnliches UI-Element anzeigen, das dem Nutzer erklärt, warum deine App der Standard-Handler für eine bestimmte Domain sein sollte.
Anfrage stellen
Nachdem 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 und einen Datenstring enthält, der mit package:com.example.pkg für die Zielanwendung ü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 Open by default (Standardmäßig öffnen). Dieser Bildschirm enthält ein Optionsfeld namens Open supported links (Unterstützte Links öffnen), wie in Abbildung 1 dargestellt.
Wenn der Nutzer Unterstützte Links öffnen aktiviert, werden im Abschnitt Links zum Öffnen in dieser App mehrere Kästchen angezeigt. Anschließend 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 Anwendung öffnen, die von Ihrer Anwendung nicht bestätigt werden können
Die Hauptfunktion deiner App besteht möglicherweise darin, Links als Dritte zu öffnen, ohne die Möglichkeit, die verarbeiteten Domains zu bestätigen. Wenn dies der Fall ist, erklären Sie den Nutzern, dass sie bei der Auswahl eines Weblinks nicht zwischen einer Erstanbieter- und Ihrer Drittanbieter-App wählen können. Nutzer müssen die Domains manuell mit Ihrer Drittanbieter-App verknüpfen.
Erwägen Sie außerdem, einen Dialog oder eine Trampolinaktivität einzurichten, mit der der Nutzer den Link in der Erstanbieter-App öffnen kann, wenn er dies bevorzugt. Dabei handelt es sich um einen Proxy. Bevor Sie eine solche Dialog- oder Trampolinaktivität einrichten, richten Sie Ihre App so ein, dass sie Paketsichtbarkeit bei Erstanbieter-Apps hat, die dem Web-Intent-Filter Ihrer App entsprechen.
App-Links testen
Wenn du die Funktion zum Verknüpfen von Apps implementierst, solltest du die Verknüpfungsfunktion testen, um sicherzustellen, dass das System deine App mit deinen Websites verknüpfen und URL-Anfragen erwartungsgemäß verarbeiten kann.
Zum Testen einer vorhandenen Anweisungsdatei können Sie das Tool Statement List Generator und Tester verwenden.
Liste der zu bestätigenden Hosts bestätigen
Beim Testen sollten Sie die Liste der verknüpften Hosts bestätigen, die das System für Ihre Anwendung prüfen soll. Erstellen Sie eine Liste aller URLs, deren entsprechenden Intent-Filter die folgenden Attribute und Elemente enthalten:
- Attribut
android:schememit dem Werthttpoderhttps - Attribut
android:hostmit einem Domain-URL-Muster android.intent.action.VIEWAktionselement- Kategorieelement „
android.intent.category.BROWSABLE“
Anhand dieser Liste können Sie prüfen, ob für jeden benannten Host und jede Subdomain eine Digital Asset Links-JSON-Datei bereitgestellt wird.
Digital Asset Links-Dateien bestätigen
Verwende für jede Website die Digital Asset Links API, um zu prüfen, ob die Digital Asset Links-JSON-Datei ordnungsgemäß 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 Testverfahrens kannst du die aktuellen Systemeinstellungen für die Linkverarbeitung überprüfen. Verwenden Sie den folgenden Befehl, um eine Liste der vorhandenen Richtlinien zur Linkbehandlung für alle Apps auf Ihrem verbundenen Gerät abzurufen:
adb shell dumpsys package domain-preferred-apps
Oder der folgende Befehl bewirkt dasselbe:
adb shell dumpsys package d
Hinweis:Warten Sie nach der Installation der Anwendung mindestens 20 Sekunden, damit das System die Überprüfung abschließen kann.
Der Befehl gibt eine Liste aller auf dem Gerät definierten Nutzer oder Profile mit einem vorangestellten Header im folgenden Format zurück:
App linkages for user 0:
Nach diesem Header wird in der Ausgabe das folgende Format verwendet, um die Einstellungen für die Linkverarbeitung für diesen Nutzer aufzulisten:
Package: com.android.vending Domains: play.google.com market.android.com Status: always : 200000002
Diese Liste gibt an, welche Apps mit welchen Domains des jeweiligen Nutzers verknüpft sind:
Package: Identifiziert eine App anhand des Paketnamens, wie im Manifest angegeben.Domains: Zeigt die vollständige Liste der Hosts an, deren Weblinks von dieser App verarbeitet werden, wobei Leerzeichen als Trennzeichen verwendet werden.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, zeigt den Statusalwaysan. Die Hexadezimalzahl nach diesem Status bezieht sich auf den Datensatz des Android-Systems zu den Einstellungen der App-Verknüpfung 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 Bestätigung abgeschlossen ist, wird für eine erfolgreiche Überprüfung möglicherweise ein falsch positives Ergebnis angezeigt, auch wenn die Überprüfung fehlgeschlagen ist. Dieser Bestätigungsfehler spielt jedoch keine Rolle, wenn der Nutzer die Anwendung explizit aktiviert hat, um unterstützte Links ohne Nachfrage zu öffnen. Das liegt daran, dass Nutzereinstellungen Vorrang vor der programmatischen Überprüfung (oder wenn diese nicht vorhanden sind) haben. Infolgedessen führt der Link direkt zu Ihrer Anwendung, ohne dass ein Dialogfeld angezeigt wird, so als wäre die Bestätigung erfolgreich abgeschlossen.
Testbeispiel
Damit App-Links bestätigt werden können, muss das System Ihre Anwendung mit jeder der Websites verifizieren, die Sie in einem bestimmten Intent-Filter angeben, der die Kriterien für Anwendungslinks 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 anhand des obigen Manifests überprüfen würde, lautet:
www.example.com mobile.example.com www.example2.com account.example.com
Die Liste der Hosts, die die Plattform nicht anhand des obigen Manifests überprüfen würde, 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 Erstellen einer Anweisungsliste.
Häufige Implementierungsfehler beheben
Wenn Sie Ihre Android-App-Links nicht bestätigen können, prüfen Sie, ob die folgenden häufigen Fehler vorliegen. In diesem Abschnitt wird example.com als Platzhalter-Domainname verwendet. Ersetzen Sie bei diesen Prüfungen example.com durch den tatsächlichen Domainnamen Ihres Servers.
- Falsche Einrichtung des Intent-Filters
- Prüfe, ob du in einem
<intent-filter>-Element eine URL verwendest, die deiner App nicht 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 dem nachgestellten Punkt) denselben Inhalt wieexample.combereitstellt.- Serverseitige Weiterleitungen
Das System überprüft keine Android-App-Links für deine App, wenn du eine Weiterleitung wie die folgende einrichtest:
http://example.combishttps://example.comexample.combiswww.example.com
Dieses Verhalten dient dem Schutz Ihrer App.
- Serverstabilität
Prüfen Sie, ob der 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 führen diese Links dazu, 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, mit der Sie Ihre App signieren. Zu den häufigsten Fehlern gehören:
- App mit einem Debug-Zertifikat signieren und nur die Release-Signatur in
assetlinks.jsonverwenden - Eine Signatur in Kleinbuchstaben in
assetlinks.json. Die Signatur sollte in Großbuchstaben geschrieben sein. - Wenn du die Play App-Signatur verwendest, achte darauf, dass du die Signatur verwendest, mit der Google jeden deiner Releases signiert. Sie können diese Details, einschließlich eines vollständigen JSON-Snippets, überprüfen, indem Sie der Anleitung zum Erklären von Websiteverknüpfungen folgen.
- App mit einem Debug-Zertifikat signieren und nur die Release-Signatur in