Kotlin: implementação de deep links e navegação dinâmica

Se você deseja melhorar a experiência do usuário e tornar seu aplicativo mais fluido e inteligente, este guia é para você. Vamos explorar como implementar essas ferramentas no Kotlin, de maneira prática e didática.

O que são deep links e navegação dinâmica?

Deep links: direcionando com precisão

• E-mail marketing: imagine um e-mail promocional com um link que leva diretamente à página de detalhes de um novo curso de Kotlin.

• Notificações push: um lembrete enviado ao usuário, que o redireciona para uma oferta limitada em um app de e-commerce.

• Compartilhamento em redes sociais: usuários compartilhando conteúdo específico do aplicativo, como um artigo, curso ou evento.

1. Melhoria na experiência do usuário: os usuários chegam rapidamente ao que precisam, reduzindo atritos e aumentando a satisfação.

2. Aumento da taxa de conversão: ao levar o usuário diretamente para páginas específicas, as chances de ele completar uma ação aumentam significativamente.

3. Análise e rastreamento eficazes: é possível monitorar de onde os usuários vêm e medir a eficácia de campanhas de marketing.

Se você deseja criar aplicativos mais inteligentes e engajadores, deep links são uma ferramenta essencial.

Navegação dinâmica: personalizando a jornada do usuário

• Usuário não logado: ele é redirecionado para uma tela de login antes de acessar o conteúdo.

• Usuário logado: o app o leva diretamente à página do curso ou ao próximo passo de sua jornada.

1. Criação de fluxos adaptáveis: seja um onboarding diferenciado ou um fluxo de compras mais intuitivo, você pode criar experiências únicas.

2. Integração com testes A/B: permite testar diferentes fluxos para otimizar o comportamento do usuário.

3. Modularização e manutenção: fluxos dinâmicos tornam o aplicativo mais fácil de modificar e escalar, especialmente em projetos grandes.

Como deep links e navegação dinâmica trabalham juntos?

1. Um deep link direciona o usuário para a página de um curso.

2. A navegação dinâmica decide o próximo passo com base em:
• Estado do usuário: está logado? É assinante?
• Dados recebidos: o ID do curso ou parâmetros específicos no link.
• Preferências do usuário: configurações personalizadas para exibir conteúdos relevantes.

Agora que você já entende o que são deep links e navegação dinâmica, vamos configurar o ambiente para começar a implementá-los no seu projeto Kotlin.

Preparando o terreno: configurando o ambiente

1. Adicionar as dependências

implementation "androidx.navigation:navigation-fragment-ktx:2.5.3"
implementation "androidx.navigation:navigation-ui-ktx:2.5.3"

2. Configurar o AndroidManifest.xml

<activity
    android:name=".MainActivity"
    android:exported="true">
    <intent-filter>
        <action android:name="android.intent.action.VIEW" />
        <category android:name="android.intent.category.DEFAULT" />
        <category android:name="android.intent.category.BROWSABLE" />
        <data
            android:scheme="rocketseat"
            android:host="curso"
            android:pathPrefix="/kotlin" />
    </intent-filter>
</activity>

• Define um deep link que usa o esquema rocketseat, com o host curso e um caminho específico (/kotlin).

• Permite que o link abra diretamente a tela inicial do seu aplicativo quando clicado.

Não esqueça de testar o link para garantir que ele esteja funcionando como esperado. Use o ADB (Android Debug Bridge) ou clique diretamente no link no navegador.

3. Criar o navigation graph

<fragment
    android:id="@+id/courseDetailsFragment"
    android:name="com.rocketseat.app.CourseDetailsFragment"
    android:label="Detalhes do Curso">
    <argument
        android:name="courseId"
        app:argType="string" />
    <deepLink
        app:uri="rocketseat://curso/kotlin?courseId={courseId}" />
</fragment>

• O destino courseDetailsFragment é criado para exibir detalhes de um curso específico.

• Um Deep Link dinâmico é configurado para receber o parâmetro courseId, permitindo que a tela se ajuste ao conteúdo específico.

Implementando deep links no Kotlin

Processando deep links no Kotlin

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        handleDeepLink(intent)
    }

    override fun onNewIntent(intent: Intent?) {
        super.onNewIntent(intent)
        handleDeepLink(intent)
    }

    private fun handleDeepLink(intent: Intent?) {
        intent?.data?.let { uri ->
            val courseId = uri.getQueryParameter("courseId")
            val bundle = Bundle().apply {
                putString("courseId", courseId)
            }
            val navController = findNavController(R.id.nav_host_fragment)
            navController.navigate(R.id.courseDetailsFragment, bundle)
        }
    }
}

1. Usamos o método handleDeepLink para capturar o deep link recebido no Intent.

2. Extraímos o parâmetro courseId da URI.

3. Criamos um Bundle com o ID do curso e o enviamos para o NavController, que direciona o usuário para a tela courseDetailsFragment.

Este é o primeiro passo para integrar deep links ao fluxo de navegação do seu aplicativo. Simples e poderoso, ele permite que o usuário seja levado diretamente ao conteúdo desejado.

Navegação dinâmica com Navigation component

class CourseDetailsFragment : Fragment() {
    private val args: CourseDetailsFragmentArgs by navArgs()

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)

        val courseId = args.courseId
        binding.courseTitle.text = "Curso de Kotlin: $courseId"

        binding.nextButton.setOnClickListener {
            if (isUserSubscriber()) {
                findNavController().navigate(R.id.subscriberWelcomeFragment)
            } else {
                findNavController().navigate(R.id.subscriptionOfferFragment)
            }
        }
    }

    private fun isUserSubscriber(): Boolean {
        // Lógica simulada: substitua pela real
        return false
    }
}

1. Capturamos o courseId passado pelo deep link usando navArgs.

2. Exibimos o nome do curso com base no ID recebido.

3. Implementamos uma lógica que verifica se o usuário é assinante. Caso seja, ele é direcionado para subscriberWelcomeFragment. Caso contrário, é redirecionado para subscriptionOfferFragment.

A combinação de deep links e navegação dinâmica permite criar experiências de navegação fluidas e personalizadas. Assim, o fluxo do aplicativo se adapta automaticamente às necessidades e ao contexto de cada usuário.

Explorando tópicos avançados

1. App Links: segurança com HTTPS

• Maior confiabilidade: links HTTPS são amplamente reconhecidos e seguros.

• Experiência contínua: se o aplicativo não estiver instalado, o usuário pode ser redirecionado para o site correspondente.

1. Configure o arquivo assetlinks.json no seu servidor para associar seu domínio ao aplicativo.

2. Atualize o AndroidManifest.xml para suportar App Links com o atributo android:autoVerify="true".

2. Firebase Dynamic Links: persistência e rastreamento

• Persistência: o link permanece funcional mesmo após a instalação do app.

• Rastreamento avançado: saiba de onde vêm os cliques, permitindo otimizar campanhas de marketing.

1. Integre o Firebase ao seu projeto.

2. Configure os links dinâmicos diretamente no console do Firebase.

3. Use o SDK do Firebase para gerenciar a navegação no app.

3. Feature modules: escalabilidade com modularização

• Cada módulo gerencia uma funcionalidade específica do app (ex.: cursos, perfil do usuário).

• Os deep links podem ser configurados para abrir destinos em módulos separados.

• Isso torna o aplicativo mais leve, reduzindo o tamanho do APK inicial.

Com essas abordagens avançadas, você eleva o nível do seu aplicativo Android, integrando segurança, rastreamento e modularização de forma inteligente e eficaz.

Conclusão