Node.js

Utiliza el Vonage Client SDK

Es hora de completar la Autenticación Silenciosa correctamente haciendo que la aplicación Android llame a la función check_url utilizando la red móvil y enviando el code al backend a través de /check-code.

En lugar de utilizar OkHttp llamar check_urlEn este caso, utilizaremos el Client SDK de Vonage porque la autenticación silenciosa depende del contexto de la red móvil (enrutamiento del operador, identidad de la SIM/red), y la solicitud puede ir a través de Wi-Fi, lo que rompe el propósito de la autenticación silenciosa.

El Vonage Client SDK existe para resolver exactamente esto:

Puede forzar la solicitud a través de datos celulares (o utilizar la ruta de red correcta)
Gestiona los redireccionamientos y los detalles de la solicitud de la forma que Silent Auth espera
Te da una respuesta estructurada para que puedas extraer la code limpiamente

En esta sección vamos a construir lo siguiente:

Si check_url existe, llámalo desde el teléfono usando el Vonage Client SDK.
Extracto code de la respuesta.
Enviar { request_id, code } al backend a través de /check-code.
Si falla la Autenticación Silenciosa, vuelva a SMS:
- llame a /next (mejor esfuerzo, para no esperar ~20 segundos).
- mostrar la interfaz de usuario del código SMS.

Añade la dependencia de Vonage Client SDK

Añade la dependencia al proyecto actual. Abra su build.gradle.kts y añade:

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

Después de añadirlo, sincroniza Gradle.

Inicializar el SDK

Inicialice el SDK una vez en 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() }
    }
}

Esto es seguro hacerlo al inicio y evita olvidarlo más tarde.

Implementar `checkSilentAuth(checkUrl)` Uso del SDK

Añada esta función a su MainActivity.kt.. Realiza una petición GET celular a check_url, sigue las redirecciones y extrae code de la respuesta 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
}

El método devuelve un code que su backend puede validar con POST /check-code.

Actualizar el flujo "Iniciar verificación" para intentar la autenticación silenciosa

Ahora sustituye la lógica de "forzar siempre el SMS fallback" de la sección anterior por:

Pruebe la autenticación silenciosa si check_url está presente
Si falla, activa /next (best-effort) y mostrar SMS UI

Conceptualmente:

POST /verification → (request_id, check_url?)
Si check_url existe:
- code = checkSilentAuth(check_url)
- POST /check-code con (request_id, code)
Si eso falla:
- llame a POST /next (optimización UX opcional)
- mostrar interfaz SMS

Esta es la parte esencial que debe utilizar en el botón Redactar onClick (dentro de una coroutine):

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