Esegui l'autenticazione con Firebase su Android utilizzando un numero di telefono

Puoi utilizzare Firebase Authentication per accedere a un utente tramite l'invio di un messaggio SMS al telefono dell'utente. L'utente accede utilizzando un codice monouso contenuto nel messaggio SMS.

Il modo più semplice per aggiungere l'accesso con numero di telefono alla tua app è utilizzare FirebaseUI che include un widget di accesso diretto che implementa i flussi di accesso per lo smartphone accesso tramite numero, nonché accesso basato su password e federato. Questo documento descrive come implementare un flusso di accesso tramite numero di telefono utilizzando l'SDK Firebase.

Prima di iniziare

1. Se non l'hai già fatto, aggiungi Firebase al tuo progetto Android.
2. Nel file Gradle del modulo (a livello di app) (di solito <project>/<app-module>/build.gradle.kts o <project>/<app-module>/build.gradle), aggiungi la dipendenza per la libreria Firebase Authentication per Android. Ti consigliamo di utilizzare Firebase Android BoM per controllare il controllo delle versioni delle librerie.

   dependencies {
       // Import the BoM for the Firebase platform
       implementation(platform("com.google.firebase:firebase-bom:33.2.0"))
   
       // Add the dependency for the Firebase Authentication library
       // When using the BoM, you don't specify versions in Firebase library dependencies
       implementation("com.google.firebase:firebase-auth")
   }

   Se utilizzi Firebase Android BoM, la tua app utilizzerà sempre versioni compatibili delle librerie Firebase Android.

   (alternativa) Aggiungi dipendenze della libreria Firebase senza utilizzare il BoM

   Se scegli di non utilizzare Firebase BoM, devi specificare ogni versione della libreria Firebase nella sua linea di dipendenza.

   Tieni presente che se utilizzi più librerie Firebase nella tua app, ti consigliamo consiglia di utilizzare BoM per gestire le versioni della libreria, in modo da garantire che tutte le versioni siano compatibili.

   dependencies {
       // Add the dependency for the Firebase Authentication library
       // When NOT using the BoM, you must specify versions in Firebase library dependencies
       implementation("com.google.firebase:firebase-auth:23.0.0")
   }

   Cerchi un modulo della libreria specifico per Kotlin? A partire da Ottobre 2023 (Firebase BoM 32.5.0), gli sviluppatori Kotlin e Java possono dipendono dal modulo principale della libreria (per i dettagli, consulta Domande frequenti su questa iniziativa).
3. Se non hai ancora collegato la tua app al progetto Firebase, puoi farlo da la console Firebase.
4. Se non hai già impostato l'hash SHA-1 dell'app nella console Firebase, farlo. Consulta Autenticazione del client per informazioni su come trovare l'algoritmo SHA-1 dell'app hash.

Problemi di sicurezza

L'autenticazione utilizzando solo un numero di telefono, sebbene comoda, è meno sicura rispetto agli altri metodi disponibili, perché il possesso di un numero di telefono può essere facilmente trasferito da un utente all'altro. Inoltre, sui dispositivi con più utenti profili, qualsiasi utente in grado di ricevere messaggi SMS può accedere a un account utilizzando il numero di telefono del dispositivo.

Se nella tua app usi l'accesso basato su numero di telefono, dovresti offrirlo oltre a metodi di accesso più sicuri, oltre a informare gli utenti del livello i pro e i contro dell'uso dell'accesso con numero di telefono.

Attivare l'accesso con numero di telefono per il progetto Firebase

Per accedere agli utenti tramite SMS, devi prima abilitare l'accesso tramite numero di telefono per il tuo progetto Firebase:

1. Nella console Firebase, apri la sezione Autenticazione.
2. Nella pagina Metodo di accesso, attiva Numero di telefono. .

Attiva la verifica app

Per utilizzare l'autenticazione del numero di telefono, Firebase deve essere in grado di verificare che le richieste di accesso tramite numero di telefono provengono dalla tua app. Ci sono tre modi Firebase Authentication ottiene questo risultato:

