Criar links dinâmicos no iOS

Você pode criar links dinâmicos curtos ou longos com a API Firebase Dynamic Links Builder. Essa API aceita um link dinâmico longo ou um objeto que contenha parâmetros de link dinâmico e retorna URLs, como no exemplo a seguir:

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

Pré-requisitos

Links dinâmicos do Firebase exigem o iOS 8 ou posterior. É possível tentar usar o iOS 7 no seu app, mas o SDK do Firebase Dynamic Links só funciona em apps executados no iOS 8 ou posterior.

Configurar o Firebase e o SDK do Dynamic Links

  1. Adicione o Firebase ao seu projeto do iOS. Inclua este pod no Podfile:
    pod 'Firebase/Core'
    pod 'Firebase/DynamicLinks'
        
  2. Execute pod install e abra o arquivo .xcworkspace criado.
  3. No Console do Firebase, abra a seção Dynamic Links.
  4. 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 links dinâmicos, anote-o. Será necessário fornecê-lo ao criar links dinâmicos de maneira programática.

  5. 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 links dinâmicos que redirecionam para sites que você não controla a partir do seu domínio. Consulte Padrões de URL da lista de permissões.
  6. Verifique se o código da App Store e o prefixo do ID do app estão especificados nas configurações dele. Para visualizar e editar as configurações do app, acesse a página Configurações do projeto do Firebase e selecione o app para iOS.

    Para confirmar se o projeto do Firebase está configurado corretamente para usar os links dinâmicos no seu aplicativo para iOS, abra o arquivo apple-app-site-association hospedado em seu domínio do Dynamic Links. Exemplo:

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

    Se o app está conectado, o arquivo apple-app-site-association contém uma referência ao código da App Store e ao código do pacote. Por exemplo:

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

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

Adicionar o Firebase ao seu app

  1. Importe o módulo do Firebase no UIApplicationDelegate:

    Swift

    import Firebase
    

    Objective-C

    @import Firebase;
    
  2. Configure uma instância compartilhada do FirebaseApp, que geralmente está no método application:didFinishLaunchingWithOptions: do aplicativo:

    Swift

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

    Objective-C

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

No 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 a partir de parâmetros ou para encurtar um link dinâmico longo.

Criar um link dinâmico a partir de parâmetros

Para criar um link dinâmico, crie um novo objeto DynamicLinkComponents e especifique os parâmetros de link dinâmico definindo as propriedades correspondentes do objeto. Em seguida, receba o link longo da propriedade url do objeto ou o link curto chamando shorten().

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

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

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

Por padrão, os links dinâmicos curtos são gerados com sufixos de links de 17 caracteres que tornam extremamente improvável que alguém consiga adivinhar um link dinâmico válido. Se não houver problemas em alguém adivinhar um link curto para seu caso de uso, talvez você prefira gerar sufixos que sejam apenas longos o bastante para serem exclusivos. Isso pode ser feito por meio da configuração da propriedade 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 de link dinâmico

Você pode 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 link dinâmico com vários parâmetros comuns definidos:

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

Você pode definir os parâmetros do link dinâmico com os seguintes objetos e propriedades:

DynamicLinkComponents
link

O link que será aberto pelo app. É possível especificar um URL que pode ser processado pelo seu app, geralmente o conteúdo/payload de um app, que pode iniciar uma lógica específica do app, como creditar o usuário com um cupom ou exibir uma tela de boas-vindas. Esse link precisa ser um URL bem formatado, ser corretamente codificado pelo URL, usar HTTP ou HTTPS e não pode ser outro link dinâmico.

domainURIPrefix Seu prefixo de URL de link dinâmico, que você pode encontrar no Console do Firebase. Um domínio de link dinâmico é semelhante aos exemplos a seguir:

