Catch up on everything announced at Firebase Summit, and learn how Firebase can help you accelerate app development and run your app with confidence. Learn More

Autenticati con Firebase su piattaforme Apple utilizzando un numero di telefono

Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Puoi utilizzare Firebase Authentication 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 l'accesso tramite numero di telefono alla tua app consiste nell'utilizzare FirebaseUI , che include un widget di accesso drop-in che implementa i flussi di accesso per l'accesso tramite numero di telefono, nonché l'accesso basato su password e federato -in. Questo documento descrive come implementare un flusso di accesso tramite numero di telefono utilizzando l'SDK Firebase.

Prima di iniziare

Utilizza Swift Package Manager per installare e gestire le dipendenze di Firebase.

  1. In Xcode, con il progetto dell'app aperto, vai a File > Add Packages .
  2. Quando richiesto, aggiungi il repository SDK delle piattaforme Firebase Apple:
  3.   https://github.com/firebase/firebase-ios-sdk
  4. Scegli la libreria Firebase Authentication.
  5. Al termine, Xcode inizierà automaticamente a risolvere e scaricare le tue dipendenze in background.
E, controlla un passaggio di configurazione:
  1. Se non hai ancora collegato la tua app al tuo progetto Firebase, fallo dalla console Firebase .

Problemi di sicurezza

L'autenticazione utilizzando solo un numero di telefono, sebbene conveniente, è meno sicura rispetto agli 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 di sicurezza dell'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 , apri la sezione Autenticazione .
  2. Nella pagina Metodo di accesso abilitare il metodo di accesso tramite numero di telefono .

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 far accedere un volume molto elevato di utenti con l'autenticazione telefonica, potrebbe essere necessario aggiornare il tuo piano tariffario. Consulta la pagina dei prezzi .

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 tramite numero di telefono provengano dalla tua app. Ci sono due modi in cui l'autenticazione Firebase esegue questa operazione:

  • Notifiche APN silenziose : quando accedi per la prima volta a un utente con il suo numero di telefono su un dispositivo, Firebase Authentication invia un token al dispositivo utilizzando una notifica push silenziosa. Se la tua app riceve correttamente la notifica da Firebase, l'accesso tramite numero di telefono può procedere.

    Per iOS 8.0 e versioni successive, le notifiche silenziose non richiedono il consenso esplicito dell'utente e pertanto non sono interessate da un utente che rifiuta di ricevere notifiche APN nell'app. Pertanto, l'app non ha bisogno di richiedere l'autorizzazione dell'utente per ricevere notifiche push durante l'implementazione dell'autenticazione del numero di telefono di Firebase.

  • Verifica reCAPTCHA : nel caso in cui l'invio o la ricezione di una notifica push silenziosa non sia possibile, ad esempio quando l'utente ha disattivato l'aggiornamento in background per la tua app o durante il test della tua app su un simulatore iOS, Firebase Authentication utilizza la verifica reCAPTCHA per completare il telefono flusso di accesso. La sfida reCAPTCHA spesso può essere completata senza che l'utente debba risolvere nulla.

Quando le notifiche push silenziose sono configurate correttamente, solo una percentuale molto piccola di utenti sperimenterà il flusso reCAPTCHA. Tuttavia, è necessario assicurarsi che l'accesso tramite numero di telefono funzioni correttamente indipendentemente dal fatto che siano disponibili o meno notifiche push silenziose.

Inizia a ricevere notifiche silenziose

Per abilitare le notifiche APN da utilizzare con Firebase Authentication:

  1. In Xcode, abilita le notifiche push per il tuo progetto.
  2. Carica la tua chiave di autenticazione APN su Firebase. Se non disponi già di una chiave di autenticazione APNs, assicurati di crearne una nell'Apple Developer Member Center .

    1. All'interno del progetto nella console Firebase, seleziona l'icona a forma di ingranaggio, seleziona Impostazioni progetto , quindi seleziona la scheda Cloud Messaging .

    2. Nella chiave di autenticazione APN in Configurazione app iOS , fai clic sul pulsante Carica .

    3. Passare alla posizione in cui è stata salvata la chiave, selezionarla e fare clic su Apri . Aggiungi l'ID chiave per la chiave (disponibile nell'Apple Developer Member Center ) e fai clic su Carica .

    Se disponi già di un certificato APNs, puoi invece caricare il certificato.

