Crie links dinâmicos no Android

Você pode criar links dinâmicos curtos ou longos com a API Firebase Dynamic Links Builder. Esta API aceita um link dinâmico longo ou um objeto contendo parâmetros de link dinâmico e retorna URLs como nos exemplos a seguir:

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

Antes de criar links dinâmicos em seu aplicativo Android, você deve incluir o SDK do Firebase. Se seu aplicativo estiver configurado para receber links dinâmicos, você já concluiu essas etapas e pode pular esta seção.

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

    Ao registrar seu aplicativo, especifique sua chave de assinatura SHA-1. Se você usa App Links, especifique também sua chave SHA-256.

  2. No arquivo Gradle do módulo (nível do aplicativo) (geralmente <project>/<app-module>/build.gradle.kts ou <project>/<app-module>/build.gradle ), adicione a dependência para os Dynamic Links biblioteca para Android. Recomendamos usar o Firebase Android BoM para controlar o controle de versão da biblioteca.

    Para uma experiência ideal com Dynamic Links, recomendamos ativar o Google Analytics em seu projeto do Firebase e adicionar o SDK do Firebase para Google Analytics ao seu aplicativo.

    dependencies {
        // Import the BoM for the Firebase platform
        implementation(platform("com.google.firebase:firebase-bom:32.8.0"))
    
        // Add the dependencies for the Dynamic Links and Analytics libraries
        // When using the BoM, you don't specify versions in Firebase library dependencies
        implementation 'com.google.firebase:firebase-dynamic-links'
        implementation 'com.google.firebase:firebase-analytics'
    }
    

    Ao usar o Firebase Android BoM , seu aplicativo sempre usará versões compatíveis das bibliotecas do Firebase Android.

    (Alternativa) Adicionar dependências da biblioteca Firebase sem usar o BoM

    Se você optar por não usar o Firebase BoM, deverá especificar cada versão da biblioteca do Firebase em sua linha de dependência.

    Observe que se você usa várias bibliotecas do Firebase no seu aplicativo, é altamente recomendável usar a BoM para gerenciar as versões da biblioteca, o que garante que todas as versões sejam compatíveis.

    dependencies {
        // Add the dependencies for the Dynamic Links and Analytics libraries
        // When NOT using the BoM, you must specify versions in Firebase library dependencies
        implementation 'com.google.firebase:firebase-dynamic-links:21.2.0'
        implementation 'com.google.firebase:firebase-analytics:21.6.1'
    }
    
    Procurando um módulo de biblioteca específico para Kotlin? A partir de outubro de 2023 (Firebase BoM 32.5.0) , tanto os desenvolvedores Kotlin quanto os Java podem depender do módulo da biblioteca principal (para obter detalhes, consulte o FAQ sobre esta iniciativa ).
  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 domínio para seus Dynamic Links, faça-o quando solicitado.

    Se você já possui um domínio Dynamic Links, anote-o. Você precisa fornecer um domínio Dynamic Links ao criar Dynamic Links programaticamente.

  5. Recomendado : especifique os padrões de URL permitidos em seus links diretos e links substitutos. Ao fazer isso, você evita que partes não autorizadas criem links dinâmicos que redirecionem do seu domínio para sites que você não controla. Consulte Permitir padrões de URL específicos .

Usar o console do Firebase

Se você deseja gerar um único link dinâmico, seja para fins de teste ou para que sua equipe de marketing crie facilmente um link que possa ser usado em algo como uma postagem em mídia social, a maneira mais simples seria visitar o console do Firebase e criar um manualmente seguindo o passo a passo.

Para criar um Dynamic Link, crie um novo objeto DynamicLink com seu Builder, especificando os parâmetros do Dynamic Link com os métodos Builder. Em seguida, chame buildDynamicLink ou buildShortDynamicLink .

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

Kotlin+KTX

