Ir para o console

Criar links dinâmicos no Android

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

Configurar o Firebase e o SDK do Dynamic Links

Antes de poder criar links dinâmicos no seu app para Android, é necessário incluir o SDK do Firebase. Se o app estiver configurado para receber links dinâmicos, isso significa que você já concluiu essas etapas e pode ignorar esta seção.

  1. Adicione o Firebase ao seu projeto para Android, caso ainda não tenha feito isso.

    Ao registrar seu aplicativo, especifique sua chave de assinatura SHA-1. Se você usa links de apps, também precisa especificar sua chave SHA-256.

  2. No seu arquivo de nível de projeto build.gradle, inclua o repositório Maven do Google, tanto nas seções buildscript e allprojects.
  3. Adicione a dependência da biblioteca do Firebase Dynamic Links Android ao seu arquivo Gradle do módulo (nível do app) (geralmente app/build.gradle):
    implementation 'com.google.firebase:firebase-dynamic-links:17.0.0'
  4. No Console do Firebase, abra a seção Dynamic Links.
  5. Se você ainda não aceitou os termos de serviço e definiu um domínio para o Dynamic Links, faça isso quando solicitado.

    Se você já tem um domínio do Dynamic Links, anote-o. Você precisa fornecer um domínio do Dynamic Links ao criar links dinâmicos de maneira programática.

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

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.

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

Para criar um link dinâmico, crie um novo objeto DynamicLink com o construtor, especificando os parâmetros do link dinâmico com os métodos do construtor. Em seguida, chame buildDynamicLink ou buildShortDynamicLink.

O exemplo mínimo a seguir cria um link dinâmico longo para https://www.example.com/ que é aberto com o app para Android no Android e o app com.example.ios no iOS:

Java
Android

DynamicLink dynamicLink = FirebaseDynamicLinks.getInstance().createDynamicLink()
        .setLink(Uri.parse("https://www.example.com/"))
        .setDomainUriPrefix("https://example.page.link")
        // Open links with this app on Android
        .setAndroidParameters(new DynamicLink.AndroidParameters.Builder().build())
        // Open links with com.example.ios on iOS
        .setIosParameters(new DynamicLink.IosParameters.Builder("com.example.ios").build())
        .buildDynamicLink();

Uri dynamicLinkUri = dynamicLink.getUri();

Kotlin
Android

val dynamicLink = FirebaseDynamicLinks.getInstance().createDynamicLink()
        .setLink(Uri.parse("https://www.example.com/"))
        .setDomainUriPrefix("https://example.page.link")
        // Open links with this app on Android
        .setAndroidParameters(DynamicLink.AndroidParameters.Builder().build())
        // Open links with com.example.ios on iOS
        .setIosParameters(DynamicLink.IosParameters.Builder("com.example.ios").build())
        .buildDynamicLink()

val dynamicLinkUri = dynamicLink.uri

Para criar um link dinâmico curto, crie um DynamicLink da mesma maneira e, em seguida, chame buildShortDynamicLink. Criar um link curto requer uma chamada de rede. Portanto, em vez de retornar o link diretamente, buildShortDynamicLink retorna uma Task, o que torna o link curto disponível quando a solicitação for concluída. Exemplo:

Java
Android

Task<ShortDynamicLink> shortLinkTask = FirebaseDynamicLinks.getInstance().createDynamicLink()
        .setLink(Uri.parse("https://www.example.com/"))
        .setDomainUriPrefix("https://example.page.link")
        // Set parameters
        // ...
        .buildShortDynamicLink()
        .addOnCompleteListener(this, new OnCompleteListener<ShortDynamicLink>() {
            @Override
            public void onComplete(@NonNull Task<ShortDynamicLink> task) {
                if (task.isSuccessful()) {
                    // Short link created
                    Uri shortLink = task.getResult().getShortLink();
                    Uri flowchartLink = task.getResult().getPreviewLink();
                } else {
                    // Error
                    // ...
                }
            }
        });

Kotlin
Android

val shortLinkTask = FirebaseDynamicLinks.getInstance().createDynamicLink()
        .setLink(Uri.parse("https://www.example.com/"))
        .setDomainUriPrefix("https://example.page.link")
        // Set parameters
        // ...
        .buildShortDynamicLink()
        .addOnSuccessListener { result ->
            // Short link created
            val shortLink = result.shortLink
            val flowchartLink = result.previewLink
        }.addOnFailureListener {
            // Error
            // ...
        }

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 no 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 ShortDynamicLink.Suffix.SHORT para o método buildShortDynamicLink:

Java
Android

Task<ShortDynamicLink> shortLinkTask = FirebaseDynamicLinks.getInstance().createDynamicLink()
        // ...
        .buildShortDynamicLink(ShortDynamicLink.Suffix.SHORT);
        // ...

Kotlin
Android

val shortLinkTask = FirebaseDynamicLinks.getInstance().createDynamicLink()
        // ...
        .buildShortDynamicLink(ShortDynamicLink.Suffix.SHORT)
        // ...

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:

Java
Android

