É possível criar Dynamic Links curtos ou longos com a API Firebase Dynamic Links Builder. Essa API aceita um Dynamic Link longo ou um objeto que contenha parâmetros Dynamic Link e retorna URLs como os exemplos 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.
- No Xcode, com seu projeto do app aberto, navegue até File > Add Packages.
- Quando solicitado, adicione o repositório do SDK do Firebase para as plataformas Apple:
- Escolha a biblioteca Dynamic Links.
- Adicione a sinalização
-ObjC
à seção Outras sinalizações do vinculador das configurações de compilação do destino. - Para uma experiência ideal 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.
- Quando terminar, o Xcode começará a resolver e fazer o download das dependências em segundo plano automaticamente.
https://github.com/firebase/firebase-ios-sdk.git
Agora execute algumas etapas de configuração:
- No console do Firebase, abra a seção Dynamic Links.
-
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á tiver um prefixo URI Dynamic Links, anote-o. Você precisa fornecê-lo para criar Dynamic Links de maneira programática.
- 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.
-
Verifique se o ID 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 Dynamic Links no app para iOS. Para isso, abra o arquivo
apple-app-site-association
hospedado no domínio Dynamic Links. O Firebase exibirá o arquivoapple-app-site-association
na raiz do domínio, bem como o subdiretório.well-known
. Por 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. Por 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
- Importe o módulo
FirebaseCore
noUIApplicationDelegate
, assim como qualquer outro módulo do Firebase usado pelo delegado do app. Por exemplo, para usar Cloud Firestore, Authentication e:SwiftUI
import SwiftUI import FirebaseCore import FirebaseFirestore import FirebaseAuth // ...
Swift
import FirebaseCore import FirebaseFirestore import FirebaseAuth // ...
Objective-C
@import FirebaseCore; @import FirebaseFirestore; @import FirebaseAuth; // ...
- Configure uma
instância compartilhada do
FirebaseApp
no métodoapplication(_: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];
- Se você estiver usando a SwiftUI, crie um delegado do aplicativo e o anexe
ao struct
App
viaUIApplicationDelegateAdaptor
ouNSApplicationDelegateAdaptor
. 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() } } } }
Use o console 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 Dynamic Link único da maneira mais simples.
Usar a API iOS Builder
Use a API iOS Builder para criar Dynamic Links com base nos parâmetros ou para encurtar um Dynamic Link longo.
Criar um Dynamic Link com base em parâmetros
Para criar um Dynamic Link, crie um novo objeto DynamicLinkComponents
e especifique os parâmetros Dynamic Link definindo as 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:
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 Dynamic Link curto, crie um DynamicLinkComponents
da
mesma maneira e 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. 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 Dynamic Links curtos são gerados com sufixos de link de 17 caracteres que
torna extremamente improvável que alguém consiga adivinhar um Dynamic Link 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
:
Swift
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)") }
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); }];
Dynamic Link parâmetros
Você pode usar a API Builder Dynamic Link para criar Dynamic Links com qualquer um dos parâmetros compatíveis. Consulte a referência da API para ver mais detalhes.
O exemplo abaixo cria um Dynamic Link 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);
É possível definir parâmetros Dynamic Link 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 ou 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 formatado corretamente, ter a codificação de URL adequada e usar HTTP ou HTTPS. Além disso, ele não pode ser outro link dinâmico. |
domainURIPrefix | Seu prefixo de URL Dynamic Link, que pode ser encontrado no console do Firebase. Um
Dynamic Link domínio tem a seguinte aparência:
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 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 ID 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 ID do pacote do app para iOS que é usado em iPads para abrir o link. O app precisa estar conectado ao seu projeto pela Página de visão geral no 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 Dynamic Link for aberto e redirecione-o para o app ou a loja. Na página de visualização do app (ativada por padrão), é possível enviar usuários de maneira confiável para o destino mais apropriado, quando eles abrem Dynamic Links nos apps. Ainda assim, se você espera que um Dynamic Link seja aberto apenas em apps que possam abrir esses Dynamic Links de maneira confiável sem esta página, é possível desativar ela usando este parâmetro. Esse parâmetro afetará o comportamento do Dynamic Link somente no iOS. |
DynamicLinkSocialMetaTagParameters | |
---|---|
title | O título a ser usado quando o Dynamic Link é compartilhado em uma postagem de mídia social. |
descriptionText | A descrição a ser usada quando o Dynamic Link é 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 de análise para o Google Play. Esses parâmetros (utm_source , utm_medium , utm_campaign , utm_term , utm_content ) são transmitidos para a Play Store e anexados ao payload do link.
|
DynamicLinkItunesConnectAnalyticsParameters | |
---|---|
providerToken affiliateToken campaignToken |
Parâmetros de análise para o iTunes Connect. Esses parâmetros (pt , at , ct ) são transmitidos para a App Store. |
Encurtar um Dynamic Link longo
Para encurtar um Dynamic Link longo, transmita o Dynamic Link longo para
shortenURL(url:options:)
junto com um
objeto DynamicLinkComponentsOptions
se você quiser gerar um link
com um sufixo curto:
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); }];
Especificação de um esquema de URL personalizado para 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 estas etapas:
- 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; }
- Sempre que você criar qualquer Dynamic Link, vai precisar especificar o esquema de URL personalizado que seu
app usa. É possível fazer isso pelo Console do Firebase, basta definir o
customScheme
na API Builder, especificar o parâmetroius
no seu URL ou enviar o parâmetroiosCustomScheme
para a API REST
Próximas etapas
Agora que você criou Dynamic Links, é necessário configurar seu app para receber Dynamic Links e direcionar os usuários ao local correto no app quando eles forem abertos.
Para receber Dynamic Links no app, consulte a documentação para iOS, Android, C++ e Unity.