Criar Dynamic Links no iOS

Crie Dynamic Links curtos ou longos com a API Firebase Dynamic Links Builder. Essa API aceita um link dinâmico longo ou um objeto com parâmetros correspondentes e retorna URLs, como no exemplo a seguir:

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

Pré-requisitos

Antes de começar, adicione o Firebase ao seu projeto do iOS.

Configurar o Firebase e o SDK do Dynamic Links

Use o Swift Package Manager para instalar e gerenciar as dependências do Firebase.

1. No Xcode, com seu projeto do app aberto, navegue até File > Add Packages.
2. Quando solicitado, adicione o repositório do SDK do Firebase para as plataformas Apple:

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

3. Escolha a biblioteca do Firebase Dynamic Links.
4. Para aproveitar a melhor experiência com o Dynamic Links, recomendamos ativar o Google Analytics no seu projeto e adicionar o SDK do Firebase para Analytics ao seu app. Você pode selecionar a biblioteca com ou sem o recurso de coleta de IDFAs.
5. Quando terminar, o Xcode começará a resolução e fará o download das dependências em segundo plano automaticamente.

Agora execute algumas etapas de configuração:

1. No Console do Firebase, abra a seção Dynamic Links.

2. Se você ainda não aceitou os termos de serviço e definiu um URI para o Dynamic Links, faça isso quando solicitado.

   Se você já tem um prefixo de URI do Dynamic Links, anote-o. Será necessário fornecê-lo ao criar Dynamic Links de maneira programática.

   

3. Recomendado: especifique os padrões de URL permitidos nos seus links diretos e links de fallback. Ao fazer isso, você evita que pessoas não autorizadas criem Dynamic Links que redirecionam para sites que você não controla no seu domínio. Consulte Permitir padrões de URL específicos.

4. Verifique se o ID do app da App Store e o prefixo do ID do app estão especificados nas configurações do aplicativo. Para visualizar e editar as configurações do app, acesse a página Configurações do projeto Firebase e selecione o app iOS.

   Confirme se o projeto do Firebase está configurado corretamente para usar o Dynamic Links no seu app para iOS. Para isso, abra o arquivo apple-app-site-association hospedado no domínio do Dynamic Links. O Firebase exibirá o arquivo apple-app-site-association na raiz do domínio, bem como o subdiretório .well-known. Exemplo:

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

   Se o app estiver conectado, o arquivo apple-app-site-association conterá uma referência ao prefixo do ID do app e ao ID do pacote do app. Exemplo:

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

   Se a propriedade details estiver vazia, verifique se você especificou o prefixo do ID do app. Pode ser que ele não seja igual ao código da sua equipe.

Adicionar o Firebase ao app

1. Importe o módulo FirebaseCore no UIApplicationDelegate, assim como qualquer outro módulo do Firebase usado pelo delegado do app. Por exemplo, para usar o Cloud Firestore e o 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. Configure uma instância compartilhada do FirebaseApp no método application(_:didFinishLaunchingWithOptions:) do delegado do 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. Se você estiver usando a SwiftUI, crie um delegado do aplicativo e o anexe ao struct App via UIApplicationDelegateAdaptor ou NSApplicationDelegateAdaptor. Também é necessário desativar o swizzling do delegado do app. Para mais informações, consulte as instruções da SwiftUI.

   SwiftUI

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

Usar o Console do Firebase

Caso você queira fazer testes ou facilitar para sua equipe de marketing a criação de um link a ser usado em uma postagem de mídia social, acesse o Console do Firebase e siga o formulário passo a passo para gerar um link dinâmico único da maneira mais simples.

Usar a API iOS Builder

Use a API iOS Builder para criar links dinâmicos de acordo com os parâmetros ou para encurtar um link dinâmico longo.

Criar um Dynamic Link usando parâmetros

Para criar um Dynamic Link, crie um novo objeto DynamicLinkComponents e especifique os parâmetros do Dynamic Link com a definição das propriedades correspondentes do objeto. Em seguida, receba o link longo da propriedade url do objeto ou o link curto ao chamar shorten().

O exemplo mínimo a seguir cria um Dynamic Link longo para https://www.example.com/my-page que é aberto com seu app para iOS no iOS e o app com.example.android no 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 gerar um Dynamic Link curto, crie um DynamicLinkComponents da mesma maneira e depois chame shorten().

A criação de um link curto requer uma chamada de rede. Portanto, em vez de retornar o link diretamente, shorten() aceita um gerenciador de conclusão, que é chamado quando a solicitação é concluída. Exemplo:

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

Por padrão, Dynamic Links curtos são gerados com sufixos de 17 caracteres. Assim, é extremamente improvável que alguém consiga adivinhar um link dinâmico válido. Se não houver problemas em um usuário conseguir prever um link curto no seu caso de uso, convém gerar sufixos que sejam apenas longos o bastante para serem exclusivos. Para isso, basta definir a propriedade dynamicLinkComponentsOptions:

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 de link dinâmico

É possível usar a API Dynamic Link Builder para criar links dinâmicos com qualquer um dos parâmetros aceitos. Consulte a referência da API para ver mais detalhes.

O exemplo a seguir cria um Dynamic Link com vários parâmetros comuns definidos:

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

Você pode definir os parâmetros do Dynamic Link com os seguintes objetos e propriedades:

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

Encurtar um link dinâmico longo

Para encurtar um link dinâmico longo, transmita ele para shortenURL(url:options:) junto com um objeto DynamicLinkComponentsOptions, se quiser gerar um link com um sufixo curto:

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

Especificar um esquema de URL personalizado para o Dynamic Links

Por padrão, o Dynamic Links usa o identificador do pacote do seu app como o esquema de URL necessário para abrir seu aplicativo. Recomendamos manter esse valor padrão para preservar a simplicidade da sua implementação.

Ainda assim, para os desenvolvedores que já estão usando um esquema de URL personalizado para outros objetivos, talvez seja recomendável usar esse mesmo esquema para os Dynamic Links. Se você estiver nessa situação, especifique um esquema de URL diferente para seu Firebase Dynamic Links seguindo as etapas a seguir:

1. Ao configurar seu aplicativo, não se esqueça de especificar o esquema de URL padrão que será usado pelo aplicativo antes de configurar a instância compartilhada FirebaseApp:

   Swift

   Observação: este produto do Firebase não está disponível para destinos macOS, Mac Catalyst, tvOS ou 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

   Observação: este produto do Firebase não está disponível para destinos macOS, Mac Catalyst, tvOS ou 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. Sempre que criar qualquer Dynamic Link, você precisará especificar o esquema de URL personalizado usado pelo seu aplicativo. É possível fazer isso pelo Console do Firebase, basta definir o customScheme na API Builder, especificar o parâmetro ius no seu URL ou enviar o parâmetro iosCustomScheme para a API REST

Próximas etapas

Agora que você criou links dinâmicos, configure seu app para recebê-los e direcionar os usuários ao local correto no app após ele ser aberto.

Para receber Dynamic Links no app, consulte a documentação para iOS, Android, C++ e Unity.