Node.js

Verwenden Sie das Vonage Client SDK

Es ist nun an der Zeit, die stille Authentifizierung ordnungsgemäß abzuschließen, indem die Android-App die check_url über das Mobilfunknetz und die anschließende Übermittlung der code zurück zum Backend über /check-code.

Anstatt die OkHttp anrufen check_urlWir verwenden das Vonage Client SDK, da die stille Authentifizierung vom Kontext des Mobilfunknetzes abhängt (Routing des Netzbetreibers, SIM-/Netzidentität) und die Anfrage möglicherweise über Wi-Fi erfolgt, was den Zweck der stummen Authentifizierung nicht erfüllt.

Das Vonage Client SDK wurde entwickelt, um genau dieses Problem zu lösen:

Er kann die Anfrage über Mobilfunkdaten erzwingen (oder die korrekte Netzroute verwenden)
Es behandelt Umleitungen und Anfragedetails so, wie es Silent Auth erwartet
Es gibt Ihnen eine strukturierte Antwort, so dass Sie die code sauber

In diesem Abschnitt bauen wir das Folgende:

Wenn check_url vorhanden ist, rufen Sie es mit dem Vonage Client SDK vom Telefon aus auf.
Auszug code aus der Antwort.
Senden Sie { request_id, code } zum Backend über /check-code.
Wenn Silent Auth fehlschlägt, wird auf SMS zurückgegriffen:
- aufrufen /next (best-effort, damit wir nicht ~20 Sekunden warten).
- die SMS-Code-Benutzeroberfläche anzeigen.

Hinzufügen der Vonage Client SDK-Abhängigkeit

Fügen Sie die Abhängigkeit zum aktuellen Projekt hinzu. Öffnen Sie Ihr build.gradle.kts und hinzufügen:

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

Nach dem Hinzufügen synchronisieren Sie Gradle.

Initialisieren des SDK

Initialisieren Sie das SDK einmal in 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() }
    }
}

Dies ist beim Start sicher und verhindert, dass man es später vergisst.

Umsetzung `checkSilentAuth(checkUrl)` Verwendung des SDK

Fügen Sie diese Funktion zu Ihrer MainActivity.kt.. Er führt eine zelluläre GET-Anfrage an check_url, folgt Umleitungen und extrahiert code aus der JSON-Antwort.

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
}

Die Methode gibt ein code Zeichenkette, die Ihr Backend validieren kann mit POST /check-code.

Aktualisieren Sie den Fluss "Überprüfung starten", um eine stille Autorisierung zu versuchen.

Ersetzen Sie nun die Logik "always force SMS fallback" aus dem vorherigen Abschnitt durch:

Versuchen Sie Silent Auth, wenn check_url vorhanden ist
Wenn es fehlschlägt, lösen Sie /next (Best-Effort) und SMS UI anzeigen

Konzeptionell:

POST /verification → (request_id, check_url?)
Wenn check_url existiert:
- code = checkSilentAuth(check_url)
- POST /check-code mit (request_id, code)
Wenn das nicht klappt:
- aufrufen POST /next (optionale UX-Optimierung)
- SMS UI anzeigen

Hier ist der Kernteil, den Sie innerhalb Ihrer Compose-Schaltfläche verwenden sollten onClick (innerhalb einer 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."
}

Erste Schritte mit der stillen Authentifizierung

Silent Authentication ist nicht ganz einfach zu verstehen. Dieses Tutorial zeigt Ihnen, wie Sie eine Integration von Grund auf mit Nodejs und Kotlin erstellen können

Verfügbar am:

Node.js

Schritte

Einführung

Backend-Voraussetzungen

Einrichten der Umgebung

Einrichten Ihrer Vonage-Anmeldeinformationen

Hinzufügen der Vonage Verify API zum Backend

Testen Sie das Backend

Voraussetzungen für die mobile App

Einrichten der Umgebung

Erstellen einer einfachen Android-Applikation