Eseguire l'autenticazione con Firebase sulle piattaforme Apple utilizzando un numero di telefono

Puoi utilizzare Firebase Authentication per consentire a un utente di accedere inviando un messaggio SMS al suo smartphone. L'utente accede utilizzando un codice monouso contenuto nel messaggio SMS.

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

Prima di iniziare

Se non hai ancora collegato l'app al progetto Firebase, fallo da console.Firebase
Utilizza Swift Package Manager per installare e gestire le dipendenze di Firebase.

Visita la nostra guida all'installazione per scoprire i diversi modi in cui puoi aggiungere gli SDK Firebase al tuo progetto Apple.
1. In Xcode, con il progetto dell'app aperto, vai a File > Add Packages (File > Aggiungi pacchetti).
2. Quando richiesto, aggiungi il repository dell'SDK delle piattaforme Apple di Firebase:
3. Scegli la Firebase Authentication libreria.
4. Aggiungi il flag -ObjC alla sezione Other Linker Flags (Altri flag del linker) delle impostazioni di compilazione della destinazione.
5. Al termine, Xcode inizierà automaticamente a risolvere e a scaricare le tue dipendenze in background.

Problemi di sicurezza

L'autenticazione che utilizza solo un numero di telefono, sebbene comoda, è meno sicura degli altri metodi disponibili, perché la proprietà di un numero di telefono può essere facilmente trasferita tra gli utenti. Inoltre, sui dispositivi con più profili utente, qualsiasi utente che può 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 con il numero di telefono.

Per consentire agli utenti di accedere tramite SMS, devi prima attivare il metodo di accesso con il numero di telefono per il progetto Firebase:

Nella Firebase console, apri la sezione Autenticazione.
Nella pagina Metodo di accesso, attiva il metodo di accesso Numero di telefono.
Nella pagina Impostazioni, imposta un criterio per le regioni a cui vuoi consentire o negare l'invio di messaggi SMS. Per i nuovi progetti, il criterio predefinito non consente alcuna regione.

Attivare la verifica dell'app

Per utilizzare l'autenticazione con il numero di telefono, Firebase deve essere in grado di verificare che le richieste di accesso con il numero di telefono provengano dalla tua app. Ci sono due modi in cui Firebase Authentication lo fa:

Notifiche APN silenziose: quando un utente accede per la prima volta 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 con il numero di telefono può continuare.
Per iOS 8.0 e versioni successive, le notifiche silenziose non richiedono il consenso esplicito dell'utente e pertanto non sono interessate dal rifiuto dell'utente di ricevere notifiche APN nell'app. Di conseguenza, l'app non deve richiedere l'autorizzazione dell'utente a ricevere notifiche push quando implementa l'autenticazione con il numero di telefono di Firebase.
Verifica reCAPTCHA: nel caso in cui non sia possibile inviare o ricevere una notifica push silenziosa, ad esempio quando l'utente ha disattivato l'aggiornamento in background per la tua app o quando testi l'app su un simulatore iOS, Firebase Authentication utilizza la verifica reCAPTCHA per completare il flusso di accesso con il numero di telefono. La verifica reCAPTCHA può spesso 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, devi assicurarti che l'accesso con il numero di telefono funzioni correttamente indipendentemente dalla disponibilità delle notifiche push silenziose.

Iniziare a ricevere notifiche silenziose

Per attivare le notifiche APN da utilizzare con Firebase Authentication:

In Xcode, attiva le notifiche push per il tuo progetto.
Carica la chiave di autenticazione APN su Firebase. Se non hai ancora una chiave di autenticazione APN, assicurati di crearne una nel Apple Developer Member Center.
1. All'interno del progetto nella console Firebase, seleziona l'icona a forma di ingranaggio , seleziona Impostazioni progetto e poi la scheda Cloud Messaging.
2. In Chiave di autenticazione APN nella sezione Configurazione app iOS, fai clic sul pulsante Carica per caricare la chiave di autenticazione di sviluppo, la chiave di autenticazione di produzione o entrambe. È necessaria almeno una delle due.
3. Vai alla posizione in cui hai salvato la chiave, selezionala e fai clic Apri. Aggiungi l'ID della chiave (disponibile nell' Apple Developer Member Center) e fai clic su Carica.
Se hai già un certificato APN, puoi caricare il certificato invece.
In Xcode, attiva la funzionalità Modalità in background per il tuo progetto, quindi seleziona le caselle di controllo per le modalità Recupero in background e Notifiche remote.

Configurare la verifica reCAPTCHA

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

