Autentica con Firebase su Android utilizzando un numero di telefono

Puoi utilizzare l'autenticazione Firebase per accedere a un utente inviando un messaggio SMS al telefono dell'utente. L'utente accede utilizzando un codice monouso contenuto nel messaggio SMS.

Il modo più semplice per aggiungere il numero di telefono di accesso per la vostra applicazione è quello di utilizzare FirebaseUI , che include un drop-in widget di sign-in che implementa firmano-in flussi per il numero di telefono di accesso, così come basata su password e segno federata -in. 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à, aggiungi Firebase al progetto Android .
  2. Utilizzando la Firebase Android BoM , dichiarare la dipendenza per la libreria di autenticazione Firebase Android nel modulo (a livello di app) File Gradle (di solito app/build.gradle ).

    Giava

    dependencies {
    // Import the BoM for the Firebase platform
    implementation platform('com.google.firebase:firebase-bom:29.0.4')

    // Declare 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'
}

    Usando il Firebase Android BoM , la vostra applicazione sarà sempre utilizzare versioni compatibili delle librerie Firebase Android.

    (Alternativa) Dichiarare Firebase dipendenze delle librerie senza utilizzare la distinta

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

    Si noti che se si utilizzano più librerie Firebase nella vostra app, ti consigliamo di utilizzare la distinta di gestire versioni della libreria, che assicura che tutte le versioni sono compatibili.

    dependencies {
    // Declare 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:21.0.1'
}

    Kotlin+KTX

    dependencies {
    // Import the BoM for the Firebase platform
    implementation platform('com.google.firebase:firebase-bom:29.0.4')

    // Declare 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-ktx'
}

    Usando il Firebase Android BoM , la vostra applicazione sarà sempre utilizzare versioni compatibili delle librerie Firebase Android.

    (Alternativa) Dichiarare Firebase dipendenze delle librerie senza utilizzare la distinta

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

    Si noti che se si utilizzano più librerie Firebase nella vostra app, ti consigliamo di utilizzare la distinta di gestire versioni della libreria, che assicura che tutte le versioni sono compatibili.

    dependencies {
    // Declare 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-ktx:21.0.1'
}
  3. Se non hai ancora collegato l'app per il vostro progetto Firebase, farlo dalla console Firebase .
  4. Se non l'hai già impostato la vostra applicazione hash SHA-1 nella console Firebase , farlo. Vedere Autenticazione del client per informazioni sulla ricerca della tua app hash SHA-1.

Problemi di sicurezza

L'autenticazione utilizzando solo un numero di telefono, sebbene conveniente, è meno sicura degli altri metodi disponibili, poiché il possesso di un numero di telefono può essere facilmente trasferito tra gli utenti. Inoltre, sui dispositivi con più profili utente, qualsiasi utente in grado di ricevere messaggi SMS può accedere a un account utilizzando il numero di telefono del dispositivo.

Se utilizzi l'accesso basato sul numero di telefono nella tua app, dovresti offrirlo insieme a metodi di accesso più sicuri e informare gli utenti dei compromessi in termini di sicurezza derivanti dall'utilizzo dell'accesso tramite numero di telefono.

Abilita l'accesso tramite numero di telefono per il tuo progetto Firebase

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

  1. Nella console Firebase , aprire la sezione di autenticazione.
  2. Nella pagina Sign-in Metodo, abilitare il numero di telefono di accesso metodo.

La quota di richieste di accesso al numero di telefono di Firebase è sufficientemente elevata da non influire sulla maggior parte delle app. Tuttavia, se devi accedere a un volume molto elevato di utenti con l'autenticazione telefonica, potresti dover aggiornare il tuo piano tariffario. Vedere la tariffazione pagina.

Abilita la verifica dell'app

