Verificare i link per app Android

Un link per app Android è un tipo speciale di link diretto che consente agli URL del tuo sito web di aprire immediatamente i contenuti corrispondenti nella tua app per Android, senza richiedere all'utente di selezionarla. I link per app Android utilizzano l'API Digital Asset Links per stabilire la fiducia che la tua app sia stata approvata dal sito web per aprire automaticamente i link per quel dominio. Se il sistema verifica correttamente che gli URL sono di tua proprietà, questi vengono instradati automaticamente alla tua app.

Per verificare di essere il proprietario sia dell'URL dell'app sia degli URL del sito web, svolgi i seguenti passaggi:

  1. Aggiungi filtri per intent che contengono l'attributo autoVerify. Questo attributo segnala al sistema che deve verificare se la tua app appartiene ai domini URL utilizzati nei filtri per intent.

  2. Dichiara l'associazione tra il tuo sito web e i filtri per intent ospitando un file JSON Digital Asset Links nella seguente posizione:

    https://domain.name/.well-known/assetlinks.json

Puoi trovare informazioni correlate nelle seguenti risorse:

Aggiungere filtri per intent per la verifica dei link dell'app

Per attivare la verifica della gestione dei link per la tua app, aggiungi filtri per intent che corrispondano al seguente formato:

<!-- 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>

Sebbene sia sufficiente includere autoVerify in una sola dichiarazione <intent-filter> per ogni host, anche se quell'host viene utilizzato in altre dichiarazioni non contrassegnate, ti consigliamo di aggiungere autoVerify a ogni elemento <intent-filter> per garantire la coerenza. Ciò garantisce anche che, dopo la rimozione o il refactoring di elementi nel file manifest, la tua app rimanga associata a tutti i domini che definisci ancora.

La procedura di verifica del dominio richiede una connessione a internet e potrebbe richiedere un po' di tempo. Per migliorare l'efficienza del processo, il sistema verifica un dominio per un'app destinata ad Android 12 o versioni successive solo se questo dominio si trova all'interno di un elemento <intent-filter> contenente il formato esatto specificato nello snippet di codice precedente.

Supporto del collegamento di app per più host

Il sistema deve essere in grado di verificare l'host specificato negli elementi di dati dei filtri per intent dell'URL dell'app rispetto ai file Digital Asset Links ospitati sui rispettivi domini web nel filtro per intent. Se la verifica non va a buon fine, il sistema utilizza per impostazione predefinita il comportamento standard per risolvere l'intent, come descritto nella sezione Creare link diretti ai contenuti dell'app. Tuttavia, l'app può comunque essere verificata come gestore predefinito per qualsiasi pattern URL definito negli altri filtri per intent dell'app.

Nota:su Android 11 (livello API 30) e versioni precedenti, il sistema non verifica la tua app come gestore predefinito, a meno che non trovi un file Digital Asset Links corrispondente per tutti gli host che definisci nel manifest.

Ad esempio, un'app con i seguenti filtri per intent supererebbe la verifica solo per https://www.example.com se viene trovato un file assetlinks.json in https://www.example.com/.well-known/assetlinks.json, ma non in 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>

Nota: tutti gli elementi <data> nello stesso filtro per intent vengono uniti per tenere conto di tutte le varianti degli attributi combinati. Ad esempio, il primo filtro per intent sopra riportato include un elemento <data> che dichiara solo lo schema HTTPS. Tuttavia, viene combinato con l'altro elemento <data> in modo che il filtro per intent supporti sia http://www.example.com sia https://www.example.com. Di conseguenza, devi creare filtri per intent separati quando vuoi definire combinazioni specifiche di schemi URI e domini.

Supporto del collegamento delle app per più sottodomini

Il protocollo Digital Asset Links tratta i sottodomini nei filtri per intent come host univoci e separati. Pertanto, se il filtro per intent elenca più host con sottodomini diversi, devi pubblicare un elemento assetlinks.json valido su ogni dominio. Ad esempio, il seguente filtro per intent include www.example.com e mobile.example.com come host di URL per intent accettati. Di conseguenza, un assetlinks.json valido deve essere pubblicato sia in https://www.example.com/.well-known/assetlinks.json sia in 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>

