Crea un link diretto per una destinazione

In Android, un link diretto è un link che rimanda direttamente a una pagina destinazione all'interno di un'app.

Il componente Navigazione consente di creare due diversi tipi di link diretti: explicit e implicit.

Creare un link diretto esplicito

Un link diretto esplicito è una singola istanza di un link diretto che utilizza un PendingIntent per indirizzare gli utenti in una posizione specifica all'interno dell'app. Potresti trovare una un link diretto esplicito in una notifica o in un widget dell'app; ad esempio.

Quando un utente apre la tua app tramite un link diretto esplicito, lo stack posteriore delle attività viene cancellate e sostituite con la destinazione del link diretto. Quando grafi di nidificazione, la destinazione iniziale da ogni livello di nidificazione, ossia la destinazione da ogni elemento <navigation> della gerarchia e viene aggiunto anche all'elenco. Ciò significa che quando un utente preme il pulsante Indietro da un link diretto destinazione, risale lo stack di navigazione come se è entrato nell'app dal suo punto di accesso.

Puoi utilizzare la NavDeepLinkBuilder per creare un PendingIntent, come mostrato nell'esempio riportato di seguito. Tieni presente che se il contesto fornito non costituisce Activity, il costruttore usa PackageManager.getLaunchIntentForPackage() come attività predefinita da avviare, se disponibile.

val pendingIntent = NavDeepLinkBuilder(context)
    .setGraph(R.navigation.nav_graph)
    .setDestination(R.id.android)
    .setArguments(args)
    .createPendingIntent()

PendingIntent pendingIntent = new NavDeepLinkBuilder(context)
    .setGraph(R.navigation.nav_graph)
    .setDestination(R.id.android)
    .setArguments(args)
    .createPendingIntent();

Per impostazione predefinita, NavDeepLinkBuilder lancia il link diretto esplicito in il lancio predefinito Activity dichiarato nel file manifest dell'app. Se NavHost si trova in un'altra attività, devi specificare il suo componente nome quando crei lo strumento per la creazione di link diretti:

val pendingIntent = NavDeepLinkBuilder(context)
    .setGraph(R.navigation.nav_graph)
    .setDestination(R.id.android)
    .setArguments(args)
    .setComponentName(DestinationActivity::class.java)
    .createPendingIntent()

PendingIntent pendingIntent = new NavDeepLinkBuilder(context)
        .setGraph(R.navigation.nav_graph)
        .setDestination(R.id.android)
        .setArguments(args)
        .setComponentName(DestinationActivity.class)
        .createPendingIntent();

Se hai una ComponentName, puoi passarlo direttamente allo strumento per la creazione:

val componentName = ...

val pendingIntent = NavDeepLinkBuilder(context)
    .setGraph(R.navigation.nav_graph)
    .setDestination(R.id.android)
    .setArguments(args)
    .setComponentName(componentName)
    .createPendingIntent()

ComponentName componentName = ...;

PendingIntent pendingIntent = new NavDeepLinkBuilder(context)
        .setGraph(R.navigation.nav_graph)
        .setDestination(R.id.android)
        .setArguments(args)
        .setComponentName(componentName)
        .createPendingIntent();

Se hai già una NavController, Puoi anche creare un link diretto NavController.createDeepLink().

Creare un link diretto implicito

Un link diretto implicito si riferisce a una una destinazione specifica in un'app. Quando viene richiamato il link diretto, ad esempio Quando un utente fa clic su un link, Android può quindi aprire la tua app destinazione.

I link diretti possono essere abbinati in base a URI, azioni intent e tipi MIME. Puoi specificare più tipi di corrispondenza per un singolo link diretto, ma tieni presente che l'URI la corrispondenza degli argomenti ha la priorità per prima, seguita dall'azione e infine da MIME di testo.

Ecco un esempio di link diretto che contiene un URI, un'azione e un tipo MIME:

<fragment android:id="@+id/a"
          android:name="com.example.myapplication.FragmentA"
          tools:layout="@layout/a">
        <deepLink app:uri="www.example.com"
                app:action="android.intent.action.MY_ACTION"
                app:mimeType="type/subtype"/>
</fragment>

Puoi anche utilizzare l'editor di navigazione per creare un link diretto implicito a un destinazione come segue:

1. Nella scheda Design dell'Editor di navigazione, seleziona la destinazione per il link diretto.
2. Fai clic su + nella sezione Link diretti del riquadro Attributi.

