Questa pagina è stata tradotta dall'API Cloud Translation.

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

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

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

Prima di iniziare

Se non hai ancora collegato la tua app al progetto Firebase, puoi farlo da la console Firebase.
Usa Swift Package Manager per installare e gestire le dipendenze di Firebase.

Consulta la nostra Guida all'installazione per scoprire i diversi modi in cui puoi aggiungere gli SDK Firebase al tuo progetto Apple, tra cui importando direttamente i framework e utilizzando CocoaPods.
1. In Xcode, con il progetto dell'app aperto, vai a File > Aggiungi pacchetti.
2. Quando richiesto, aggiungi il repository dell'SDK delle piattaforme Apple di Firebase:
3. Scegli la raccolta Firebase Authentication.
4. Aggiungi il flag -ObjC alla sezione Altri flag linker delle impostazioni di build del target.
5. Al termine, Xcode inizierà automaticamente a risolvere e scaricare il le dipendenze in background.

Problemi di sicurezza

L'autenticazione basata esclusivamente su un numero di telefono, sebbene sia pratica, è meno sicura rispetto agli altri metodi disponibili, in quanto il possesso di un numero di telefono possono essere trasferite facilmente da un utente all'altro. Inoltre, sui dispositivi con più utenti profili, qualsiasi utente in grado di ricevere messaggi SMS può accedere a un account utilizzando il numero di telefono del dispositivo.

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

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

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

Attivare 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 provengono dalla tua app. Ci sono due modi Firebase Authentication ottiene questo risultato:

Notifiche silenziose del servizio APN: quando accedi a un utente tramite il suo numero di telefono per la prima volta su un dispositivo, Firebase Authentication invia un al dispositivo tramite una notifica push silenziosa. Se la tua app riceve correttamente la notifica da Firebase, numero di telefono l'accesso può procedere.
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. Pertanto, l'app non deve richiedere all'utente l'autorizzazione per ricevere notifiche push quando implementa l'autenticazione tramite numero di telefono Firebase.
Verifica reCAPTCHA: se non è possibile inviare o ricevere una notifica push silenziosa, ad esempio se l'utente ha disattivato l'aggiornamento in background per la tua app o se stai testando la tua app su un simulatore iOS, Firebase Authentication utilizza la verifica reCAPTCHA per completare il flusso di accesso dallo smartphone. Spesso la verifica reCAPTCHA può essere completata senza che l'utente debba risolvere nulla.

Quando le notifiche push silenziose sono configurate correttamente, solo un numero percentuale di utenti che sperimenterà il flusso reCAPTCHA. Ciononostante, garantire che l'accesso tramite numero di telefono funzioni correttamente, indipendentemente dal fatto che il push silenzioso le notifiche.

Iniziare a ricevere notifiche silenziose

Per attivare le notifiche APN da utilizzare con Firebase Authentication:

In Xcode, attivare le notifiche push per il tuo progetto.
Carica la chiave di autenticazione del servizio APN in Firebase. Se non disponi già di una chiave di autenticazione del servizio APN, assicurati di crearne una nella Centro membri per gli sviluppatori Apple.
1. All'interno del progetto nella console Firebase, seleziona icona a forma di ingranaggio, seleziona Impostazioni progetto, quindi seleziona Scheda Cloud Messaging.
2. Nella sezione Chiave di autenticazione APN in Configurazione app per iOS, fai clic sul pulsante Carica .
3. Vai alla posizione in cui hai salvato la chiave, selezionala e fai clic su Apri. Aggiungi l'ID chiave per la chiave (disponibile nel Centro membri Apple Developer) e fai clic su Carica.
Se hai già un certificato del servizio APN, puoi caricarlo.
In Xcode, abilita la funzionalità Modalità in background per il progetto, quindi seleziona le caselle di controllo per le modalità Recupero in background e Notifiche remote.

Configura la verifica reCAPTCHA

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

Aggiungi schemi URL personalizzati al tuo progetto Xcode:
1. Apri la configurazione del progetto: fai doppio clic sul nome del progetto nella vista ad albero a sinistra. Seleziona la tua app dalla sezione TARGET, poi Seleziona la scheda Informazioni ed espandi la sezione Tipi di URL.
2. Fai clic sul pulsante + e aggiungi l'ID app codificato come URL . Puoi trovare l'ID app codificato nella Generali Impostazioni della console Firebase, nella sezione iOS. dell'app. Lascia vuoti gli altri campi.
  Una volta completata, la configurazione dovrebbe essere simile alla seguenti (ma con valori specifici per l'applicazione):
Facoltativo: se vuoi personalizzare il modo in cui la tua app presenta il SFSafariViewController quando mostra il 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 con il numero di telefono, presenta all'utente un'interfaccia che richieda di fornire il proprio numero di telefono e poi di chiamare verifyPhoneNumber(_:uiDelegate:completion:) per richiedere a Firebase invia un codice di autenticazione al telefono dell'utente tramite SMS:

Recupera il numero di telefono dell'utente.

I requisiti legali variano ma come best practice e definire aspettative per gli utenti, è bene informarli che, se utilizzano all'accesso con il telefono, potrebbero ricevere un SMS per la verifica si applicano le tariffe.
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 limitato a una quota giornaliera di messaggi SMS inviati. Vedi Firebase Authentication Limiti.

Il metodo verifyPhoneNumber è di nuovo inserito: se lo chiami più volte, ad esempio nel metodo onAppear di una vista, il metodo verifyPhoneNumber non inviare 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 presenta una verifica reCAPTCHA all'utente. Dopo che l'app ha ricevuto notifica o l'utente completa la verifica reCAPTCHA, Firebase invia un SMS contenente un codice di autenticazione alla numero di telefono specificato e passa un ID verifica al tuo completamento personalizzata. Ti serviranno sia il codice di verifica sia il codice di verifica ID per far accedere l'utente.

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

Puoi mantenere l'ID di verifica in qualsiasi modo. Un modo semplice è salva l'ID verifica con l'oggetto NSUserDefaults:
Swift
```
UserDefaults.standard.set(verificationID, forKey: "authVerificationID")
```
Objective-C
```
NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
[defaults setObject:verificationID forKey:@"authVerificationID"];
```
A questo punto, 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:) ha esito positivo, puoi chiedere all'utente di digitare il codice di verifica quando ricevilo nell'SMS.