In alternativa, se dichiari il tuo nome host con un carattere jolly (ad esempio *.example.com), devi pubblicare il file assetlinks.json nel nome host principale (example.com). Ad esempio, un'app con il seguente filtro per intent supererà la verifica di qualsiasi sottodominio di example.com (come foo.example.com), purché il file assetlinks.json sia pubblicato in 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>

Verifica la presenza di più app associate allo stesso dominio

Se pubblichi più app associate allo stesso dominio, puoi verificarle ognuna correttamente. Tuttavia, se le app sono in grado di risolvere esattamente lo stesso host e lo stesso percorso del dominio, come nel caso delle versioni Lite e complete di un'app, solo l'app installata più di recente può risolvere i web intent per quel dominio.

In un caso come questo, verifica la presenza di possibili app in conflitto sul dispositivo dell'utente, a condizione che tu disponga della visibilità dei pacchetti necessaria. Dopodiché, nell'app, mostra una finestra di dialogo personalizzata che contiene i risultati della chiamata a queryIntentActivities(). L'utente può selezionare l'app preferita dall'elenco di app corrispondenti visualizzato nella finestra di dialogo.

Dichiara le associazioni di siti web

Sul tuo sito web deve essere pubblicato un file JSON Digital Asset Links per indicare le app per Android associate al sito web e verificare gli intent dell'URL dell'app. Il file JSON utilizza i seguenti campi per identificare le app associate:

  • package_name: l'ID applicazione dichiarato nel file build.gradle dell'app.
  • sha256_cert_fingerprints: le fingerprint SHA256 del certificato di firma dell'app. Puoi utilizzare il seguente comando per generare l'impronta tramite lo strumento Java Key:
    keytool -list -v -keystore my-release-key.keystore
    
    Questo campo supporta più fingerprint, che possono essere utilizzate per supportare diverse versioni dell'app, ad esempio build di debug e produzione.

    Se utilizzi la firma dell'app di Google Play, in genere l'impronta digitale del certificato prodotta eseguendo keytool localmente non corrisponderà a quella sui dispositivi degli utenti. Puoi verificare se stai utilizzando la firma dell'app di Google Play per la tua app nel tuo account sviluppatore Play Console in Release > Setup > App signing. In questo caso, troverai anche lo snippet JSON Digital Asset Links corretto per la tua app nella stessa pagina.

Il seguente file assetlinks.json di esempio concede diritti di apertura dei link a un'app per Android 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"]
  }
}]

Associare un sito web a più app

Un sito web può dichiarare associazioni con più app all'interno dello stesso file assetlinks.json. Il seguente elenco di file mostra un esempio di file di istruzione che dichiara l'associazione con due app separatamente e si trova in 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"]
  }
}]

App diverse possono gestire i link per risorse diverse nello stesso host web. Ad esempio, app1 potrebbe dichiarare un filtro per intent per https://example.com/articles e app2 potrebbe dichiarare un filtro per intent per https://example.com/videos.

Nota: più app associate a un dominio possono essere firmate con certificati uguali o diversi.

Associare più siti web a una singola app

Più siti web possono dichiarare associazioni con la stessa app nei rispettivi file assetlinks.json. I seguenti elenchi di file mostrano un esempio di come dichiarare l'associazione di example.com ed example.net con app1. La prima scheda mostra l'associazione di example.com con 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"]
  }
}]

La scheda successiva mostra l'associazione di example.net con app1. Solo la posizione in cui sono ospitati questi file è diversa (.com e .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"]
  }
}]

Pubblicare il file di verifica JSON

Devi pubblicare il tuo file di verifica JSON nella seguente posizione:

https://domain.name/.well-known/assetlinks.json