val dynamicLink = Firebase.dynamicLinks.dynamicLink {
    link = Uri.parse("https://www.example.com/")
    domainUriPrefix = "https://example.page.link"
    // Open links with this app on Android
    androidParameters { }
    // Open links with com.example.ios on iOS
    iosParameters("com.example.ios") { }
}

val dynamicLinkUri = dynamicLink.uri

Java

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

Para criar um link dinâmico curto, crie um DynamicLink da mesma maneira e chame buildShortDynamicLink . Construir um link curto requer uma chamada de rede, portanto, em vez de retornar o link diretamente, buildShortDynamicLink retorna um Task , que disponibiliza o link curto quando a solicitação for concluída. Por exemplo:

Kotlin+KTX

val shortLinkTask = Firebase.dynamicLinks.shortLinkAsync {
    link = Uri.parse("https://www.example.com/")
    domainUriPrefix = "https://example.page.link"
    // Set parameters
    // ...
}.addOnSuccessListener { (shortLink, flowchartLink) ->
    // You'll need to import com.google.firebase.dynamiclinks.component1 and
    // com.google.firebase.dynamiclinks.component2

    // Short link created
    processShortLink(shortLink, flowchartLink)
}.addOnFailureListener {
    // Error
    // ...
}

Java

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
                    // ...
                }
            }
        });

Por padrão, links dinâmicos curtos são gerados com sufixos de link de 17 caracteres que tornam extremamente improvável que alguém consiga adivinhar um link dinâmico válido. Se, para o seu caso de uso, não houver mal nenhum em alguém adivinhar com sucesso um link curto, você pode preferir gerar sufixos que sejam tão longos quanto necessário para serem únicos, o que você pode fazer passando ShortDynamicLink.Suffix.SHORT para o método buildShortDynamicLink :

Kotlin+KTX

val shortLinkTask = Firebase.dynamicLinks.shortLinkAsync(ShortDynamicLink.Suffix.SHORT) {
    // Set parameters
    // ...
}

Java

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

Você pode usar a API Dynamic Link Builder para criar links dinâmicos com qualquer um dos parâmetros suportados. Consulte a referência da API para obter detalhes.

O exemplo a seguir cria um link dinâmico com vários parâmetros comuns definidos:

Kotlin+KTX

val dynamicLink = Firebase.dynamicLinks.dynamicLink { // or Firebase.dynamicLinks.shortLinkAsync
    link = Uri.parse("https://www.example.com/")
    domainUriPrefix = "https://example.page.link"
    androidParameters("com.example.android") {
        minimumVersion = 125
    }
    iosParameters("com.example.ios") {
        appStoreId = "123456789"
        minimumVersion = "1.0.1"
    }
    googleAnalyticsParameters {
        source = "orkut"
        medium = "social"
        campaign = "example-promo"
    }
    itunesConnectAnalyticsParameters {
        providerToken = "123456"
        campaignToken = "example-promo"
    }
    socialMetaTagParameters {
        title = "Example of a Dynamic Link"
        description = "This link works whether the app is installed or not!"
    }
}

Java

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

Você pode definir parâmetros do Dynamic Link com os seguintes métodos:

Parâmetros DynamicLink
definirLink

O link que seu aplicativo será aberto. Especifique um URL que seu aplicativo possa manipular, normalmente o conteúdo ou a carga útil do aplicativo, que inicia uma lógica específica do aplicativo (como creditar um cupom ao usuário ou exibir uma tela de boas-vindas). Este link deve ser um URL bem formatado, codificado corretamente em URL, usar HTTP ou HTTPS e não pode ser outro link dinâmico.

