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 correttamente che gli URL sono di tua proprietà, indirizzerà automaticamente gli intent URL alla tua app.
Per verificare di avere la proprietà sia dell'app sia degli URL del sito web, segui questi passaggi:
Aggiungi filtri per intent contenenti l'attributo
autoVerify. Questo attributo indica al sistema che deve verificare se la tua app appartiene ai domini URL utilizzati nei filtri intent.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:
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 intent corrispondenti 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>. 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 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 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 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 l'intenzione supporti sia http://www.example.com che 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 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. 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 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 filebuild.gradledell'app.sha256_cert_fingerprints: le impronte SHA256 del certificato di firma dell'app. Puoi utilizzare il seguente comando per generare l'impronta con lo strumento chiave Java:keytool -list -v -keystore my-release-key.keystore
Se utilizzi la firma dell'app Google Play per la tua app, in genere la fingerprint del certificato prodotta dall'esecuzione di
keytoollocalmente 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 inRelease > 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 certificati 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. 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"] } }]
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.jsonviene pubblicato con il valoreapplication/jsonper il content-type. - Il file
assetlinks.jsondeve 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.jsondeve essere accessibile senza reindirizzamenti (nessun reindirizzamento 301 o 302). - Se i link dell'app supportano più domini host, devi pubblicare il file
assetlinks.jsonsu 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 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:
- Il sistema controlla tutti i filtri per intent che includono uno qualsiasi dei seguenti elementi:
- Azione:
android.intent.action.VIEW - Categorie:
android.intent.category.BROWSABLEeandroid.intent.category.DEFAULT - Schema dei dati:
httpohttps
- Azione:
- 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 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 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 il tempo necessario per 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 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 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 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 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 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 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:
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 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 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.
Fornisci 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.
Fai 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:
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 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 selezioneranno un link all'interno dei domini che hanno aggiunto, il link si aprirà automaticamente nella tua app.
Aprire nella tua app domini che non può verificare
La funzione principale della tua app potrebbe essere aprire link come terze parti, 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, configura l'app in modo che abbia la visibilità dei pacchetti nelle app proprietarie corrispondenti al filtro per intent web dell'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:schemecon il valorehttpohttps - Attributo
android:hostcon 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.
Verifica 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 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 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 contieneandroid:autoVerify="true"mostra lo statoalways. 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 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 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 se sono presenti i seguenti errori comuni. Questa sezione utilizza example.com come nome di dominio segnaposto. Quando esegui questi controlli, sostituisci example.com con il nome di dominio effettivo del tuo server.
- Configurazione errata del filtro per intenzione
- Verifica di non includere un URL non di tua proprietà in un elemento
<intent-filter>. - 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 diexample.com.- Reindirizzamenti lato server
Il sistema non verifica nessun link alle app Android per la tua app se configuri un reindirizzamento come il seguente:
- Da
http://example.comahttps://example.com - Da
example.comawww.example.com
Questo comportamento protegge la sicurezza della tua app.
- Da
- 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 includono:
- 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.
- Firma dell'app con un certificato di debug e presenza della firma della release solo in