Verifica quanto segue:

  • Il file assetlinks.json viene pubblicato con il tipo di contenuto application/json.
  • Il file assetlinks.json deve essere accessibile tramite una connessione HTTPS, indipendentemente dal fatto che i filtri per intent dell'app dichiarino HTTPS come schema di dati.
  • Il file assetlinks.json deve essere accessibile senza reindirizzamenti (non sono previsti reindirizzamenti 301 o 302).
  • Se i link dell'app supportano più domini host, devi pubblicare il file assetlinks.json su ogni dominio. Vedi Supporto del collegamento delle app per più host.
  • Non pubblicare nel file manifest l'app nel file manifest contenente URL di sviluppo/test che potrebbero non essere accessibili al pubblico (ad esempio URL accessibili solo con una VPN). Una soluzione alternativa in questi casi è configurare le varianti di build per generare un file manifest diverso per le build di sviluppo.

Verifica Link per app Android

Se android:autoVerify="true" è presente in almeno uno dei filtri di intent dell'app, se installi l'app su un dispositivo con Android 6.0 (livello API 23) o versioni successive il sistema verifica automaticamente gli host associati agli URL nei filtri per intent dell'app. Su Android 12 e versioni successive, puoi anche chiamare manualmente la procedura di verifica per testare la logica di verifica.

Verifica automatica

La verifica automatica del sistema prevede quanto segue:

  1. Il sistema controlla tutti i filtri per intent che includono uno dei seguenti elementi:
    • Azione: android.intent.action.VIEW
    • Categorie: android.intent.category.BROWSABLE e android.intent.category.DEFAULT
    • Schema dei dati: http o https
  2. Per ogni nome host univoco trovato nei filtri per intent precedenti, Android esegue una query sui siti web corrispondenti per il file Digital Asset Links all'indirizzo https://hostname/.well-known/assetlinks.json.

Dopo aver verificato l'elenco di siti web da associare alla tua app e verificato che il file JSON ospitato sia valido, installa l'app sul tuo dispositivo. Attendi almeno 20 secondi per il completamento della procedura di verifica asincrona. Usa il seguente comando per verificare se il sistema ha verificato la tua app e impostare i criteri di gestione dei link corretti:

adb shell am start -a android.intent.action.VIEW \
    -c android.intent.category.BROWSABLE \
    -d "http://domain.name:optional_port"

Verifica manuale

A partire da Android 12, puoi richiamare manualmente la verifica del dominio per un'app installata su un dispositivo. Puoi eseguire questa procedura indipendentemente dal fatto che la tua app abbia come target Android 12.

Stabilisci una connessione a internet

Per eseguire la verifica del dominio, il dispositivo di test deve essere connesso a internet.

Supporta la procedura di verifica del dominio aggiornata

Se la tua app ha come target Android 12 o versioni successive, il sistema utilizza automaticamente la procedura di verifica del dominio aggiornata.

In caso contrario, puoi attivare manualmente la procedura di verifica aggiornata. Per farlo, esegui questo comando in una finestra del terminale:

adb shell am compat enable 175408749 PACKAGE_NAME

Reimpostare lo stato di Link per app Android su un dispositivo

Prima di richiamare manualmente la verifica del dominio su un dispositivo, devi reimpostare lo stato dei link per app Android sul dispositivo di test. Per farlo, esegui questo comando in una finestra del terminale:

adb shell pm set-app-links --package PACKAGE_NAME 0 all

Questo comando posiziona il dispositivo nello stesso stato in cui si trova prima che l'utente scelga le app predefinite per qualsiasi dominio.

Richiamare la procedura di verifica del dominio

Dopo aver reimpostato lo stato di Link per app Android su un dispositivo, puoi eseguire la verifica stessa. Per farlo, esegui questo comando in una finestra del terminale:

adb shell pm verify-app-links --re-verify PACKAGE_NAME

Esamina i risultati della verifica

Dopo aver concesso all'agente di verifica del tempo per completare le sue richieste, esamina i risultati della verifica. Per farlo, esegui questo comando:

