Creare link dinamici su Android

Puoi creare brevi o lunghi Dynamic Links con l'API Builder Firebase Dynamic Links. Questa API accetta un Dynamic Link lungo o un oggetto contenente Dynamic Link parametri e restituisce URL come i seguenti esempi:

https://example.com/link/WXYZ
https://example.page.link/WXYZ

Prima di poter creare Dynamic Links nella tua app per Android, devi includere l'SDK Firebase. Se la tua app è configurata per ricevere Dynamic Links, hai già completato questi passaggi e puoi saltare questa sezione.

  1. Se non l'hai già fatto, aggiungi Firebase al tuo progetto Android.

    Quando registri l'app, specifica la chiave di firma SHA-1. Se utilizzi i link app, specifica anche la chiave SHA-256.

  2. Nel file Gradle del modulo (a livello di app) (in genere <project>/<app-module>/build.gradle.kts o <project>/<app-module>/build.gradle), aggiungi la dipendenza per la libreria Dynamic Links per Android. Ti consigliamo di utilizzare la Firebase Android BoM per controllare il controllo delle versioni della libreria.

    Per un'esperienza ottimale con Dynamic Links, ti consigliamo di attivare Google Analytics nel tuo progetto Firebase e di aggiungere l'SDK Firebase per Google Analytics alla tua app. 

    dependencies {
    // Import the BoM for the Firebase platform
    implementation(platform("com.google.firebase:firebase-bom:34.11.0"))

    // Add the dependencies for the Dynamic Links and Analytics libraries
    // When using the BoM, you don't specify versions in Firebase library dependencies
    implementation 'com.google.firebase:firebase-dynamic-links'
    implementation 'com.google.firebase:firebase-analytics'
}

    Con la Firebase Android BoM, la tua app utilizzerà sempre versioni compatibili delle librerie Firebase Android.

    (Alternativa)  Aggiungi le dipendenze della libreria Firebase senza utilizzare la BoM

    Se scegli di non utilizzare la Firebase BoM, devi specificare la versione di ogni libreria Firebase nella riga di dipendenza.

    Tieni presente che, se utilizzi più librerie Firebase nella tua app, ti consigliamo vivamente di utilizzare la BoM per gestire le versioni delle librerie, in modo da garantire che tutte le versioni siano compatibili. 

    dependencies {
    // Add the dependencies for the Dynamic Links and Analytics libraries
    // When NOT using the BoM, you must specify versions in Firebase library dependencies
    implementation 'com.google.firebase:firebase-dynamic-links:22.1.0'
    implementation 'com.google.firebase:firebase-analytics:23.2.0'
}
  3. Nella console Firebase, apri la sezione Dynamic Links.

  4. Se non hai ancora accettato i Termini di servizio e impostato un dominio per i tuoi Dynamic Links, fallo quando ti viene richiesto.

    Se hai già un dominio Dynamic Links, prendine nota. Devi fornire un Dynamic Links dominio quando crei Dynamic Links a livello di programmazione.

  5. Consigliato: specifica i pattern URL consentiti nei link diretti e nei link di fallback. In questo modo, impedisci a terze parti non autorizzate di creare Dynamic Links che reindirizzano dal tuo dominio a siti che non controlli. Consulta Consenti pattern URL specifici.

Utilizza la Firebase console

Se vuoi generare un singolo Dynamic Link, per scopi di test o per consentire al tuo team di marketing di creare facilmente un link da utilizzare, ad esempio, in un post sui social media, il modo più semplice sarebbe visitare la Firebase console e crearne uno manualmente seguendo il modulo passo passo.

Per creare un Dynamic Link, crea un nuovo oggetto DynamicLink con il relativo Builder, specificando i parametri di Dynamic Link con i metodi Builder. Poi, chiama buildDynamicLink o buildShortDynamicLink.