Dopo che l'utente ha fornito alla tua app il codice di verifica ricevuto nell'SMS messaggio, accedi all'utente creando un FIRPhoneAuthCredential del codice di verifica e dell'ID di verifica e trasmetterlo a signInWithCredential:completion:.

Ricevi il codice di verifica dall'utente.

Crea un oggetto FIRPhoneAuthCredential dalla verifica il codice di verifica e l'ID di verifica.

Swift

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

Objective-C

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

Accedi all'utente 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;
  // ...
}];

Esegui test con numeri di telefono fittizi

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

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

I numeri di telefono fittizi devono soddisfare i seguenti requisiti:

Assicurati di utilizzare numeri di telefono fittizi e che non esistono già. Firebase Authentication non consente di impostare numeri di telefono esistenti utilizzati da utenti reali come numeri di test. Un'opzione è utilizzare 555 numeri con prefisso come numeri di telefono di prova statunitensi, ad esempio: +39 338 555 3434
I numeri di telefono devono essere formattati correttamente in termini di lunghezza e altri vincoli. Saranno 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 prova difficili da indovinare e cambiare di frequente.

Creare numeri di telefono e codici di verifica fittizi

Nella console Firebase, apri la nella sezione Autenticazione.
Nella scheda Metodo di accesso, attiva il provider telefonico, se non l'hai ancora fatto.
Apri il menu Numeri di telefono per i test di accordion.
Fornisci il numero di telefono che vuoi verificare, 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 serve, puoi eliminare il numero di telefono e passa il mouse sopra la riga corrispondente e fai clic sull'icona del cestino.

Test manuale

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

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

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

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

Test di integrazione

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

Su iOS, l'impostazione appVerificationDisabledForTesting deve essere impostata su TRUE prima di chiamare verifyPhoneNumber. L'elaborazione viene eseguita senza richiedere il token del servizio APN o l'invio di notifiche push silenziose in background, per eseguire più facilmente in un simulatore. Questa operazione disattiva anche il flusso di fallback reCAPTCHA.

Tieni presente che quando la verifica app è disattivata, l'utilizzo di un numero di telefono non fittizio non completino 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 (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
    }];
}];

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 la rotazione del metodo per ottenere automaticamente il token del servizio APN, per gestire le notifiche push silenziose inviate da Firebase della tua app e intercettare automaticamente il reindirizzamento dello schema personalizzato pagina di verifica reCAPTCHA durante la verifica.

Se preferisci non utilizzare lo swizzling, puoi disabilitarlo aggiungendo il flag FirebaseAppDelegateProxyEnabled al file Info.plist dell'app e impostandolo su NO. Tieni presente che l'impostazione di questo flag su NO disattiva anche la rotazione per altri prodotti Firebase, tra cui Firebase Cloud Messaging.

Se disattivi lo swizzling, devi passare esplicitamente il token del dispositivo del servizio APN, 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 per gli APN, notifiche push e l'URL di reindirizzamento dello schema personalizzato a Firebase Authentication.

Per ottenere il token del dispositivo per gli APN, implementa la funzione application(_:didRegisterForRemoteNotificationsWithDeviceToken:) e al suo interno passa il token del dispositivo al metodoAuth setAPNSToken(_:type:).

Nota: le app SwiftUI devono utilizzare UIApplicationDelegateAdaptor o wrapper proprietà NSApplicationDelegateAdaptor per fornire un tipo corrispondente ai delega dell'app.

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:): , verifica se ci sono notifiche relative all'autenticazione Firebase richiamando Metodo canHandleNotification(_:) di Auth.

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 metodo application(_:open:options:) e poi passa l'URL al metodo canHandleURL(_:) di Auth.

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 metodo scene(_:openURLContexts:) e poi passa l'URL al metodo canHandleURL(_:) di Auth.

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

Nelle tue app puoi ottenere le informazioni di base del profilo dell'utente dal User . Vedi Gestire gli utenti.
In Firebase Realtime Database e Cloud Storage Regole di sicurezza, puoi ottieni l'ID utente unico dell'utente che ha eseguito l'accesso dalla variabile auth, e usarli per controllare i dati a cui un utente può accedere.

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

Per disconnettere un utente, chiama signOut:.

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 il codice per la gestione degli errori per l'intero intervallo di autenticazione errori. Vedi Gestire gli errori.

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

Prima di iniziare

Problemi di sicurezza

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

Attivare la verifica dell'app

Iniziare a ricevere notifiche silenziose

Configura la verifica reCAPTCHA

Invia un codice di verifica al telefono dell'utente

Swift

Objective-C

Swift

Objective-C

Swift

Objective-C

Swift

Objective-C

Accedere con il codice di verifica

Swift

Objective-C

Swift

Objective-C

Esegui test con numeri di telefono fittizi

Creare numeri di telefono e codici di verifica fittizi

Test manuale

Test di integrazione

Swift

Objective-C

Appendice: Accesso tramite telefono senza ruotare

Swift

Objective-C

Swift

Objective-C

Swift

Objective-C

Swift

Objective-C

Passaggi successivi

Swift

Objective-C