S'authentifier avec Firebase sur Android à l'aide de la validation du numéro de téléphone Firebase

Dans la version Preview publique de Firebase PNV, Firebase Authentication ne peut pas accepter directement un jeton Firebase PNV pour la connexion. Toutefois, vous pouvez permettre aux utilisateurs de se connecter avec Firebase PNV en utilisant la fonctionnalité d'authentification personnalisée de Firebase Authentication.

Créer un point de terminaison d'échange de jetons

L'étape clé de l'implémentation d'une solution d'authentification personnalisée dans Firebase consiste à créer un point de terminaison capable de recevoir un jeton Firebase PNV, de le valider, puis d'émettre un jeton d'authentification personnalisée Firebase. Votre application peut ensuite utiliser ce jeton personnalisé pour connecter l'utilisateur.

Ce point de terminaison peut être hébergé sur n'importe quelle plate-forme, mais dans l'exemple suivant, il est hébergé à l'aide de Cloud Functions pour Firebase :

Node.js

import { JwtVerifier } from "aws-jwt-verify";
import { getApp } from "firebase-admin/app";
import { getAuth, UserRecord } from "firebase-admin/auth";
import { onRequest } from "firebase-functions/https";

// Because we're deploying to Cloud Functions for Firebase, admin credentials
// are automatically available.
const app = getApp();
const authAdmin = getAuth(app);

// Find your Firebase project number in the Firebase console.
const FIREBASE_PROJECT_NUMBER = "123456789";

// The issuer and audience claims of the FPNV token are specific to your
// project.
const issuer = `https://fpnv.googleapis.com/projects/${FIREBASE_PROJECT_NUMBER}`;
const audience = `https://fpnv.googleapis.com/projects/${FIREBASE_PROJECT_NUMBER}`;

// The JWKS URL contains the current public signing keys for FPNV tokens.
const jwksUri = "https://fpnv.googleapis.com/v1beta/jwks";

// Configure a JWT verifier to check the following:
// - The token is signed by Google
// - The issuer and audience claims match your project
// - The token has not yet expired (default begavior)
const fpnvVerifier = JwtVerifier.create({ issuer, audience, jwksUri });

// This Cloud Function is your token exchange endpoint. You pass the endpoint an
// FPNV token, and the Cloud Function verifies it and exchanges it for a
// Firebase Auth token corresponding to the same user.
export const signInWithFpnv = onRequest(async (req, res) => {
    // Get the FPNV token from the request body.
    const fpnvToken = req.body?;
    if (!fpnvToken) {
        res.sendStatus(400);
        return;
    }

    let verifiedPhoneNumber;
    try {
        // Attempt to verify the token using the verifier configured above.
        const verifiedPayload = await fpnvVerifier.verify(fpnvToken);

        // If verification succeeds, the subject claim of the token contains the
        // verified phone number.
        verifiedPhoneNumber = verifiedPayload.sub;
    } catch {
        // If verification fails, reject the token.
        res.sendStatus(403);
        return;
    }

    // Now that you have a verified phone number, look it up in your Firebase
    // project's user database.
    let user: UserRecord;
    try {
        // If a user account already exists with the phone number, retrieve it.
        user = await authAdmin.getUserByPhoneNumber(verifiedPhoneNumber);
    } catch {
        // Otherwise, create a new user account using the phone number.
        user = await authAdmin.createUser({phoneNumber: verifiedPhoneNumber});
    }

    // Finally, mint a Firebase custom auth token containing the UID of the user
    // you looked up or created. Return this token to the caller.
    const authToken = await authAdmin.createCustomToken(user.uid);
    res.status(200).send(authToken);
    return;
});

Se connecter avec le jeton d'authentification personnalisé

Une fois le point de terminaison déployé, connectez les utilisateurs à Firebase en suivant ces étapes :

  1. Obtenez un jeton Firebase PNV en suivant le flux décrit sur la page Premiers pas avec Firebase Phone Number Verification.

  2. Transmettez ce jeton au point de terminaison Cloud Functions. Le point de terminaison renverra à votre application un jeton d'authentification personnalisé que vous pourrez transmettre à signInWithCustomToken().

    Par exemple, vous pouvez utiliser Retrofit pour écrire une méthode, signInWithFpnvToken(), qui possède une interface semblable à l'une des méthodes signin de Firebase :

    Kotlin 

    class FpnvSigninExample {
    interface FPNVTokenExchangeService {
        @POST("signInWithFpnv")
        suspend fun signInWithFpnv(@Body fpnvToken: String): String
    }

    val retrofit = Retrofit.Builder()
        .baseUrl("https://example-project.cloudfunctions.net/")
        .build()
    val service: FPNVTokenExchangeService = retrofit.create(FPNVTokenExchangeService::class.java)

    suspend fun signInWithFpnvToken(fpnvToken: String): Task<AuthResult?> = coroutineScope {
        val authToken = service.signInWithFpnv(fpnvToken)
        return@coroutineScope Firebase.auth.signInWithCustomToken(authToken)
    }
}