3. Nella finestra di dialogo Aggiungi link diretto visualizzata, inserisci le informazioni sul tuo link diretto.

   Nota:

   • Per gli URI senza schema vengono presi http o https. Ad esempio: www.google.com corrisponde sia a http://www.google.com che https://www.google.com.
   • I segnaposto dei parametri di percorso nel formato {placeholder_name} corrispondono a uno o più caratteri. Ad esempio, http://www.example.com/users/{id} corrisponde a http://www.example.com/users/4. Il componente Navigazione tenta di analizza i valori segnaposto nei tipi appropriati abbinando i segnaposto ai nomi degli argomenti definiti definite per la destinazione del link diretto. Se non esistono argomenti con lo stesso nome è definito, per l'argomento viene utilizzato un tipo String predefinito valore. Puoi utilizzare il carattere jolly .* per trovare una corrispondenza con 0 o più caratteri.
   • È possibile utilizzare i segnaposto dei parametri di query al posto di o in combinazione con parametri del percorso. Ad esempio: http://www.example.com/users/{id}?myarg={myarg} corrispondenze http://www.example.com/users/4?myarg=28.
   • Segnaposto dei parametri di query per le variabili definite con valore predefinito o Non è necessario che i valori nulli corrispondano. Ad esempio: http://www.example.com/users/{id}?arg1={arg1}&arg2={arg2} corrispondenze http://www.example.com/users/4?arg2=28 o http://www.example.com/users/4?arg1=7. Questo non avviene per il percorso parametri. Ad esempio, http://www.example.com/users?arg1=7&arg2=28 non corrisponde al pattern riportato sopra perché il parametro del percorso richiesto è non specificato.
   • I parametri di query non pertinenti non influiscono sulla corrispondenza dell'URI del link diretto. Per esempio, http://www.example.com/users/{id} corrisponde a http://www.example.com/users/4?extraneousParam=7, anche se extraneousParam non è definito nel pattern URI.

4. (Facoltativo) Seleziona Verifica automatica per richiedere a Google di verificare che tu sia il proprietario dell'URI. Per ulteriori informazioni, vedi Verifica i link per app Android.

5. Fai clic su Aggiungi. Icona di un link viene visualizzato sopra la destinazione selezionata per indicare che esiste una link diretto.

6. Fai clic sulla scheda Codice per passare alla visualizzazione XML. Una proprietà <deepLink> nidificata è stato aggiunto alla destinazione:

   <deepLink app:uri="https://www.google.com" />
   

Per attivare i link diretti impliciti, devi anche aggiungere alla sezione manifest.xml. Aggiungi un singolo elemento <nav-graph> a un'attività che rimanda a un grafico di navigazione esistente, come illustrato nell'esempio seguente:

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.myapplication">

    <application ... >

        <activity name=".MainActivity" ...>
            ...

            <nav-graph android:value="@navigation/nav_graph" />

            ...

        </activity>
    </application>
</manifest>

Quando crei il progetto, il componente Navigazione sostituisce <nav-graph> con elementi <intent-filter> generati per corrispondere a tutti i link diretti nel grafico di navigazione.

Quando si attiva un link diretto implicito, lo stato del back stack dipende da se l'elemento Intent implicito è stato avviato con Intent.FLAG_ACTIVITY_NEW_TASK Segnala:

• Se il flag viene impostato, lo stack precedente delle attività viene cancellato e sostituito con destinazione del link diretto. Come per i link diretti espliciti, quando grafi di nidificazione, la destinazione iniziale da ogni livello di nidificazione, ovvero destinazione da ogni elemento <navigation> della gerarchia; viene aggiunta anche lo stack. Ciò significa che quando un utente preme il pulsante Indietro da un punto destinazione del link, risale lo stack di navigazione come se è entrato nella tua app dal suo punto di accesso.
• Se il flag non viene impostato, rimani nello stack di attività dell'app precedente in cui è stato attivato il link diretto implicito. In questo caso, il pulsante Indietro ti riporta all'app precedente, mentre il pulsante Su avvia l'attività dell'app nella destinazione principale gerarchica all'interno del grafico di navigazione.

Gestione dei link diretti

Ti consigliamo vivamente di utilizzare sempre il valore predefinito launchMode di standard quando utilizzi il Navigatore. Quando usi la modalità di avvio di standard, Navigazione gestisce automaticamente i link diretti chiamando handleDeepLink() per elaborare eventuali link diretti espliciti o impliciti all'interno di Intent. Tuttavia, Ciò non avviene automaticamente se Activity viene riutilizzato quando si utilizza un launchMode alternativo come singleTop. In questo caso, è necessario per chiamare manualmente handleDeepLink() in onNewIntent(), come mostrato in nell'esempio seguente:

override fun onNewIntent(intent: Intent?) {
    super.onNewIntent(intent)
    navController.handleDeepLink(intent)
}

@Override
protected void onNewIntent(Intent intent) {
    super.onNewIntent(intent);
    navController.handleDeepLink(intent);
}

Risorse aggiuntive

Per saperne di più sulla navigazione, consulta le risorse seguenti.

Campioni

• Esempio di navigazione di base dei componenti dell'architettura Android

Codelab

• Codelab sulla navigazione

Video

• Android Jetpack: gestire la navigazione nell'UI con il controller di navigazione (Google I/O '18)