Verificare i link per app Android

Un link per app Android è un tipo speciale di link diretto che consente gli URL del tuo sito web di aprire immediatamente i contenuti corrispondenti nella tua app per Android, senza e richiedere all'utente di selezionare l'app. I link per app Android utilizzano gli asset digitali l'API Links per stabilire l'attendibilità 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 la tua proprietà sia degli URL dell'app sia degli URL dei siti web, completa la procedura seguenti passaggi:

  1. Aggiungi filtri per intent contenenti 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 la tua intenzione i filtri 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 corrispondenti nel 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, per coerenza ti consigliamo di aggiungere autoVerify a ogni elemento <intent-filter>. In questo modo, dopo aver rimosso o riorganizzato gli elementi nel file manifest, la tua app rimarrà associata a tutti i domini che continui a definire.

La procedura di verifica del dominio richiede una connessione a internet e potrebbe richiedere per il completamento. 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.

Supporto del collegamento delle app per più host

Il sistema deve essere in grado di verificare l'host specificato nei dati dei filtri per intent dell'URL dell'app con i file Digital Asset Links ospitati nei rispettivi domini web in quel filtro per intent. Se la verifica non va a buon fine, il sistema utilizza il comportamento standard per impostazione predefinita. risolvere l'intento, come descritto Creare link diretti a contenuti dell'app. Tuttavia, l'app può essere comunque 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 il seguente intent filtri superano 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 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 per intent riportato sopra include un elemento <data> che dichiara soltanto Schema HTTPS. Tuttavia, viene combinato con l'altro elemento <data> in modo che l'intent supporta 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 unici con host separati. Se quindi il tuo intento elenca più host con sottodomini diversi, devi pubblicare un assetlinks.json su ciascun dominio. Ad esempio: il seguente filtro per intent include www.example.com e mobile.example.com come host di URL di intent accettati. Quindi un numero assetlinks.json deve essere pubblicato in entrambi https://www.example.com/.well-known/assetlinks.json e 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 passerà la verifica per il sottonome di example.com (ad esempio foo.example.com) come 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>

Verificare la presenza di più app associate allo stesso dominio

Se pubblichi più app associate allo stesso dominio, queste possono essere verificati correttamente. Tuttavia, se le app sono in grado di risolvere lo stesso host di dominio e lo stesso percorso, come nel caso delle versioni lite e complete 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 abbia il pacchetto necessario visibilità. Poi, nella tua app, mostra una finestra di dialogo del selettore che contiene i risultati della chiamata queryIntentActivities() L'utente può selezionare l'app preferita dall'elenco di app corrispondenti che vengono visualizzate nella finestra di dialogo.

Dichiara le associazioni di siti web

Una risorsa digitale Il file JSON Link deve essere pubblicato sul tuo sito web per indicare le app per Android associati al sito web e verificano gli intent dell'URL dell'app. Il file JSON utilizza i seguenti campi per identificare le app associate:

  • package_name: l'ID applicazione dichiarate 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 usate 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, il certificato l'impronta digitale prodotta eseguendo keytool in locale di solito non corrisponde a quella dell'account utente dispositivi mobili. 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 di esempio assetlinks.json 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 assetlinks.json . Il seguente elenco di file mostra un esempio di file di istruzioni che dichiara l'associazione con 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 account o certificati diversi.

Associare più siti web a una singola app

Più siti web possono dichiarare associazioni con la stessa app nei propri i 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 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 voce successiva mostra l'associazione di example.net con app1. Solo il 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"]
  }
}]

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 content-type application/json.
  • Il file assetlinks.json deve essere accessibile tramite una connessione HTTPS a prescindere dal fatto che i filtri per intent dell'app dichiarino HTTPS come schema dei dati.
  • Il file assetlinks.json deve essere accessibile senza reindirizzamenti (nessun reindirizzamento reindirizzamenti 301 o 302).
  • Se i link dell'app supportano più domini host, devi pubblicare il assetlinks.json su ciascun dominio. Consulta Supporto del collegamento di 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). R in questi casi è configurare la build varianti per generare un file manifest diverso per le build di sviluppo.

Verifica tramite link per app Android

Quando android:autoVerify="true" è presente in almeno uno degli intent dell'app filtri, installando la tua app su un dispositivo con Android 6.0 (livello API 23) oppure un'impostazione più alta determina la verifica automatica da parte del sistema degli host associati 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 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 in precedenza, Android esegue query i siti web corrispondenti per il file Digital Asset Links su https://hostname/.well-known/assetlinks.json.
di Gemini Advanced.

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 affinché la procedura di verifica asincrona completato. Utilizza il seguente comando per controllare se il sistema ha verificato il tuo 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 il dominio verifica di un'app installata su un dispositivo. Puoi eseguire questa indipendentemente dal fatto che l'app abbia come target Android 12.

Stabilire una connessione a internet

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