Aggiungi schemi URL personalizzati al progetto Xcode:
1. Apri la configurazione del progetto: fai doppio clic sul nome del progetto nella visualizzazione ad albero a sinistra. Seleziona l'app dalla sezione TARGETS (Destinazioni), quindi seleziona la scheda Info ed espandi la sezione URL Types (Tipi di URL).
2. Fai clic sul pulsante + e aggiungi l'ID app codificato come schema URL scheme. Puoi trovare l'ID app codificato nella pagina Impostazioni generali della console Firebase, nella sezione relativa all'app per iOS. Lascia vuoti gli altri campi.
  Al termine, la configurazione dovrebbe essere simile alla seguente (ma con i valori specifici dell'applicazione):
Facoltativo: se vuoi personalizzare il modo in cui l'app presenta SFSafariViewController quando mostra reCAPTCHA all'utente, crea una classe personalizzata conforme al protocollo AuthUIDelegate e passala a verifyPhoneNumber(_:uiDelegate:completion:).

Inviare un codice di verifica allo smartphone dell'utente

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

Recupera il numero di telefono dell'utente.

I requisiti legali variano, ma come best practice e per impostare le aspettative degli utenti, dovresti informarli che se utilizzano l'accesso con il numero di telefono, potrebbero ricevere un messaggio SMS per la verifica e che si applicano le tariffe standard.
Chiama verifyPhoneNumber(_:uiDelegate:completion:), passandogli il numero di telefono dell'utente.
Swift
```
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
      // ...
  }
```
Objective-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
  // ...
}];
```
Nota: a seconda del piano di fatturazione, potresti essere soggetto a una quota giornaliera di messaggi SMS inviati. Consulta Firebase Authentication Limiti.

Il metodo verifyPhoneNumber è rientrante: se lo chiami più volte, ad esempio nel metodo onAppear di una visualizzazione, 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 emette una verifica reCAPTCHA per l'utente. Dopo che l'app riceve la notifica o l'utente completa la verifica reCAPTCHA, Firebase invia un messaggio SMS contenente un codice di autenticazione al numero di telefono specificato e passa un ID di verifica alla funzione di completamento. Per consentire all'utente di accedere, avrai bisogno sia del codice di verifica sia dell'ID di verifica.

Il messaggio SMS inviato da Firebase può anche essere localizzato specificando la lingua di autenticazione tramite la languageCode proprietà nell'istanza Auth.
Swift
```
 // Change language code to french.
 Auth.auth().languageCode = "fr";
```
Objective-C
```
 // Change language code to french.
 [FIRAuth auth].languageCode = @"fr";
