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 che l'utente debba selezionare l'app. I link per app Android utilizzano l'API Digital Asset Links per stabilire che la tua app è stata approvata dal sito web per aprire automaticamente i link per quel dominio. Se il sistema verifica che sei il proprietario degli URL, indirizza automaticamente gli intent degli URL alla tua app.

Per verificare di avere la proprietà sia dell'app sia degli URL del sito web, segui questi passaggi:

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

2. Dichiara l'associazione tra il tuo sito web e i tuoi filtri di 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:

• Supporto di URL e indicizzazione delle app in Android Studio
• Creare un elenco di istruzioni

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 di 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". -->
    <!-- Do not include other schemes. -->
    <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 l'host viene utilizzato in altre dichiarazioni non contrassegnate, per coerenza è consigliabile aggiungere autoVerify a ogni elemento <intent-filter>. In questo modo, dopo aver rimuovere o riorganizzato gli elementi nel file manifest, l'app rimane associata a tutti i domini che continui a definire.

La procedura di verifica del dominio richiede una connessione a internet e potrebbe richiedere un po' di tempo. Per contribuire a migliorare l'efficienza della procedura, il sistema verifica un dominio per un'app che ha come target Android 12 o versioni successive solo se il dominio si trova all'interno di un elemento <intent-filter> che contiene il formato esatto specificato nello snippet di codice precedente. Ad esempio, schema diversi da "http" e "https", come <data android:scheme="custom" />, impediranno a un <intent-filter> di attivare la verifica del dominio.

Supporto del collegamento delle app per più host

Il sistema deve essere in grado di verificare l'host specificato negli elementi di dati dei filtri per intent URL dell'app in base ai file Digital Asset Links ospitati sui rispettivi domini web in quel filtro per intent. Se la verifica non va a buon fine, il sistema adotta il comportamento standard per risolvere lo scopo, come descritto in 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 definiti nel manifest.

Ad esempio, un'app con i seguenti filtri di intente supererebbe la verifica solo per https://www.example.com se un file assetlinks.json fosse trovato 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 intent vengono uniti per tenere conto di tutte le varianti dei relativi attributi combinati. Ad esempio, il primo filtro intent riportato sopra include un elemento <data> che dichiara solo lo schema HTTPS. Tuttavia, viene combinato con l'altro elemento <data> in modo che il filtro per intenzione supporti sia http://www.example.com che https://www.example.com. Di conseguenza, devi creare filtri di intent separati quando vuoi definire combinazioni specifiche di schemi e domini URI.

Supporto del collegamento delle app per più sottodomini

Il protocollo Digital Asset Links tratta i sottodomini nei filtri di intent come host unici e distinti. Pertanto, se il filtro per intent elenca più host con sottodomini diversi, devi pubblicare un assetlinks.json valido su ogni dominio. Ad esempio, il seguente filtro di intent include www.example.com e mobile.example.com come host URL intent accettati. Pertanto, un valore 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 nome host con un carattere jolly (ad es. *.example.com), devi pubblicare il file assetlinks.json al nome host principale (example.com). Ad esempio, un'app con il seguente filtro intent supererà la verifica per qualsiasi nome secondario di example.com (ad es. foo.example.com) se il file assetlinks.json è pubblicato su 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>

Verificare la presenza di più app associate allo stesso dominio

Se pubblichi più app associate allo stesso dominio, ciascuna può essere verificata correttamente. Tuttavia, se le app possono risolvere lo stesso indirizzo e percorso del dominio, come potrebbe essere il caso delle versioni lite e complete di un'app, solo l'app installata più di recente può risolvere gli intent web per quel dominio.

In un caso come questo, controlla se sul dispositivo dell'utente sono presenti app in conflitto, a condizione che tu disponga della visibilità del pacchetto necessaria. Poi, nella tua app, mostra una finestra di dialogo di selezione personalizzata contenente i risultati della chiamata di queryIntentActivities(). L'utente può selezionare l'app che preferisce dall'elenco di app corrispondenti visualizzato nella finestra di dialogo.

Dichiarare le associazioni di siti web

Sul tuo sito web deve essere pubblicato un file JSON Digital Asset Links per indicare le app Android associate al sito web e verificare le intenzioni 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 impronte SHA256 del certificato di firma dell'app. Puoi utilizzare il seguente comando per generare l'impronta tramite il keytool Java:

  keytool -list -v -keystore my-release-key.keystore
  

  Questo campo supporta più impronte, che possono essere utilizzate per supportare diverse versioni dell'app, ad esempio build di debug e di produzione.

  Se utilizzi la firma dell'app Google Play per la tua app, in genere la fingerprint del certificato prodotta dall'esecuzione di keytool localmente non corrisponde a quella sui dispositivi degli utenti. Puoi verificare se utilizzi la firma dell'app Google Play per la tua app nel tuo account sviluppatore Play Console in Release > Setup > App signing. Se è così, nella stessa pagina troverai anche lo snippet JSON Digital Asset Links corretto per la tua app.

