Vernetzung zum Backend
Die folgenden Kotlin-Funktionen definieren, wie der mobile Client mit dem Backend-Server kommuniziert, um eine Telefonnummernüberprüfung mithilfe der Verify-API durchzuführen. Dieser Prozess besteht aus drei Hauptschritten:
- Beginnen Sie den Verifizierungsprozess mit der Übermittlung der Telefonnummer.
- Prüfung auf ein Ergebnis der stillen Authentifizierung, die automatisch im Hintergrund erfolgt.
- Übermittlung des Verifizierungscodes (der stillschweigend oder per Fallback, z. B. SMS, empfangen wird), um die Verifizierung abzuschließen.
Jede Funktion läuft innerhalb einer Coroutine und führt Netzwerkoperationen auf dem IO dispatcher um ein Blockieren des Haupt-Threads zu vermeiden.
Überprüfung starten
Diese Funktion leitet den Verifizierungsprozess ein, indem sie die Telefonnummer des Benutzers an das Backend sendet. Das Backend startet dann die Verifizierung über die Vonage Verify API und antwortet mit zwei Werten:
request_id: Ein eindeutiger Bezeichner für die Überprüfungsanfrage.check_url: Eine URL, die verwendet werden kann, um das Ergebnis der stillen Authentifizierung zu überprüfen.
suspend fun startVerification(phoneNumber: String): Pair<String, String> = withContext(Dispatchers.IO) {
val client = OkHttpClient()
// Prepare request JSON body
val requestJson = mapOf("phone" to phoneNumber)
val requestBody = Gson()
.toJson(requestJson)
.toRequestBody("application/json".toMediaType())
// Make POST request to /verification
val request = Request.Builder()
.url("$BACKEND_URL/verification")
.post(requestBody)
.build()
val response = client.newCall(request).execute()
// Ensure request succeeded
if (!response.isSuccessful) {
throw IOException("Verification failed with code ${response.code}")
}
// Parse response
val responseBody = response.body?.string()
?: throw IOException("Empty response from server")
val json = Gson().fromJson(responseBody, JsonObject::class.java)
// Extract check URL and request ID
val checkUrl = json.get("check_url")?.asString
?: throw IOException("Missing check_url in response")
val requestId = json.get("request_id")?.asString
?: throw IOException("Missing request_id in response")
return@withContext Pair(requestId, checkUrl)
}
Stille Authentifizierung prüfen
Nachdem die Überprüfung eingeleitet wurde, initialisiert diese Funktion die stille Authentifizierung, indem sie eine GET-Anfrage an die check_url früher erhalten. Wenn die stille Authentifizierung erfolgreich ist, antwortet der Server (nach einigen Umleitungen) mit einem Verifizierungscode, mit dem der Verifizierungsprozess abgeschlossen werden kann.
suspend fun checkSilentAuth(checkUrl: String): String = withContext(Dispatchers.IO) {
val client = OkHttpClient()
// Send GET request to check_url
val request = Request.Builder()
.url(checkUrl)
.get()
.build()
val response = client.newCall(request).execute()
if (!response.isSuccessful) {
throw IOException("Silent Auth failed with code ${response.code}")
}
val responseBody = response.body?.string()
?: throw IOException("Empty response from Silent Auth")
val json = Gson().fromJson(responseBody, JsonObject::class.java)
return@withContext json.get("code")?.asString
?: throw IOException("Missing code in Silent Auth response")
}
Code einreichen
Diese Funktion sendet den Verifizierungscode an das Backend, um den Verifizierungsprozess abzuschließen. Das Backend verifiziert den Code mit der Verify-API und antwortet mit einem Booleschen Wert, der angibt, ob die Verifizierung erfolgreich war.
suspend fun submitCode(requestId: String, code: String): Boolean = withContext(Dispatchers.IO) {
val client = OkHttpClient()
val requestJson = mapOf("request_id" to requestId, "code" to code)
val requestBody = Gson()
.toJson(requestJson)
.toRequestBody("application/json".toMediaType())
val request = Request.Builder()
.url("$BACKEND_URL/check-code")
.post(requestBody)
.build()
val response = client.newCall(request).execute()
if (!response.isSuccessful) {
throw IOException("Code verification failed with code ${response.code}")
}
val responseBody = response.body?.string()
?: throw IOException("Empty response from server")
val json = Gson().fromJson(responseBody, JsonObject::class.java)
return@withContext json.get("verified")?.asBoolean ?: false
}
Mit diesen Funktionen kann sich Ihre Android-App mit Ihrem Backend verbinden, um den Prozess der Telefonnummernverifizierung mit Vonage Verify abzuschließen. Der nächste Schritt besteht in der Regel darin, den Erfolg oder Misserfolg in Ihrer Benutzeroberfläche zu behandeln, entsprechende Meldungen anzuzeigen oder den Benutzer entsprechend weiterzuleiten.
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