Node.js

Use o Vonage Client SDK

É hora de concluir a autenticação silenciosa corretamente, fazendo com que o aplicativo para Android chame o check_url usando a rede móvel e, em seguida, enviando o resultado code de volta ao backend por meio de /check-code.

Em vez de usar OkHttp para ligar check_url, vamos usar o Vonage Client SDK, pois a autenticação silenciosa depende do contexto da rede móvel (roteamento da operadora, identidade do SIM/da rede), e a solicitação pode ser feita por Wi-Fi, o que vai contra o objetivo da autenticação silenciosa.

O Vonage Client SDK foi criado justamente para resolver isso:

Isso pode forçar a solicitação a ser feita por meio de dados móveis (ou usar a rota de rede correta)
Ele lida com redirecionamentos e detalhes de solicitações da maneira esperada pelo Silent Auth
Ele oferece uma resposta estruturada para que você possa extrair o code de forma organizada

Nesta seção, vamos criar o seguinte:

Se check_url se existir, acesse-o pelo celular usando o Vonage Client SDK.
Trecho code a partir da resposta.
Enviar { request_id, code } para o backend por meio de /check-code.
Se a autenticação silenciosa falhar, recorra ao SMS:
- chamada /next (fazemos o possível para não ficarmos esperando cerca de 20 segundos).
- exibir a interface do usuário do código SMS.

Adicionar a dependência do Vonage Client SDK

Adicione a dependência ao projeto atual. Abra seu build.gradle.kts e acrescente:

implementation 'com.vonage:client-library:1.0.1'

Depois de adicioná-lo, sincronize o Gradle.

Inicializar o SDK

Inicialize o SDK uma vez em MainActivity.onCreate():

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // Needed for Silent Auth cellular requests
        VGCellularRequestClient.initializeSdk(this.applicationContext)

        setContent { VerifyApp() }
    }
}

É seguro fazer isso na inicialização e assim evita-se esquecer mais tarde.

Implementar `checkSilentAuth(checkUrl)` Como usar o SDK

Adicione esta função ao seu MainActivity.kt.. Ele realiza uma solicitação GET por rede celular para check_url, segue redirecionamentos e extrai code a partir da resposta JSON.

import com.vonage.clientlibrary.VGCellularRequestClient
import com.vonage.clientlibrary.VGCellularRequestParameters
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import java.io.IOException

private suspend fun checkSilentAuth(url: String): String = withContext(Dispatchers.IO) {
    val params = VGCellularRequestParameters(
        url = url,
        headers = mapOf(),
        queryParameters = mapOf(),
        maxRedirectCount = 10
    )

    val response = VGCellularRequestClient.getInstance()
        .startCellularGetRequest(params, false)

    val httpStatus = response.optInt("http_status", -1)
    val sdkError = response.optString("error", "")

    if (sdkError.isNotEmpty()) {
        throw IOException("Silent Auth SDK error: $sdkError")
    }

    if (httpStatus !in 200..299) {
        val rawBody = response.optString("response_raw_body", "")
        throw IOException("Silent Auth failed: HTTP $httpStatus - ${rawBody.take(200)}")
    }

    val bodyJsonObj = response.optJSONObject("response_body")
    val code = bodyJsonObj?.optString("code", null)

    if (code.isNullOrBlank()) {
        throw IOException("Silent Auth response missing 'code'")
    }

    code
}

O método retorna um code string que seu backend possa validar POST /check-code.

Atualize o fluxo “Iniciar verificação” para tentar a autenticação silenciosa

Agora, substitua a lógica “sempre forçar o recurso alternativo por SMS” da seção anterior por:

Experimente o Silent Auth se check_url está presente
Se falhar, acione /next (melhor esforço) e exibir a interface do usuário do SMS

Conceitualmente:

POST /verification → (request_id, check_url?)
Se check_url existe:
- code = checkSilentAuth(check_url)
- POST /check-code com (request_id, code)
Se isso não der certo:
- chamada POST /next (otimização opcional da experiência do usuário)
- exibir a interface do usuário do SMS

Aqui está a parte principal que você deve usar dentro do seu botão do Compose onClick (dentro de uma corrotina):

val start = startVerification(phone)
val requestId = start.requestId
val checkUrl = start.checkUrl

if (!checkUrl.isNullOrBlank()) {
    statusMessage = "Attempting Silent Authentication..."

    try {
        val codeFromSa = checkSilentAuth(checkUrl)
        val result = submitCode(requestId, codeFromSa)

        if (result.verified) {
            uiState = VerifyUiState.Verified("Silent Authentication")
            statusMessage = "Verified via Silent Authentication"
        } else {
            // Silent Auth did not complete successfully
            uiState = VerifyUiState.EnterSms(requestId)
            statusMessage = "Silent Auth didn't complete. Please enter the SMS code."
        }
    } catch (e: Exception) {
        // Silent Auth failed quickly: force fallback so we don't wait ~20 seconds
        statusMessage = "Silent Auth failed. Please enter the SMS code."

        try {
            requestNextWorkflow(requestId)
        } catch (fallbackError: Exception) {
            // Ignore fallback error, just proceed to SMS
        }

        uiState = VerifyUiState.EnterSms(requestId)
    }
} else {
    // No check_url: Silent Auth not available. Go straight to SMS.
    uiState = VerifyUiState.EnterSms(requestId)
    statusMessage = "Silent Authentication is not available. Please enter the SMS code."
}