adb shell pm get-app-links PACKAGE_NAME

L'output di questo comando è simile al seguente:

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

Lo stato di verifica del dominio dei domini che superano la verifica è verified. Qualsiasi altro stato indica che non è stato possibile eseguire la verifica del dominio. In particolare, lo stato none indica che l'agente di verifica potrebbe non aver ancora completato la procedura di verifica.

Il seguente elenco mostra i possibili valori restituiti che la verifica del dominio può restituire per un determinato dominio:

none
Non è stato registrato nulla per questo dominio. Attendi ancora qualche minuto affinché l'agente di verifica completi le richieste relative alla verifica del dominio, quindi richiama di nuovo la procedura di verifica del dominio.
verified
Il dominio è stato verificato per l'app che li dichiara.
approved
Il dominio è stato approvato in modo forzato, di solito eseguendo un comando shell.
denied
Il dominio è stato negato in modo forzato, di solito eseguendo un comando shell.
migrated
Il sistema ha conservato il risultato di una procedura precedente che utilizzava la verifica del dominio legacy.
restored
Il dominio è stato approvato dopo che l'utente ha eseguito un ripristino dei dati. si presume che il dominio sia stato verificato in precedenza.
legacy_failure
Il dominio è stato rifiutato da uno strumento di verifica precedente. Il motivo specifico dell'errore è sconosciuto.
system_configured
Il dominio è stato approvato automaticamente dalla configurazione del dispositivo.
Codice di errore 1024 o superiore

Codice di errore personalizzato specifico per lo strumento di verifica del dispositivo.

Assicurati di aver stabilito una connessione di rete e richiama di nuovo la procedura di verifica del dominio.

Richiedi all'utente di associare la tua app a un dominio

Un altro modo affinché la tua app venga approvata per un dominio è chiedere all'utente di associare la tua app a quel dominio.

Verificare se la tua app è già approvata per il dominio

Prima di chiedere all'utente, controlla se la tua app è il gestore predefinito per i domini che definisci nei tuoi elementi <intent-filter>. Puoi eseguire query sullo stato di approvazione utilizzando uno dei seguenti metodi:

Gestore della verifica del dominio

Il seguente snippet di codice mostra come utilizzare l'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);
    }
}

Programma a riga di comando

Quando testi la tua app durante lo sviluppo, puoi eseguire questo comando per eseguire query sullo stato di verifica dei domini di proprietà della tua organizzazione:

adb shell pm get-app-links --user cur PACKAGE_NAME

Nel seguente output di esempio, anche se la verifica dell'app per il dominio "example.org" non è riuscita, l'utente 0 ha approvato manualmente l'app nelle impostazioni di sistema e nessun altro pacchetto è stato verificato per quel dominio.

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

Puoi anche utilizzare i comandi della shell per simulare il processo in cui l'utente seleziona l'app associata a un determinato dominio. Una spiegazione completa di questi comandi è disponibile nell'output di adb shell pm.

Fornisci il contesto per la richiesta

Prima di inviare questa richiesta di approvazione del dominio, fornisci un po' di contesto per l'utente. Ad esempio, potresti mostrare all'utente una schermata iniziale, una finestra di dialogo o un elemento UI simile che spiega all'utente perché la tua app dovrebbe essere il gestore predefinito per un determinato dominio.

Effettua la richiesta

Dopo che l'utente ha capito cosa richiede la tua app, invia la richiesta. A questo scopo, richiama un intent che includa l'azione dell'intent ACTION_APP_OPEN_BY_DEFAULT_SETTINGS e una stringa di dati corrispondente package:com.example.pkg per l'app di destinazione, come mostrato nel seguente snippet di codice:

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

Quando l'intent viene richiamato, gli utenti visualizzano una schermata delle impostazioni denominata Apri per impostazione predefinita. Questa schermata contiene un pulsante di opzione chiamato Apri link supportati, come mostrato nella Figura 1.

