Puoi creare Dynamic Links brevi o lunghi con l'API Firebase Dynamic Links Builder. Questa API accetta un valore Dynamic Link lungo o un oggetto contenente parametri Dynamic Link e restituisce URL come gli esempi riportati di seguito:
https://example.com/link/WXYZ https://example.page.link/WXYZ
Configura Firebase e l'SDK Dynamic Links
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.
Se non lo hai già fatto, aggiungi Firebase al tuo progetto Android.
Quando registri la tua app, specifica la chiave di firma SHA-1. Se utilizzi Link per app, specifica anche la chiave SHA-256.
-
Nel file Gradle del modulo (a livello di app) (di solito
<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 Firebase Android BoM per controllare la versione 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:33.6.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 Firebase Android BoM, la tua app utilizzerà sempre versioni compatibili delle librerie Firebase per Android.
(Alternativa) Aggiungi le dipendenze della libreria Firebase senza utilizzare il file BoM
Se scegli di non utilizzare Firebase BoM, devi specificare ogni versione della libreria Firebase nella relativa riga di dipendenza.
Tieni presente che se nella tua app utilizzi più librerie Firebase, ti consigliamo vivamente di utilizzare BoM per gestire le versioni delle librerie, in modo da garantire la compatibilità di tutte le versioni.
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:22.1.2' }
- Nella console Firebase, apri la sezione Dynamic Links.
-
Se non hai ancora accettato i Termini di servizio e impostato un dominio per Dynamic Links, fallo quando richiesto.
Se hai già un dominio Dynamic Links, prendine nota. Devi fornire un dominio Dynamic Links quando crei Dynamic Links tramite programmazione.
- Consigliato: specifica i pattern URL consentiti nei link diretti e 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 Consentire pattern di URL specifici.
Utilizzare la console Firebase
Se vuoi generare un singolo Dynamic Link, a scopo di test o per consentire al tuo team di marketing di creare facilmente un link che possa essere utilizzato, ad esempio, in un post sui social media, il modo più semplice è visitare la console Firebase e crearne uno manualmente seguendo la procedura dettagliata.
Creare un Dynamic Link dai parametri
Per creare un Dynamic Link, crea un nuovo oggetto DynamicLink
con il relativo
Generatore, specificando i parametri Dynamic Link con i metodi del Generatore. Quindi, chiama
buildDynamicLink
o buildShortDynamicLink
.
Il seguente esempio minimo crea un lungo Dynamic Link a
https://www.example.com/
che si apre con la tua app Android su Android
e l'app com.example.ios
su iOS:
Kotlin+KTX
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
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();
Per creare un breve Dynamic Link, crea un DynamicLink
nello stesso modo e poi chiama buildShortDynamicLink
. La creazione di un link breve richiede una chiamata di rete, pertanto, anziché restituire direttamente il link, buildShortDynamicLink
restituisce un Task
, che rende il link breve disponibile al termine della richiesta. Ad esempio:
Kotlin+KTX
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 // ... }
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 // ... } } });
Per impostazione predefinita, i Dynamic Links brevi vengono generati con suffissi dei 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 lunghi solo il necessario per essere univoci. A tal fine, puoi passare ShortDynamicLink.Suffix.SHORT
al metodo buildShortDynamicLink
:
Kotlin+KTX
val shortLinkTask = Firebase.dynamicLinks.shortLinkAsync(ShortDynamicLink.Suffix.SHORT) { // Set parameters // ... }
Java
Task<ShortDynamicLink> shortLinkTask = FirebaseDynamicLinks.getInstance().createDynamicLink() // ... .buildShortDynamicLink(ShortDynamicLink.Suffix.SHORT); // ...
Parametri Dynamic Link
Puoi utilizzare l'API Dynamic Link Builder per creare Dynamic Links con uno qualsiasi dei parametri supportati. Per informazioni dettagliate, consulta il riferimento all'API.
L'esempio seguente crea un Dynamic Link con diversi parametri comuni impostati:
Kotlin+KTX
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!" } }
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()
Puoi impostare i parametri Dynamic Link con i seguenti metodi:
Parametri DynamicLink | |
---|---|
setLink |
Il link che aprirà l'app. Specifica un URL che la tua app può gestire, in genere i contenuti o il payload dell'app, che avvia una logica specifica per l'app (ad esempio l'accreditamento 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 link dinamico. |
setDomainUriPrefix | Il prefisso URL di 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 valore per fare qualcosa di diverso dall'installare l'app dal Play Store quando non è installata, ad esempio aprire la versione web mobile dei contenuti o mostrare una pagina promozionale per l'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 indirizzare gli utenti all'App Store quando l'app non è installata |
setFallbackUrl | Il link da aprire quando l'app non è installata. Specifica questo valore per fare qualcosa di diverso dall'installare l'app dall'App Store quando l'app non è installata, ad esempio aprire la versione web mobile dei contenuti o mostrare una pagina promozionale per l'app. |
setCustomScheme | Lo schema URL personalizzato dell'app, se definito come diverso dall'ID bundle dell'app |
setIpadFallbackUrl | Il link da aprire sugli iPad quando l'app non è installata. Specifica questo valore per fare qualcosa di diverso dall'installare la tua app dall'App Store quando l'app non è installata, ad esempio aprire la versione web dei contenuti o mostrare una pagina promozionale per la tua app. |
setIpadBundleId | L'ID bundle dell'app per iOS da utilizzare sugli iPad per aprire il link. L'app deve essere collegata al tuo progetto dalla pagina Panoramica della console Firebase. |
setMinimumVersion | Il numero di versione della versione minima della tua app che può aprire il link. Questo flag viene passato all'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 Dynamic Link e reindirizza all'app o allo Store. La pagina di anteprima dell'app (attivata per impostazione predefinita) può indirizzare gli utenti alla destinazione più appropriata in modo più affidabile quando aprono Dynamic Links nelle app. Tuttavia, se prevedi che un Dynamic Link venga aperto solo nelle app che possono aprire Dynamic Links in modo affidabile senza questa pagina, puoi disattivarla con questo parametro. Questo parametro influisce sul comportamento di Dynamic Link solo su iOS. |
SocialMetaTagParameters | |
---|---|
setTitle | Il titolo da utilizzare quando il Dynamic Link viene condiviso in un post social. |
setDescription | La descrizione da utilizzare quando Dynamic Link viene condiviso in un post social. |
setImageUrl | L'URL di un'immagine correlata a questo link. L'immagine deve essere di almeno 300 x 200 px e di dimensioni inferiori a 300 KB. |
GoogleAnalyticsParameters | |
---|---|
setSource setMedium setCampaign setTerm setContent |
Parametri di Dati di Google Play. Questi parametri
(utm_source , utm_medium ,
utm_campaign , utm_term , utm_content )
vengono trasmessi 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 trasmessi all'App Store. |
Accorciare un Dynamic Link lungo
Per accorciare un Dynamic Link lungo, specifica l'URL del Dynamic Link utilizzando
setLongLink
anziché impostare i parametri con gli altri metodi
del generatore:
Kotlin+KTX
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 // ... }
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 // ... } } });