Imposta la verifica reCAPTCHA

Per consentire all'SDK Firebase di utilizzare la verifica reCAPTCHA:

  1. Aggiungi schemi URL personalizzati al tuo progetto Xcode:
    1. Apri la configurazione del tuo progetto: fai doppio clic sul nome del progetto nella vista ad albero a sinistra. Seleziona la tua app dalla sezione TARGETS , quindi seleziona la scheda Informazioni ed espandi la sezione Tipi di URL .
    2. Fai clic sul pulsante + e aggiungi uno schema URL per il tuo ID cliente invertito. Per trovare questo valore, apri il file di configurazione GoogleService-Info.plist e cerca la chiave REVERSED_CLIENT_ID . Copia il valore di tale chiave e incollalo nella casella Schemi URL nella pagina di configurazione. Lascia vuoti gli altri campi.

      Al termine, la configurazione dovrebbe essere simile alla seguente (ma con i valori specifici dell'applicazione):

  2. Facoltativo : se desideri personalizzare il modo in cui la tua app presenta SFSafariViewController quando mostra reCAPTCHA all'utente, crea una classe personalizzata conforme al protocollo AuthUIDelegate e passala a verifyPhoneNumber(_:uiDelegate:completion:) .

Invia un codice di verifica al telefono dell'utente

Per avviare l'accesso tramite numero di telefono, presenta all'utente un'interfaccia che richiede di fornire il proprio numero di telefono, quindi chiama verifyPhoneNumber(_:uiDelegate:completion:) per richiedere a Firebase di inviare un codice di autenticazione al telefono dell'utente tramite SMS:

  1. Ottenere il numero di telefono dell'utente.

    I requisiti legali variano, ma come best practice e per impostare le aspettative per i tuoi utenti, dovresti informarli che se utilizzano l'accesso telefonico, potrebbero ricevere un messaggio SMS per la verifica e si applicano le tariffe standard.

  2. Chiama verifyPhoneNumber(_:uiDelegate:completion:) , passandogli il numero di telefono dell'utente.

    Rapido

    PhoneAuthProvider.provider()
      .verifyPhoneNumber(phoneNumber, uiDelegate: nil) { verificationID, error in
          if let error = error {
            self.showMessagePrompt(error.localizedDescription)
            return
          }
          // Sign in using the verificationID and the code sent to the user
          // ...
      }

    Obiettivo-C

    [[FIRPhoneAuthProvider provider] verifyPhoneNumber:userInput
                                            UIDelegate:nil
                                            completion:^(NSString * _Nullable verificationID, NSError * _Nullable error) {
      if (error) {
        [self showMessagePrompt:error.localizedDescription];
        return;
      }
      // Sign in using the verificationID and the code sent to the user
      // ...
    }];

    Il metodo verifyPhoneNumber è rientrante: se lo chiami più volte, come nel metodo onAppear di una vista, il metodo verifyPhoneNumber non invierà un secondo SMS a meno che la richiesta originale non sia scaduta.

    Quando chiami verifyPhoneNumber(_:uiDelegate:completion:) , Firebase invia una notifica push silenziosa alla tua app o invia una verifica reCAPTCHA all'utente. Dopo che l'app ha ricevuto la notifica o l'utente ha completato il test reCAPTCHA, Firebase invia un messaggio SMS contenente un codice di autenticazione al numero di telefono specificato e trasmette un ID di verifica alla tua funzione di completamento. Avrai bisogno sia del codice di verifica che dell'ID di verifica per accedere come utente.

    Il messaggio SMS inviato da Firebase può anche essere localizzato specificando la lingua auth tramite la proprietà languageCode sulla tua istanza Auth.

    Rapido

     // Change language code to french.
     Auth.auth().languageCode = "fr";
    

    Obiettivo-C

     // Change language code to french.
     [FIRAuth auth].languageCode = @"fr";
    
  3. Salva l'ID di verifica e ripristinalo al caricamento dell'app. In questo modo, puoi assicurarti di avere ancora un ID di verifica valido se la tua app viene terminata prima che l'utente completi il ​​flusso di accesso (ad esempio, durante il passaggio all'app SMS).

    Puoi mantenere l'ID di verifica come preferisci. Un modo semplice è salvare l'ID di verifica con l'oggetto NSUserDefaults :

    Rapido

    UserDefaults.standard.set(verificationID, forKey: "authVerificationID")
    

    Obiettivo-C

    NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
    [defaults setObject:verificationID forKey:@"authVerificationID"];
    

    Quindi, puoi ripristinare il valore salvato:

    Rapido

    let verificationID = UserDefaults.standard.string(forKey: "authVerificationID")
    

    Obiettivo-C

    NSString *verificationID = [defaults stringForKey:@"authVerificationID"];
    