Il seguente file assetlinks.json di esempio concede i diritti di apertura dei link a un'app 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 nello stesso file assetlinks.json. L'elenco di file riportato di seguito mostra un esempio di file di istruzioni 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 link per risorse diverse nello stesso host web. Ad esempio, l'app1 può dichiarare un filtro per intent per https://example.com/articles e l'app2 può dichiarare un filtro per intent per https://example.com/videos.

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

Associare più siti web a una singola app

Più siti web possono dichiarare associazioni con la stessa app nei rispettivi file assetlinks.json. Le seguenti schede dei file mostrano un esempio di come dichiarare l'associazione di example.com e example.net con app1. La prima voce 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 voce successiva mostra l'associazione di example.net con app1. È diversa solo la posizione in cui sono ospitati questi file (.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"]
  }
}]

Pubblicazione del file di verifica JSON

Devi pubblicare il file di verifica JSON nella seguente posizione:

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

Assicurati di quanto segue:

• Il file assetlinks.json viene pubblicato con il valore application/json per il content-type.
• 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 (nessun reindirizzamento 301 o 302).
• Se i link dell'app supportano più domini host, devi pubblicare il fileassetlinks.json su ogni dominio. Consulta Supportare il collegamento delle app per più host.
• Non pubblicare l'app con URL di sviluppo/test nel file manifest che potrebbero non essere accessibili al pubblico (ad esempio quelli accessibili solo con una VPN). In questi casi, una possibile soluzione è configurare le varianti di build per generare un file manifest diverso per le build di sviluppo.

Verifica di Link per app Android

Quando android:autoVerify="true" è presente in almeno uno dei filtri intent della tua app, l'installazione dell'app su un dispositivo con Android 6.0 (livello API 23) o versioni successive fa sì che il sistema verifichi automaticamente gli host associati agli URL nei filtri intent della tua app. Su Android 12 e versioni successive, puoi anche richiamare 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 di 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 intent riportati sopra, Android esegue query sui siti web corrispondenti per il file Digital Asset Links all'indirizzo https://hostname/.well-known/assetlinks.json.

Dopo aver confermato l'elenco dei siti web da associare alla tua app e aver confermato che il file JSON ospitato è valido, installa l'app sul tuo dispositivo. Attendi almeno 20 secondi per il completamento della procedura di verifica asincrona. Utilizza il seguente comando per verificare se il sistema ha verificato la tua app e impostato 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.

Stabilire una connessione a internet

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

Supportare 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 il seguente comando in una finestra del terminale:

adb shell am compat enable 175408749 PACKAGE_NAME

Ripristinare lo stato dei link alle app Android su un dispositivo

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

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

Questo comando imposta il dispositivo nello stesso stato in cui si trova prima che l'utente scelga le app predefinite per i domini.

Avvia la procedura di verifica del dominio

Dopo aver reimpostato lo stato dei link alle app Android su un dispositivo, puoi eseguire la verifica stessa. Per farlo, esegui il seguente 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 il tempo necessario per completare le richieste, esamina i risultati della verifica. Per farlo, esegui il seguente 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

I domini che superano la verifica hanno uno stato di verifica del dominio equale a verified. Qualsiasi altro stato indica che non è stato possibile eseguire la verifica del dominio. In particolare, uno stato none indica che l'agente di verifica potrebbe non aver ancora completato la procedura di verifica.

L'elenco seguente 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 qualche altro minuto affinché l'agente di verifica completi le richieste relative alla verifica del dominio, quindi richiama la procedura di verifica del dominio di nuovo.

verified

Il dominio è stato verificato correttamente per l'app dichiarante.

approved

Il dominio è stato approvato forzatamente, in genere mediante l'esecuzione di un comando shell.

denied

Il dominio è stato rifiutato forzatamente, in genere mediante l'esecuzione di 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 un verificatore precedente. Il motivo specifico del rifiuto è sconosciuto.

system_configured

Il dominio è stato approvato automaticamente dalla configurazione del dispositivo.

Codice di errore pari o superiore a 1024

Codice di errore personalizzato specifico per il verificatore del dispositivo.

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

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

Un altro modo per ottenere l'approvazione della tua app per un dominio è chiedere all'utente di associarla al dominio.

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

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

