Eseguire l'autenticazione con Firebase utilizzando il link email in Android

Puoi utilizzare Firebase Authentication per far accedere un utente inviandogli un'email contenente un link su cui può fare clic per accedere. Durante la procedura, viene verificato anche l'indirizzo email dell'utente.

L'accesso via email offre numerosi vantaggi:

  • Registrazione e accesso semplici.
  • Rischio ridotto di riutilizzo delle password tra le applicazioni, che può compromettere la sicurezza anche di password ben scelte.
  • La possibilità di autenticare un utente e, al contempo, verificare che sia il legittimo proprietario di un indirizzo email.
  • Per accedere, un utente deve solo disporre di un account email accessibile. Non è richiesta la proprietà di un numero di telefono o di un account di social media.
  • Un utente può accedere in modo sicuro senza dover fornire (o ricordare) una password, il che può essere complicato su un dispositivo mobile.
  • Un utente esistente che ha eseguito l'accesso in precedenza con un identificatore email (password o federato) può eseguire l'upgrade per accedere solo con l'email. Ad esempio, un utente che ha dimenticato la password può comunque accedere senza doverla reimpostare.

Prima di iniziare

Configura il progetto Android

  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 della libreria.

    Inoltre, nell'ambito della configurazione di Firebase Authentication, devi aggiungere l'SDK Google Play Services alla tua app.

    dependencies {
        // Import the BoM for the Firebase platform
        implementation(platform("com.google.firebase:firebase-bom:35.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")
    // Also add the dependency for the Google Play services library and specify its version implementation("com.google.android.gms:play-services-auth:22.0.0")
    }

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

    (Alternativa)  Aggiungi le dipendenze della libreria Firebase senza utilizzare BoM

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

    Tieni presente che se utilizzi più librerie Firebase nella tua app, ti consigliamo vivamente di utilizzare BoM per gestire le versioni delle librerie, 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:25.0.0")
    // Also add the dependency for the Google Play services library and specify its version implementation("com.google.android.gms:play-services-auth:22.0.0")
    }

Attiva l'accesso tramite link via email per il tuo progetto Firebase

Per consentire agli utenti di accedere tramite link via email, devi prima attivare il provider email e il metodo di accesso tramite link via email per il tuo progetto Firebase:

  1. Nella console Firebase, vai a Sicurezza > Autenticazione.

  2. Nella scheda Metodo di accesso, abilita il provider di accesso Email/Password. Tieni presente che l'accesso con email/password deve essere abilitato per utilizzare l'accesso con link via email.

  3. Nella stessa sezione, attiva il provider di accesso Link via email (accesso senza password).

  4. Fai clic su Salva.