setDomainUriPrefix Seu prefixo de URL do link dinâmico, que você pode encontrar no console do Firebase. Um domínio Dynamic Link se parece com os seguintes exemplos:
https://example.com/link
https://example.page.link
Parâmetros Android
definirFallbackUrl O link a ser aberto quando o aplicativo não estiver instalado. Especifique isso para fazer algo diferente de instalar seu aplicativo da Play Store quando o aplicativo não estiver instalado, como abrir a versão web móvel do conteúdo ou exibir uma página promocional para seu aplicativo.
setMinimumVersion O versionCode da versão mínima do seu aplicativo que pode abrir o link. Caso o app instalado seja de uma versão mais antiga, o usuário é levado à Play Store para atualizar o app.
Parâmetros Ios
setAppStoreId O ID da App Store do seu aplicativo, usado para enviar usuários à App Store quando o aplicativo não está instalado
definirFallbackUrl O link a ser aberto quando o aplicativo não estiver instalado. Especifique isso para fazer algo diferente de instalar seu aplicativo da App Store quando o aplicativo não estiver instalado, como abrir a versão web móvel do conteúdo ou exibir uma página promocional para seu aplicativo.
definirCustomScheme O esquema de URL personalizado do seu aplicativo, se definido como algo diferente do ID do pacote do seu aplicativo
setIpadFallbackUrl O link para abrir em iPads quando o aplicativo não estiver instalado. Especifique isso para fazer algo diferente de instalar seu aplicativo da App Store quando o aplicativo não estiver instalado, como abrir a versão web do conteúdo ou exibir uma página promocional para seu aplicativo.
setIpadBundleId O ID do pacote do aplicativo iOS a ser usado em iPads para abrir o link. O aplicativo deve estar conectado ao seu projeto na página Visão geral do console do Firebase.
setMinimumVersion O número da versão mínima do seu aplicativo que pode abrir o link. Esse sinalizador é passado para seu aplicativo quando ele é aberto, e seu aplicativo deve decidir o que fazer com ele.
Parâmetros de informações de navegação
setForcedRedirectEnabled Se definido como '1', pule a página de visualização do aplicativo quando o link dinâmico for aberto e, em vez disso, redirecione para o aplicativo ou loja. A página de visualização do aplicativo (ativada por padrão) pode enviar os usuários de maneira mais confiável ao destino mais apropriado quando eles abrem links dinâmicos em aplicativos; no entanto, se você espera que um link dinâmico seja aberto apenas em aplicativos que podem abrir links dinâmicos de maneira confiável sem essa página, você pode desativá-lo com este parâmetro. Este parâmetro afetará o comportamento do Dynamic Link apenas no iOS.
Parâmetros SocialMetaTag
definirTítulo O título a ser usado quando o link dinâmico é compartilhado em uma postagem social.
setDescrição A descrição a ser usada quando o link dinâmico é compartilhado em uma postagem social.
setImageUrl O URL de uma imagem relacionada a este link. A imagem deve ter pelo menos 300x200 px e menos de 300 KB.
Parâmetros do GoogleAnalytics
definir Fonte
setMédio
setCampaign
definirTermo
setContent
Parâmetros analíticos do Google Play. Esses parâmetros ( utm_source , utm_medium , utm_campaign , utm_term , utm_content ) são passados ​​para a Play Store e também anexados à carga útil do link.
Parâmetros ItunesConnectAnalytics
setProviderToken
setAffiliateToken
setCampaignToken
Parâmetros analíticos do iTunes Connect. Esses parâmetros ( pt , at , ct ) são passados ​​para a App Store.

Para encurtar um link dinâmico longo, especifique a URL do link dinâmico usando setLongLink em vez de definir parâmetros com outros métodos do construtor:

Kotlin+KTX

val shortLinkTask = Firebase.dynamicLinks.shortLinkAsync {
    longLink = Uri.parse(
        "https://example.page.link/?link=" +
            "https://www.example.com/&apn=com.example.android&ibn=com.example.ios",
    )
}.addOnSuccessListener { (shortLink, flowChartLink) ->
    // You'll need to import com.google.firebase.dynamiclinks.component1 and
    // com.google.firebase.dynamiclinks.component2

    // Short link created
    processShortLink(shortLink, flowChartLink)
}.addOnFailureListener {
    // Error
    // ...
}

Java

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
                    // ...
                }
            }
        });