• L'API DomainVerificationManager (in fase di esecuzione).
• Un programma a riga di comando (durante il test).

DomainVerificationManager

Il seguente snippet di codice mostra come utilizzare l'API DomainVerificationManager:

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 }

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 l'app durante lo sviluppo, puoi eseguire il seguente 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

Nell'esempio di output seguente, anche se l'app non ha superato la verifica per il dominio "example.org", l'utente 0 ha approvato manualmente l'app nelle impostazioni di sistema e nessun altro pacchetto è 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 shell per simulare la procedura 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.

Fornire il contesto della richiesta

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

Effettua la richiesta

Dopo che l'utente ha compreso cosa gli sta chiedendo la tua app, effettua la richiesta. A tale scopo, invoca un'intenzione che includa l'azione ACTION_APP_OPEN_BY_DEFAULT_SETTINGS dell'intenzione e una stringa di dati corrispondente package:com.example.pkg per l'app di destinazione, come mostrato nel seguente snippet di codice:

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)

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 viene invocato l'intent, gli utenti visualizzano una schermata delle impostazioni denominata Apri per default. Questa schermata contiene un pulsante di opzione denominato Apri link supportati, come mostrato nella figura 1.

Quando l'utente attiva l'opzione Apri i link supportati, viene visualizzata una serie di caselle di controllo in 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 in un secondo momento gli utenti selezionato un link all'interno dei domini che hanno aggiunto, il link si apre automaticamente nella tua app.

Aprire nella tua app domini che non può verificare

La funzione principale della tua app potrebbe essere aprire link come entità terza, senza la possibilità di verificare i 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, ti consigliamo di introdurre un'attività di dialogo o trampolino che consenta all'utente di aprire il link nell'app proprietaria, se preferisce, fungendo da proxy. Prima di configurare un'attività di dialogo o trampolino, imposta la tua app in modo che abbia visibilità del pacchetto nelle app proprietarie corrispondenti al filtro intent web della tua app.

Testare i link alle app

Quando implementi la funzionalità di collegamento delle app, devi testare la funzionalità di collegamento per verificare 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 di elenchi di istruzioni.

Conferma l'elenco di host da verificare

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

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

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

Verificare 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

Controllare le norme relative ai link

Durante la procedura di test, puoi controllare le impostazioni di sistema correnti per la gestione dei link. Utilizza il seguente comando per ottenere un elenco dei criteri di gestione dei link esistenti per tutte le app sul tuo dispositivo connesso:

adb shell dumpsys package domain-preferred-apps

In alternativa, puoi eseguire la seguente operazione:

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 ogni utente o profilo definito sul dispositivo, preceded by an header in the following format:

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

Questa 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 di cui questa app gestisce i link web, 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 è andata a buon fine.

Nota:se un utente modifica le impostazioni di collegamento di un'app prima del completamento della verifica, potresti visualizzare un falso positivo per una verifica riuscita, anche se la verifica non è andata a buon fine. Questo errore di verifica, tuttavia, non è importante se l'utente ha attivato esplicitamente l'apertura dei link supportati da parte dell'app senza chiedere. Questo accade perché le preferenze dell'utente hanno la precedenza sulla verifica programmatica (o sulla sua assenza). Di conseguenza, il link rimanda direttamente alla tua app, senza mostrare una finestra di dialogo, come se la verifica fosse andata a buon fine.

Esempio di test

Affinché la verifica del link dell'app vada a buon fine, 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 per i link dell'app. L'esempio seguente mostra una configurazione manifest con diversi link di 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 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 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 Creare un elenco di istruzioni.

Correggere gli errori di implementazione comuni

Se non riesci a verificare i tuoi link alle app per Android, controlla se si verificano 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 tuo server.

Configurazione errata del filtro per intenzione

Controlla se in un elemento <intent-filter> includi un URL non di tua proprietà.

Configurazione errata del server

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

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

Reindirizzamenti lato server

Il sistema non verifica nessun link all'app Android per la tua app se configuri un reindirizzamento come il seguente:

• 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

Verifica 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 all'app Android per la tua app.

Firma errata in assetlinks.json

Verifica che la firma sia corretta e corrisponda a quella utilizzata per firmare la tua app. Gli errori più comuni sono:

• Firma dell'app con un certificato di debug e presenza della firma della release solo in assetlinks.json.
• Firma in minuscolo in assetlinks.json. La firma deve essere in maiuscolo.
• Se utilizzi la funzionalità di firma dell'app di Google Play, assicurati di utilizzare la firma impiegata da Google per firmare ogni release. Puoi verificare questi dettagli, incluso uno snippet JSON completo, seguendo le istruzioni per la dichiarazione delle associazioni di siti web.