Crea collegamenti dinamici su Android

Puoi creare link dinamici brevi o lunghi con l'API Firebase Dynamic Links Builder. Questa API accetta un lungo collegamento dinamico 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 link dinamici nella tua app Android, devi includere Firebase SDK. Se la tua app è configurata per ricevere link 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 tua chiave di firma SHA-1. Se utilizzi App Link, specifica anche la tua chiave SHA-256.

2. Utilizzando Firebase Android BoM , dichiara la dipendenza per la libreria Android di Dynamic Links nel file Gradle del modulo (a livello di app) (di solito app/build.gradle ).

   Per un'esperienza ottimale con Dynamic Links, ti consigliamo di abilitare Google Analytics nel tuo progetto. Inoltre, come parte della configurazione di Analytics, devi aggiungere l'SDK Firebase per Google Analytics alla tua app.

   Giava

   dependencies {
       // Import the BoM for the Firebase platform
       implementation platform('com.google.firebase:firebase-bom:27.0.0')
   
       // Declare 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 Firebase Android BoM , la tua app utilizzerà sempre versioni compatibili delle librerie Firebase Android.

   (Alternativa) Dichiara le dipendenze della libreria Firebase senza utilizzare BoM

   Se scegli di non utilizzare Firebase BoM, 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 BoM per gestire le versioni delle librerie, il che garantisce che tutte le versioni siano compatibili.

   dependencies {
       // Declare 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:19.1.1'
       implementation 'com.google.firebase:firebase-analytics:18.0.3'
   }
   

   Kotlin + KTX

   dependencies {
       // Import the BoM for the Firebase platform
       implementation platform('com.google.firebase:firebase-bom:27.0.0')
   
       // Declare 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-ktx'
       implementation 'com.google.firebase:firebase-analytics-ktx'
   }
   

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

   (Alternativa) Dichiara le dipendenze della libreria Firebase senza utilizzare BoM

   Se scegli di non utilizzare Firebase BoM, 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 BoM per gestire le versioni delle librerie, il che garantisce che tutte le versioni siano compatibili.

   dependencies {
       // Declare 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-ktx:19.1.1'
       implementation 'com.google.firebase:firebase-analytics-ktx:18.0.3'
   }
   

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 hai già un dominio Dynamic Links, prendine nota. È necessario fornire un dominio di collegamenti dinamici quando si creano collegamenti dinamici a livello di codice.

   

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

Usa 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 può 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, crea un nuovo oggetto DynamicLink con il suo Builder, specificando i parametri di Dynamic Link con i metodi 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:

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

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

Per creare un breve Dynamic Link, costruire un DynamicLink allo stesso modo, e quindi chiamare buildShortDynamicLink . Costruire un breve collegamento richiede una chiamata di rete, così invece di tornare direttamente il link, buildShortDynamicLink restituisce un Task , che rende il collegamento breve disponibile quando la Completa di richiesta. Per esempio:

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

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.ktx.component1 and
    // com.google.firebase.dynamiclinks.ktx.component2

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

Per impostazione predefinita, vengono generati collegamenti dinamici brevi 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 di generare suffissi che sono solo il tempo necessario per essere univoci, cosa che puoi fare passando ShortDynamicLink.Suffix.SHORT al metodo buildShortDynamicLink :

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

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

Parametri di collegamento dinamico

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

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

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

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

Puoi impostare i parametri di Dynamic Link con i seguenti metodi:

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

Accorcia un lungo collegamento dinamico

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

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

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.ktx.component1 and
    // com.google.firebase.dynamiclinks.ktx.component2

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