Per utilizzare l'autenticazione del numero di telefono, Firebase deve essere in grado di verificare che le richieste di accesso al numero di telefono provengano dalla tua app. Ci sono due modi in cui Firebase Authentication realizza questo:

  • SafetyNet: Se un utente ha un dispositivo con Google Play Services installato, e Firebase autenticazione in grado di verificare il dispositivo come legittima con Android SafetyNet , il numero di telefono di accesso può procedere.

    • Per abilitare SafetyNet per l'uso con l'autenticazione Firebase:

    1. Nel Google Cloud Console, abilitare l' API DeviceCheck Android per il vostro progetto. Verrà utilizzata la chiave API Firebase predefinita e deve essere consentito l'accesso all'API DeviceCheck.
    2. Se non avete ancora specificato la vostra applicazione SHA-256 impronte digitali, farlo dalla pagina Impostazioni della console Firebase. Fare riferimento a Autenticazione del client per i dettagli su come ottenere la vostra applicazione SHA-256 impronte digitali.
  • reCAPTCHA verifica: Nel caso in cui SafetyNet non possono essere utilizzati, ad esempio quando l'utente non dispone di Google Play Services supportano, o quando si prova la tua applicazione su un emulatore, Firebase autenticazione utilizza una verifica reCAPTCHA per completare il segno-in flusso di telefono. La sfida reCAPTCHA può spesso essere completata senza che l'utente debba risolvere nulla. Tieni presente che questo flusso richiede che un SHA-1 sia associato alla tua applicazione.

Invia un codice di verifica al telefono dell'utente

Per avviare l'accesso tramite numero di telefono, presenta all'utente un'interfaccia che richieda di digitare il proprio numero di telefono. I requisiti legali variano, ma come best practice e per definire le aspettative per i tuoi utenti, dovresti informarli che se utilizzano l'accesso tramite telefono, potrebbero ricevere un messaggio SMS per la verifica e si applicano le tariffe standard.

Quindi, passare il loro numero di telefono per il PhoneAuthProvider.verifyPhoneNumber metodo per richiedere che Firebase verificare il numero di telefono dell'utente. Per esempio:

Giava

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

Kotlin+KTX

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

Il verifyPhoneNumber metodo è rientrante: se lo si chiama più volte, ad esempio in un'attività di onStart metodo, il verifyPhoneNumber metodo non invierà un secondo SMS a meno che la richiesta originale è scaduta.

Puoi usare questo comportamento per riprendere il processo 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 , impostare un flag che indica che la verifica è in corso. Quindi, salvare la bandiera del tuo attività onSaveInstanceState metodo e ripristinare la bandiera in onRestoreInstanceState . Infine, nella tua attività di onStart metodo, verificare se la verifica è già in corso, e in tal caso, chiamare verifyPhoneNumber di nuovo. Assicurarsi di cancellare il flag quando verifica esito positivo o negativo (vedi callback di verifica ).

Per gestire facilmente la rotazione dello schermo e altre istanze di riavvio di attività, passare l'attività alla verifyPhoneNumber metodo. I callback verranno scollegati automaticamente quando l'attività si interrompe, quindi puoi scrivere liberamente il codice di transizione dell'interfaccia utente nei metodi di callback.

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

Giava

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

Kotlin+KTX

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

Quando si chiama PhoneAuthProvider.verifyPhoneNumber , è necessario fornire anche un'istanza di OnVerificationStateChangedCallbacks , che contiene implementazioni delle funzioni di callback che gestiscono i risultati della richiesta. Per esempio:

Giava