L'esempio minimo seguente crea un Dynamic Link lungo Dynamic Link a https://www.example.com/ che si apre con la tua app per Android su Android e l'app com.example.ios su iOS:

Kotlin

val dynamicLink = Firebase.dynamicLinks.dynamicLink {
    link = Uri.parse("https://www.example.com/")
    domainUriPrefix = "https://example.page.link"
    // Open links with this app on Android
    androidParameters { }
    // Open links with com.example.ios on iOS
    iosParameters("com.example.ios") { }
}

val dynamicLinkUri = dynamicLink.uri
MainActivity.kt

Java

DynamicLink dynamicLink = FirebaseDynamicLinks.getInstance().createDynamicLink()
        .setLink(Uri.parse("https://www.example.com/"))
        .setDomainUriPrefix("https://example.page.link")
        // Open links with this app on Android
        .setAndroidParameters(new DynamicLink.AndroidParameters.Builder().build())
        // Open links with com.example.ios on iOS
        .setIosParameters(new DynamicLink.IosParameters.Builder("com.example.ios").build())
        .buildDynamicLink();

Uri dynamicLinkUri = dynamicLink.getUri();
MainActivity.java

Per creare un Dynamic Link breve, crea un DynamicLink nello stesso modo, e quindi chiama buildShortDynamicLink. La creazione di un link breve richiede una chiamata di rete, quindi, anziché restituire direttamente il link, buildShortDynamicLink restituisce un Task, che rende disponibile il link breve al completamento della richiesta. Ad esempio:

Kotlin

val shortLinkTask = Firebase.dynamicLinks.shortLinkAsync {
    link = Uri.parse("https://www.example.com/")
    domainUriPrefix = "https://example.page.link"
    // Set parameters
    // ...
}.addOnSuccessListener { (shortLink, flowchartLink) ->
    // You'll need to import com.google.firebase.dynamiclinks.component1 and
    // com.google.firebase.dynamiclinks.component2

    // Short link created
    processShortLink(shortLink, flowchartLink)
}.addOnFailureListener {
    // Error
    // ...
}
MainActivity.kt

Java

Task<ShortDynamicLink> shortLinkTask = FirebaseDynamicLinks.getInstance().createDynamicLink()
        .setLink(Uri.parse("https://www.example.com/"))
        .setDomainUriPrefix("https://example.page.link")
        // Set parameters
        // ...
        .buildShortDynamicLink()
        .addOnCompleteListener(this, new OnCompleteListener<ShortDynamicLink>() {
            @Override
            public void onComplete(@NonNull Task<ShortDynamicLink> task) {
                if (task.isSuccessful()) {
                    // Short link created
                    Uri shortLink = task.getResult().getShortLink();
                    Uri flowchartLink = task.getResult().getPreviewLink();
                } else {
                    // Error
                    // ...
                }
            }
        });
MainActivity.java

Per impostazione predefinita, i Dynamic Links brevi vengono generati con suffissi di link di 17 caratteri che rendono estremamente improbabile che qualcuno possa indovinare un Dynamic Link valido. Se, per il tuo caso d'uso, non è un problema che qualcuno indovini un link breve, potresti preferire generare suffissi che siano solo della lunghezza necessaria per essere univoci. Puoi farlo passando ShortDynamicLink.Suffix.SHORT al metodo buildShortDynamicLink:

Kotlin

val shortLinkTask = Firebase.dynamicLinks.shortLinkAsync(ShortDynamicLink.Suffix.SHORT) {
    // Set parameters
    // ...
}
MainActivity.kt

Java

Task<ShortDynamicLink> shortLinkTask = FirebaseDynamicLinks.getInstance().createDynamicLink()
        // ...
        .buildShortDynamicLink(ShortDynamicLink.Suffix.SHORT);
        // ...
MainActivity.java

Puoi utilizzare l'API Dynamic Link Builder per creare Dynamic Links con uno qualsiasi dei parametri supportati. Per ulteriori dettagli, consulta il riferimento API.