Quando l'utente attiva l'opzione Apri link supportati, viene visualizzata una serie di caselle di controllo sotto una sezione denominata Link da aprire in questa app. Da qui, gli utenti possono selezionare i domini da associare alla tua app. Possono anche selezionare Aggiungi link per aggiungere domini, come mostrato nella figura 2. Quando gli utenti in seguito selezionano un link all'interno dei domini che aggiungono, il link si apre automaticamente nella tua app.

Quando il pulsante di opzione è attivato, una sezione nella parte inferiore
    include caselle di controllo e un pulsante chiamato &quot;Aggiungi link&quot;
Figura 1. Schermata delle impostazioni di sistema in cui gli utenti possono scegliere quali link aprire nella tua app per impostazione predefinita.
Ogni casella di controllo rappresenta un dominio che puoi aggiungere. I pulsanti della finestra di dialogo sono &quot;Annulla&quot; e &quot;Aggiungi&quot;.
Figura 2. Finestra di dialogo in cui gli utenti possono scegliere domini aggiuntivi da associare alla tua app.

Aprire domini nella tua app che questa non può verificare

La funzione principale dell'app potrebbe essere l'apertura di link come terze parti, senza la possibilità di verificare i relativi domini gestiti. In questo caso, spiega agli utenti che, quando selezionano un link web, non possono scegliere tra un'app proprietaria e la tua app di terze parti. Gli utenti devono associare manualmente i domini alla tua app di terze parti.

Inoltre, valuta la possibilità di introdurre un'attività di dialogo o trampolino che consenta all'utente di aprire il link nell'app proprietaria, se preferisce farlo, agendo come proxy. Prima di impostare una finestra di dialogo o un'attività di trampolino, configura la tua app in modo che abbia la visibilità dei pacchetti nelle app proprietarie che corrispondono al filtro per intent web dell'app.

Link dell'app di prova

Quando implementi la funzionalità di collegamento delle app, devi testarla per assicurarti che il sistema possa associare la tua app ai tuoi siti web e gestire le richieste di URL, come previsto.

Per testare un file di istruzioni esistente, puoi utilizzare lo strumento Generatore e tester dell'elenco di istruzioni.

Conferma l'elenco di host da verificare

Durante il test, devi confermare l'elenco degli host associati che il sistema deve verificare per la tua app. Crea un elenco di tutti gli URL i cui filtri per intent corrispondenti includono i seguenti attributi ed elementi:

  • Attributo android:scheme con un valore di http o https
  • Attributo android:host con un pattern URL di dominio
  • android.intent.action.VIEW elemento azione
  • android.intent.category.BROWSABLE elemento categoria

Utilizza questo elenco per verificare che su ogni host e sottodominio denominato venga fornito un file JSON Digital Asset Links.

Conferma i file Digital Asset Links

Per ogni sito web, utilizza l'API Digital Asset Links per verificare che il file JSON Digital Asset Links sia ospitato e definito correttamente:

https://digitalassetlinks.googleapis.com/v1/statements:list?
   source.web.site=https://domain.name:optional_port&
   relation=delegate_permission/common.handle_all_urls

Nell'ambito del processo di test, puoi verificare le attuali impostazioni di sistema per la gestione dei link. Utilizza il seguente comando per ottenere un elenco delle norme di gestione dei link esistenti per tutte le app sul tuo dispositivo connesso:

adb shell dumpsys package domain-preferred-apps

Oppure procedi come segue:

adb shell dumpsys package d

Nota: assicurati di attendere almeno 20 secondi dopo l'installazione dell'app per consentire al sistema di completare la procedura di verifica.

Il comando restituisce un elenco di ciascun utente o profilo definito sul dispositivo, preceduto da un'intestazione nel seguente formato:

App linkages for user 0:

Dopo questa intestazione, l'output utilizza il seguente formato per elencare le impostazioni di gestione dei link per l'utente in questione:

Package: com.android.vending
Domains: play.google.com market.android.com
Status: always : 200000002