Per avviare il flusso di autenticazione, mostra all'utente un'interfaccia che lo invita a fornire il proprio indirizzo email, quindi chiama sendSignInLinkToEmail per richiedere a Firebase di inviare il link di autenticazione all'indirizzo email dell'utente.

  1. Crea l'oggetto ActionCodeSettings, che fornisce a Firebase le istruzioni su come creare il link email. Imposta i seguenti campi:

    • url: il deep link da incorporare e qualsiasi stato aggiuntivo da trasmettere. Se non lo hai già fatto, aggiungi il dominio del link all'elenco dei domini autorizzati:

      1. Nella console Firebase, vai a Sicurezza > Autenticazione > scheda Impostazioni.

      2. Nella sezione Domini autorizzati, fai clic su Aggiungi dominio e aggiungi il dominio del link.

      Il link reindirizzerà l'utente a questo URL se l'app non è installata sul suo dispositivo e non è stato possibile installarla.

    • androidPackageName e iOSBundleId: aiutano Firebase Authentication a determinare se creare un link solo per il web o per dispositivi mobili che viene aperto su un dispositivo Android o Apple.
    • handleCodeInApp: impostato su true. L'operazione di accesso deve essere sempre completata nell'app, a differenza di altre azioni email fuori banda (reimpostazione della password e verifiche email). Questo perché, alla fine del flusso, l'utente dovrebbe aver eseguito l'accesso e il suo stato di autenticazione dovrebbe essere persistente all'interno dell'app.
    • linkDomain: quando per un progetto vengono definiti domini di link Hosting personalizzati, specifica quale utilizzare quando il link deve essere aperto da un'app mobile specificata. In caso contrario, viene selezionato automaticamente il dominio predefinito (ad esempio, PROJECT_ID.firebaseapp.com).
    • dynamicLinkDomain: deprecato. Non specificare questo parametro.

    Kotlin

    val actionCodeSettings = actionCodeSettings {
        // URL you want to redirect back to. The domain (www.example.com) for this
        // URL must be whitelisted in the Firebase Console.
        url = "https://www.example.com/finishSignUp?cartId=1234"
        // This must be true
        handleCodeInApp = true
        setIOSBundleId("com.example.ios")
        setAndroidPackageName(
            "com.example.android",
            true, // installIfNotAvailable
            "12", // minimumVersion
        )
    }

    Java

    ActionCodeSettings actionCodeSettings =
            ActionCodeSettings.newBuilder()
                    // URL you want to redirect back to. The domain (www.example.com) for this
                    // URL must be whitelisted in the Firebase Console.
                    .setUrl("https://www.example.com/finishSignUp?cartId=1234")
                    // This must be true
                    .setHandleCodeInApp(true)
                    .setIOSBundleId("com.example.ios")
                    .setAndroidPackageName(
                            "com.example.android",
                            true, /* installIfNotAvailable */
                            "12"    /* minimumVersion */)
                    .build();

    Per scoprire di più su ActionCodeSettings, consulta la sezione Passaggio dello stato nelle azioni email.

  2. Chiedi all'utente il suo indirizzo email.

  3. Invia il link di autenticazione all'indirizzo email dell'utente e salva l'indirizzo email dell'utente nel caso in cui l'utente completi l'accesso via email sullo stesso dispositivo.

    Kotlin

    Firebase.auth.sendSignInLinkToEmail(email, actionCodeSettings)
        .addOnCompleteListener { task ->
            if (task.isSuccessful) {
                Log.d(TAG, "Email sent.")
            }
        }

    Java

    FirebaseAuth auth = FirebaseAuth.getInstance();
    auth.sendSignInLinkToEmail(email, actionCodeSettings)
            .addOnCompleteListener(new OnCompleteListener<Void>() {
                @Override
                public void onComplete(@NonNull Task<Void> task) {
                    if (task.isSuccessful()) {
                        Log.d(TAG, "Email sent.");
                    }
                }
            });

Problemi di sicurezza

Per evitare che un link di accesso venga utilizzato per accedere come utente non previsto o su un dispositivo non previsto, Firebase Authentication richiede che l'indirizzo email dell'utente venga fornito durante il completamento del flusso di accesso. Affinché l'accesso vada a buon fine, questo indirizzo email deve corrispondere all'indirizzo a cui è stato originariamente inviato il link di accesso.

Puoi semplificare questo flusso per gli utenti che aprono il link di accesso sullo stesso dispositivo su cui richiedono il link, memorizzando il loro indirizzo email localmente, ad esempio utilizzando SharedPreferences, quando invii l'email di accesso. Poi, utilizza questo indirizzo per completare la procedura. Non trasmettere l'indirizzo email dell'utente nei parametri dell'URL di reindirizzamento e non riutilizzarlo, in quanto ciò potrebbe consentire l'inserimento di sessioni.

Al termine dell'accesso, qualsiasi meccanismo di accesso non verificato precedente verrà rimosso dall'utente e tutte le sessioni esistenti verranno invalidate. Ad esempio, se qualcuno ha creato in precedenza un account non verificato con la stessa email e la stessa password, la password dell'utente verrà rimossa per impedire all'utente che ha rivendicato la proprietà e creato l'account non verificato di accedere di nuovo con l'email e la password non verificate.

Assicurati inoltre di utilizzare un URL HTTPS in produzione per evitare che il link venga potenzialmente intercettato da server intermediari.

Completamento dell'accesso in un'app per Android

Firebase Authentication utilizza Firebase Hosting per inviare il link via email a un dispositivo mobile. Per completare l'accesso tramite l'applicazione mobile, l'applicazione deve essere configurata in modo da rilevare il link dell'applicazione in entrata, analizzare il deep link sottostante e quindi completare l'accesso. Per saperne di più, consulta la documentazione di Android App Links.

Configura Firebase Hosting