Se la chiamata a verifyPhoneNumber(_:uiDelegate:completion:) ha esito positivo, puoi chiedere all'utente di digitare il codice di verifica quando lo riceve nel messaggio SMS.

Accedi come utente con il codice di verifica

Dopo che l'utente ha fornito alla tua app il codice di verifica del messaggio SMS, accedi creando un oggetto FIRPhoneAuthCredential dal codice di verifica e dall'ID di verifica e passando tale oggetto a signInWithCredential:completion: .

  1. Ottenere il codice di verifica dall'utente.
  2. Crea un oggetto FIRPhoneAuthCredential dal codice di verifica e dall'ID di verifica.

    Rapido

    let credential = PhoneAuthProvider.provider().credential(
      withVerificationID: verificationID,
      verificationCode: verificationCode
    )

    Obiettivo-C

    FIRAuthCredential *credential = [[FIRPhoneAuthProvider provider]
        credentialWithVerificationID:verificationID
                    verificationCode:userInput];
  3. Accedi l'utente con l'oggetto FIRPhoneAuthCredential :

    Rapido

    Auth.auth().signIn(with: credential) { authResult, error in
        if let error = error {
          let authError = error as NSError
          if isMFAEnabled, authError.code == AuthErrorCode.secondFactorRequired.rawValue {
            // The user is a multi-factor user. Second factor challenge is required.
            let resolver = authError
              .userInfo[AuthErrorUserInfoMultiFactorResolverKey] as! MultiFactorResolver
            var displayNameString = ""
            for tmpFactorInfo in resolver.hints {
              displayNameString += tmpFactorInfo.displayName ?? ""
              displayNameString += " "
            }
            self.showTextInputPrompt(
              withMessage: "Select factor to sign in\n\(displayNameString)",
              completionBlock: { userPressedOK, displayName in
                var selectedHint: PhoneMultiFactorInfo?
                for tmpFactorInfo in resolver.hints {
                  if displayName == tmpFactorInfo.displayName {
                    selectedHint = tmpFactorInfo as? PhoneMultiFactorInfo
                  }
                }
                PhoneAuthProvider.provider()
                  .verifyPhoneNumber(with: selectedHint!, uiDelegate: nil,
                                     multiFactorSession: resolver
                                       .session) { verificationID, error in
                    if error != nil {
                      print(
                        "Multi factor start sign in failed. Error: \(error.debugDescription)"
                      )
                    } else {
                      self.showTextInputPrompt(
                        withMessage: "Verification code for \(selectedHint?.displayName ?? "")",
                        completionBlock: { userPressedOK, verificationCode in
                          let credential: PhoneAuthCredential? = PhoneAuthProvider.provider()
                            .credential(withVerificationID: verificationID!,
                                        verificationCode: verificationCode!)
                          let assertion: MultiFactorAssertion? = PhoneMultiFactorGenerator
                            .assertion(with: credential!)
                          resolver.resolveSignIn(with: assertion!) { authResult, error in
                            if error != nil {
                              print(
                                "Multi factor finanlize sign in failed. Error: \(error.debugDescription)"
                              )
                            } else {
                              self.navigationController?.popViewController(animated: true)
                            }
                          }
                        }
                      )
                    }
                  }
              }
            )
          } else {
            self.showMessagePrompt(error.localizedDescription)
            return
          }
          // ...
          return
        }
        // User is signed in
        // ...
    }

    Obiettivo-C

    [[FIRAuth auth] signInWithCredential:credential
                              completion:^(FIRAuthDataResult * _Nullable authResult,
                                           NSError * _Nullable error) {
        if (isMFAEnabled && error && error.code == FIRAuthErrorCodeSecondFactorRequired) {
          FIRMultiFactorResolver *resolver = error.userInfo[FIRAuthErrorUserInfoMultiFactorResolverKey];
          NSMutableString *displayNameString = [NSMutableString string];
          for (FIRMultiFactorInfo *tmpFactorInfo in resolver.hints) {
            [displayNameString appendString:tmpFactorInfo.displayName];
            [displayNameString appendString:@" "];
          }
          [self showTextInputPromptWithMessage:[NSString stringWithFormat:@"Select factor to sign in\n%@", displayNameString]
                               completionBlock:^(BOOL userPressedOK, NSString *_Nullable displayName) {
           FIRPhoneMultiFactorInfo* selectedHint;
           for (FIRMultiFactorInfo *tmpFactorInfo in resolver.hints) {
             if ([displayName isEqualToString:tmpFactorInfo.displayName]) {
               selectedHint = (FIRPhoneMultiFactorInfo *)tmpFactorInfo;
             }
           }
           [FIRPhoneAuthProvider.provider
            verifyPhoneNumberWithMultiFactorInfo:selectedHint
            UIDelegate:nil
            multiFactorSession:resolver.session
            completion:^(NSString * _Nullable verificationID, NSError * _Nullable error) {
              if (error) {
                [self showMessagePrompt:error.localizedDescription];
              } else {
                [self showTextInputPromptWithMessage:[NSString stringWithFormat:@"Verification code for %@", selectedHint.displayName]
                                     completionBlock:^(BOOL userPressedOK, NSString *_Nullable verificationCode) {
                 FIRPhoneAuthCredential *credential =
                     [[FIRPhoneAuthProvider provider] credentialWithVerificationID:verificationID
                                                                  verificationCode:verificationCode];
                 FIRMultiFactorAssertion *assertion = [FIRPhoneMultiFactorGenerator assertionWithCredential:credential];
                 [resolver resolveSignInWithAssertion:assertion completion:^(FIRAuthDataResult * _Nullable authResult, NSError * _Nullable error) {
                   if (error) {
                     [self showMessagePrompt:error.localizedDescription];
                   } else {
                     NSLog(@"Multi factor finanlize sign in succeeded.");
                   }
                 }];
               }];
              }
            }];
         }];
        }
      else if (error) {
        // ...
        return;
      }
      // User successfully signed in. Get user data from the FIRUser object
      if (authResult == nil) { return; }
      FIRUser *user = authResult.user;
      // ...
    }];

