Node.js

Utiliser le Client SDK de Vonage

Il est temps de compléter correctement l'authentification silencieuse en demandant à l'application Android d'appeler la fonction check_url en utilisant le réseau mobile, puis en envoyant le résultat code vers le backend via /check-code.

Plutôt que d'utiliser OkHttp pour appeler check_urlNous utiliserons le Client SDK de Vonage parce que l'authentification silencieuse dépend du contexte du réseau mobile (routage de l'opérateur, identité SIM/réseau) et que la demande peut passer par le Wi-Fi, ce qui va à l'encontre de l'objectif de l'authentification silencieuse.

Le Client SDK de Vonage existe pour résoudre exactement ce problème :

Il peut forcer la demande à passer par les données cellulaires (ou utiliser la bonne route réseau).
Il gère les redirections et les détails de la demande de la manière attendue par Silent Auth
Il vous donne une réponse structurée qui vous permet d'extraire les éléments suivants code proprement

Dans cette section, nous construisons ce qui suit :

Si check_url existe, appelez-le à partir du téléphone en utilisant le Vonage Client SDK.
Extrait code de la réponse.
Envoyer { request_id, code } vers le backend via /check-code.
En cas d'échec de l'authentification silencieuse, il faut revenir au SMS :
- appel /next (meilleur effort, donc nous n'attendons pas ~20 secondes).
- afficher l'interface utilisateur du code SMS.

Ajouter la dépendance du Client SDK de Vonage

Ajouter la dépendance au projet en cours. Ouvrez votre build.gradle.kts et ajouter :

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

Après l'avoir ajouté, synchronisez Gradle.

Initialiser le SDK

Initialiser le SDK une fois dans 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() }
    }
}

Il s'agit d'une opération sûre à effectuer au démarrage et qui permet d'éviter les oublis ultérieurs.

Mettre en œuvre `checkSilentAuth(checkUrl)` Utiliser le SDK

Ajoutez cette fonction à votre MainActivity.kt.. Il effectue une requête GET cellulaire à check_urlsuit les redirections, et extrait code de la réponse 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
}

La méthode renvoie un code que votre backend peut valider avec POST /check-code.

Mise à jour du flux "Démarrer la vérification" pour tenter l'authentification silencieuse

Remplacez maintenant la logique "toujours forcer le repli par SMS" de la section précédente par :

Essayez l'authentification silencieuse si check_url est présent
En cas d'échec, déclencher /next (best-effort) et afficher l'interface utilisateur SMS

Sur le plan conceptuel :

POST /verification → (request_id, check_url?)
Si check_url existent :
- code = checkSilentAuth(check_url)
- POST /check-code avec (request_id, code)
En cas d'échec :
- appel POST /next (optimisation UX optionnelle)
- afficher l'interface utilisateur SMS

Voici la partie principale que vous devez utiliser dans votre bouton Compose onClick (à l'intérieur d'une 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."
}

Premiers pas avec l'authentification silencieuse

L'authentification silencieuse est assez difficile à comprendre. Ce tutoriel vous montre comment construire une intégration à partir de zéro avec Nodejs et Kotlin.

Disponible sur :

Node.js

Étapes

Introduction

Prérequis pour le backend

Mise en place de l'environnement

Configurer vos informations d'identification Vonage

Ajouter l'API Verify de Vonage au backend

Tester le backend

Conditions préalables pour l'application mobile

Mise en place de l'environnement

Créer une application Android de base