Ir a la consola

Crea Dynamic Links en iOS

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

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

Requisitos previos

Para usar Firebase Dynamic Links, debes tener iOS 8 o una versión más reciente. Puedes orientar tu app a iOS 7, pero ten en cuenta que las llamadas al SDK de Firebase Dynamic Links no funcionarán si la app no se está ejecutando en iOS 8 o una versión posterior.

Configura Firebase y el SDK de Dynamic Links

  1. Agrega Firebase al proyecto de iOS. Incluye el siguiente pod en el Podfile:
    pod 'Firebase/Analytics'
    pod 'Firebase/DynamicLinks'    
  2. Ejecuta pod install y abre el archivo .xcworkspace creado.
  3. En Firebase console, abre la sección Dynamic Links.
  4. Si aún no has aceptado las Condiciones del Servicio ni configurado un prefijo de URI para tus Dynamic Links, deberás hacerlo cuando el sistema lo solicite.

    Si ya tienes un prefijo de URI de Dynamic Links, anótalo. Debes proporcionarlo 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 agregar patrones de URL a la lista blanca.
  6. Asegúrate de que el ID de App Store y el prefijo de ID de tu app estén especificados en su configuración. Para ver y editar la configuración de tu app, ve a la página de configuración del proyecto de Firebase y selecciona tu app para iOS.

    Confirma que el proyecto de Firebase tenga la configuración correcta a fin de usar Dynamic Links en tu app para iOS. Para ello, abre el archivo apple-app-site-association alojado en tu dominio de Dynamic Links: Por ejemplo:

    https://example.com/apple-app-site-association

    Si tu app está conectada, el archivo apple-app-site-association contiene una referencia al ID de la App Store y el ID de paquete de tu app. Por ejemplo:

    {"applinks":{"apps":[],"details":[{"appID":"1234567890.com.example.ios","paths":["/*"]}]}}

    Si la propiedad details está vacía, vuelve a verificar que hayas especificado el prefijo de ID de la app. Ten en cuenta que el prefijo de ID de la app puede no coincidir con el ID del equipo.

Agrega Firebase a tu app

  1. Importa el módulo de Firebase en tu UIApplicationDelegate:

    Swift

    import Firebase

    Objective-C

    @import Firebase;
  2. Configura una instancia compartida de FirebaseApp, generalmente en el método application:didFinishLaunchingWithOptions: de tu aplicación:

    Swift

    // Use Firebase library to configure APIs
    FirebaseApp.configure()

    Objective-C

    // Use Firebase library to configure APIs
    [FIRApp configure];

Usa Firebase console

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

Usa la API de iOS Builder

Puedes usar la API de iOS Builder para compilar Dynamic Links a partir de parámetros o para acortar un Dynamic Link largo.

Crea un Dynamic Link a partir de parámetros

Para crear un Dynamic Link, crea un objeto DynamicLinkComponents nuevo y especifica los parámetros del Dynamic Link mediante la configuración de las propiedades del objeto correspondientes. A continuación, obtén el vínculo largo mediante la propiedad url del objeto. También puedes llamar a shorten() para obtener el vínculo corto.

El siguiente ejemplo simple crea un Dynamic Link largo a https://www.example.com/my-page que se abre con tu app para iOS y la app com.example.android en Android:

Swift

guard let link = URL(string: "https://www.example.com/my-page") else { return }
let dynamicLinksDomainURIPrefix = "https://example.com/link"
let linkBuilder = DynamicLinkComponents(link: link, domainURIPrefix: dynamicLinksDomainURIPRefix)
linkBuilder.iOSParameters = DynamicLinkIOSParameters(bundleID: "com.example.ios")
linkBuilder.androidParameters = DynamicLinkAndroidParameters(packageName: "com.example.android")

guard let longDynamicLink = linkBuilder.url else { return }
print("The long URL is: \(longDynamicLink)")

Objective-C

NSURL *link = [[NSURL alloc] initWithString:@"https://www.example.com/my-page"];
NSString *dynamicLinksDomainURIPrefix = @"https://example.com/link";
FIRDynamicLinkComponents *linkBuilder = [[FIRDynamicLinkComponents alloc]
                                         initWithLink:link
                                               domainURIPrefix:dynamicLinksDomainURIPrefix];