Test 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 i seguenti vantaggi:

  • Prova l'autenticazione del numero di telefono senza consumare la tua quota di utilizzo.
  • Prova l'autenticazione del numero di telefono senza inviare un vero messaggio SMS.
  • 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 ai 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 siano davvero fittizi e che non esistano già. Firebase Authentication non consente di impostare i numeri di telefono esistenti utilizzati da utenti reali come numeri di prova. Un'opzione consiste nell'utilizzare i numeri con prefisso 555 come numeri di telefono di prova negli Stati Uniti, ad 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. Utilizzare numeri di telefono/codici di prova difficili da indovinare e modificarli frequentemente.

Crea numeri di telefono fittizi e codici di verifica

  1. Nella console Firebase , apri la sezione Autenticazione .
  2. Nella scheda Metodo di accesso , abilita il Gestore telefonico se non l'hai già fatto.
  3. Apri il menu Numeri di telefono per testare la fisarmonica.
  4. Fornisci il numero di telefono che desideri testare, 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 ce n'è bisogno, puoi eliminare il numero di telefono e il relativo codice passando con il mouse sopra la 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 limitazione. 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 consiste nell'impostare un ruolo di test tramite attestazioni personalizzate su questi utenti per differenziarli come utenti falsi se si desidera limitare ulteriormente l'accesso.

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 possibile il test di automazione in questi flussi e più facile da implementare. Inoltre, aiutano a fornire la possibilità di testare i flussi di verifica istantanea su Android.

