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 selezionare l'app. I link per app Android utilizzano l'API Digital Asset Links per stabilire con certezza che la tua app è 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à, indirizzerà automaticamente gli intent URL alla tua app.

Per verificare la tua proprietà sia degli URL dell'app sia degli URL del sito web, completa i seguenti passaggi:

1. Aggiungi filtri per intent contenenti 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 tuoi 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:

• Supportare URL e indicizzazione delle app in Android Studio
• Creare un elenco di estratti conto

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 l'host viene utilizzato in altre dichiarazioni non contrassegnate, ti consigliamo di aggiungere autoVerify a ogni elemento <intent-filter> per garantire coerenza. Ciò garantisce inoltre che, dopo la rimozione o il refactoring degli elementi nel file manifest, l'app rimanga associata a tutti i domini che definisci ancora.

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

Supporto del collegamento delle app per più host

Il sistema deve essere in grado di verificare l'host specificato negli elementi dati dei filtri per intent dell'URL dell'app a fronte dei file Digital Asset Links ospitati sui rispettivi domini web nel filtro per intent. Se la verifica non va a buon fine, il sistema ripristina il comportamento standard per risolvere l'intent, 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 da te definiti 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 dei loro attributi combinati. Ad esempio, il primo filtro per 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 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 valore assetlinks.json valido su ciascun 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, è necessario pubblicare un elemento assetlinks.json valido sia in https://www.example.com/.well-known/assetlinks.json che 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 sottonome di example.com (ad esempio foo.example.com), purché il file assetlinks.json sia pubblicato all'indirizzo 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. Tuttavia, se le app sono in grado di risolvere esattamente lo stesso host di dominio e lo stesso percorso, come nel 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 questi casi, verifica la presenza di eventuali app in conflitto sul dispositivo dell'utente, a condizione che tu disponga della visibilità dei pacchetti necessaria. Poi, nell'app, mostra una finestra di dialogo di scelta personalizzata contenente i risultati della chiamata queryIntentActivities(). L'utente può selezionare l'app preferita dall'elenco di app corrispondenti visualizzate 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 Android associate al sito web e verificare gli intent 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 della tua app. Puoi utilizzare il seguente comando per generare l'impronta con lo strumento chiave Java:

  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 di produzione.

  Se utilizzi la firma dell'app di Google Play per la tua app, l'impronta digitale del certificato prodotta eseguendo keytool in locale di solito non corrisponde 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 nella sezione Release > Setup > App signing. In questo caso, 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 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 istruzioni che dichiara l'associazione a due app separatamente e si trova all'indirizzo 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, app1 potrebbe dichiarare un filtro per intent per https://example.com/articles, mentre app2 potrebbe dichiarare un filtro per intent per https://example.com/videos.

Nota:è possibile che più app associate a un dominio vengano firmate con lo stesso certificato o con certificati diversi.

Associare più siti web a una singola app

Più siti web possono dichiarare le 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. Il primo elenco 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"]
  }
}]

L'elenco successivo mostra l'associazione di example.net ad app1. È diversa solo la località 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

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 consentiti reindirizzamenti 301 o 302).
• Se i link dell'app supportano più domini host, devi pubblicare il file assetlinks.json su ciascun dominio. Consulta Supporto del collegamento di app per più host.
• Non pubblicare nel file manifest la tua app con URL di sviluppo/test che potrebbero non essere accessibili al pubblico (ad esempio quelli accessibili solo con una VPN). Una soluzione alternativa in questi casi consiste nel configurare le varianti di build in modo da generare un file manifest diverso per le build di sviluppo.

Verifica tramite link per app Android

Se android:autoVerify="true" è presente in almeno uno dei filtri per 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 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 per intent che includono uno qualsiasi 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 riportati sopra, Android esegue una query sui siti web corrispondenti per trovare il file Digital Asset Links all'indirizzo https://hostname/.well-known/assetlinks.json.

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

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 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 di Android App Links 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 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 Android App Links 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 di completare le 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

I domini che superano la verifica hanno uno stato di verifica del dominio 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.

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 in modo che l'agente di verifica completi le richieste relative alla verifica del dominio, quindi riattiva di nuovo la procedura di verifica del dominio.

verified

Il dominio è stato verificato per l'app che dichiara l'app.

approved

Il dominio è stato approvato in modo forzato, solitamente mediante l'esecuzione di un comando shell.

denied

Il dominio è stato negato in modo forzato, solitamente mediante l'esecuzione di un comando shell.

migrated

Il sistema ha conservato il risultato di una procedura precedente che utilizzava la verifica del dominio precedente.

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 pari o superiore a 1024

Codice di errore personalizzato specifico dello strumento di verifica del dispositivo.

Assicurati di aver stabilito una connessione di rete e richiama di nuovo il processo di verifica del dominio.

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