linkBuilder.iOSParameters = [[FIRDynamicLinkIOSParameters alloc]
                             initWithBundleID:@"com.example.ios"];
linkBuilder.androidParameters = [[FIRDynamicLinkAndroidParameters alloc]
                                 initWithPackageName:@"com.example.android"];

NSLog(@"The long URL is: %@", linkBuilder.url);

Para crear un Dynamic Link corto, compila un DynamicLinkComponents de la misma manera y, a continuación, llama a shorten().

La compilación de un vínculo corto requiere una llamada de red, de modo que en lugar de mostrar directamente el vínculo, shorten() acepta el controlador de finalización, el que se llama cuando se completa la solicitud. Por ejemplo:

Swift

linkBuilder.shorten() { url, warnings, error in
  guard let url = url, error != nil else { return }
  print("The short URL is: \(url)")
}

Objective-C

[linkBuilder shortenWithCompletion:^(NSURL * _Nullable shortURL,
                                     NSArray<NSString *> * _Nullable warnings,
                                     NSError * _Nullable error) {
  if (error || shortURL == nil) { return; }
  NSLog(@"The short URL is: %@", shortURL);
}];
      

Según la configuración predeterminada, los Dynamic Links cortos se generan 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 práctico, no es perjudicial que una persona adivine el vínculo corto correctamente, puedes generar sufijos que solo tengan el largo suficiente a fin de que sean únicos. Para ello, configura la propiedad dynamicLinkComponentsOptions:

Swift

linkBuilder.dynamicLinkComponentsOptions = DynamicLinkComponentsOptions()
linkBuilder.dynamicLinkComponentsOptions.pathLength = .short
linkBuilder.shorten() { url, warnings, error in
  guard let url = url, error != nil else { return }
  print("The short URL is: \(url)")
}

Objective-C

linkBuilder.dynamicLinkComponentsOptions = [[FIRDynamicLinkComponentsOptions alloc] init];
linkBuilder.dynamicLinkComponentsOptions.pathLength = FIRShortDynamicLinkPathLengthShort;
[linkBuilder shortenWithCompletion:^(NSURL * _Nullable shortURL,
                                     NSArray<NSString *> * _Nullable warnings,
                                     NSError * _Nullable error) {
  if (error || shortURL == nil) { return; }
  NSLog(@"The short URL is: %@", shortURL);
}];
      

Parámetros del Dynamic Link

Puedes usar la API de Dynamic Link 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 permite crear un Dynamic Link con varios parámetros comunes configurados:

Swift

guard let link = URL(string: "https://www.example.com/my-page") else { return }
let dynamicLinksDomainURIPrefix = "https://example.com/link"
let linkBuilder = DynamicLinkComponents(link: link, domainURIPRefix: dynamicLinksDomainURIPrefix)

linkBuilder.iOSParameters = DynamicLinkIOSParameters(bundleID: "com.example.ios")
linkBuilder.iOSParameters.appStoreID = "123456789"
linkBuilder.iOSParameters.minimumAppVersion = "1.2.3"

linkBuilder.androidParameters = DynamicLinkAndroidParameters(packageName: "com.example.android")
linkBuilder.androidParameters.minimumVersion = 123

linkBuilder.analyticsParameters = DynamicLinkGoogleAnalyticsParameters(source: "orkut",
                                                                       medium: "social",
                                                                       campaign: "example-promo")

linkBuilder.iTunesConnectParameters = DynamicLinkItunesConnectAnalyticsParameters()
linkBuilder.iTunesConnectParameters.providerToken = "123456"
linkBuilder.iTunesConnectParameters.campaignToken = "example-promo"

linkBuilder.socialMetaTagParameters = DynamicLinkSocialMetaTagParameters()
linkBuilder.socialMetaTagParameters.title = "Example of a Dynamic Link"
linkBuilder.socialMetaTagParameters.descriptionText = "This link works whether the app is installed or not!"
linkBuilder.socialMetaTagParameters.imageURL = "https://www.example.com/my-image.jpg"

guard let longDynamicLink = linkBuilder.url else { return }
print("The long URL is: \(longDynamicLink)")

Objective-C