L'esempio seguente crea un Dynamic Link con diversi parametri comuni impostati:

Kotlin

val dynamicLink = Firebase.dynamicLinks.dynamicLink { // or Firebase.dynamicLinks.shortLinkAsync
    link = Uri.parse("https://www.example.com/")
    domainUriPrefix = "https://example.page.link"
    androidParameters("com.example.android") {
        minimumVersion = 125
    }
    iosParameters("com.example.ios") {
        appStoreId = "123456789"
        minimumVersion = "1.0.1"
    }
    googleAnalyticsParameters {
        source = "orkut"
        medium = "social"
        campaign = "example-promo"
    }
    itunesConnectAnalyticsParameters {
        providerToken = "123456"
        campaignToken = "example-promo"
    }
    socialMetaTagParameters {
        title = "Example of a Dynamic Link"
        description = "This link works whether the app is installed or not!"
    }
}
MainActivity.kt

Java

DynamicLink dynamicLink = FirebaseDynamicLinks.getInstance().createDynamicLink()
        .setLink(Uri.parse("https://www.example.com/"))
        .setDomainUriPrefix("https://example.page.link")
        .setAndroidParameters(
                new DynamicLink.AndroidParameters.Builder("com.example.android")
                        .setMinimumVersion(125)
                        .build())
        .setIosParameters(
                new DynamicLink.IosParameters.Builder("com.example.ios")
                        .setAppStoreId("123456789")
                        .setMinimumVersion("1.0.1")
                        .build())
        .setGoogleAnalyticsParameters(
                new DynamicLink.GoogleAnalyticsParameters.Builder()
                        .setSource("orkut")
                        .setMedium("social")
                        .setCampaign("example-promo")
                        .build())
        .setItunesConnectAnalyticsParameters(
                new DynamicLink.ItunesConnectAnalyticsParameters.Builder()
                        .setProviderToken("123456")
                        .setCampaignToken("example-promo")
                        .build())
        .setSocialMetaTagParameters(
                new DynamicLink.SocialMetaTagParameters.Builder()
                        .setTitle("Example of a Dynamic Link")
                        .setDescription("This link works whether the app is installed or not!")
                        .build())
        .buildDynamicLink();  // Or buildShortDynamicLink()
MainActivity.java

Puoi impostare i parametri Dynamic Link con i seguenti metodi:

Parametri di Dynamic Links
setLink

