Configurar o ambiente do aplicativo móvel

Nesta parte, vamos criar um aplicativo Android moderno usando Kotlin e Jetpack Compose para a interface do usuário, que servirá como modelo para o próximo módulo, no qual o aplicativo se comunicará com o backend (que criamos anteriormente). O backend se comunicará com o Vonage Verify.

Visão geral do fluxo do aplicativo

O aplicativo seguirá este fluxo:

1. O usuário digita seu número de telefone.
2. O aplicativo envia o número de telefone para o backend (POST /verification).
3. Se a autenticação silenciosa for bem-sucedida, o usuário é verificado.
4. Se isso não funcionar (ou não estiver disponível), o usuário será solicitado a fornecer o código por SMS.
5. O aplicativo envia o código para o backend (POST /check-code).
6. O aplicativo exibe o resultado da verificação.

Criar o projeto Android

1. Abra o Android Studio.

2. Clique Novo projeto → Atividade de criação vazia.

3. Use estas configurações:

   • Nome: Verify2FADemo
   • Idioma: Kotlin
   • SDK mínimo: API 24 (Android 7.0)

4. Clique Concluir e aguarde até que a sincronização do Gradle seja concluída.

Configurar as dependências do Android

Abrir app/build.gradle.kts e adicione (ou atualize) as seguintes dependências.

dependencies {
    // Jetpack Compose (UI)
    implementation("androidx.activity:activity-compose:1.12.3")
    implementation(platform("androidx.compose:compose-bom:2026.01.01"))
    implementation("androidx.compose.ui:ui")
    implementation("androidx.compose.material3:material3")

    // Networking + JSON parsing
    implementation("com.squareup.okhttp3:okhttp:5.3.2")
    implementation("com.google.code.gson:gson:2.13.2")

    // Coroutines (we'll use these for background networking)
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.10.2")
}

Vale a pena explicar isso aos leitores que ainda não estão familiarizados com o mundo dos dispositivos móveis:

• Bibliotecas de composição: Criar uma interface de usuário com funções em Kotlin em vez de layouts em XML (menos código repetitivo, mais fácil de acompanhar em um tutorial).

• OkHttp: Um cliente HTTP confiável para se comunicar com seu backend. (O Android não vem com um cliente HTTP moderno e “bom” por padrão.)

• Gson: Converte objetos Kotlin/Java ↔ JSON para que você não precise criar manualmente strings JSON em todos os lugares.

• Corrotinas: Os aplicativos Android não devem bloquear a thread principal. As corrotinas nos permitem realizar operações de rede em segundo plano e atualizar a interface do usuário com segurança.

Depois de editar o arquivo, clique em Sincronizar agora.

Permissões de Internet e rede local

Em AndroidManifest.xml, adicione isso dentro do <manifest> tag:

<uses-permission android:name="android.permission.INTERNET" />

Sem isso, o Android simplesmente bloqueará todas as chamadas de rede de saída.

Se você chamar um backend por conexão simples http://... (não HTTPS), o Android pode bloqueá-lo, dependendo do SDK de destino e das configurações de segurança de rede.

Para o desenvolvimento local, você pode permitir o tráfego em texto simples adicionando isto ao arquivo <application> tag:

<application
     android:usesCleartextTraffic="true"
   ... >

Armazenar a configuração do backend da loja em local.properties

Codificar URLs diretamente nos arquivos Kotlin é frágil e inseguro.
Em vez disso, vamos armazenar a URL do backend em local.properties, que é:

• Não foi enviado para o Git
• Específico do ambiente
• Projetado para configuração local

Abrir (ou criar) local.properties na raiz do projeto Android e adicione:

BACKEND_URL=http://your-backend-ip:3000

Em seguida, disponibilizamos esse valor para o aplicativo Android por meio de BuildConfig.

Em app/build.gradle.kts, acrescente:

android {
    defaultConfig {
        buildConfigField(
            "String",
            "BACKEND_URL",
            "\"${project.findProperty("BACKEND_URL")}\""
        )
    }
}

Em seguida, sincronize o Gradle novamente. Isso gera:

BuildConfig.BACKEND_URL

que podemos usar com segurança no código Kotlin.