NSURL *link = [[NSURL alloc] initWithString:@"https://www.example.com/my-page"];
NSString *dynamicLinksDomainURIPrefix = @"https://example.com/link";
FIRDynamicLinkComponents *linkBuilder = [[FIRDynamicLinkComponents alloc]
                                         initWithLink:link
                                         domainURIPrefix:dynamicLinksDomainURIPrefix];

linkBuilder.iOSParameters = [[FIRDynamicLinkIOSParameters alloc]
                             initWithBundleID:@"com.example.ios"];
linkBuilder.iOSParameters.appStoreID = @"123456789";
linkBuilder.iOSParameters.minimumAppVersion = @"1.2.3";

linkBuilder.androidParameters = [[FIRDynamicLinkAndroidParameters alloc]
                                 initWithPackageName:@"com.example.android"];
linkBuilder.androidParameters.minimumVersion = 123;

linkBuilder.analyticsParameters = [[FIRDynamicLinkGoogleAnalyticsParameters alloc]
                                   initWithSource:@"orkut"
                                           medium:@"social"
                                         campaign:@"example-promo"];

linkBuilder.iTunesConnectParameters = [[FIRDynamicLinkItunesConnectAnalyticsParameters alloc] init];
linkBuilder.iTunesConnectParameters.providerToken = @"123456";
linkBuilder.iTunesConnectParameters.campaignToken = @"example-promo";

linkBuilder.socialMetaTagParameters = [[FIRDynamicLinkSocialMetaTagParameters alloc] init];
linkBuilder.socialMetaTagParameters.title = @"Example of a Dynamic Link";
linkBuilder.socialMetaTagParameters.descriptionText = @"This link works whether the app is installed or not!";
linkBuilder.socialMetaTagParameters.imageURL = @"https://www.example.com/my-image.jpg";

NSLog(@"The long URL is: %@", linkBuilder.url);

Puedes configurar los parámetros del Dynamic Link con los siguientes objetos y propiedades:

DynamicLinkComponents
link

El vínculo que abrirá tu app. Especifica una URL que tu app pueda manejar, como el contenido o la carga útil, que inicia una lógica específica de la app (como darle créditos al usuario con un cupón o mostrar una pantalla de bienvenida). Este vínculo debe ser una URL con un formato correcto y la codificación URL adecuada, debe usar HTTP o HTTPS y no puede ser otro Dynamic Link.

domainURIPrefix El prefijo de URI del Dynamic Link, que puedes encontrar en Firebase console. Un dominio de Dynamic Link debería tener un formato similar a los siguientes ejemplos:

https://example.com/link
https://example.page.link
DynamicLinkAndroidParameters
fallbackURL El vínculo que se debe abrir cuando la app no esté instalada. Especifica el parámetro para hacer otra acción distinta de instalar tu app desde Play Store cuando no esté instalada, como abrir la versión web móvil del contenido o mostrar una página promocional de tu app.
minimumVersion El versionCode de la versión mínima de tu app que puede abrir el vínculo. Si la app instalada es una versión anterior, se dirige al usuario a Play Store para que la actualice.
DynamicLinkIOSParameters
appStoreID El ID de la app en App Store, que se usa para enviar usuarios a App Store cuando la app no está instalada.
fallbackURL El vínculo que se debe abrir cuando la app no esté instalada. Especifica este parámetro para hacer otra acción distinta de instalar la app desde App Store cuando no esté instalada, como abrir la versión web móvil del contenido o mostrar una página promocional de la app.
customScheme El esquema de URL personalizada de la app, si se define con un valor diferente del ID de paquete.
iPadFallbackURL El vínculo que se debe abrir en iPads cuando la app no está instalada. Especifica esto para que haga algo diferente de instalar tu app desde App Store cuando la app no esté instalada, como abrir la versión web del contenido o mostrar una página promocional de tu app.
iPadBundleID El ID de paquete de la app para iOS que se usa en iPads para abrir el vínculo. La app debe estar conectada a tu proyecto desde la página Información general de Firebase console.
minimumAppVersion El número de la versión mínima de la app que puede abrir el vínculo. Este indicador se pasa a tu app cuando se abre y la app debe decidir qué hacer con él.
DynamicLinkNavigationInfoParameters
forcedRedirectEnabled Si se configura en “1”, omite la página de vista previa de la app cuando se abre el Dynamic Link y, en su lugar, redirecciona a la app o la tienda. La página de vista previa de la app (habilitada en la configuración predeterminada) puede enviar a los usuarios de manera más confiable al destino más apropiado cuando abren Dynamic Links en apps. Sin embargo, si esperas que se abra solo un Dynamic Link en apps que pueden abrir Dynamic Links de manera confiable sin esta página, puedes inhabilitarla con este parámetro. Nota: Actualmente, solo se muestra la página de vista previa de la app en iOS, pero podría mostrarse en Android en algún momento. Este parámetro afectará el comportamiento del Dynamic Link en ambas plataformas.
DynamicLinkSocialMetaTagParameters
cargo El título que se usará cuando se comparta el Dynamic Link en una publicación de redes sociales.
descriptionText La descripción que se usará cuando se comparta el Dynamic Link en una publicación de redes sociales.
imageURL La URL a una imagen relacionada con este vínculo. La imagen debe tener al menos 300x200 px y pesar menos de 300 KB.
DynamicLinkGoogleAnalyticsParameters
source
medium
campaign
term
content
Parámetros de análisis de Google Play. Estos parámetros (utm_source, utm_medium, utm_campaign, utm_term, utm_content) se pasan a Play Store y se agregan a la carga útil del vínculo.
DynamicLinkItunesConnectAnalyticsParameters
providerToken
affiliateToken
campaignToken
Parámetros de análisis de iTunes Connect. Se pasan estos parámetros (pt, at, ct) a App Store.