Su iOS, l'impostazione appVerificationDisabledForTesting deve essere impostata su TRUE prima di chiamare verifyPhoneNumber . Questo viene elaborato senza richiedere alcun token APN o inviare notifiche push silenziose in background, semplificando il test in un simulatore. Questo disabilita anche il flusso di fallback reCAPTCHA.

Tieni presente che quando la verifica dell'app è disabilitata, l'utilizzo di un numero di telefono non fittizio non consentirà di completare l'accesso. Con questa API è possibile utilizzare solo numeri di telefono fittizi.

Rapido

let phoneNumber = "+16505554567"

// This test verification code is specified for the given test phone number in the developer console.
let testVerificationCode = "123456"

Auth.auth().settings.isAppVerificationDisabledForTesting = TRUE
PhoneAuthProvider.provider().verifyPhoneNumber(phoneNumber, uiDelegate:nil) {
                                                            verificationID, error in
    if (error) {
      // Handles error
      self.handleError(error)
      return
    }
    let credential = PhoneAuthProvider.provider().credential(withVerificationID: verificationID ?? "",
                                                               verificationCode: testVerificationCode)
    Auth.auth().signInAndRetrieveData(with: credential) { authData, error in
      if (error) {
        // Handles error
        self.handleError(error)
        return
      }
      _user = authData.user
    }];
}];

Obiettivo-C

NSString *phoneNumber = @"+16505554567";

// This test verification code is specified for the given test phone number in the developer console.
NSString *testVerificationCode = @"123456";

[FIRAuth auth].settings.appVerificationDisabledForTesting = YES;
[[FIRPhoneAuthProvider provider] verifyPhoneNumber:phoneNumber
                                        completion:^(NSString *_Nullable verificationID,
                                                     NSError *_Nullable error) {
    if (error) {
      // Handles error
      [self handleError:error];
      return;
    }
    FIRAuthCredential *credential =
        [FIRPhoneAuthProvider credentialWithVerificationID:verificationID
                                          verificationCode:testVerificationCode];
    [FIRAuth auth] signInWithAndRetrieveDataWithCredential:credential
                                                completion:^(FIRUser *_Nullable user,
                                                             NSError *_Nullable error) {
      if (error) {
        // Handles error
        [self handleError:error];
        return;
      }
      _user = user;
    }];
}];

Appendice: utilizzo dell'accesso tramite telefono senza swizzling

Firebase Authentication utilizza il metodo swizzling per ottenere automaticamente il token APNs della tua app, per gestire le notifiche push silenziose che Firebase invia alla tua app e per intercettare automaticamente il reindirizzamento dello schema personalizzato dalla pagina di verifica reCAPTCHA durante la verifica.

Se preferisci non usare lo swizzling, puoi disabilitarlo aggiungendo il flag FirebaseAppDelegateProxyEnabled al file Info.plist della tua app e impostandolo su NO . Tieni presente che l'impostazione di questo flag su NO disabilita anche lo swizzling per altri prodotti Firebase, incluso Firebase Cloud Messaging.

Se disabiliti lo swizzling, devi passare esplicitamente il token del dispositivo APN, le notifiche push e l'URL di reindirizzamento dello schema personalizzato all'autenticazione Firebase.

Se stai creando un'applicazione SwiftUI, devi anche passare esplicitamente il token del dispositivo APN, le notifiche push e l'URL di reindirizzamento dello schema personalizzato all'autenticazione Firebase.

Per ottenere il token del dispositivo APNs, implementa il metodo application(_:didRegisterForRemoteNotificationsWithDeviceToken:) e, in esso, passa il token del dispositivo al metodo setAPNSToken(_:type:) Auth .

Rapido

func application(_ application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
  // Pass device token to auth
  Auth.auth().setAPNSToken(deviceToken, type: .prod)

  // Further handling of the device token if needed by the app
  // ...
}