• API Play Integrity: se un utente ha un dispositivo su cui è installato Google Play services e Firebase Authentication può verificare che il dispositivo sia legittimo con l'API Play Integrity, il sistema può procedere con l'accesso tramite numero di telefono. L'API Play Integrity è attivata su un progetto di proprietà di Google da Firebase Authentication, non sul tuo progetto. Ciò non contribuisce alle quote dell'API Play Integrity associate al tuo progetto. L'assistenza di Play Integrity è disponibile con SDK Authentication versione 21.2.0 o successive (Firebase BoM versione 31.4.0 e successive).

  Se non hai ancora specificato l'impronta SHA-256 della tua app, per usare Play Integrity dovrai farlo dal Progetto impostazioni della console Firebase. Consulta la sezione Autentificazione del client per informazioni dettagliate su come ottenere l'impronta SHA-256 della tua app.

• Verifica reCAPTCHA: nel caso in cui non sia possibile usare Play Integrity, ad esempio quando un utente ha un dispositivo senza Google Play services installato, Firebase Authentication utilizza una verifica reCAPTCHA per completare il flusso di accesso tramite telefono. La verifica reCAPTCHA può spesso vengono completate senza che l'utente debba risolvere nulla. Tieni presente che questo flusso richiede un SHA-1 sia associato alla tua applicazione. Questo flusso richiede inoltre che la tua chiave API sia senza restrizioni o inserita nella lista consentita per PROJECT_ID.firebaseapp.com.

  Alcuni scenari in cui viene attivato reCAPTCHA:

  • Se sul dispositivo dell'utente finale non è installato Google Play services.
  • Se l'app non è distribuita tramite Google Play Store (su Authentication SDK v21.2.0 e versioni successive).
  • Se il token SafetyNet ottenuto non era valido (nelle versioni dell'SDK Authentication precedenti alla v21.2.0).

  Quando per la verifica delle app vengono utilizzati SafetyNet o Play Integrity, il campo %APP_NAME% nel modello di SMS viene compilato con il nome dell'app determinato da Google Play Store. Negli scenari in cui viene attivato reCAPTCHA, il campo %APP_NAME% viene compilato come PROJECT_ID.firebaseapp.com.

  di Gemini Advanced.

Risoluzione dei problemi

• "Stato iniziale mancante" errore durante l'utilizzo di reCAPTCHA per la verifica dell'app

  Questo può verificarsi quando il flusso reCAPTCHA viene completato correttamente, ma non reindirizza l'utente all'applicazione nativa. In questo caso, l'utente viene reindirizzato all'URL di riserva PROJECT_ID.firebaseapp.com/__/auth/handler. Nei browser Firefox, l'apertura dei link alle app native è disattivata per impostazione predefinita. Se vedi l'errore riportato sopra in Firefox, segui la procedura descritta in Impostare Firefox per Android per aprire i link nelle app native per attivare l'apertura dei link dell'app.

Invia un codice di verifica al telefono dell'utente

Per avviare l'accesso tramite numero di telefono, presenta all'utente un'interfaccia che lo invita a digitare il proprio numero di telefono. I requisiti legali variano ma come best practice e definire aspettative per gli utenti, è bene informarli che, se utilizzano all'accesso con il telefono, potrebbero ricevere un SMS per la verifica si applicano le tariffe.

Quindi, passa il suo numero di telefono al PhoneAuthProvider.verifyPhoneNumber metodo per richiedere che Firebase verificare il numero di telefono dell'utente. Ad esempio:

val options = PhoneAuthOptions.newBuilder(auth)
    .setPhoneNumber(phoneNumber) // Phone number to verify
    .setTimeout(60L, TimeUnit.SECONDS) // Timeout and unit
    .setActivity(this) // Activity (for callback binding)
    .setCallbacks(callbacks) // OnVerificationStateChangedCallbacks
    .build()
PhoneAuthProvider.verifyPhoneNumber(options)
PhoneAuthActivity.kt

PhoneAuthOptions options = 
  PhoneAuthOptions.newBuilder(mAuth) 
      .setPhoneNumber(phoneNumber)       // Phone number to verify
      .setTimeout(60L, TimeUnit.SECONDS) // Timeout and unit
      .setActivity(this)                 // (optional) Activity for callback binding
      // If no activity is passed, reCAPTCHA verification can not be used.
      .setCallbacks(mCallbacks)          // OnVerificationStateChangedCallbacks
      .build();
  PhoneAuthProvider.verifyPhoneNumber(options);     
PhoneAuthActivity.java

Il metodo verifyPhoneNumber è ricorsivo: se lo chiami più volte, ad esempio nel metodo onStart di un'attività, il metodo verifyPhoneNumber non invierà un secondo SMS a meno che il tempo di attesa della richiesta originale non sia scaduto.

Puoi utilizzare questo comportamento per riprendere la procedura di accesso al numero di telefono se l'app si chiude prima che l'utente possa accedere (ad esempio, mentre l'utente sta usando l'app per gli SMS). Dopo aver chiamato verifyPhoneNumber, imposta un flag che indica che la verifica è in corso. Quindi, salva il flag nella sezione onSaveInstanceState e ripristina il flag nel onRestoreInstanceState. Infine, nel metodo onStart della tua attività, controlla se la verifica è già in corso e, in caso affermativo, chiama di nuovo verifyPhoneNumber. Assicurati di cancellare la segnalazione quando la verifica viene completata o non va a buon fine (vedi Callback di verifica).

Per gestire facilmente la rotazione dello schermo e altri casi di riavvii dell'attività, procedi nel seguente modo: passa la tua attività al metodo verifyPhoneNumber. I callback verrà scollegato automaticamente quando l'attività si interrompe, in modo da poter scrivere liberamente nell'interfaccia utente il codice di transizione nei metodi di callback.

Il messaggio SMS inviato da Firebase può essere localizzato anche specificando la lingua di autenticazione tramite il metodo setLanguageCode nell'istanza Auth.

auth.setLanguageCode("fr")
// To apply the default app language instead of explicitly setting it.
// auth.useAppLanguage()
MainActivity.kt

auth.setLanguageCode("fr");
// To apply the default app language instead of explicitly setting it.
// auth.useAppLanguage();
MainActivity.java

Quando chiami PhoneAuthProvider.verifyPhoneNumber, devi anche fornisce un'istanza di OnVerificationStateChangedCallbacks, che contiene implementazioni delle funzioni di callback che gestiscono i risultati la richiesta. Ad esempio:

callbacks = object : PhoneAuthProvider.OnVerificationStateChangedCallbacks() {

    override fun onVerificationCompleted(credential: PhoneAuthCredential) {
        // This callback will be invoked in two situations:
        // 1 - Instant verification. In some cases the phone number can be instantly
        //     verified without needing to send or enter a verification code.
        // 2 - Auto-retrieval. On some devices Google Play services can automatically
        //     detect the incoming verification SMS and perform verification without
        //     user action.
        Log.d(TAG, "onVerificationCompleted:$credential")
        signInWithPhoneAuthCredential(credential)
    }

    override fun onVerificationFailed(e: FirebaseException) {
        // This callback is invoked in an invalid request for verification is made,
        // for instance if the the phone number format is not valid.
        Log.w(TAG, "onVerificationFailed", e)

        if (e is FirebaseAuthInvalidCredentialsException) {
            // Invalid request
        } else if (e is FirebaseTooManyRequestsException) {
            // The SMS quota for the project has been exceeded
        } else if (e is FirebaseAuthMissingActivityForRecaptchaException) {
            // reCAPTCHA verification attempted with null Activity
        }

        // Show a message and update the UI
    }

    override fun onCodeSent(
        verificationId: String,
        token: PhoneAuthProvider.ForceResendingToken,
    ) {
        // The SMS verification code has been sent to the provided phone number, we
        // now need to ask the user to enter the code and then construct a credential
        // by combining the code with a verification ID.
        Log.d(TAG, "onCodeSent:$verificationId")

        // Save verification ID and resending token so we can use them later
        storedVerificationId = verificationId
        resendToken = token
    }
}
PhoneAuthActivity.kt

mCallbacks = new PhoneAuthProvider.OnVerificationStateChangedCallbacks() {

    @Override
    public void onVerificationCompleted(@NonNull PhoneAuthCredential credential) {
        // This callback will be invoked in two situations:
        // 1 - Instant verification. In some cases the phone number can be instantly
        //     verified without needing to send or enter a verification code.
        // 2 - Auto-retrieval. On some devices Google Play services can automatically
        //     detect the incoming verification SMS and perform verification without
        //     user action.
        Log.d(TAG, "onVerificationCompleted:"   credential);

        signInWithPhoneAuthCredential(credential);
    }

    @Override
    public void onVerificationFailed(@NonNull FirebaseException e) {
        // This callback is invoked in an invalid request for verification is made,
        // for instance if the the phone number format is not valid.
        Log.w(TAG, "onVerificationFailed", e);

        if (e instanceof FirebaseAuthInvalidCredentialsException) {
            // Invalid request
        } else if (e instanceof FirebaseTooManyRequestsException) {
            // The SMS quota for the project has been exceeded
        } else if (e instanceof FirebaseAuthMissingActivityForRecaptchaException) {
            // reCAPTCHA verification attempted with null Activity
        }

        // Show a message and update the UI
    }

    @Override
    public void onCodeSent(@NonNull String verificationId,
                           @NonNull PhoneAuthProvider.ForceResendingToken token) {
        // The SMS verification code has been sent to the provided phone number, we
        // now need to ask the user to enter the code and then construct a credential
        // by combining the code with a verification ID.
        Log.d(TAG, "onCodeSent:"   verificationId);

        // Save verification ID and resending token so we can use them later
        mVerificationId = verificationId;
        mResendToken = token;
    }
};
PhoneAuthActivity.java

Callback di verifica

Nella maggior parte delle app, implementi onVerificationCompleted, Callback onVerificationFailed e onCodeSent. Tu potrebbe anche implementare onCodeAutoRetrievalTimeOut, a seconda delle i requisiti dell'app.

onVerificaCompletato(PhoneAuthCredential)

Questo metodo viene chiamato in due situazioni:

• Verifica immediata: in alcuni casi il numero di telefono può essere visualizzato immediatamente verificati senza dover inviare o inserire un codice di verifica.
• Recupero automatico: su alcuni dispositivi, Google Play Services può rilevare automaticamente l'SMS di verifica in arrivo ed eseguire la verifica senza intervento dell'utente. Questa funzionalità potrebbe non essere disponibile con alcuni operatori. Viene utilizzato il parametro API SMS Retriever, include un hash di 11 caratteri alla fine dell'SMS.

onVerificaFailed(FirebaseEccezione)

Questo metodo viene chiamato in risposta a una richiesta di verifica non valida, ad esempio come richiesta che specifica un numero di telefono o un codice di verifica non validi.

onCodeSent(Id di verifica stringa, PhoneAuthProvider.ForceInviaingToken)

Facoltativo. Questo metodo viene chiamato dopo che il codice di verifica è stato inviato tramite SMS al numero di telefono fornito.

Quando questo metodo viene chiamato, la maggior parte delle app mostra una UI che richiede all'utente per digitare il codice di verifica nell'SMS. (Allo stesso tempo, la verifica automatica potrebbe continuare in background). Poi, dopo che l'utente digita il codice di verifica, puoi utilizzare il codice di verifica e l'ID verifica che è stato trasmesso al metodo per creare un Oggetto PhoneAuthCredential, che puoi utilizzare a sua volta per accedere per l'utente. Tuttavia, alcune app potrebbero attendere onCodeAutoRetrievalTimeOut viene chiamato prima di visualizzare UI del codice di verifica (sconsigliato).

onCodeAutoRetrievalTimeOut(ID verifica stringa)

Facoltativo. Questo metodo viene chiamato dopo la durata del timeout specificata su verifyPhoneNumber è trascorso senza onVerificationCompleted viene attivato per primo. Sui dispositivi senza schede SIM, questo metodo viene chiamato immediatamente perché il recupero automatico degli SMS non è possibile.

Alcune app bloccano l'input utente fino allo scadere del periodo di verifica automatica. e visualizzare una UI che chiede all'utente di digitare il codice di verifica dall'SMS (sconsigliato).

Crea un oggetto PhoneAuthCredential

Dopo che l'utente inserisce il codice di verifica inviato da Firebase alla sua telefono, crea un oggetto PhoneAuthCredential, utilizzando la verifica di verifica e l'ID di verifica trasmesso alla onCodeSent o Chiamata onCodeAutoRetrievalTimeOut. (Quando Chiamata onVerificationCompleted, riceverai un PhoneAuthCredential oggetto direttamente, quindi puoi saltare questo passaggio.)

Per creare l'oggetto PhoneAuthCredential, chiama PhoneAuthProvider.getCredential:

val credential = PhoneAuthProvider.getCredential(verificationId!!, code)
PhoneAuthActivity.kt

PhoneAuthCredential credential = PhoneAuthProvider.getCredential(verificationId, code);
PhoneAuthActivity.java

Consenti l'accesso all'utente

Dopo aver ottenuto un oggetto PhoneAuthCredential, sia nel onVerificationCompleted o tramite chiamata PhoneAuthProvider.getCredential, completa il flusso di accesso entro il giorno passa l'oggetto PhoneAuthCredential FirebaseAuth.signInWithCredential:

private fun signInWithPhoneAuthCredential(credential: PhoneAuthCredential) {
    auth.signInWithCredential(credential)
        .addOnCompleteListener(this) { task ->
            if (task.isSuccessful) {
                // Sign in success, update UI with the signed-in user's information
                Log.d(TAG, "signInWithCredential:success")

                val user = task.result?.user
            } else {
                // Sign in failed, display a message and update the UI
                Log.w(TAG, "signInWithCredential:failure", task.exception)
                if (task.exception is FirebaseAuthInvalidCredentialsException) {
                    // The verification code entered was invalid
                }
                // Update UI
            }
        }
}
PhoneAuthActivity.kt

private void signInWithPhoneAuthCredential(PhoneAuthCredential credential) {
    mAuth.signInWithCredential(credential)
            .addOnCompleteListener(this, new OnCompleteListener<AuthResult>() {
                @Override
                public void onComplete(@NonNull Task<AuthResult> task) {
                    if (task.isSuccessful()) {
                        // Sign in success, update UI with the signed-in user's information
                        Log.d(TAG, "signInWithCredential:success");

                        FirebaseUser user = task.getResult().getUser();
                        // Update UI
                    } else {
                        // Sign in failed, display a message and update the UI
                        Log.w(TAG, "signInWithCredential:failure", task.getException());
                        if (task.getException() instanceof FirebaseAuthInvalidCredentialsException) {
                            // The verification code entered was invalid
                        }
                    }
                }
            });
}
PhoneAuthActivity.java

Esegui test con numeri di telefono fittizi

Puoi configurare numeri di telefono fittizi per lo sviluppo tramite la console Firebase. Test con smartphone fittizio numeri offre i seguenti vantaggi:

• Testa l'autenticazione del numero di telefono senza consumare la tua quota di utilizzo.
• Verifica l'autenticazione del numero di telefono senza inviare un SMS effettivo.
• Esegui test consecutivi con lo stesso numero di telefono senza essere limitato. Questo riduce al minimo il rischio di rifiuto durante il processo di revisione dello store se il revisore usa lo stesso numero di telefono per i test.
• Esegui subito test in ambienti di sviluppo senza alcuno sforzo in più, ad esempio la possibilità di sviluppare in un simulatore iOS o in un emulatore Android senza Google Play Services.
• Scrivere test di integrazione senza essere bloccato dai controlli di sicurezza normalmente applicati su numeri di telefono reali in un ambiente di produzione.

I numeri di telefono fittizi devono soddisfare i seguenti requisiti:

1. Assicurati di utilizzare numeri di telefono che siano effettivamente inventati e non esistano già. Firebase Authentication non ti consente di impostare come numeri di test numeri di telefono esistenti utilizzati da utenti reali. Un'opzione è utilizzare 555 numeri con prefisso come numeri di telefono di prova statunitensi, ad esempio: 39 338 555 3434
2. I numeri di telefono devono essere formattati correttamente per la lunghezza e altre i vincoli. Saranno comunque sottoposti alla stessa convalida del numero di telefono di un utente reale.
3. Puoi aggiungere fino a 10 numeri di telefono per lo sviluppo.
4. Utilizza numeri di telefono/codici di prova difficili da indovinare e cambiare di frequente.

Crea numeri di telefono fittizi e codici di verifica

1. Nella console Firebase, apri la nella sezione Autenticazione.
2. Nella scheda Metodo di accesso, attiva il provider di telefonia, se non l'hai ancora fatto.
3. Apri il menu a scomparsa Numeri di telefono per il test.
4. Fornisci il numero di telefono che vuoi verificare, ad esempio: 1 650-555-3434.
5. Fornisci il codice di verifica a 6 cifre per quel numero specifico, ad esempio: 654321.
6. Aggiungi il numero. Se necessario, puoi eliminare il numero di telefono e il relativo codice passando il mouse sopra la riga corrispondente e facendo clic sull'icona del cestino.

Test manuale

Puoi iniziare subito a utilizzare un numero di telefono fittizio nella tua applicazione. Questo consente di eseguire test manuali durante le fasi di sviluppo senza riscontrare problemi di quota o limitazioni. Puoi anche eseguire il test direttamente da un simulatore iOS o un emulatore Android senza Google Play Services installato.

Quando fornisci il numero di telefono fittizio e invii il codice di verifica, non viene effettuato alcun SMS inviate. Devi invece fornire il codice di verifica configurato in precedenza per completare la firma in.

Al completamento dell'accesso, viene creato un utente Firebase con quel numero di telefono. La l'utente ha lo stesso comportamento e le stesse proprietà di un utente reale con un numero di telefono e può accedere Realtime Database/Cloud Firestore e gli altri servizi allo stesso modo. Il token ID generato durante questo processo ha la stessa firma di un utente reale di un numero di telefono.

Un'altra opzione è impostare un ruolo di test tramite rivendicazioni su questi utenti per differenziarli come utenti falsi, nel caso in cui tu voglia limitare ulteriormente l'accesso.

Per attivare manualmente il flusso reCAPTCHA per i test, utilizza il metodo forceRecaptchaFlowForTesting().

// Force reCAPTCHA flow
FirebaseAuth.getInstance().getFirebaseAuthSettings().forceRecaptchaFlowForTesting();

Test di integrazione

Oltre ai test manuali, Firebase Authentication fornisce API per facilitare la scrittura dei test di integrazione per i test di autenticazione dello smartphone. Queste API disabilitano la verifica app disabilitando reCAPTCHA di notifica web e le notifiche push silenziose in iOS. Ciò rende possibili i test di automazione questi flussi e più facile da implementare. Inoltre, offrono la possibilità di eseguire test istantanei di verifica su Android.

Su Android, chiama setAppVerificationDisabledForTesting() prima del Chiamata signInWithPhoneNumber. La verifica dell'app viene disattivata automaticamente, consentendoti di passare il numero di telefono senza risolverlo manualmente. Anche se Play Integrity e reCAPTCHA sono disattivati. L'utilizzo di un numero di telefono reale non riuscirà comunque a completare l'accesso. Con questa API è possibile utilizzare solo numeri di telefono fittizi.

// Turn off phone auth app verification.
FirebaseAuth.getInstance().getFirebaseAuthSettings()
   .setAppVerificationDisabledForTesting();

La chiamata a verifyPhoneNumber con un numero fittizio attiva il callback onCodeSent, in cui dovrai fornire il codice di verifica corrispondente le API nel tuo codice. Ciò consente i test negli emulatori Android.

String phoneNum = " 16505554567";
String testVerificationCode = "123456";

// Whenever verification is triggered with the whitelisted number,
// provided it is not set for auto-retrieval, onCodeSent will be triggered.
FirebaseAuth auth = FirebaseAuth.getInstance();
PhoneAuthOptions options = PhoneAuthOptions.newBuilder(auth)
        .setPhoneNumber(phoneNum)
        .setTimeout(60L, TimeUnit.SECONDS)
        .setActivity(this)
        .setCallbacks(new PhoneAuthProvider.OnVerificationStateChangedCallbacks() {
            @Override
            public void onCodeSent(@NonNull String verificationId,
                                   @NonNull PhoneAuthProvider.ForceResendingToken forceResendingToken) {
                // Save the verification id somewhere
                // ...

                // The corresponding whitelisted code above should be used to complete sign-in.
                MainActivity.this.enableUserManuallyInputCode();
            }

            @Override
            public void onVerificationCompleted(@NonNull PhoneAuthCredential phoneAuthCredential) {
                // Sign in with the credential
                // ...
            }

            @Override
            public void onVerificationFailed(@NonNull FirebaseException e) {
                // ...
            }
        })
        .build();
PhoneAuthProvider.verifyPhoneNumber(options);
MainActivity.java

val phoneNum = " 16505554567"
val testVerificationCode = "123456"

// Whenever verification is triggered with the whitelisted number,
// provided it is not set for auto-retrieval, onCodeSent will be triggered.
val options = PhoneAuthOptions.newBuilder(Firebase.auth)
    .setPhoneNumber(phoneNum)
    .setTimeout(30L, TimeUnit.SECONDS)
    .setActivity(this)
    .setCallbacks(object : PhoneAuthProvider.OnVerificationStateChangedCallbacks() {

        override fun onCodeSent(
            verificationId: String,
            forceResendingToken: PhoneAuthProvider.ForceResendingToken,
        ) {
            // Save the verification id somewhere
            // ...

            // The corresponding whitelisted code above should be used to complete sign-in.
            this@MainActivity.enableUserManuallyInputCode()
        }

        override fun onVerificationCompleted(phoneAuthCredential: PhoneAuthCredential) {
            // Sign in with the credential
            // ...
        }

        override fun onVerificationFailed(e: FirebaseException) {
            // ...
        }
    })
    .build()
PhoneAuthProvider.verifyPhoneNumber(options)
MainActivity.kt

Inoltre, puoi testare i flussi di recupero automatico in Android impostando il numero fittizio e al codice di verifica corrispondente per il recupero automatico setAutoRetrievedSmsCodeForPhoneNumber.

Quando il valore di verifyPhoneNumber è chiamato, attiva onVerificationCompleted con PhoneAuthCredential . Questa opzione funziona solo con numeri di telefono fittizi.

Assicurati che questa opzione sia disattivata e che nessun numero di telefono fittizio sia impostato come hardcoded in l'app quando la pubblichi sul Google Play Store.

// The test phone number and code should be whitelisted in the console.
String phoneNumber = " 16505554567";
String smsCode = "123456";

FirebaseAuth firebaseAuth = FirebaseAuth.getInstance();
FirebaseAuthSettings firebaseAuthSettings = firebaseAuth.getFirebaseAuthSettings();

// Configure faking the auto-retrieval with the whitelisted numbers.
firebaseAuthSettings.setAutoRetrievedSmsCodeForPhoneNumber(phoneNumber, smsCode);

PhoneAuthOptions options = PhoneAuthOptions.newBuilder(firebaseAuth)
        .setPhoneNumber(phoneNumber)
        .setTimeout(60L, TimeUnit.SECONDS)
        .setActivity(this)
        .setCallbacks(new PhoneAuthProvider.OnVerificationStateChangedCallbacks() {
            @Override
            public void onVerificationCompleted(@NonNull PhoneAuthCredential credential) {
                // Instant verification is applied and a credential is directly returned.
                // ...
            }

            // ...
        })
        .build();
PhoneAuthProvider.verifyPhoneNumber(options);
MainActivity.java

// The test phone number and code should be whitelisted in the console.
val phoneNumber = " 16505554567"
val smsCode = "123456"

val firebaseAuth = Firebase.auth
val firebaseAuthSettings = firebaseAuth.firebaseAuthSettings

// Configure faking the auto-retrieval with the whitelisted numbers.
firebaseAuthSettings.setAutoRetrievedSmsCodeForPhoneNumber(phoneNumber, smsCode)

val options = PhoneAuthOptions.newBuilder(firebaseAuth)
    .setPhoneNumber(phoneNumber)
    .setTimeout(60L, TimeUnit.SECONDS)
    .setActivity(this)
    .setCallbacks(object : PhoneAuthProvider.OnVerificationStateChangedCallbacks() {
        override fun onVerificationCompleted(credential: PhoneAuthCredential) {
            // Instant verification is applied and a credential is directly returned.
            // ...
        }

        // ...
    })
    .build()
PhoneAuthProvider.verifyPhoneNumber(options)
MainActivity.kt

Passaggi successivi

Dopo che un utente ha eseguito l'accesso per la prima volta, viene creato un nuovo account utente e collegati alle credenziali, ovvero nome utente, password, numero o informazioni del provider di autenticazione, ovvero l'utente con cui ha eseguito l'accesso. Questo nuovo account viene archiviato nel tuo progetto Firebase e può essere utilizzato per identificare un utente in tutte le app del progetto, indipendentemente da come accede.

• Nelle tue app puoi ottenere le informazioni di base del profilo dell'utente dal FirebaseUser. Vedi Gestisci utenti.

• In Firebase Realtime Database e Cloud Storage Regole di sicurezza, puoi ottieni l'ID utente unico dell'utente che ha eseguito l'accesso dalla variabile auth, e usarli per controllare i dati a cui un utente può accedere.

Puoi consentire agli utenti di accedere alla tua app utilizzando più autenticazioni collegando le credenziali del provider di autenticazione a un a un account utente esistente.

Per disconnettere un utente, chiama signOut:

Firebase.auth.signOut()
MainActivity.kt

FirebaseAuth.getInstance().signOut();
MainActivity.java