Firebase Authentication utilizza i domini Firebase Hosting quando crea e invia un link che deve essere aperto in un'applicazione mobile. È già stato configurato un dominio Firebase Hosting predefinito.

  1. Configura i domini Firebase Hosting:

    Nella console Firebase, vai a Hosting e serverless > Hosting.

    • Se vuoi utilizzare il dominio predefinito per il link email che si apre nelle applicazioni mobile, vai al tuo sito predefinito e prendi nota del dominio Hosting predefinito. In genere, un dominio Hosting predefinito ha il seguente aspetto: PROJECT_ID.firebaseapp.com.

      Questo valore ti servirà quando configurerai l'app per intercettare il link in entrata.

    • Se vuoi utilizzare un dominio personalizzato per il link via email, puoi registrarne uno con Firebase Hosting e utilizzarlo per il dominio del link.

  2. Configurazione delle app per Android:

    Per gestire questi link dalla tua app per Android, il nome del pacchetto dell'app deve essere specificato nelle impostazioni progetto della console Firebase. Inoltre, è necessario fornire gli hash SHA-1 e SHA-256 del certificato dell'applicazione.

    Se vuoi che questi link reindirizzino a un'attività specifica, devi configurare un filtro per intent nel file AndroidManifest.xml. Il filtro per intent deve intercettare i link email del tuo dominio. In AndroidManifest.xml:

    <intent-filter android:autoVerify="true">
      <action android:name="android.intent.action.VIEW" />
      <category android:name="android.intent.category.BROWSABLE" />
      <category android:name="android.intent.category.DEFAULT" />
      <data
        android:scheme="https"
        android:host="<PROJECT_ID>.firebaseapp.com or your custom domain"
        android:pathPrefix="/__/auth/links" />
    </intent-filter>
    

    Quando gli utenti aprono un link di hosting con il percorso /__/auth/links e lo schema e l'host specificati, la tua app avvierà l'attività con questo filtro per intent per gestire il link.

Dopo aver ricevuto il link come descritto sopra, verifica che sia destinato all'autenticazione tramite link via email e completa l'accesso.

Kotlin

val auth = Firebase.auth
val intent = intent
val emailLink = intent.data.toString()

// Confirm the link is a sign-in with email link.
if (auth.isSignInWithEmailLink(emailLink)) {
    // Retrieve this from wherever you stored it
    val email = "someemail@domain.com"

    // The client SDK will parse the code from the link for you.
    auth.signInWithEmailLink(email, emailLink)
        .addOnCompleteListener { task ->
            if (task.isSuccessful) {
                Log.d(TAG, "Successfully signed in with email link!")
                val result = task.result
                // You can access the new user via result.getUser()
                // Additional user info profile *not* available via:
                // result.getAdditionalUserInfo().getProfile() == null
                // You can check if the user is new or existing:
                // result.getAdditionalUserInfo().isNewUser()
            } else {
                Log.e(TAG, "Error signing in with email link", task.exception)
            }
        }
}

Java

FirebaseAuth auth = FirebaseAuth.getInstance();
Intent intent = getIntent();
String emailLink = intent.getData().toString();

// Confirm the link is a sign-in with email link.
if (auth.isSignInWithEmailLink(emailLink)) {
    // Retrieve this from wherever you stored it
    String email = "someemail@domain.com";

    // The client SDK will parse the code from the link for you.
    auth.signInWithEmailLink(email, emailLink)
            .addOnCompleteListener(new OnCompleteListener<AuthResult>() {
                @Override
                public void onComplete(@NonNull Task<AuthResult> task) {
                    if (task.isSuccessful()) {
                        Log.d(TAG, "Successfully signed in with email link!");
                        AuthResult result = task.getResult();
                        // You can access the new user via result.getUser()
                        // Additional user info profile *not* available via:
                        // result.getAdditionalUserInfo().getProfile() == null
                        // You can check if the user is new or existing:
                        // result.getAdditionalUserInfo().isNewUser()
                    } else {
                        Log.e(TAG, "Error signing in with email link", task.getException());
                    }
                }
            });
}

Per scoprire di più su come gestire l'accesso con link via email in un'applicazione Apple, consulta la guida alle piattaforme Apple.

Per scoprire come gestire l'accesso con link via email in un'applicazione web, consulta la guida web.

Puoi anche collegare questo metodo di autenticazione a un utente esistente. Ad esempio, un utente precedentemente autenticato con un altro provider, come un numero di telefono, può aggiungere questo metodo di accesso al proprio account esistente.

La differenza sta nella seconda metà dell'operazione:

Kotlin

// Construct the email link credential from the current URL.
val credential = EmailAuthProvider.getCredentialWithLink(email, emailLink)

// Link the credential to the current user.
Firebase.auth.currentUser!!.linkWithCredential(credential)
    .addOnCompleteListener { task ->
        if (task.isSuccessful) {
            Log.d(TAG, "Successfully linked emailLink credential!")
            val result = task.result
            // You can access the new user via result.getUser()
            // Additional user info profile *not* available via:
            // result.getAdditionalUserInfo().getProfile() == null
            // You can check if the user is new or existing:
            // result.getAdditionalUserInfo().isNewUser()
        } else {
            Log.e(TAG, "Error linking emailLink credential", task.exception)
        }
    }