Obiettivo-C

- (void)application:(UIApplication *)application
    didRegisterForRemoteNotificationsWithDeviceToken:(NSData *)deviceToken {
  // Pass device token to auth.
  [[FIRAuth auth] setAPNSToken:deviceToken type:FIRAuthAPNSTokenTypeProd];
  // Further handling of the device token if needed by the app.
}

Per gestire le notifiche push, nel application(_:didReceiveRemoteNotification:fetchCompletionHandler:): controlla le notifiche relative all'autenticazione Firebase chiamando il metodo canHandleNotification(_:) di Auth .

Rapido

func application(_ application: UIApplication,
    didReceiveRemoteNotification notification: [AnyHashable : Any],
    fetchCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void) {
  if Auth.auth().canHandleNotification(notification) {
    completionHandler(.noData)
    return
  }
  // This notification is not auth related; it should be handled separately.
}

Obiettivo-C

- (void)application:(UIApplication *)application
    didReceiveRemoteNotification:(NSDictionary *)notification
          fetchCompletionHandler:(void (^)(UIBackgroundFetchResult))completionHandler {
  // Pass notification to auth and check if they can handle it.
  if ([[FIRAuth auth] canHandleNotification:notification]) {
    completionHandler(UIBackgroundFetchResultNoData);
    return;
  }
  // This notification is not auth related; it should be handled separately.
}

Per gestire l'URL di reindirizzamento dello schema personalizzato, implementa il metodo application(_:open:options:) e, in essi, passa l'URL al metodo canHandleURL(_:) di Auth .

Rapido

func application(_ application: UIApplication, open url: URL,
    options: [UIApplicationOpenURLOptionsKey : Any]) -> Bool {
  if Auth.auth().canHandle(url) {
    return true
  }
  // URL not auth related; it should be handled separately.
}

Obiettivo-C

- (BOOL)application:(UIApplication *)app
            openURL:(NSURL *)url
            options:(NSDictionary<UIApplicationOpenURLOptionsKey, id> *)options {
  if ([[FIRAuth auth] canHandleURL:url]) {
    return YES;
  }
  // URL not auth related; it should be handled separately.
}

Se utilizzi SwiftUI o UISceneDelegate , per gestire l'URL di reindirizzamento, implementa il metodo scene(_:openURLContexts:) e, in essi, passa l'URL al metodo canHandleURL(_:) di Auth .

Rapido

func scene(_ scene: UIScene, openURLContexts URLContexts: Set<UIOpenURLContext>) {
  for urlContext in URLContexts {
      let url = urlContext.url
      Auth.auth().canHandle(url)
  }
  // URL not auth related; it should be handled separately.
}

Obiettivo-C

- (void)scene:(UIScene *)scene openURLContexts:(NSSet<UIOpenURLContext *> *)URLContexts {
  for (UIOpenURLContext *urlContext in URLContexts) {
    [FIRAuth.auth canHandleURL:urlContext.url];
    // URL not auth related; it should be handled separately.
  }
}

Prossimi passi

Dopo che un utente ha effettuato 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 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 dalla modalità di accesso dell'utente.

  • Nelle tue app puoi ottenere le informazioni di base sul profilo dell'utente dall'oggetto FIRUser . Vedere Gestire gli utenti .

  • In Firebase Realtime Database and Cloud Storage Security Rules , puoi ottenere l'ID utente univoco dell'utente che ha eseguito l'accesso dalla variabile auth e utilizzarlo per controllare a quali dati può accedere un utente.

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: .

Rapido

    let firebaseAuth = Auth.auth()
do {
  try firebaseAuth.signOut()
} catch let signOutError as NSError {
  print("Error signing out: %@", signOutError)
}
  

Obiettivo-C

    NSError *signOutError;
BOOL status = [[FIRAuth auth] signOut:&signOutError];
if (!status) {
  NSLog(@"Error signing out: %@", signOutError);
  return;
}

Potresti anche voler aggiungere il codice di gestione degli errori per l'intera gamma di errori di autenticazione. Vedere Gestione degli errori .