Crea collegamenti dinamici su Android

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

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

Configura Firebase e Dynamic Links SDK

Prima di poter creare collegamenti dinamici nella tua app Android, devi includere l'SDK Firebase. Se la tua app è configurata per ricevere collegamenti dinamici, 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 la tua app, specifica la chiave di firma SHA-1. Se utilizzi i collegamenti alle app, specifica anche la chiave SHA-256.

2. Nel file Gradle del tuo modulo (a livello di app) (solitamente <project>/<app-module>/build.gradle.kts o <project>/<app-module>/build.gradle ), aggiungi la dipendenza per i collegamenti dinamici libreria per Android. Ti consigliamo di utilizzare la distinta base Android Firebase per controllare il controllo delle versioni della libreria.

   Per un'esperienza ottimale con Dynamic Links, ti consigliamo di abilitare 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:32.8.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'
   }
   

   Utilizzando la distinta base Firebase per Android , la tua app utilizzerà sempre le versioni compatibili delle librerie Firebase Android.

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

   Se scegli di non utilizzare la distinta base Firebase, devi specificare ciascuna versione della libreria Firebase nella relativa riga di dipendenza.

   Tieni presente che se utilizzi più librerie Firebase nella tua app, ti consigliamo vivamente di utilizzare la distinta base per gestire le versioni della libreria, il che garantisce 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:21.2.0'
       implementation 'com.google.firebase:firebase-analytics:21.6.1'
   }
   

   Cerchi un modulo di libreria specifico per Kotlin? A partire da ottobre 2023 (Firebase BoM 32.5.0) , sia gli sviluppatori Kotlin che quelli Java potranno dipendere dal modulo della libreria principale (per i dettagli, vedere le FAQ su questa iniziativa ).
3. Nella console Firebase, apri la sezione Collegamenti dinamici .

4. Se non hai già accettato i termini di servizio e impostato un dominio per i tuoi collegamenti dinamici, fallo quando richiesto.

   Se possiedi già un dominio Dynamic Links, prendine nota. È necessario fornire un dominio Dynamic Links quando crei Dynamic Links a livello di codice.

   

5. Consigliato : specifica i pattern URL consentiti nei link diretti e nei link di riserva. In questo modo, impedisci a soggetti non autorizzati di creare collegamenti dinamici che reindirizzano dal tuo dominio a siti che non controlli. Consulta Consentire modelli URL specifici .

Utilizza la console Firebase

Se desideri generare un singolo collegamento dinamico, a scopo di test o per consentire al tuo team di marketing di creare facilmente un collegamento che possa essere utilizzato in qualcosa come un post sui social media, il modo più semplice sarebbe visitare la console Firebase e crearne uno manualmente seguendo il modulo passo passo.

Crea un collegamento dinamico dai parametri

Per creare un Dynamic Link, creare un nuovo oggetto DynamicLink con il suo Builder, specificando i parametri Dynamic Link con i metodi del Builder. Quindi, chiama buildDynamicLink o buildShortDynamicLink .

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

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

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 breve collegamento dinamico, crea un DynamicLink nello stesso modo, quindi chiama buildShortDynamicLink . La creazione di un collegamento breve richiede una chiamata di rete, quindi invece di restituire direttamente il collegamento, buildShortDynamicLink restituisce un Task , che rende disponibile il collegamento breve al completamento della richiesta. Per esempio:

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

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 collegamenti dinamici brevi vengono generati con suffissi di collegamento di 17 caratteri che rendono estremamente improbabile che qualcuno possa indovinare un collegamento dinamico valido. Se, per il tuo caso d'uso, non c'è nulla di male nel fatto che qualcuno indovini con successo un collegamento breve, potresti preferire generare suffissi che siano lunghi solo quanto necessario per essere univoci, cosa che puoi fare passando ShortDynamicLink.Suffix.SHORT al metodo buildShortDynamicLink :

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

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

Parametri del collegamento dinamico

Puoi utilizzare l'API Dynamic Link Builder per creare collegamenti dinamici con uno qualsiasi dei parametri supportati. Consulta il riferimento API per i dettagli.

L'esempio seguente crea un collegamento dinamico con diversi parametri comuni impostati:

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

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

È possibile impostare i parametri di Dynamic Link con i seguenti metodi:

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

Accorcia un collegamento dinamico lungo

Per abbreviare un collegamento dinamico lungo, specifica l'URL del collegamento dinamico utilizzando setLongLink invece di impostare i parametri con gli altri metodi del builder:

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

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