Crea Dynamic Links en iOS

Puedes crear Dynamic Links cortos o largos con la API de Builder de Firebase Dynamic Links. Esta API acepta un Dynamic Link largo o un objeto que contenga parámetros de Dynamic Link parámetros y muestra URLs como los siguientes ejemplos:

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

Requisitos previos

Antes de comenzar, asegúrate de agregar Firebase a tu proyecto de iOS.

Configura Firebase y el SDK de Dynamic Links

Usa Swift Package Manager para instalar y administrar las dependencias de Firebase.

1. En Xcode, con tu proyecto de app abierto, navega a File > Add Packages.
2. Cuando se te solicite, agrega el repositorio del SDK de Firebase para plataformas de Apple:

  https://github.com/firebase/firebase-ios-sdk.git

3. Elige la biblioteca de Dynamic Links.
4. Agrega la marca -ObjC a la sección Other Linker Flags de la configuración de compilación de tu destino.
5. Para obtener una experiencia óptima con Dynamic Links, te recomendamos habilitar Google Analytics en tu proyecto de Firebase y agregar el SDK de Firebase para Google Analytics a la app. Puedes seleccionar la biblioteca sin la colección de IDFA o con la colección de IDFA. Consulta nuestras Preguntas frecuentes sobre la organización más reciente de los módulos en el SDK de Google Analytics para Firebase.
6. Cuando termines, Xcode comenzará a resolver y descargar automáticamente tus dependencias en segundo plano.

Ahora, debes realizar los siguientes pasos de configuración:

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

2. 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 proporcionarla cuando crees Dynamic Links de manera programática.

   

3. 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.

4. Asegúrate de que el ID de App Store y el prefijo de ID de la app estén especificados en la configuración de la app. 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 tu proyecto de Firebase esté configurado correctamente para usar Dynamic Links en tu app para iOS abriendo el archivo apple-app-site-association alojado en tu Dynamic Links. Firebase entregará el archivo apple-app-site-association desde la raíz del dominio, así como el subdirectorio .well-known. Por ejemplo:

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

   Si tu app está conectada, el archivo apple-app-site-association contiene una referencia al ID del paquete y al prefijo de ID de la 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 del ID de la app. Ten en cuenta que el prefijo del ID de la app puede no coincidir con el ID del equipo.

Agrega Firebase a tu app

1. Importa el módulo FirebaseCore en tu UIApplicationDelegate, así como cualquier otro módulo de Firebase que use el delegado de la app. Por ejemplo, para usar Cloud Firestore y Authentication:

   SwiftUI

   import SwiftUI
   import FirebaseCore
   import FirebaseFirestore
   import FirebaseAuth
   // ...
         

   Swift

   import FirebaseCore
   import FirebaseFirestore
   import FirebaseAuth
   // ...
         

   Objective-C

   @import FirebaseCore;
   @import FirebaseFirestore;
   @import FirebaseAuth;
   // ...
         

2. Configura una instancia compartida de FirebaseApp en el método application(_:didFinishLaunchingWithOptions:) del delegado de la app:

   SwiftUI

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

   Swift

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

   Objective-C

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

3. Si usas SwiftUI, debes crear un delegado de la aplicación y adjuntarlo al struct de tu App a través de UIApplicationDelegateAdaptor o NSApplicationDelegateAdaptor. También debes inhabilitar el swizzling del delegado de la app. Para obtener más información, consulta las instrucciones de SwiftUI.

   SwiftUI

   @main
   struct YourApp: App {
     // register app delegate for Firebase setup
     @UIApplicationDelegateAdaptor(AppDelegate.self) var delegate
   
     var body: some Scene {
       WindowGroup {
         NavigationView {
           ContentView()
         }
       }
     }
   }
         

Usa la consola de Firebase

Si quieres generar un único Dynamic Link, ya sea para fines de pruebas o para que tu equipo de marketing cree fácilmente un vínculo que pueda usarse en algo como una publicación de redes sociales, la forma más sencilla sería visitar la consola de Firebase o crear uno manualmente siguiendo el formulario paso a paso.

Usa la API de iOS Builder

Puedes usar la API de iOS Builder para crear 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 nuevo objeto DynamicLinkComponents y especifica los parámetros de Dynamic Link estableciendo las propiedades correspondientes del objeto. 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.

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

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)")

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, al cual se llama cuando se completa la solicitud. Por ejemplo:

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

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

De forma predeterminada, se generan 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 alguien adivine correctamente los vínculos cortos, puedes generar sufijos que solo tengan el largo suficiente para que sean únicos. Para ello, configura la propiedad dynamicLinkComponentsOptions de esta manera:

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

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 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.

En el siguiente ejemplo, se crea un Dynamic Link con varios parámetros conjuntos de ejemplos comunes:

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)")

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 parámetros de Dynamic Link con los siguientes objetos y propiedades:

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

Acorta un Dynamic Link largo

Para acortar un Dynamic Link largo, pasa el Dynamic Link largo a shortenURL(url:options:) junto con un objeto DynamicLinkComponentsOptions en caso de que quieras generar un vínculo con un sufijo corto:

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

[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);
}];

Especifica 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 tu Firebase Dynamic Links de la siguiente manera:

1. Cuando configures la app, asegúrate de especificar el esquema de URL personalizada que usará antes de configurar la instancia compartida de FirebaseApp:

   Swift

   Nota: Este producto de Firebase no se encuentra disponible en objetivos de macOS, Mac Catalyst, tvOS ni watchOS.

   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 = customURLScheme
     FirebaseApp.configure()
   
     return true
   }

   Objective-C

   Nota: Este producto de Firebase no se encuentra disponible en objetivos de macOS, Mac Catalyst, tvOS ni watchOS.

   - (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. Puedes hacerlo a través de la consola Firebase, si configuras customScheme en la API de Builder y especificas el parámetro ius en tu URL. También puedes enviar el parámetro iosCustomScheme a la API de REST

Próximos pasos

Ahora que creaste Dynamic Links, debes configurar tu app para recibir Dynamic Links y enviar a los usuarios al lugar correcto de tu app después de que los abra.

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