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 l'SDK Dynamic Links

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à, aggiungi Firebase al progetto Android .

   Quando registri la tua app, specifica la tua chiave di firma SHA-1. Se usi App Links, specifica anche la tua chiave SHA-256.

2. Utilizzando la Firebase Android BoM , dichiarare la dipendenza per la libreria dinamica Link Android nel modulo (a livello di app) File Gradle (di solito app/build.gradle ).

   Per un'esperienza ottimale con Dynamic Link, si consiglia consentendo di Google Analytics nel progetto Firebase e aggiungendo il Firebase SDK per Google Analytics per la vostra applicazione.

   Giava

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

   Usando il Firebase Android BoM , la vostra applicazione sarà sempre utilizzare versioni compatibili delle librerie Firebase Android.

   (Alternativa) Dichiarare Firebase dipendenze delle librerie senza utilizzare la distinta

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

   Si noti che se si utilizzano più librerie Firebase nella vostra app, ti consigliamo di utilizzare la distinta di gestire versioni della libreria, che assicura che tutte le versioni sono 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:20.1.1'
       implementation 'com.google.firebase:firebase-analytics:19.0.0'
   }
   

   Kotlin+KTX

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

   Usando il Firebase Android BoM , la vostra applicazione sarà sempre utilizzare versioni compatibili delle librerie Firebase Android.

   (Alternativa) Dichiarare Firebase dipendenze delle librerie senza utilizzare la distinta

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

   Si noti che se si utilizzano più librerie Firebase nella vostra app, ti consigliamo di utilizzare la distinta di gestire versioni della libreria, che assicura che tutte le versioni sono 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:20.1.1'
       implementation 'com.google.firebase:firebase-analytics-ktx:19.0.0'
   }
   

3. Nella console Firebase, aprire la sezione dinamica Links.

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 Dynamic Links quando si creano collegamenti dinamici a livello di codice.

   

5. Consigliato: specificare i pattern URL consentite nei tuoi link profondi e collegamenti di ripiego. In questo modo, impedisci a soggetti non autorizzati di creare collegamenti dinamici che reindirizzano dal tuo dominio a siti che non controlli. Vedere Consentire modelli specifici URL .

Usa la console Firebase

Se si desidera generare un unico collegamento dinamico, sia per scopi di test, o per il vostro team di marketing di creare facilmente un link che può essere utilizzato in qualcosa di simile a un post di social media, il modo più semplice sarebbe quella di visitare la console Firebase e creare uno manualmente seguendo il modulo passo passo.

Crea un collegamento dinamico dai parametri

Per creare un collegamento dinamico, creare un nuovo DynamicLink oggetto con il suo costruttore, specificando i parametri di collegamento dinamico con i metodi Builder. Poi, chiamare buildDynamicLink o buildShortDynamicLink .

Il seguente esempio minimale crea una lunga Dynamic Link per https://www.example.com/ che si apre con la tua applicazione Android su Android e le 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, 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 vostro caso d'uso, non c'è nulla di male nel qualcuno indovinare con successo un link breve, si potrebbe preferire di generare suffissi che sono solo il tempo necessario per essere unico, che si può fare passando ShortDynamicLink.Suffix.SHORT al buildShortDynamicLink metodo :

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 collegamenti dinamici con uno qualsiasi dei parametri supportati. Vedere 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

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

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

Accorciare un collegamento dinamico lungo

Per abbreviare una lunga Dynamic Link, specificare l'URL del link dinamico utilizzando setLongLink invece di impostare i parametri con gli altri metodi costruttore:

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