Weryfikacja linków aplikacji na Androida

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:

  1. 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.

  2. 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:

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 pliku build.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 koncie Release > 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:

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"]
  }
}]

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):

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"]
  }
}]

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-type application/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:

  1. System sprawdza wszystkie filtry intencji, które zawierają dowolny z tych elementów:
    • Działanie: android.intent.action.VIEW
    • Kategorie: android.intent.category.BROWSABLE i android.intent.category.DEFAULT
    • Schemat danych: http lub https
  2. 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:

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.

Gdy ta opcja jest włączona, sekcja u dołu strony zawiera pola wyboru i przycisk „Dodaj link”
Rysunek 1. Ekran ustawień systemu, na którym użytkownicy mogą wybrać, które linki mają być domyślnie otwierane w Twojej aplikacji.
Każde pole wyboru odpowiada domenie, którą możesz dodać. Dostępne są przyciski Anuluj i Dodaj.
Rysunek 2. Okno, w którym użytkownicy mogą wybrać dodatkowe domeny do powiązania z Twoją aplikacją.

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ści http lub https
  • 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

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 zawiera android:autoVerify="true", ma stan always. 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 co example.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.