Criar Dynamic Links no Android

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

Configurar o Firebase e o SDK do Dynamic Links

Antes de criar Dynamic Links no app Android, inclua o SDK do Firebase. Caso seu app esteja configurado para receber Dynamic Links, então você já concluiu as etapas abaixo 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 arquivo Gradle do módulo (nível do app) (geralmente <project>/<app-module>/build.gradle.kts ou <project>/<app-module>/build.gradle), adicione a dependência da biblioteca Android do Dynamic Links. Para gerenciar o controle de versões das bibliotecas, recomendamos usar a BoM do Firebase para Android.

   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.

   Kotlin+KTX

   dependencies {
       // Import the BoM for the Firebase platform
       implementation(platform("com.google.firebase:firebase-bom:32.3.1"))
   
       // 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-ktx'
       implementation 'com.google.firebase:firebase-analytics-ktx'
   }
   

   Com a BoM do Firebase para Android, seu app sempre vai usar versões compatíveis das bibliotecas do Firebase para Android.

   (Alternativa) Adicionar dependências das bibliotecas do Firebase sem usar a BoM

   Se você preferir não usar a BoM do Firebase, especifique cada versão das bibliotecas do Firebase na linha de dependência correspondente.

   Se você usa várias bibliotecas do Firebase no seu app, recomendamos utilizar a BoM para gerenciar as versões delas, porque isso ajuda a garantir a compatibilidade de todas as bibliotecas.

   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-ktx:21.1.0'
       implementation 'com.google.firebase:firebase-analytics-ktx:21.3.0'
   }
   

   Java

   dependencies {
       // Import the BoM for the Firebase platform
       implementation(platform("com.google.firebase:firebase-bom:32.3.1"))
   
       // 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'
   }
   

   Com a BoM do Firebase para Android, seu app sempre vai usar versões compatíveis das bibliotecas do Firebase para Android.

   (Alternativa) Adicionar dependências das bibliotecas do Firebase sem usar a BoM

   Se você preferir não usar a BoM do Firebase, especifique cada versão das bibliotecas do Firebase na linha de dependência correspondente.

   Se você usa várias bibliotecas do Firebase no seu app, recomendamos utilizar a BoM para gerenciar as versões delas, porque isso ajuda a garantir a compatibilidade de todas as bibliotecas.

   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.1.0'
       implementation 'com.google.firebase:firebase-analytics:21.3.0'
   }
   

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

   

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 Dynamic Links que redirecionam para sites que você não controla no seu domínio. Consulte Permitir padrões de URL específicos.

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.

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

Para gerar um link dinâmico, crie um novo objeto DynamicLink usando o builder e, com os métodos dele, especifique os parâmetros. Em seguida, chame buildDynamicLink ou buildShortDynamicLink.

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

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
MainActivity.kt

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();
MainActivity.java

Para gerar um link dinâmico curto, crie um DynamicLink da mesma forma e chame buildShortDynamicLink. A criação de um link curto requer uma chamada de rede. Por isso, em vez de gerar o link diretamente, buildShortDynamicLink retorna um Task, disponibilizando o link curto quando a solicitação é concluída. Exemplo:

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.ktx.component1 and
    // com.google.firebase.dynamiclinks.ktx.component2

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

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

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 há problemas em um usuário conseguir descobrir um link curto no seu caso de uso, convém gerar sufixos longos o suficiente para serem exclusivos. Nesse caso, basta enviar ShortDynamicLink.Suffix.SHORT ao método buildShortDynamicLink:

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

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

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

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!"
    }
}
MainActivity.kt

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()
MainActivity.java

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

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

Encurtar um link dinâmico longo

Para encurtar um Dynamic Link longo, especifique o URL dele usando setLongLink em vez de configurar parâmetros com os métodos do outro builder:

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.ktx.component1 and
    // com.google.firebase.dynamiclinks.ktx.component2

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

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