```
Salva l'ID di verifica e ripristinalo quando l'app viene caricata. In questo modo, puoi assicurarti di avere ancora un ID di verifica valido se l'app viene terminata prima che l'utente completi il flusso di accesso (ad esempio, quando passa all'app SMS).

Puoi rendere persistente l'ID di verifica in qualsiasi modo. Un modo semplice è salvare l'ID di verifica con l'oggetto NSUserDefaults:
Swift
```
UserDefaults.standard.set(verificationID, forKey: "authVerificationID")
```
Objective-C
```
NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
[defaults setObject:verificationID forKey:@"authVerificationID"];
```
Poi, puoi ripristinare il valore salvato:
Swift
```
let verificationID = UserDefaults.standard.string(forKey: "authVerificationID")
```
Objective-C
```
NSString *verificationID = [defaults stringForKey:@"authVerificationID"];
```

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

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

Recupera il codice di verifica dall'utente.

Crea un oggetto FIRPhoneAuthCredential dal codice di verifica e dall'ID di verifica.

Swift

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

Objective-C

FIRAuthCredential *credential = [[FIRPhoneAuthProvider provider]
    credentialWithVerificationID:verificationID
                verificationCode:userInput];

Consenti all'utente di accedere con l'oggetto FIRPhoneAuthCredential:

Swift

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

Objective-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;
  // ...
}];

Testare con numeri di telefono fittizi

Puoi configurare numeri di telefono fittizi per lo sviluppo tramite la Firebase console. I test con numeri di telefono fittizi offrono i seguenti vantaggi:

Testare l'autenticazione con il numero di telefono senza consumare la quota di utilizzo.
Testare l'autenticazione con il numero di telefono senza inviare un messaggio SMS effettivo.
Eseguire test consecutivi con lo stesso numero di telefono senza essere limitato. In questo modo si riduce al minimo il rischio di rifiuto durante la procedura di revisione dell'App Store se il revisore utilizza lo stesso numero di telefono per i test.
Testare facilmente negli ambienti di sviluppo senza ulteriori sforzi, 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 bloccati dai controlli di sicurezza normalmente applicati ai numeri di telefono reali in un ambiente di produzione.

I numeri di telefono fittizi devono soddisfare i seguenti requisiti:

Assicurati di utilizzare numeri di telefono effettivamente fittizi e non ancora esistenti. Firebase Authentication non ti consente di impostare come numeri di test i numeri di telefono esistenti utilizzati da utenti reali. Un'opzione è utilizzare i numeri con prefisso 555 come numeri di telefono di test statunitensi, ad esempio: +1 650-555-3434
I numeri di telefono devono essere formattati correttamente per lunghezza e altri vincoli. Verranno comunque sottoposti alla stessa convalida del numero di telefono di un utente reale.
Puoi aggiungere fino a 10 numeri di telefono per lo sviluppo.
Utilizza numeri di telefono/codici di test difficili da indovinare e modifica quelli di frequente.

Creare numeri di telefono e codici di verifica fittizi

Nella Firebase console, apri la sezione Autenticazione.
Nella scheda Metodo di accesso , attiva il provider di telefonia, se non l'hai già fatto.
Apri il menu a fisarmonica Numeri di telefono per i test.
Fornisci il numero di telefono che vuoi testare, ad esempio: +1 650-555-3434.
Fornisci il codice di verifica a 6 cifre per quel numero specifico, ad esempio: 654321.
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. In questo modo, puoi eseguire test manuali durante le fasi di sviluppo senza incorrere in problemi di quota o limitazione. Puoi anche eseguire test direttamente da un simulatore iOS o da 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. inviato. Dovrai invece fornire il codice di verifica configurato in precedenza per completare l'accesso.

Al termine 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 un numero di telefono reale e può accedere a Realtime Database/Cloud Firestore e ad altri servizi allo stesso modo. Il token ID generato durante questa procedura ha la stessa firma di un utente con un numero di telefono reale.

Un'altra opzione è impostare un ruolo di test tramite rivendicazioni personalizzate per questi utenti per distinguerli come utenti falsi se vuoi limitare ulteriormente l'accesso.

Test di integrazione

Oltre ai test manuali, Firebase Authentication fornisce API per aiutarti a scrivere test di integrazione per i test di autenticazione telefonica. Queste API disabilitano la verifica dell'app disattivando il requisito reCAPTCHA nel web e le notifiche push silenziose in iOS. In questo modo è possibile eseguire test di automazione in questi flussi e semplificarne l'implementazione. Inoltre, consentono di testare i flussi di verifica immediata su Android.

Su iOS, l'impostazione appVerificationDisabledForTesting deve essere impostata su TRUE prima di chiamare verifyPhoneNumber. Questa operazione viene elaborata senza richiedere alcun token APN o inviare notifiche push silenziose in background, semplificando i test in un simulatore. Inoltre, disattiva il flusso di fallback reCAPTCHA.

Tieni presente che quando la verifica dell'app è disattivata, 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.

Swift

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 let error = error {
      // Handles error
      self.handleError(error)
      return
    }
    let credential = PhoneAuthProvider.provider().credential(withVerificationID: verificationID ?? "",
                                                               verificationCode: testVerificationCode)
    Auth.auth().signIn(with: credential) { authResult, error in
      if let error = error {
        // Handles error
        self.handleError(error)
        return
      }
      _user = authResult.user
    };
};

Objective-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;
    }];
}];

Firebase Authentication utilizza lo swizzling dei metodi per ottenere automaticamente il token APN 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 utilizzare lo swizzling, puoi disattivarlo 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 disattiva lo swizzling anche per altri prodotti Firebase, tra cui Firebase Cloud Messaging.

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

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 a Firebase Authentication.

Per ottenere il token del dispositivo APN, implementa il application(_:didRegisterForRemoteNotificationsWithDeviceToken:) metodo e, al suo interno, passa il token del dispositivo al Auth's setAPNSToken(_:type:) metodo.

Nota: le app SwiftUI devono utilizzare i wrapper delle proprietà UIApplicationDelegateAdaptor o NSApplicationDelegateAdaptor per fornire un tipo corrispondente al protocollo del delegato dell'app appropriato.

Swift

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

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

Objective-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:): metodo, controlla le notifiche correlate all'autenticazione Firebase chiamando il Auth's canHandleNotification(_:) metodo.

Swift

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

Objective-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 application(_:open:options:) metodo e, al suo interno, passa l'URL al metodo Auth's canHandleURL(_:).

Swift

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

Objective-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 scene(_:openURLContexts:) metodo e, al suo interno, passa l'URL al metodo Auth's canHandleURL(_:).

Swift

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

Objective-C

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

Passaggi successivi

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

Nelle tue app, puoi ottenere le informazioni di base del profilo dell'utente dall' User oggetto. Consulta Gestire gli 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:.

Swift

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

Objective-C

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

Potresti anche voler aggiungere codice di gestione degli errori per l'intera gamma di errori di autenticazione. Consulta Gestire gli errori.

Eseguire l'autenticazione con Firebase sulle piattaforme Apple utilizzando un numero di telefono Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Prima di iniziare

Problemi di sicurezza

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

Attivare la verifica dell'app

Iniziare a ricevere notifiche silenziose

Configurare la verifica reCAPTCHA

Inviare un codice di verifica allo smartphone dell'utente

Swift

Objective-C

Swift

Objective-C

Swift

Objective-C

Swift

Objective-C

Consentire all'utente di accedere con il codice di verifica

Swift

Objective-C

Swift

Objective-C

Testare con numeri di telefono fittizi

Creare numeri di telefono e codici di verifica fittizi

Test manuale

Test di integrazione

Swift

Objective-C

Appendice: utilizzare l'accesso con il numero di telefono senza swizzling

Swift

Objective-C

Swift

Objective-C

Swift

Objective-C

Swift

Objective-C

Passaggi successivi

Swift

Objective-C

Eseguire l'autenticazione con Firebase sulle piattaforme Apple utilizzando un numero di telefono