Un altro modo per far sì che la tua app venga approvata per un dominio è chiedere all'utente di associare l'app a quel dominio.

Controlla 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 negli elementi <intent-filter>. Puoi eseguire query sullo stato di approvazione utilizzando uno dei seguenti metodi:

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

Gestore della verifica del dominio

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 la tua app durante lo sviluppo, puoi eseguire il comando seguente per eseguire una query sullo stato della verifica dei domini di proprietà della tua organizzazione:

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

Nell'output di esempio che segue, anche se la verifica dell'app per il dominio "example.org" non è andata a buon fine, 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 shell per simulare il processo in cui l'utente seleziona quale app è associata a un determinato dominio. Una spiegazione completa di questi comandi è disponibile nell'output di adb shell pm.

Fornisci il contesto della richiesta

Prima di effettuare questa richiesta per l'approvazione del dominio, fornisci qualche contesto per l'utente. Ad esempio, potresti mostrare 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 compreso cosa gli chiede di fare la tua app, effettua la richiesta. A questo scopo, richiama un intent che includa l'azione di intent ACTION_APP_OPEN_BY_DEFAULT_SETTINGS e una stringa di dati corrispondente a 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 l'intent viene richiamato, gli utenti vedono una schermata di impostazioni chiamata Apri per impostazione predefinita. Questa schermata contiene un pulsante di opzione Apri link supportati, come mostrato nella Figura 1.

Quando l'utente attiva Apri 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 che vogliono associare alla tua app. Possono anche selezionare Aggiungi link per aggiungere domini, come mostrato nella figura 2. Quando gli utenti selezionano in un secondo momento un link qualsiasi all'interno dei domini che aggiungono, il link si apre automaticamente nella tua app.

Apri i domini nell'app che la tua app non può verificare

La funzione principale della tua app potrebbe essere quella di aprire link come terze parti, senza la possibilità di verificare i propri domini gestiti. In questo caso, spiega agli utenti che, nel momento in cui 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 una finestra di dialogo o un'attività con trampolino che consenta all'utente di aprire il link nell'app proprietaria, se preferisce, utilizzando un proxy. Prima di configurare un'attività di dialogo o trampolino, configura l'app in modo che abbia la visibilità dei pacchetti nelle app proprietarie corrispondenti al filtro per intent web dell'app.

Test dei link dell'app

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

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

Conferma l'elenco degli 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 il valore http o https
• Attributo android:host con un pattern URL del dominio
• Elemento di azione android.intent.action.VIEW
• Elemento 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.

Conferma i file Digital Asset Links

Per ogni sito web, utilizza l'API Digital Asset Links per confermare 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

Controlla le norme sui link

Nell'ambito della procedura di test, puoi controllare le impostazioni di sistema attuali per la gestione dei link. Utilizza il seguente comando per visualizzare un elenco dei criteri esistenti per la gestione dei link per tutte le app sul dispositivo collegato:

adb shell dumpsys package domain-preferred-apps

Oppure viene fatto lo stesso:

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

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 quell'utente:

• Package: identifica un'app tramite il nome del pacchetto, come dichiarato nel file manifest.
• Domains: mostra l'elenco completo degli host di cui vengono gestiti i link web da questa app, utilizzando spazi vuoti come delimitatori.
• Status: mostra l'impostazione corrente di gestione dei link 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 visualizzare un falso positivo relativo a una verifica riuscita, anche se la verifica non è andata a buon fine. Questo errore di verifica, tuttavia, non è importante se l'utente ha esplicitamente abilitato l'app ad aprire i link supportati senza chiedere l'autorizzazione. Il motivo è che le preferenze dell'utente hanno la precedenza sulla verifica programmatica (o la loro mancanza). Di conseguenza, il link rimanda direttamente alla tua app, senza mostrare una finestra di dialogo, proprio come se la verifica avesse avuto esito positivo.

Esempio di test

Affinché la verifica del link dell'app abbia esito positivo, il sistema deve essere in grado di verificare l'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 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 degli 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 degli host che la piattaforma non ha tentato 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 estratti conto, consulta Creare un elenco di estratti conto.

Correggere gli errori di implementazione più comuni

Se non riesci a verificare i link per app Android, controlla se sono presenti i seguenti errori comuni. In questa sezione viene utilizzato 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 intent

Verifica se includi un URL che non è di proprietà della tua app in un elemento <intent-filter>.

Configurazione del server non corretta

Controlla la configurazione JSON del 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 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

Controlla se il tuo server è in grado di 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 per la tua app.

Firma errata in assetlinks.json

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

• Firmare l'app con un certificato di debug e avere solo la firma di release in assetlinks.json.
• Firma in minuscolo in assetlinks.json. La firma deve essere in maiuscolo.
• 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 su dichiarare le associazioni di siti web.