Android App Link to specjalny typ precyzyjnego linku, który pozwala adresom URL witryny na natychmiastowe otwarcie odpowiedniej treści w aplikacji na Androida bez konieczności wyboru aplikacji przez użytkownika. Linki aplikacji na Androida korzystają z interfejsu Digital Asset Links API, aby mieć pewność, że Twoja aplikacja została zatwierdzona przez witrynę i automatycznie otwiera linki w tej domenie. Jeśli system potwierdzi własność adresów URL, automatycznie przekieruje te intencje do aplikacji.
Aby potwierdzić, że jesteś właścicielem zarówno adresu URL aplikacji, jak i witryny, wykonaj te czynności:
Dodaj filtry intencji, które zawierają atrybut
autoVerify
. Ten atrybut informuje system, że powinien sprawdzić, czy aplikacja należy do domen adresów URL używanych w filtrach intencji.Zadeklaruj powiązanie między swoją witryną a filtrami intencji, hostując plik JSON protokołu Digital Asset Links w tej lokalizacji:
https://domain.name/.well-known/assetlinks.json
Powiązane informacje znajdziesz w tych materiałach:
- Obsługa indeksowania adresów URL i indeksowania aplikacji w Android Studio
- Tworzenie listy instrukcji
Dodaj filtry intencji na potrzeby weryfikacji linków do aplikacji
Aby włączyć w swojej aplikacji weryfikację obsługi linków, dodaj filtry intencji pasujące do tego formatu:
<!-- 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>
Chociaż wystarczy umieścić autoVerify
w jednej deklaracji <intent-filter>
dla każdego hosta, nawet jeśli ten host jest używany w innych nieoznaczonych deklaracjach, zalecamy dodanie autoVerify
do każdego elementu <intent-filter>
, aby zachować spójność. Dzięki temu po usunięciu lub refaktoryzacji elementów z pliku manifestu aplikacja pozostanie powiązana ze wszystkimi jeszcze zdefiniowanymi domenami.
Proces weryfikacji domeny wymaga połączenia z internetem i może zająć trochę czasu. Aby zwiększyć wydajność tego procesu, system weryfikuje domenę aplikacji kierowanej na Androida 12 lub nowszego tylko wtedy, gdy ta domena znajduje się w elemencie <intent-filter>
zawierającym format dokładnie określony w poprzednim fragmencie kodu.
Obsługa łączenia aplikacji z wieloma hostami
System musi mieć możliwość zweryfikowania hosta określonego w elementach danych filtrów intencji adresu URL aplikacji pod kątem plików Digital Asset Links w odpowiednich domenach internetowych w tym filtrze intencji. Jeśli weryfikacja się nie powiedzie, system domyślnie użyje standardowego działania, aby rozwiązać intencję, zgodnie z opisem w sekcji Tworzenie precyzyjnych linków do zawartości aplikacji. Można ją jednak nadal zweryfikować jako domyślny moduł obsługi dowolnych wzorców adresów URL zdefiniowanych w innych filtrach intencji aplikacji.
Uwaga: na Androidzie 11 (poziom interfejsu API 30) i starszych system nie weryfikuje aplikacji jako domyślnego modułu obsługi, chyba że znajdzie pasujący plik Digital Asset Links dla wszystkich hostów określonych w pliku manifestu.
Na przykład aplikacja z tymi filtrami intencji przejdzie weryfikację tylko w przypadku https://www.example.com
, jeśli plik assetlinks.json
zostanie znaleziony pod adresem https://www.example.com/.well-known/assetlinks.json
, ale nie pod adresem https://www.example.net/.well-known/assetlinks.json
:
<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>
Uwaga: wszystkie elementy <data>
w tym samym filtrze intencji są scalone, aby uwzględnić wszystkie odmiany połączonych atrybutów. Na przykład pierwszy filtr intencji powyżej zawiera element <data>
, który deklaruje tylko schemat HTTPS. Jest on jednak połączony z innym elementem <data>
, dzięki czemu filtr intencji obsługuje zarówno http://www.example.com
, jak i https://www.example.com
.
Jeśli chcesz zdefiniować konkretne kombinacje schematów i domen, musisz utworzyć osobne filtry intencji.
Obsługa łączenia aplikacji z wieloma subdomenami
Protokół Digital Asset Links traktuje subdomeny w filtrach intencji jako unikalne, oddzielne hosty. Jeśli więc filtr intencji zawiera wiele hostów z różnymi subdomenami, musisz opublikować prawidłową zasadę assetlinks.json
w każdej domenie. Na przykład ten filtr intencji obejmuje www.example.com
i mobile.example.com
jako akceptowane hosty adresu URL intencji. Dlatego prawidłowa właściwość assetlinks.json
musi zostać opublikowana zarówno w https://www.example.com/.well-known/assetlinks.json
, jak i w https://mobile.example.com/.well-known/assetlinks.json
.
<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>
Jeśli zadeklarujesz nazwę hosta za pomocą symbolu wieloznacznego (np. *.example.com
), musisz opublikować plik assetlinks.json
pod główną nazwą hosta (example.com
). Na przykład aplikacja z podanym niżej filtrem intencji przejdzie weryfikację dla dowolnej nazwy podrzędnej example.com
(takiej jak foo.example.com
), dopóki plik assetlinks.json
zostanie opublikowany pod adresem https://example.com/.well-known/assetlinks.json
:
<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>
Sprawdź, czy z tą samą domeną jest powiązanych kilka aplikacji.
Jeśli publikujesz wiele aplikacji, z których każda jest powiązana z tą samą domeną, każda z nich może zostać zweryfikowana. Jeśli jednak aplikacje mogą obsługiwać dokładnie ten sam host domeny i ścieżkę, jak w przypadku wersji uproszczonej i pełnej, tylko ostatnio zainstalowana aplikacja będzie mogła realizować intencje internetowe w przypadku danej domeny.
W takim przypadku sprawdź, czy na urządzeniu użytkownika nie ma aplikacji będących w konflikcie, o ile masz niezbędną widoczność pakietu. Następnie w aplikacji wyświetl okno selektora niestandardowego zawierające wyniki wywołania queryIntentActivities()
.
Użytkownik może wybrać preferowaną aplikację z listy pasujących aplikacji, która pojawi się w oknie.
Deklarowanie powiązań witryny
Musisz opublikować w swojej witrynie plik JSON Digital Asset Links, aby wskazać aplikacje na Androida powiązane z tą witryną i zweryfikować intencje związane z adresem URL aplikacji. Plik JSON używa tych pól do identyfikowania powiązanych aplikacji:
package_name
: identyfikator aplikacji zadeklarowany w plikubuild.gradle
aplikacji.sha256_cert_fingerprints
: odciski cyfrowe SHA256 certyfikatu podpisywania aplikacji. Do wygenerowania odcisku cyfrowego za pomocą narzędzia Java Keytool możesz wygenerować wiele odcisków cyfrowych za pomocą tego polecenia:keytool -list -v -keystore my-release-key.keystore
To pole obsługuje wiele odcisków cyfrowych, które umożliwiają obsługę różnych wersji aplikacji, takich jak kompilacje do debugowania i produkcyjne.Jeśli w przypadku aplikacji używasz podpisywania aplikacji przez Google Play, odcisk cyfrowy certyfikatu wygenerowany przez lokalne uruchomienie
keytool
zwykle nie będzie zgodny z odciskiem cyfrowym na urządzeniach użytkowników. To, czy korzystasz w przypadku aplikacji z usługi podpisywania aplikacji przez Google Play, możesz sprawdzić na koncie dewelopera w Konsoli Play na koncieRelease > Setup > App signing
. W takim przypadku na tej samej stronie znajdziesz też prawidłowy fragment kodu JSON protokołu Digital Asset Links dla Twojej aplikacji.
Ten przykładowy plik assetlinks.json
przyznaje uprawnienia do otwierania linków do aplikacji na Androida w systemie com.example
:
[{ "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"] } }]
Powiązanie witryny z wieloma aplikacjami
W tym samym pliku assetlinks.json
witryna może deklarować powiązania z wieloma aplikacjami. Poniższy plik zawiera przykład pliku instrukcji, który deklaruje powiązanie z 2 aplikacjami (osobno) i znajduje się pod adresem https://www.example.com/.well-known/assetlinks.json
:
[{ "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"] } }]
Różne aplikacje mogą obsługiwać linki do różnych zasobów w ramach tego samego dostawcy hostingu witryn. Na przykład aplikacja 1 może zadeklarować filtr intencji dla właściwości https://example.com/articles
, a aplikacja app2 – filtr intencji dla https://example.com/videos
.
Uwaga: wiele aplikacji powiązanych z domeną może być podpisanych tym samym lub różnymi certyfikatami.
Powiązanie wielu witryn z 1 aplikacją
Powiązania z tą samą aplikacją mogą deklarować wiele witryn w odpowiednich plikach assetlinks.json
. Poniżej znajdziesz listę plików pokazujących przykład zadeklarowania powiązania domeny example.com i example.net z aplikacją app1. Pierwszy wykaz pokazuje powiązanie domeny example.com z aplikacją 1:
[{ "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"] } }]
Na następnej stronie widać powiązanie domeny example.net z aplikacją 1. Różni się tylko lokalizacja, w której te pliki są hostowane (.com
i .net
):
[{ "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"] } }]
Publikowanie pliku weryfikacyjnego JSON
Plik weryfikacyjny JSON musisz opublikować w tej lokalizacji:
https://domain.name/.well-known/assetlinks.json
Upewnij się, że:
- Plik
assetlinks.json
jest udostępniany z parametrem content-typeapplication/json
. - Plik
assetlinks.json
musi być dostępny przez połączenie HTTPS niezależnie od tego, czy filtry intencji aplikacji deklarują HTTPS jako schemat danych. - Plik
assetlinks.json
musi być dostępny bez żadnych przekierowań (bez przekierowań 301 ani 302). - Jeśli linki do aplikacji obsługują wiele domen hostów, musisz opublikować plik
assetlinks.json
w każdej z nich. Patrz artykuł Obsługa łączenia aplikacji z wieloma hostami. - Nie publikuj w pliku manifestu aplikacji z adresami URL trybu deweloperskiego/testowego, które mogą nie być publicznie dostępne (np. takich, które są dostępne tylko przez sieć VPN). Obejściem w takich przypadkach jest skonfigurowanie wariantów kompilacji w celu wygenerowania innego pliku manifestu dla kompilacji deweloperskich.
Weryfikacja linków aplikacji na Androida
Jeśli właściwość android:autoVerify="true"
występuje w co najmniej jednym z filtrów intencji aplikacji, zainstalowanie jej na urządzeniu z Androidem 6.0 (poziom interfejsu API 23) lub wyższym spowoduje, że system automatycznie weryfikuje hosty powiązane z adresami URL w filtrach intencji aplikacji. W Androidzie 12 i nowszych możesz też ręcznie wywołać proces weryfikacji, aby przetestować logikę weryfikacji.
Automatyczna weryfikacja
Automatyczna weryfikacja systemowa obejmuje:
- System sprawdza wszystkie filtry intencji, które zawierają dowolny z tych elementów:
- Działanie:
android.intent.action.VIEW
- Kategorie:
android.intent.category.BROWSABLE
iandroid.intent.category.DEFAULT
- Schemat danych:
http
lubhttps
- Działanie:
- W przypadku każdej niepowtarzalnej nazwy hosta znalezionej w powyższych filtrach intencji Android wysyła zapytanie do odpowiednich witryn w celu pobrania pliku Digital Asset Links na
https://hostname/.well-known/assetlinks.json
.
Gdy potwierdzisz listę witryn, które chcesz powiązać z aplikacją, oraz potwierdzisz, że hostowany plik JSON jest prawidłowy, zainstaluj aplikację na urządzeniu. Poczekaj co najmniej 20 sekund na zakończenie asynchronicznego procesu weryfikacji. Aby sprawdzić, czy system zweryfikował aplikację, i ustawić prawidłowe zasady obsługi linków, użyj tego polecenia:
adb shell am start -a android.intent.action.VIEW \ -c android.intent.category.BROWSABLE \ -d "http://domain.name:optional_port"
Weryfikacja ręczna
Począwszy od Androida 12 możesz ręcznie wywołać weryfikację domeny dla aplikacji zainstalowanej na urządzeniu. Ten proces możesz wykonać niezależnie od tego, czy Twoja aplikacja jest kierowana na Androida 12.
Nawiąż połączenie z internetem
Aby zweryfikować domenę, urządzenie testowe musi być połączone z internetem.
Obsługa zaktualizowanego procesu weryfikacji domeny
Jeśli aplikacja jest kierowana na Androida 12 lub nowszego, system automatycznie użyje zaktualizowanego procesu weryfikacji domeny.
W przeciwnym razie możesz ręcznie włączyć zaktualizowany proces weryfikacji. Aby to zrobić, uruchom następujące polecenie w oknie terminala:
adb shell am compat enable 175408749 PACKAGE_NAME
Resetowanie stanu linków aplikacji na Androida na urządzeniu
Zanim ręcznie wywołasz weryfikację domeny na urządzeniu, musisz zresetować stan linków aplikacji na Androida na urządzeniu testowym. Aby to zrobić, uruchom następujące polecenie w oknie terminala:
adb shell pm set-app-links --package PACKAGE_NAME 0 all
To polecenie powoduje ustawienie urządzenia w taki sam sposób, w jakim się znajduje, zanim użytkownik wybierze aplikacje domyślne dla dowolnej domeny.
Wywoływanie procesu weryfikacji domeny
Po zresetowaniu stanu linków aplikacji na Androida na urządzeniu możesz samodzielnie przeprowadzić weryfikację. Aby to zrobić, uruchom następujące polecenie w oknie terminala:
adb shell pm verify-app-links --re-verify PACKAGE_NAME
Sprawdzanie wyników weryfikacji
Gdy pracownik obsługi klienta ds. weryfikacji zrealizuje żądania, odczekaj jakiś czas, sprawdź wyniki weryfikacji. Aby to zrobić, uruchom następujące polecenie:
adb shell pm get-app-links PACKAGE_NAME
Wynik tego polecenia jest podobny do tego:
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
Domeny, które pomyślnie przeszły weryfikację, mają stan weryfikacji domeny verified
. Każdy inny stan oznacza, że nie udało się przeprowadzić weryfikacji domeny. W szczególności stan none
oznacza, że agent weryfikacyjny mógł jeszcze nie ukończyć procesu weryfikacji.
Na liście poniżej znajdziesz możliwe wartości zwracane dla danej domeny, które może zwrócić weryfikacja domeny:
none
- Nic nie zostało zarejestrowane w tej domenie. Poczekaj jeszcze kilka minut, aż agent weryfikacyjny zakończy żądania związane z weryfikacją domeny, a następnie wywołaj proces weryfikacji domeny ponownie.
verified
- Domena została potwierdzona na potrzeby deklaracji aplikacji.
approved
- Zatwierdzenie domeny zostało wymuszane, zwykle poprzez wykonanie polecenia powłoki.
denied
- Wymuszono odmowę dostępu do domeny, zwykle za pomocą polecenia powłoki.
migrated
- System zachował wynik poprzedniego procesu, który korzystał ze starszej wersji weryfikacji domeny.
restored
- Domena została zatwierdzona po przywróceniu danych przez użytkownika. Przyjmujemy, że domena została wcześniej zweryfikowana.
legacy_failure
- Domena została odrzucona przez starszy weryfikator. Przyczyna niepowodzenia jest nieznana.
system_configured
- Domena została automatycznie zatwierdzona przez konfigurację urządzenia.
- Kod błędu o wartości
1024
lub nowszej Niestandardowy kod błędu przypisany do weryfikatora urządzenia.
Dokładnie sprawdź, czy masz połączenie sieciowe, i ponownie wywołaj proces weryfikacji domeny.
Poproś użytkownika o powiązanie aplikacji z domeną
Innym sposobem na zatwierdzenie aplikacji w domenie jest poproszenie użytkownika o powiązanie aplikacji z tą domeną.
Sprawdzanie, czy aplikacja została już zatwierdzona w domenie
Zanim wyślesz prośbę do użytkownika, sprawdź, czy Twoja aplikacja jest domyślnym modułem obsługi domen zdefiniowanych w elementach <intent-filter>
. Możesz wysyłać zapytania o stan zatwierdzenia, korzystając z jednej z tych metod:
- Interfejs API
DomainVerificationManager
(w czasie działania). - program wiersza poleceń (podczas testów),
Menedżer weryfikacji domen
Ten fragment kodu pokazuje, jak korzystać z interfejsu API DomainVerificationManager
:
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); } }
Program wiersza poleceń
Podczas testowania aplikacji w fazie programowania możesz uruchomić to polecenie, aby przesłać zapytanie o stan weryfikacji domen należących do Twojej organizacji:
adb shell pm get-app-links --user cur PACKAGE_NAME
W poniższych przykładowych danych wyjściowych aplikacja nie przeszła weryfikacji w domenie „example.org”, ale użytkownik 0 ręcznie zatwierdził aplikację w ustawieniach systemu i nie zweryfikowano żadnego innego pakietu w tej domenie.
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
Możesz też używać poleceń powłoki, aby symulować proces, w którym użytkownik wybiera aplikację, która jest powiązana z daną domeną. Pełne wyjaśnienie tych poleceń jest dostępne w danych wyjściowych adb shell pm
.
Podaj kontekst żądania
Zanim poprosisz o zatwierdzenie domeny, przekaż informacje o kontekście użytkownika. Możesz na przykład wyświetlić ekran powitalny, okno lub podobny element interfejsu, który wyjaśnia użytkownikowi, dlaczego aplikacja powinna być domyślnym modułem obsługi w danej domenie.
Prześlij prośbę
Gdy użytkownik już rozumie, o co prosi aplikacja, wyślij prośbę.
Aby to zrobić, wywołaj intencję zawierającą działanie intencji ACTION_APP_OPEN_BY_DEFAULT_SETTINGS
oraz ciąg danych pasujący do ciągu danych package:com.example.pkg
w przypadku aplikacji docelowej, jak widać w tym fragmencie kodu:
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);
Po wywołaniu intencji użytkownicy zobaczą ekran ustawień o nazwie Otwórz domyślnie. Na tym ekranie znajduje się przycisk Otwórz obsługiwane linki, jak widać na ilustracji 1.
Gdy użytkownik włączy opcję Otwórz obsługiwane linki, w sekcji Linki do otwarcia w tej aplikacji pojawią się pola wyboru. Tutaj użytkownicy mogą wybrać domeny, które chcą powiązać z aplikacją. Mogą też kliknąć Dodaj link, aby dodać domeny, jak widać na ilustracji 2. Gdy użytkownicy klikną później dowolny link w dodanych przez siebie domenach, automatycznie otworzy się on w Twojej aplikacji.
Otwieraj w aplikacji domeny, których aplikacja nie może zweryfikować
Główną funkcją Twojej aplikacji może być otwieranie linków przez firmę zewnętrzną bez możliwości weryfikacji obsługiwanych domen. W takim przypadku wyjaśnij użytkownikom, że po wybraniu linku internetowego nie mogą wybrać między aplikacją własnej a Twoją (inną) aplikacji. Użytkownicy muszą ręcznie powiązać domeny z Twoją aplikacją innej firmy.
Rozważ też wprowadzenie okna lub aktywności na trampolinie, która (jeśli jest to potrzebne) pozwoli użytkownikowi otworzyć link w aplikacji własnej. Przed skonfigurowaniem takiego okna lub aktywności na trampolinie skonfiguruj aplikację tak, aby miała widoczność pakietów dla aplikacji własnych, które pasują do filtra intencji internetowych Twojej aplikacji.
Linki do aplikacji testowej
Implementując funkcję łączenia aplikacji, przetestuj ją, aby mieć pewność, że system może powiązać aplikację z Twoimi witrynami i obsługiwać żądania adresów URL zgodnie z oczekiwaniami.
Aby przetestować istniejący plik z instrukcjami, możesz użyć narzędzia Generator i tester listy instrukcji.
Potwierdź listę hostów do zweryfikowania
Podczas testowania musisz sprawdzić listę powiązanych hostów, które system powinien zweryfikować pod kątem Twojej aplikacji. Zrób listę wszystkich adresów URL, których odpowiednie filtry intencji zawierają te atrybuty i elementy:
- Atrybut
android:scheme
o wartościhttp
lubhttps
- Atrybut
android:host
ze wzorcem adresu URL domeny - Działanie
android.intent.action.VIEW
android.intent.category.BROWSABLE
element kategorii
Na tej liście możesz sprawdzić, czy każdy nazwany host i subdomenę zawiera plik JSON protokołu Digital Asset Links.
Potwierdź pliki Digital Asset Links
W przypadku każdej witryny użyj interfejsu Digital Asset Links API, aby sprawdzić, czy plik JSON protokołu Digital Asset Links jest prawidłowo hostowany i zdefiniowany:
https://digitalassetlinks.googleapis.com/v1/statements:list? source.web.site=https://domain.name:optional_port& relation=delegate_permission/common.handle_all_urls
Sprawdź zasady dotyczące linków
W ramach procesu testowania możesz sprawdzić bieżące ustawienia systemu dotyczące obsługi linków. Aby wyświetlić listę istniejących zasad obsługi linków dla wszystkich aplikacji na połączonym urządzeniu, użyj tego polecenia:
adb shell dumpsys package domain-preferred-apps
Albo następujące polecenie działa tak samo:
adb shell dumpsys package d
Uwaga: po zainstalowaniu aplikacji poczekaj co najmniej 20 sekund, aby umożliwić systemowi ukończenie procesu weryfikacji.
To polecenie zwraca listę każdego użytkownika lub profilu zdefiniowanego na urządzeniu poprzedzony nagłówkiem w tym formacie:
App linkages for user 0:
Po tym nagłówku dane wyjściowe z listą ustawień obsługi linków dla danego użytkownika mają następujący format:
Package: com.android.vending Domains: play.google.com market.android.com Status: always : 200000002
Te informacje wskazują, które aplikacje są powiązane z domenami danego użytkownika:
Package
– identyfikuje aplikację na podstawie nazwy pakietu podanej w pliku manifestu.Domains
– pokazuje pełną listę hostów, których linki internetowe obsługuje ta aplikacja (przy użyciu pustych spacji jako ograniczników).Status
– pokazuje bieżące ustawienie obsługi linków w tej aplikacji. Aplikacja, która przeszła weryfikację i której plik manifestu zawieraandroid:autoVerify="true"
, ma stanalways
. Liczba szesnastkowa po tym stanie odpowiada zapisowi ustawień połączenia aplikacji użytkownika w systemie Android. Ta wartość nie wskazuje, czy weryfikacja się powiodła.
Uwaga: jeśli użytkownik zmieni ustawienia linku do aplikacji przed zakończeniem weryfikacji, mimo że weryfikacja się nie powiodła, wynik weryfikacji może być fałszywy. Ten błąd weryfikacji nie ma jednak znaczenia, czy użytkownik bezpośrednio włączył w aplikacji otwieranie obsługiwanych linków bez pytania. Dzieje się tak, ponieważ preferencje użytkownika mają pierwszeństwo przed automatyczną weryfikacją (lub jej brak). W rezultacie link prowadzi bezpośrednio do aplikacji i nie wyświetla okna, tak jak w przypadku pomyślnej weryfikacji.
Przykład testowy
Aby weryfikacja linku do aplikacji się powiodła, system musi być w stanie zweryfikować Twoją aplikację w każdej witrynie określonej w filtrze intencji spełniającym kryteria linków do aplikacji. Ten przykład przedstawia konfigurację pliku manifestu ze zdefiniowanymi linkami aplikacji:
<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>
Lista hostów, które platforma mogłaby zweryfikować za pomocą powyższego pliku manifestu:
www.example.com mobile.example.com www.example2.com account.example.com
Lista hostów, których platforma nie mogłaby zweryfikować z poziomu tego pliku manifestu:
map.example.com (it does not have android.intent.category.BROWSABLE) market://example.com (it does not have either an "http" or "https" scheme)
Więcej informacji o listach instrukcji znajdziesz w artykule o tworzeniu listy instrukcji.
Naprawianie najczęstszych błędów implementacji
Jeśli nie możesz zweryfikować linków aplikacji na Androida, sprawdź, czy nie występują tu typowe błędy. Ta sekcja używa example.com
jako nazwy domeny zastępczej. Podczas wykonywania tych kontroli zastąp example.com
rzeczywistą nazwą domeny serwera.
- Nieprawidłowa konfiguracja filtra intencji
- Sprawdź, czy w elemencie
<intent-filter>
podajesz adres URL, który nie należy do Twojej aplikacji. - Nieprawidłowa konfiguracja serwera
Sprawdź konfigurację JSON serwera i upewnij się, że wartość SHA jest prawidłowa.
Sprawdź też, czy adres
example.com.
(z końcową kropką) zawiera te same treści coexample.com
.- Przekierowania po stronie serwera
System nie weryfikuje żadnych linków aplikacji na Androida, jeśli masz skonfigurowane przekierowanie takie jak:
http://example.com
–https://example.com
example.com
–www.example.com
To działanie pomaga chronić bezpieczeństwo aplikacji.
- Niezawodność serwera
Sprawdź, czy serwer może łączyć się z aplikacjami klienckimi.
- Linki nieweryfikowalne
Do celów testowych możesz celowo dodawać linki niemożliwe do zweryfikowania. Pamiętaj, że na Androidzie 11 i starszych linki te powodują, że system nie weryfikuje wszystkich linków aplikacji na Androida powiązanych z Twoją aplikacją.
- Nieprawidłowy podpis w pliku assetlinks.json
Sprawdź, czy podpis jest prawidłowy i zgodny z podpisem używanym do podpisania aplikacji. Typowe błędy to:
- Podpisywanie aplikacji za pomocą certyfikatu debugowania i wyświetlanie tylko podpisu wersji w
assetlinks.json
. - Podpis pisany małymi literami w języku
assetlinks.json
. Podpis powinien być pisany wielkimi literami. - Jeśli używasz podpisywania aplikacji przez Google Play, sprawdź, czy używasz podpisu używanego przez Google do podpisywania każdej wersji. Możesz zweryfikować te informacje, w tym pełny fragment kodu JSON, wykonując instrukcje deklarowania powiązań witryn.
- Podpisywanie aplikacji za pomocą certyfikatu debugowania i wyświetlanie tylko podpisu wersji w