https://example.com/link
https://example.page.link
DynamicLinkAndroidParameters
fallbackURL O link a ser aberto quando o app não estiver instalado. Especifique isso para realizar outra ação que não seja instalar o app da Play Store quando ele não estiver instalado. A ação pode ser abrir a versão da Web para dispositivos móveis do conteúdo ou exibir uma página promocional para o app.
minimumVersion O versionCode da versão mínima do seu app que pode abrir o link. Se o app instalado for uma versão mais antiga, o usuário será direcionado para a Play Store para atualizá-lo.
DynamicLinkIOSParameters
appStoreID O código do seu app na App Store, usado para direcionar os usuários à App Store quando o app não estiver instalado.
fallbackURL O link a ser aberto quando o app não estiver instalado. Especifique isso para realizar outra ação que não seja instalar o app da App Store quando ele não estiver instalado. A ação pode ser abrir a versão da Web para dispositivos móveis do conteúdo ou exibir uma página promocional para o app.
customScheme O esquema de URL personalizado do seu app, se definido de modo diferente do código do pacote do seu app.
iPadFallbackURL O link a ser aberto em iPads quando o app não estiver instalado. Especifique isso para realizar outra ação, que não seja instalar o app da App Store quando ele não estiver instalado. A ação pode ser abrir a versão da Web do conteúdo ou exibir uma página promocional para o app.
iPadBundleID O código do pacote do app para iOS a ser usado em iPads para abrir o link. O app precisa estar conectado ao seu projeto na página de visão geral do Console do Firebase.
minimumAppVersion O número da versão mínima do seu app que pode abrir o link. Esse sinalizador é transmitido para seu app quando ele é aberto, e seu app precisa decidir o que fazer com ele.
DynamicLinkNavigationInfoParameters
forcedRedirectEnabled Se configurado como "1", ignore a página de visualização do app quando o link dinâmico for aberto e, em vez disso, redirecione-o para o aplicativo ou a loja. A página de visualização do app (ativada por padrão) pode enviar usuários de maneira mais confiável para o destino apropriado quando eles abrem links dinâmicos em apps. No entanto, se você espera que um link dinâmico seja aberto somente em apps que possam abrir links dinâmicos de maneira confiável sem esta página, você pode desativá-lo com este parâmetro. Observação: no momento, a página de visualização do app só é exibida no iOS, mas, em breve, ela também poderá ser aberta no Android. Este parâmetro afetará o comportamento do link dinâmico em ambas as plataformas.
DynamicLinkSocialMetaTagParameters
title O título a ser usado quando o link dinâmico é compartilhado em uma postagem de mídia social.
descriptionText A descrição a ser usada quando o link dinâmico é compartilhado em uma postagem de mídia social.
imageURL O URL para uma imagem relacionada a este link. A imagem precisa ser de pelo menos 300 x 200 px e ter menos de 300 KB.
DynamicLinkGoogleAnalyticsParameters
source
medium
campaign
term
content
Parâmetros do Analytics para o Google Play. Esses parâmetros (utm_source, utm_medium, utm_campaign, utm_term, utm_content) são transmitidos para a Play Store, assim como anexados ao payload do link.
DynamicLinkItunesConnectAnalyticsParameters
providerToken
affiliateToken
campaignToken
Parâmetros do Analytics para o iTunes Connect. Esses parâmetros (pt, at, ct) são transmitidos para a App Store.

Encurtar um link dinâmico longo

Para encurtar um link dinâmico longo por meio da geração de um link com sufixo curto, transmita esse link para shortenURL(url:options:) junto com um objeto DynamicLinkComponentsOptions:

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

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.

No entanto, 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 links dinâmicos. Se você estiver nessa situação, especifique um esquema de URL diferente para seus links dinâmicos do Firebase 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

    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. Sempre que criar qualquer link dinâmico, você precisará especificar o esquema de URL personalizado usado pelo seu aplicativo. Para isso, use o Console do Firebase, configurando o customScheme na API Builder, especificando o parâmetro ius no URL ou enviando 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 links dinâmicos no seu app, consulte a documentação do iOS, do Android, do C++ e do Unity.

Enviar comentários sobre…

Precisa de ajuda? Acesse nossa página de suporte.