La scheda indica quali app sono associate a quali domini per l'utente:

  • Package: identifica un'app tramite il nome del pacchetto, come dichiarato nel file manifest.
  • Domains: mostra l'elenco completo degli host i cui link web sono gestiti da questa app, utilizzando gli spazi vuoti come delimitatori.
  • Status: mostra l'impostazione di gestione dei link corrente per questa app. Un'app che ha superato la verifica e il cui file manifest contiene android:autoVerify="true" mostra lo stato always. Il numero esadecimale dopo questo stato è correlato al record del sistema Android delle preferenze di collegamento delle app dell'utente. Questo valore non indica se la verifica è riuscita.

Nota: se un utente modifica le impostazioni del link dell'app per un'app prima del completamento della verifica, potresti vedere un falso positivo se la verifica è andata a buon fine, anche se la verifica non è andata a buon fine. La mancata riuscita della verifica, tuttavia, non è importante se l'utente ha abilitato esplicitamente l'app per aprire i link supportati senza chiedere l'autorizzazione. Questo perché le preferenze dell'utente hanno la precedenza sulla verifica programmatica (o la loro assenza). Di conseguenza, il link rimanda direttamente alla tua app, senza mostrare una finestra di dialogo, come se la verifica fosse riuscita.

Esempio di test

Affinché la verifica dei link dell'app abbia esito positivo, il sistema deve essere in grado di verificare la tua app con ciascuno dei siti web specificati in un determinato filtro per intent che soddisfa i criteri relativi ai link dell'app. L'esempio seguente mostra una configurazione del file manifest con diversi link dell'app definiti:

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

L'elenco di host che la piattaforma tenterà di verificare dal file manifest riportato sopra è:

www.example.com
mobile.example.com
www.example2.com
account.example.com

L'elenco di host che la piattaforma non tenterà di verificare dal file manifest riportato sopra è:

map.example.com (it does not have android.intent.category.BROWSABLE)
market://example.com (it does not have either an "http" or "https" scheme)

Per scoprire di più sugli elenchi di istruzioni, consulta la pagina relativa alla creazione di un elenco di istruzioni.

Correggere gli errori comuni di implementazione

Se non riesci a verificare i tuoi link per app Android, controlla se sono presenti i seguenti errori comuni. Questa sezione utilizza example.com come nome di dominio segnaposto. Quando esegui questi controlli, sostituisci example.com con il nome di dominio effettivo del server.

Impostazione del filtro per intent non corretta
Verifica se includi un URL non di proprietà della tua app in un elemento <intent-filter>.
Configurazione errata del server

Controlla la configurazione JSON del tuo server e assicurati che il valore SHA sia corretto.

Inoltre, verifica che example.com. (con il punto finale) pubblichi gli stessi contenuti di example.com.

Reindirizzamenti lato server

Il sistema non verifica nessun link per app Android per la tua app se configuri un reindirizzamento come segue:

  • Da http://example.com a https://example.com
  • Da example.com a www.example.com

Questo comportamento protegge la sicurezza della tua app.

Robustezza del server

Controlla se il server può connettersi alle app client.

Link non verificabili

A scopo di test, potresti aggiungere intenzionalmente link non verificabili. Tieni presente che, su Android 11 e versioni precedenti, questi link impediscono al sistema di verificare tutti i link per app Android relativi alla tua app.

Firma non corretta in assetlinks.json

Verifica che la firma sia corretta e corrisponda alla firma utilizzata per firmare l'app. Gli errori comuni includono:

  • Firma dell'app con un certificato di debug e la firma della release soltanto in assetlinks.json.
  • Firmare una firma in minuscolo in assetlinks.json. La firma deve essere in lettere maiuscole.
  • Se usi la firma dell'app di Google Play, assicurati di usare la firma che Google usa per firmare tutte le tue release. Puoi verificare questi dettagli, incluso uno snippet JSON completo, seguendo le istruzioni relative alla dichiarazione delle associazioni di siti web.