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

Configure o Firebase e o SDK do Dynamic Links

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.

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

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:

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

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
    // ...
}
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, 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 :

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

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:

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 parâmetros do Dynamic Link com os seguintes métodos:

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

Encurte um link dinâmico longo

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:

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