Supportare la procedura di verifica del dominio aggiornata

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

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 mette il dispositivo nello stesso stato in cui si trova prima che l'utente sceglie le app predefinite per tutti 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 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 il 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 equale a verified. Qualsiasi altro stato indica che la verifica del dominio non è riuscita eseguire il deployment. In particolare, lo stato none indica che la verifica dell'agente potrebbe non aver ancora completato la procedura di verifica.

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

none
Non è stato registrato nulla per questo dominio. Attendi qualche altro minuto agente di verifica per completare le richieste relative alla verifica del dominio, quindi richiamare la procedura di verifica del dominio.
verified
Il dominio è stato verificato per l'app che dichiara l'app.
approved
Il dominio è stato approvato forzatamente, in genere 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 un processo precedente che utilizzava un dominio legacy la verifica dell'identità.
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.

Verifica 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 per far sì che l'app venga approvata per un dominio è chiedere all'utente di associare la tua app al dominio.

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

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

DomainVerificationManager

Il seguente snippet di codice illustra come utilizzare il parametro 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: invia 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 non è riuscita per "example.org" dominio, 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 il processo in cui l'utente seleziona quale app è associata a un determinato dominio. Una spiegazione completa di questi aspetti è disponibile dall'output di adb shell pm.

Fornisci il contesto della richiesta

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

Effettua la richiesta

Dopo che l'utente ha compreso cosa gli sta chiedendo la tua app, effettua la richiesta. A tale scopo, richiama un intent che includa la classe ACTION_APP_OPEN_BY_DEFAULT_SETTINGS e una stringa di dati corrispondente package:com.example.pkg per l'app di destinazione, come mostrato in il 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 vedono una schermata di impostazioni chiamata Apri tramite predefinita. Questa schermata contiene un pulsante di opzione 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 nella sezione Link da aprire in questa app. Da qui, gli utenti possono e selezionare i domini da associare alla tua app. Possono anche Seleziona 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.

Quando il pulsante di opzione è attivato, viene visualizzata una sezione nella parte inferiore
    include caselle di controllo e un pulsante &quot;Aggiungi link&quot;
Figura 1. Schermata Impostazioni di sistema in cui gli utenti possono scegliere quali link si aprono nell'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.

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 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 dialogo o un'attività con trampolino, imposta Impostare la tua app in modo che abbia la visibilità dei pacchetti nelle app proprietarie che corrispondono al filtro per intent web della tua app.

Test dei link dell'app

Quando implementi la funzionalità di collegamento delle app, devi testarla 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 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 quanto segue attributi ed elementi:

  • Attributo android:scheme con un 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 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 della procedura di test, puoi controllare le impostazioni di sistema attuali per la gestione dei link. Utilizza il seguente comando per ottenere un elenco dei criteri di gestione dei link esistenti per tutti app installate sul dispositivo connesso:

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 ciascun utente o profilo definito sul dispositivo. preceduta 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 quell'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 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 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 con verifica superata e il cui manifest contiene android:autoVerify="true", mostra uno stato di always. Il numero esadecimale dopo questo stato è correlato alla record delle preferenze di collegamento delle app dell'utente. Questo valore non indica se la verifica riuscito.

Nota: se un utente modifica le impostazioni del link dell'app per un'app prima della verifica viene completata, potresti notare un falso positivo relativo a una verifica andata a buon fine, anche se la verifica non è andata a buon fine. Questo errore di verifica, tuttavia, non è importante se l'utente attivato 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 sulla sua mancanza). 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 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 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 istruzioni, consulta Creare un elenco di istruzioni.

Correggere gli errori di implementazione comuni

Se non riesci a verificare i link per app Android, controlla i seguenti aspetti comuni errori. In questa sezione viene utilizzato example.com come nome di dominio segnaposto. quando eseguendo questi controlli, sostituisci example.com con i valori effettivi del server nome di dominio.

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

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

Inoltre, verifica che example.com. (con il punto finale) pubblichi lo stesso contenuti come example.com.

Reindirizzamenti lato server

Il sistema non verifica nessun link per app Android per la tua app se hai configurato 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. Conserva tieni presente che su Android 11 e versioni precedenti, questi link causano per non verificare tutti i link per app Android relativi alla tua app.

Firma errata in assetlinks.json

Verifica che la firma sia corretta e corrisponda alla firma utilizzata per firmare la tua app. Di seguito sono riportati alcuni errori comuni:

  • Firmare l'app con un certificato di debug e avere solo la release firma in assetlinks.json.
  • Firma in minuscolo in assetlinks.json. La firma deve in maiuscolo.
  • Se usi la firma dell'app di Google Play, assicurati di usarla che Google utilizza per firmare tutte le tue release. Puoi verificare questi dettagli, includere uno snippet JSON completo, seguendo le istruzioni dichiarare le associazioni di siti web.