Java

// Construct the email link credential from the current URL.
AuthCredential credential =
        EmailAuthProvider.getCredentialWithLink(email, emailLink);

// Link the credential to the current user.
auth.getCurrentUser().linkWithCredential(credential)
        .addOnCompleteListener(new OnCompleteListener<AuthResult>() {
            @Override
            public void onComplete(@NonNull Task<AuthResult> task) {
                if (task.isSuccessful()) {
                    Log.d(TAG, "Successfully linked emailLink credential!");
                    AuthResult result = task.getResult();
                    // You can access the new user via result.getUser()
                    // Additional user info profile *not* available via:
                    // result.getAdditionalUserInfo().getProfile() == null
                    // You can check if the user is new or existing:
                    // result.getAdditionalUserInfo().isNewUser()
                } else {
                    Log.e(TAG, "Error linking emailLink credential", task.getException());
                }
            }
        });

Può essere utilizzato anche per autenticare nuovamente un utente con link via email prima di eseguire un'operazione sensibile.

Kotlin

// Construct the email link credential from the current URL.
val credential = EmailAuthProvider.getCredentialWithLink(email, emailLink)

// Re-authenticate the user with this credential.
Firebase.auth.currentUser!!.reauthenticateAndRetrieveData(credential)
    .addOnCompleteListener { task ->
        if (task.isSuccessful) {
            // User is now successfully reauthenticated
        } else {
            Log.e(TAG, "Error reauthenticating", task.exception)
        }
    }

Java

// Construct the email link credential from the current URL.
AuthCredential credential =
        EmailAuthProvider.getCredentialWithLink(email, emailLink);

// Re-authenticate the user with this credential.
auth.getCurrentUser().reauthenticateAndRetrieveData(credential)
        .addOnCompleteListener(new OnCompleteListener<AuthResult>() {
            @Override
            public void onComplete(@NonNull Task<AuthResult> task) {
                if (task.isSuccessful()) {
                    // User is now successfully reauthenticated
                } else {
                    Log.e(TAG, "Error reauthenticating", task.getException());
                }
            }
        });

Tuttavia, poiché il flusso potrebbe terminare su un dispositivo diverso su cui l'utente originale non ha eseguito l'accesso, questo flusso potrebbe non essere completato. In questo caso, all'utente può essere mostrato un errore per forzarlo ad aprire il link sullo stesso dispositivo. Alcuni stati possono essere passati nel link per fornire informazioni sul tipo di operazione e sull'UID dell'utente.

In precedenza, l'autenticazione tramite link via email si basava su Firebase Dynamic Links, che verrà disattivato il 25 agosto 2025.

Abbiamo pubblicato una soluzione alternativa nell'SDK Android Firebase Authentication v23.2.0+ e Firebase BoM v33.9.0+.

Se la tua app utilizza i link di vecchio tipo, devi eseguire la migrazione dell'app al nuovo sistema basato su Firebase Hosting.

Se hai creato il progetto il 15 settembre 2023 o in una data successiva, la protezione dall'enumerazione delle email è abilitata per impostazione predefinita. Questa funzionalità migliora la sicurezza degli account utente del tuo progetto, ma disattiva il metodo fetchSignInMethodsForEmail(), che in precedenza consigliavamo di implementare per i flussi Identifier-First.

Sebbene sia possibile disattivare la protezione da enumerazione email per il tuo progetto, ti consigliamo di non farlo.

Per ulteriori dettagli, consulta la documentazione sulla protezione dall'enumerazione delle email.

Passaggi successivi

Dopo che un utente ha eseguito l'accesso per la prima volta, viene creato un nuovo account utente e collegato alle credenziali, ovvero nome utente e password, numero di telefono o informazioni del provider di autenticazione, con cui l'utente ha eseguito 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 progetto, indipendentemente dalla modalità di accesso dell'utente.

  • Nelle tue app, puoi ottenere le informazioni di base del profilo dell'utente dall'oggetto FirebaseUser. Consulta Gestisci utenti.

  • Nelle regole di sicurezza di Firebase Realtime Database e Cloud Storage, puoi ottenere l'ID utente univoco dell'utente che ha eseguito l'accesso dalla variabile auth e utilizzarlo per controllare i dati a cui un utente può accedere.

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

Per disconnettere un utente, chiama signOut:

Kotlin

Firebase.auth.signOut()

Java

FirebaseAuth.getInstance().signOut();