Il link che la tua app aprirà. Specifica un URL che la tua app può gestire, in genere i contenuti o il payload dell'app, che avvia una logica specifica dell'app (ad esempio, l'assegnazione di un coupon all'utente o la visualizzazione di una schermata di benvenuto). Questo link deve essere un URL ben formattato, codificato correttamente, utilizzare HTTP o HTTPS e non può essere un altro Dynamic Link.
setDomainUriPrefix Il prefisso dell'URL Dynamic Link, che puoi trovare nella console Firebase. Un dominio Dynamic Link è simile ai seguenti esempi: 
https://example.com/link
https://example.page.link
AndroidParameters
setFallbackUrl Il link da aprire quando l'app non è installata. Specifica questo parametro per eseguire un'azione diversa dall'installazione dell'app dal Play Store quando l'app non è installata, ad esempio aprire la versione web mobile dei contenuti o visualizzare una pagina promozionale per la tua app.
setMinimumVersion Il versionCode della versione minima della tua app che può aprire il link. Se l'app installata è una versione precedente, l'utente viene indirizzato al Play Store per eseguire l'upgrade dell'app.
IosParameters
setAppStoreId L'ID App Store della tua app, utilizzato per inviare gli utenti all'App Store quando l'app non è installata.
setFallbackUrl Il link da aprire quando l'app non è installata. Specifica questo parametro per eseguire un'azione diversa dall'installazione dell'app dall'App Store quando l'app non è installata, ad esempio aprire la versione web mobile dei contenuti o visualizzare una pagina promozionale per la tua app.
setCustomScheme Lo schema URL personalizzato della tua app, se definito in modo diverso dall'ID pacchetto dell'app.
setIpadFallbackUrl Il link da aprire su iPad quando l'app non è installata. Specifica questo parametro per eseguire un'azione diversa dall'installazione dell'app dall'App Store quando l'app non è installata, ad esempio aprire la versione web dei contenuti o visualizzare una pagina promozionale per la tua app.
setIpadBundleId L'ID pacchetto dell'app per iOS da utilizzare su iPad per aprire il link. L'app deve essere collegata al tuo progetto dalla pagina Panoramica della Firebase console.
setMinimumVersion Il numero di versione della versione minima della tua app che può aprire il link. Questo flag viene passato alla tua app quando viene aperta e l'app deve decidere cosa farne.
NavigationInfoParameters
setForcedRedirectEnabled Se impostato su '1', salta la pagina di anteprima dell'app quando viene aperto il Dynamic Link e reindirizza invece all'app o allo store. La pagina di anteprima dell'app (attivata per impostazione predefinita) può inviare gli utenti in modo più affidabile alla destinazione più appropriata quando aprono Dynamic Links nelle app. Tuttavia, se prevedi che un Dynamic Link venga aperto solo in app che possono aprire Dynamic Links in modo affidabile senza questa pagina, puoi disattivarla con questo parametro. Questo parametro influirà sul comportamento del Dynamic Link solo su iOS.
SocialMetaTagParameters
setTitle Il titolo da utilizzare quando il Dynamic Link viene condiviso in un post sui social media.
setDescription La descrizione da utilizzare quando il Dynamic Link viene condiviso in un post sui social media.
setImageUrl L'URL di un'immagine correlata a questo link. L'immagine deve avere dimensioni di almeno 300 x 200 px e non superare i 300 KB.
GoogleAnalyticsParameters
setSource
setMedium
setCampaign
setTerm
setContent		 Parametri di analisi di Google Play. Questi parametri (utm_source, utm_medium, utm_campaign, utm_term, utm_content) vengono passati al Play Store e aggiunti al payload del link.
ItunesConnectAnalyticsParameters
setProviderToken
setAffiliateToken
setCampaignToken		 Parametri di analisi di iTunes Connect. Questi parametri (pt, at, ct) vengono passati all'App Store.

Per accorciare un Dynamic Link lungo, specifica l'URL del Dynamic Link utilizzando setLongLink anziché impostare i parametri con gli altri metodi del builder:

Kotlin

val shortLinkTask = Firebase.dynamicLinks.shortLinkAsync {
    longLink = Uri.parse(
        "https://example.page.link/?link=" +
            "https://www.example.com/&apn=com.example.android&ibn=com.example.ios",
    )
}.addOnSuccessListener { (shortLink, flowChartLink) ->
    // You'll need to import com.google.firebase.dynamiclinks.component1 and
    // com.google.firebase.dynamiclinks.component2

    // Short link created
    processShortLink(shortLink, flowChartLink)
}.addOnFailureListener {
    // Error
    // ...
}
MainActivity.kt

Java

Task<ShortDynamicLink> shortLinkTask = FirebaseDynamicLinks.getInstance().createDynamicLink()
        .setLongLink(Uri.parse("https://example.page.link/?link=https://www.example.com/&apn=com.example.android&ibn=com.example.ios"))
        .buildShortDynamicLink()
        .addOnCompleteListener(this, new OnCompleteListener<ShortDynamicLink>() {
            @Override
            public void onComplete(@NonNull Task<ShortDynamicLink> task) {
                if (task.isSuccessful()) {
                    // Short link created
                    Uri shortLink = task.getResult().getShortLink();
                    Uri flowchartLink = task.getResult().getPreviewLink();
                } else {
                    // Error
                    // ...
                }
            }
        });
MainActivity.java