Crea Dynamic Links en Android

Puedes crear Dynamic Links cortos o largos con la API de Firebase Dynamic Links Builder, que acepta un Dynamic Link largo o un objeto que contenga parámetros de Dynamic Links y muestra URLs similares a las de estos ejemplos:

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

Configura Firebase y el SDK de Dynamic Links

Para poder crear Dynamic Links en la app para Android, debes incluir el SDK de Firebase. Si tu app está configurada para recibir Dynamic Links, ya completaste estos pasos y puedes omitir esta sección.

1. Si aún no lo has hecho, agrega Firebase a tu proyecto de Android.

   Cuando registres tu app, especifica la clave de firma SHA-1. Si usas App Links, también debes especificar la clave SHA‑256.

2. En el archivo de Gradle (generalmente <project>/<app-module>/build.gradle.kts o <project>/<app-module>/build.gradle) de tu módulo (a nivel de app), agrega la dependencia de la biblioteca de Android para Dynamic Links. Te recomendamos usar la BoM de Firebase para Android para controlar las versiones de las bibliotecas.

   Para obtener una experiencia óptima con Dynamic Links, recomendamos habilitar Google Analytics en tu proyecto de Firebase y agregar el SDK de Firebase para Google Analytics a la app.

   Kotlin+KTX

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

   Si usas la BoM de Firebase para Android, tu app siempre utilizará versiones compatibles de las bibliotecas de Firebase para Android.

   (Alternativa) Agrega dependencias de la biblioteca de Firebase sin usar la BoM

   Si eliges no usar la BoM de Firebase, debes especificar cada versión de la biblioteca de Firebase en su línea de dependencia.

   Ten en cuenta que, si usas múltiples bibliotecas de Firebase en tu app, es muy recomendable que utilices la BoM para administrar las versiones de las bibliotecas para garantizar que todas las versiones sean compatibles.

   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-ktx:21.1.0'
       implementation 'com.google.firebase:firebase-analytics-ktx:21.3.0'
   }
   

   Java

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

   Si usas la BoM de Firebase para Android, tu app siempre utilizará versiones compatibles de las bibliotecas de Firebase para Android.

   (Alternativa) Agrega dependencias de la biblioteca de Firebase sin usar la BoM

   Si eliges no usar la BoM de Firebase, debes especificar cada versión de la biblioteca de Firebase en su línea de dependencia.

   Ten en cuenta que, si usas múltiples bibliotecas de Firebase en tu app, es muy recomendable que utilices la BoM para administrar las versiones de las bibliotecas con el fin de garantizar que todas las versiones sean compatibles.

   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.1.0'
       implementation 'com.google.firebase:firebase-analytics:21.3.0'
   }
   

3. En Firebase console, abre la sección Dynamic Links.

4. Si aún no aceptaste las Condiciones del Servicio ni configuraste un dominio para los Dynamic Links, deberás hacerlo cuando el sistema lo solicite.

   Si ya tienes un dominio de Dynamic Links, anótalo. Deberás proporcionar un dominio para crear Dynamic Links de manera programática.

   

5. Recomendado: Especifica los patrones de URL que se permiten en tus vínculos directos y de resguardo. De esa manera, evitas que grupos no autorizados creen Dynamic Links que redireccionen de tu dominio a otros sitios que no puedes controlar. Consulta cómo permitir patrones de URL específicos.

Usa Firebase console

Visita Firebase console y sigue los pasos que se indican en el formulario para generar un Dynamic Link manualmente. Esta es la forma más sencilla de producirlos, ya sea para hacer pruebas o para que tu equipo de marketing cree con facilidad un vínculo que pueda usarse, por ejemplo, en publicaciones de redes sociales.

Crea un Dynamic Link a partir de parámetros

Para crear un Dynamic Link, crea un objeto DynamicLink nuevo con su compilador y especifica los parámetros del Dynamic Link con los métodos del compilador. Luego, llama a buildDynamicLink o buildShortDynamicLink.

El siguiente ejemplo simple crea un Dynamic Link largo a https://www.example.com/ que se abre con tu app para Android y la app com.example.ios en 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

Para crear un Dynamic Link corto, compila un DynamicLink de la misma manera y, a continuación, llama a buildShortDynamicLink. La compilación de un vínculo corto requiere una llamada de red, de manera que, en lugar de mostrar directamente el vínculo, buildShortDynamicLink muestra un Task, que habilita el vínculo corto cuando se completa la solicitud. Por ejemplo:

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

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

Según la configuración predeterminada, se generan los Dynamic Links cortos con sufijos de vínculos de 17 caracteres. Esto hace que sea muy improbable que una persona adivine un Dynamic Link válido. Si en tu caso de uso no es perjudicial que una persona adivine correctamente los vínculos cortos, puedes generar sufijos que solo tengan el largo suficiente a fin de que sean únicos. Para ello, pasa ShortDynamicLink.Suffix.SHORT al método buildShortDynamicLinkde esta manera:

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

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

Parámetros del Dynamic Link

Puedes usar la API de Dynamic Links Builder para crear Dynamic Links con cualquiera de los parámetros admitidos. Consulta la referencia de la API para obtener más detalles.

El siguiente ejemplo crea un Dynamic Link con varios parámetros comunes configurados:

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

Puedes configurar los parámetros del Dynamic Link con los siguientes métodos:

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

Acorta un Dynamic Link largo

Para acortar un Dynamic Link largo, especifica su URL mediante setLongLink en lugar de configurar parámetros con los otros métodos de compilación:

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

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