mCallbacks = new PhoneAuthProvider.OnVerificationStateChangedCallbacks() {

    @Override
    public void onVerificationCompleted(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(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
        }

        // 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

Kotlin+KTX

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
        }

        // 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

Richiamate di verifica

Nella maggior parte delle applicazioni, si implementano i onVerificationCompleted , onVerificationFailed e onCodeSent callback. Si potrebbe anche implementare onCodeAutoRetrievalTimeOut , a seconda delle esigenze della vostra app.

onVerificationCompleted(PhoneAuthCredential)

Questo metodo viene chiamato in due situazioni:

  • Verifica istantanea: in alcuni casi il numero di telefono può essere verificato istantaneamente senza bisogno di inviare o inserire un codice di verifica.
  • Recupero automatico: su alcuni dispositivi, i servizi di Google Play possono rilevare automaticamente l'SMS di verifica in arrivo ed eseguire la verifica senza l'intervento dell'utente. (Questa capacità potrebbe non essere disponibile con alcuni vettori.) Questo utilizza l'API SMS Retriever , che include un hash 11 carattere alla fine del messaggio SMS.
In entrambi i casi, il numero di telefono dell'utente è stata verificata con successo, ed è possibile utilizzare l' PhoneAuthCredential oggetto che è passato al callback per accedere l'utente .

onVerificationFailed(FirebaseException)

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

onCodeSent (String verificaId, PhoneAuthProvider.ForceResendingToken)

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

Quando viene chiamato questo metodo, la maggior parte delle app visualizza un'interfaccia utente che richiede all'utente di digitare il codice di verifica dal messaggio SMS. (Allo stesso tempo, l'auto-verifica potrebbe essere attiva in background.) Poi, dopo l'utente digita il codice di verifica, è possibile utilizzare il codice di verifica e l'ID di verifica che è stato passato al metodo per creare un PhoneAuthCredential oggetto, che puoi a tua volta utilizzare per accedere all'utente. Tuttavia, alcune applicazioni potrebbero attendere fino onCodeAutoRetrievalTimeOut viene chiamato prima di visualizzare il codice di verifica UI (non raccomandato).

onCodeAutoRetrievalTimeOut (ID verifica stringa)

Opzionale. Questo metodo viene chiamato dopo la durata timeout specificato per verifyPhoneNumber ha superato senza onVerificationCompleted attivazione prima. Sui dispositivi senza schede SIM, questo metodo viene chiamato immediatamente perché il recupero automatico degli SMS non è possibile.

Alcune app bloccano l'input dell'utente fino al timeout del periodo di verifica automatica e solo allora visualizzano un'interfaccia utente che richiede all'utente di digitare il codice di verifica dal messaggio SMS (non consigliato).

Crea un oggetto PhoneAuthCredential

Dopo l'utente inserisce il codice di verifica che Firebase inviato al telefono dell'utente, creare un PhoneAuthCredential oggetto, utilizzando il codice di verifica e l'ID di verifica che è stato passato al onCodeSent o onCodeAutoRetrievalTimeOut callback. (Quando onVerificationCompleted viene chiamato, si ottiene un PhoneAuthCredential oggetto direttamente, in modo da poter saltare questo passaggio.)

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

Giava

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

Kotlin+KTX

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

Accedi come utente

Dopo aver ottenere un PhoneAuthCredential oggetto, sia in onVerificationCompleted callback o chiamando PhoneAuthProvider.getCredential , completare il segno-in flusso passando l' PhoneAuthCredential oggetto da FirebaseAuth.signInWithCredential :

Giava

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

Kotlin+KTX

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

Prova con numeri di telefono fittizi

Puoi impostare numeri di telefono fittizi per lo sviluppo tramite la console Firebase. Il test con numeri di telefono fittizi offre questi vantaggi:

  • Prova l'autenticazione del numero di telefono senza consumare la quota di utilizzo.
  • Prova l'autenticazione del numero di telefono senza inviare un messaggio SMS effettivo.
  • Esegui test consecutivi con lo stesso numero di telefono senza subire limitazioni. Ciò riduce al minimo il rischio di rifiuto durante il processo di revisione dell'App Store se il revisore utilizza lo stesso numero di telefono per il test.
  • Testa facilmente in ambienti di sviluppo senza alcuno sforzo aggiuntivo, come la possibilità di sviluppare in un simulatore iOS o un emulatore Android senza Google Play Services.
  • Scrivi 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 questi requisiti:

  1. Assicurati di utilizzare numeri di telefono che sono effettivamente fittizi e non esistono già. L'autenticazione Firebase non consente di impostare numeri di telefono esistenti utilizzati da utenti reali come numeri di prova. Una possibilità è quella di utilizzare 555 numeri preceduti da numeri telefonici prova Uniti, per esempio: +1 650-555-3434
  2. I numeri di telefono devono essere formattati correttamente per la lunghezza e altri vincoli. Passeranno comunque attraverso la stessa convalida del numero di telefono di un utente reale.
  3. Puoi aggiungere fino a 10 numeri di telefono per lo sviluppo.
  4. Usa numeri di telefono/codici di prova difficili da indovinare e cambiali frequentemente.

Crea numeri di telefono e codici di verifica fittizi

  1. Nella console Firebase , aprire la sezione di autenticazione.
  2. Nel segno nella scheda Metodo, permettere al prestatore del telefono se non l'hai già.
  3. Aprire i numeri di telefono per testare menù fisarmonica.
  4. Fornire il numero di telefono che si desidera verificare, ad esempio: +1 650-555-3434.
  5. Fornire il codice di verifica 6 cifre per quel numero specifico, per esempio: 654321.
  6. Aggiungere il numero. Se necessario, puoi eliminare il numero di telefono e il relativo codice passando con il mouse sulla riga corrispondente e facendo clic sull'icona del cestino.

Test manuale

Puoi iniziare direttamente a utilizzare un numero di telefono fittizio nella tua applicazione. Ciò consente di eseguire test manuali durante le fasi di sviluppo senza incorrere in problemi di quota o limitazioni. Puoi anche testare 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 inviato alcun SMS effettivo. Devi invece fornire il codice di verifica configurato in precedenza per completare l'accesso.

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

Un'altra opzione è quella di impostare un ruolo di test mediante attestazioni personalizzate su questi utenti di li differenziano come utenti falsi se si vuole limitare ulteriormente l'accesso.

Per attivare manualmente il flusso reCAPTCHA per testare, utilizzare il forceRecaptchaFlowForTesting() metodo.

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

Test d'integrazione

Oltre ai test manuali, Firebase Authentication fornisce API per aiutare a scrivere test di integrazione per i test di autenticazione del telefono. Queste API disabilitano la verifica dell'app disabilitando il requisito reCAPTCHA nel web e le notifiche push silenziose in iOS. Ciò rende i test di automazione possibili in questi flussi e più facili da implementare. Inoltre, aiutano a fornire la possibilità di testare i flussi di verifica istantanea su Android.

Su Android, chiamata setAppVerificationDisabledForTesting() prima della signInWithPhoneNumber chiamata. Ciò disabilita automaticamente la verifica dell'app, consentendoti di passare il numero di telefono senza risolverlo manualmente. Tieni presente che anche se reCAPTCHA e/o SafetyNet sono disabilitati, 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();

Chiamata verifyPhoneNumber con un numero immaginario innesca la onCodeSent richiamata, in cui è necessario fornire il codice di verifica corrispondente. Ciò consente il test negli emulatori Android.

Giava

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(String verificationId,
                                   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(PhoneAuthCredential phoneAuthCredential) {
                // Sign in with the credential
                // ...
            }

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

Kotlin+KTX

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, è possibile verificare i flussi di auto-recupero di Android impostando il numero di finzione e il corrispondente codice di verifica per auto-recupero chiamando setAutoRetrievedSmsCodeForPhoneNumber .

Quando verifyPhoneNumber si chiama, si innesca onVerificationCompleted con il PhoneAuthCredential direttamente. Funziona solo con numeri di telefono fittizi.

Assicurati che sia disabilitato e che nessun numero di telefono fittizio sia codificato nella tua app quando pubblichi la tua applicazione sul Google Play Store.

Giava

// 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(PhoneAuthCredential credential) {
                // Instant verification is applied and a credential is directly returned.
                // ...
            }

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

Kotlin+KTX

// 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

Prossimi passi

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

  • Nelle vostre applicazioni, è possibile ottenere informazioni sul profilo di base dell'utente dal FirebaseUser oggetto. Vedere Gestione utenti .

  • Nel database Firebase in tempo reale e cloud storage Regole di sicurezza , è possibile ottenere la firma-in ID utente univoco dell'utente dal auth variabile e utilizzarlo per controllare quali dati un accesso utente può.

È possibile consentire agli utenti di accedere alla vostra applicazione utilizzando più provider di autenticazione da collegando Auth credenziali di provider per un account utente esistente.

Per firmare un utente, chiamata signOut :

Giava

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

Kotlin+KTX

Firebase.auth.signOut()
MainActivity.kt