Cómo acortar un Dynamic Link largo

Para acortar un Dynamic Link largo, pásalo a shortenURL(url:options:) junto con un objeto DynamicLinkComponentsOptions si deseas generar un vínculo con un sufijo corto:

Swift

DynamicLinkComponents.shortenURL(url: longLinkUrl, options: nil) { url, warnings, error in
  guard let url = url, error != nil else { return }
  print("The short URL is: \(url)")
}

Objective-C

[FIRDynamicLinkComponents shortenURL:longLinkUrl
                             options:nil
                          completion:^(NSURL * _Nullable shortURL,
                                       NSArray<NSString *> * _Nullable warnings,
                                       NSError * _Nullable error) {
  if (error || shortURL == nil) { return; }
  NSLog(@"The short URL is: %@", shortURL);
}];

Especificación de un esquema de URL personalizada para Dynamic Links

En la configuración predeterminada, Dynamic Links usa el identificador de paquete de tu aplicación como el esquema de URL necesario para abrirla. Te recomendamos mantener ese valor predeterminado a fin de evitar complicaciones en tu implementación.

Sin embargo, es posible que los desarrolladores que ya usen un esquema de URL personalizada por otros motivos quieran usar ese mismo esquema en sus Dynamic Links. Si este es tu caso, puedes especificar un esquema de URL diferente para tus Firebase Dynamic Links de la siguiente manera:

  1. Cuando configures la app, especifica el esquema de URL personalizada que usará y luego configura tu instancia compartida de FirebaseApp:

    Swift

    func application(_ application: UIApplication,
                     didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
      // Set deepLinkURLScheme to the custom URL scheme you defined in your
      // Xcode project.
      FirebaseOptions.defaultOptions()?.deepLinkURLScheme = self.customURLScheme
      FirebaseApp.configure()
    
      return true
    }

    Objective-C

    - (BOOL)application:(UIApplication *)application
        didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
      // Set deepLinkURLScheme to the custom URL scheme you defined in your
      // Xcode project.
      [FIROptions defaultOptions].deepLinkURLScheme = CUSTOM_URL_SCHEME;
      [FIRApp configure];
    
      return YES;
    }
  2. Cuando crees un Dynamic Link, deberás especificar el esquema de URL personalizada que usa la app. Para ello, visita Firebase console, configura el customScheme en la API de Builder, especifica el parámetro ius en tu URL o envía el parámetro del iosCustomScheme a la API de REST.

Próximos pasos

Ahora que creaste Dynamic Links, debes configurar tu app para recibirlos y enviar a los usuarios al lugar correcto de la app cuando los abran.

Para recibir Dynamic Links en tu app, consulta la documentación de iOS, Android, C++ y Unity.