DynamicLink dynamicLink = FirebaseDynamicLinks.getInstance().createDynamicLink()
        .setLink(Uri.parse("https://www.example.com/"))
        .setDomainUriPrefix("https://example.page.link")
        .setAndroidParameters(
                new DynamicLink.AndroidParameters.Builder("com.example.android")
                        .setMinimumVersion(125)
                        .build())
        .setIosParameters(
                new DynamicLink.IosParameters.Builder("com.example.ios")
                        .setAppStoreId("123456789")
                        .setMinimumVersion("1.0.1")
                        .build())
        .setGoogleAnalyticsParameters(
                new DynamicLink.GoogleAnalyticsParameters.Builder()
                        .setSource("orkut")
                        .setMedium("social")
                        .setCampaign("example-promo")
                        .build())
        .setItunesConnectAnalyticsParameters(
                new DynamicLink.ItunesConnectAnalyticsParameters.Builder()
                        .setProviderToken("123456")
                        .setCampaignToken("example-promo")
                        .build())
        .setSocialMetaTagParameters(
                new DynamicLink.SocialMetaTagParameters.Builder()
                        .setTitle("Example of a Dynamic Link")
                        .setDescription("This link works whether the app is installed or not!")
                        .build())
        .buildDynamicLink();  // Or buildShortDynamicLink()

Kotlin
Android

val dynamicLink = FirebaseDynamicLinks.getInstance().createDynamicLink()
        .setLink(Uri.parse("https://www.example.com/"))
        .setDomainUriPrefix("https://example.page.link")
        .setAndroidParameters(
                DynamicLink.AndroidParameters.Builder("com.example.android")
                        .setMinimumVersion(125)
                        .build())
        .setIosParameters(
                DynamicLink.IosParameters.Builder("com.example.ios")
                        .setAppStoreId("123456789")
                        .setMinimumVersion("1.0.1")
                        .build())
        .setGoogleAnalyticsParameters(
                DynamicLink.GoogleAnalyticsParameters.Builder()
                        .setSource("orkut")
                        .setMedium("social")
                        .setCampaign("example-promo")
                        .build())
        .setItunesConnectAnalyticsParameters(
                DynamicLink.ItunesConnectAnalyticsParameters.Builder()
                        .setProviderToken("123456")
                        .setCampaignToken("example-promo")
                        .build())
        .setSocialMetaTagParameters(
                DynamicLink.SocialMetaTagParameters.Builder()
                        .setTitle("Example of a Dynamic Link")
                        .setDescription("This link works whether the app is installed or not!")
                        .build())
        .buildDynamicLink() // Or buildShortDynamicLink()

Você pode definir os parâmetros de link dinâmico com os seguintes métodos:

Parâmetros de link dinâmico
setLink

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.

setDomainUriPrefix 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
AndroidParameters
setFallbackUrl 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 Web para dispositivos móveis com o conteúdo ou exibir uma página promocional para o app.
setMinimumVersion 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.
IosParameters
setAppStoreId O código da App Store do seu app, usado para direcionar os usuários à App Store quando o app não estiver instalado.
setFallbackUrl 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 Web para dispositivos móveis com o conteúdo ou exibir uma página promocional para o app.
setCustomScheme O esquema de URL personalizado do seu app, se definido de modo diferente do código de pacote do seu app.
setIpadFallbackUrl 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 Web com o conteúdo ou exibir uma página promocional para o app.
setIpadBundleId O código de pacote do app para iOS a ser usado em iPads para abrir o link. O app precisa estar conectado ao seu projeto a partir da Página de visão geral no Console do Firebase.
setMinimumVersion O número da versão mínima do seu app que pode abrir o link. Essa sinalização é transmitida para o seu app no momento em que ele é aberto, e seu app precisa decidir o que fazer.
NavigationInfoParameters
setForcedRedirectEnabled 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.
SocialMetaTagParameters
setTitle O título a ser usado quando o link dinâmico é compartilhado em uma postagem social.
setDescription A descrição a ser usada quando o link dinâmico é compartilhado em uma postagem social.
setImageUrl 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.
GoogleAnalyticsParameters
setSource
setMedium
setCampaign
setTerm
setContent
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, bem como anexados ao payload do link.
ItunesConnectAnalyticsParameters
setProviderToken
setAffiliateToken
setCampaignToken
Parâmetros de análise 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, use setLongLink para especificar o URL do link em vez de configurar parâmetros com os métodos do outro builder:

Java
Android

Task<ShortDynamicLink> shortLinkTask = FirebaseDynamicLinks.getInstance().createDynamicLink()
        .setLongLink(Uri.parse("https://example.page.link/?link=https://www.example.com/&apn=com.example.android&ibn=com.example.ios"))
        .buildShortDynamicLink()
        .addOnCompleteListener(this, new OnCompleteListener<ShortDynamicLink>() {
            @Override
            public void onComplete(@NonNull Task<ShortDynamicLink> task) {
                if (task.isSuccessful()) {
                    // Short link created
                    Uri shortLink = task.getResult().getShortLink();
                    Uri flowchartLink = task.getResult().getPreviewLink();
                } else {
                    // Error
                    // ...
                }
            }
        });

Kotlin
Android

val shortLinkTask = FirebaseDynamicLinks.getInstance().createDynamicLink()
        .setLongLink(Uri.parse("https://example.page.link/?link=" +
                "https://www.example.com/&apn=com.example.android&ibn=com.example.ios"))
        .buildShortDynamicLink()
        .addOnSuccessListener { result ->
            // Short link created
            val shortLink = result.shortLink
            val flowchartLink = result.previewLink
        }
        .addOnFailureListener {
            // Error
            // ...
        }