Catch up on everthing we announced at this year's Firebase Summit. Learn more

Authentification avec Firebase sur les plates-formes Apple à l'aide d'un numéro de téléphone

Vous pouvez utiliser l'authentification Firebase pour connecter un utilisateur en envoyant un message SMS sur le téléphone de l'utilisateur. L'utilisateur se connecte à l'aide d'un code à usage unique contenu dans le message SMS.

La meilleure façon d'ajouter de connexion à votre application numéro de téléphone est d'utiliser FirebaseUI , qui comprend un widget un signe en baisse en implémentant signe en flux pour le numéro de téléphone de connexion, ainsi que par mot de passe et signe fédéré -dans. Ce document explique comment mettre en œuvre un flux de connexion par numéro de téléphone à l'aide du SDK Firebase.

Avant que tu commences

Utilisez Swift Package Manager pour installer et gérer les dépendances de Firebase.

  1. Dans Xcode, avec votre projet d'application ouvert, accédez à Fichier> Paquets Swift> Ajouter un package de dépendance.
  2. Lorsque vous y êtes invité, ajoutez le référentiel SDK des plates-formes Firebase Apple :
  3.   https://github.com/firebase/firebase-ios-sdk
      
  4. Choisissez la bibliothèque d'authentification Firebase.
  5. Une fois terminé, Xcode commencera automatiquement à résoudre et à télécharger vos dépendances en arrière-plan.
Et, vérifiez une étape de configuration :
  1. Si vous n'êtes pas encore connecté votre application à votre projet Firebase, faites à partir de la console Firebase .

Problèmes de sécurité

L'authentification utilisant uniquement un numéro de téléphone, bien que pratique, est moins sûre que les autres méthodes disponibles, car la possession d'un numéro de téléphone peut être facilement transférée entre les utilisateurs. De plus, sur les appareils dotés de plusieurs profils d'utilisateurs, tout utilisateur pouvant recevoir des messages SMS peut se connecter à un compte à l'aide du numéro de téléphone de l'appareil.

Si vous utilisez la connexion basée sur un numéro de téléphone dans votre application, vous devez l'offrir avec des méthodes de connexion plus sécurisées et informer les utilisateurs des compromis de sécurité liés à l'utilisation de la connexion par numéro de téléphone.

Activer la connexion par numéro de téléphone pour votre projet Firebase

Pour connecter les utilisateurs par SMS, vous devez d'abord activer la méthode de connexion par numéro de téléphone pour votre projet Firebase :

  1. Dans la console Firebase , ouvrez la section d' authentification.
  2. Sur la page de connexion Méthode, activez le signe dans Numéro de téléphone méthode.

Le quota de demande de connexion par numéro de téléphone de Firebase est suffisamment élevé pour que la plupart des applications ne soient pas affectées. Cependant, si vous devez vous connecter à un très grand nombre d'utilisateurs avec une authentification par téléphone, vous devrez peut-être mettre à niveau votre plan tarifaire. Voir la prix page.

Activer la vérification de l'application

Pour utiliser l'authentification par numéro de téléphone, Firebase doit être en mesure de vérifier que les demandes de connexion par numéro de téléphone proviennent de votre application. Firebase Authentication accomplit cela de deux manières :

  • Notifications silencieux IPA: Lorsque vous vous connectez un utilisateur avec leur numéro de téléphone pour la première fois sur un périphérique, Firebase authentification envoie un jeton à l'appareil en utilisant une notification push silencieuse. Si votre application reçoit avec succès la notification de Firebase, la connexion par numéro de téléphone peut se poursuivre.

    Pour iOS 8.0 et versions ultérieures, les notifications silencieuses ne nécessitent pas le consentement explicite de l'utilisateur et ne sont donc pas affectées par un utilisateur refusant de recevoir des notifications APN dans l'application. Ainsi, l'application n'a pas besoin de demander l'autorisation de l'utilisateur pour recevoir des notifications push lors de la mise en œuvre de l'authentification du numéro de téléphone Firebase.

  • vérification reCAPTCHA: Dans le cas où l' envoi ou la réception d' une notification push silencieuse est impossible, par exemple lorsque l'utilisateur rafraîchissement de fond désactivé pour votre application, ou lorsque vous testez votre application sur un simulateur iOS, Firebase authentification utilise la vérification reCAPTCHA pour compléter le téléphone flux de connexion. Le défi reCAPTCHA peut souvent être complété sans que l'utilisateur n'ait à résoudre quoi que ce soit.

Lorsque les notifications push silencieuses sont correctement configurées, seul un très petit pourcentage d'utilisateurs connaîtra le flux reCAPTCHA. Néanmoins, vous devez vous assurer que la connexion par numéro de téléphone fonctionne correctement, que des notifications push silencieuses soient disponibles ou non.

Commencer à recevoir des notifications silencieuses

Pour activer les notifications APN à utiliser avec Firebase Authentication :

  1. Dans Xcode, activer les notifications push pour votre projet.
  2. Téléchargez votre clé d'authentification APNs sur Firebase. Si vous ne possédez pas déjà une clé d'authentification APNs, assurez - vous de créer un dans le Apple Developer Member Center .

    1. A l' intérieur de votre projet dans la console Firebase, sélectionnez l'icône d'engrenage, sélectionnez Paramètres du projet, puis sélectionnez l'onglet Nuage de messagerie.

    2. Dans clé d'authentification APNs sous la configuration iOS app, cliquez sur le bouton Ajouter.

    3. Accédez à l'emplacement où vous avez enregistré votre clé, sélectionnez - le et cliquez sur Ouvrir. Ajoutez l'ID de la touche (disponible dans le membre Apple Developer Centre ) et cliquez sur Télécharger.

    Si vous disposez déjà d'un certificat APNs, vous pouvez le télécharger à la place.

Configurer la vérification reCAPTCHA

Pour permettre au SDK Firebase d'utiliser la vérification reCAPTCHA :

  1. Ajoutez des schémas d'URL personnalisés à votre projet Xcode :
    1. Ouvrez votre configuration de projet : double-cliquez sur le nom du projet dans l'arborescence de gauche. Sélectionnez votre application de la section CIBLES, puis sélectionnez l'onglet Info, et développez la section Types d'URL.
    2. Cliquez sur le bouton +, et ajouter un schéma d'URL pour votre ID client inverse. Pour trouver cette valeur, ouvrez le GoogleService-Info.plist fichier de configuration, et recherchez le REVERSED_CLIENT_ID clé. Copiez la valeur de cette clé, et le coller dans l'URL Schemes boîte sur la page de configuration. Laissez les autres champs vides.

      Une fois terminée, votre configuration devrait ressembler à ce qui suit (mais avec des valeurs spécifiques à votre application) :

  2. Facultatif: Si vous voulez personnaliser la façon dont vos cadeaux d'application de la SFSafariViewController ou UIWebView lors de l' affichage du reCAPTCHA à l'utilisateur, créer une classe personnalisée qui est conforme au FIRAuthUIDelegate protocole, et le transmettre à verifyPhoneNumber:UIDelegate:completion: .

Envoyer un code de vérification sur le téléphone de l'utilisateur

Pour lancer la connexion au numéro de téléphone, présenter à l'utilisateur une interface qui invites eux pour fournir leur numéro de téléphone, puis appelez verifyPhoneNumber:UIDelegate:completion: à la demande que Firebase envoyer un code d'authentification sur le téléphone de l'utilisateur par SMS:

  1. Obtenez le numéro de téléphone de l'utilisateur.

    Les exigences légales varient, mais en tant que meilleure pratique et pour définir les attentes de vos utilisateurs, vous devez les informer que s'ils utilisent la connexion par téléphone, ils peuvent recevoir un message SMS pour vérification et que les tarifs standard s'appliquent.

  2. Appel verifyPhoneNumber:UIDelegate:completion: , en lui passant le numéro de téléphone de l'utilisateur.

    Rapide

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

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

    Lorsque vous appelez verifyPhoneNumber:UIDelegate:completion: , Firebase envoie une notification push silencieuse à votre application, ou un défi reCAPTCHA questions à l'utilisateur. Une fois que votre application a reçu la notification ou que l'utilisateur a terminé le défi reCAPTCHA, Firebase envoie un message SMS contenant un code d'authentification au numéro de téléphone spécifié et transmet un ID de vérification à votre fonction d'achèvement. Vous aurez besoin à la fois du code de vérification et de l'ID de vérification pour vous connecter à l'utilisateur.

    Le message SMS envoyé par Firebase peut également être localisée en spécifiant la langue auth via le languageCode propriété sur votre instance Auth.

    Rapide

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

    Objectif c

     // Change language code to french.
     [FIRAuth auth].languageCode = @"fr";
    
  3. Enregistrez l'ID de vérification et restaurez-le lorsque votre application se charge. Ce faisant, vous pouvez vous assurer que vous disposez toujours d'un ID de vérification valide si votre application est fermée avant que l'utilisateur n'ait terminé le flux de connexion (par exemple, lors du passage à l'application SMS).

    Vous pouvez conserver l'ID de vérification comme vous le souhaitez. Une méthode simple consiste à enregistrer l'ID de vérification avec le NSUserDefaults objet:

    Rapide

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

    Objectif c

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

    Ensuite, vous pouvez restaurer la valeur enregistrée :

    Rapide

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

    Objectif c

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

Si l'appel à verifyPhoneNumber:UIDelegate:completion: réussit, vous pouvez demander à l'utilisateur de saisir le code de vérification quand ils le reçoivent dans le message SMS.

Connectez-vous à l'utilisateur avec le code de vérification

Une fois l'utilisateur fournit votre application avec le code de vérification du message SMS, connectez - vous l'utilisateur en créant un FIRPhoneAuthCredential objet à partir du code de vérification et l' ID de vérification et de passage à cet objet signInWithCredential:completion: .

  1. Obtenez le code de vérification de l'utilisateur.
  2. Créer un FIRPhoneAuthCredential objet à partir du code de vérification et l' ID de vérification.

    Rapide

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

    Objectif c

    FIRAuthCredential *credential = [[FIRPhoneAuthProvider provider]
        credentialWithVerificationID:verificationID
                    verificationCode:userInput];
  3. Connectez - vous à l'utilisateur l' FIRPhoneAuthCredential objet:

    Rapide

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

    Objectif 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 avec des numéros de téléphone fictifs

Vous pouvez configurer des numéros de téléphone fictifs pour le développement via la console Firebase. Les tests avec des numéros de téléphone fictifs offrent les avantages suivants :

  • Testez l'authentification du numéro de téléphone sans consommer votre quota d'utilisation.
  • Testez l'authentification du numéro de téléphone sans envoyer de message SMS réel.
  • Exécutez des tests consécutifs avec le même numéro de téléphone sans être limité. Cela minimise le risque de rejet lors du processus de révision de l'App Store si le réviseur utilise le même numéro de téléphone pour les tests.
  • Testez facilement dans des environnements de développement sans aucun effort supplémentaire, comme la possibilité de développer dans un simulateur iOS ou un émulateur Android sans les services Google Play.
  • Rédigez des tests d'intégration sans être bloqué par les contrôles de sécurité normalement appliqués sur de vrais numéros de téléphone dans un environnement de production.

Les numéros de téléphone fictifs doivent répondre aux exigences suivantes :

  1. Assurez-vous d'utiliser des numéros de téléphone qui sont effectivement fictifs et qui n'existent pas déjà. L'authentification Firebase ne vous permet pas de définir des numéros de téléphone existants utilisés par de vrais utilisateurs comme numéros de test. Une option consiste à utiliser 555 numéros préfixés que les numéros de téléphone de test américain, par exemple: +1 650-555-3434
  2. Les numéros de téléphone doivent être correctement formatés pour la longueur et d'autres contraintes. Ils passeront toujours par la même validation que le numéro de téléphone d'un utilisateur réel.
  3. Vous pouvez ajouter jusqu'à 10 numéros de téléphone pour le développement.
  4. Utilisez des numéros de téléphone/codes de test difficiles à deviner et changez-les fréquemment.

Créez des numéros de téléphone et des codes de vérification fictifs

  1. Dans la console Firebase , ouvrez la section d' authentification.
  2. Dans l'onglet Connexion de la méthode, permettre au fournisseur de téléphone si vous avez pas déjà.
  3. Ouvrez les numéros de téléphone pour tester le menu accordéon.
  4. Indiquez le numéro de téléphone que vous souhaitez tester, par exemple: +1 650-555-3434.
  5. Fournir le code de vérification à 6 chiffres pour ce numéro spécifique, par exemple: 654321.
  6. Ajouter le numéro. En cas de besoin, vous pouvez supprimer le numéro de téléphone et son code en survolant la ligne correspondante et en cliquant sur l'icône de la corbeille.

Test manuel

Vous pouvez directement commencer à utiliser un numéro de téléphone fictif dans votre application. Cela vous permet d'effectuer des tests manuels pendant les étapes de développement sans rencontrer de problèmes de quota ou de limitation. Vous pouvez également tester directement à partir d'un simulateur iOS ou d'un émulateur Android sans que les services Google Play ne soient installés.

Lorsque vous fournissez le numéro de téléphone fictif et envoyez le code de vérification, aucun SMS réel n'est envoyé. Au lieu de cela, vous devez fournir le code de vérification précédemment configuré pour terminer la connexion.

Une fois la connexion terminée, un utilisateur Firebase est créé avec ce numéro de téléphone. L'utilisateur a le même comportement et les mêmes propriétés qu'un véritable utilisateur de numéro de téléphone et peut accéder de la même manière à la base de données en temps réel/au Cloud Firestore et à d'autres services. Le jeton d'identification créé au cours de ce processus a la même signature qu'un véritable utilisateur de numéro de téléphone.

Une autre option est de définir un rôle de test via les revendications personnalisées sur ces utilisateurs pour les différencier les utilisateurs de faux si vous voulez limiter davantage l' accès.

Tests d'intégration

En plus des tests manuels, Firebase Authentication fournit des API pour aider à écrire des tests d'intégration pour les tests d'authentification téléphonique. Ces API désactivent la vérification des applications en désactivant l'exigence reCAPTCHA dans les notifications push Web et silencieuses dans iOS. Cela rend les tests d'automatisation possibles dans ces flux et plus faciles à mettre en œuvre. De plus, ils permettent de tester les flux de vérification instantanée sur Android.

Sur iOS, le appVerificationDisabledForTesting paramètre doit être réglé sur TRUE avant d' appeler verifyPhoneNumber . Ceci est traité sans nécessiter de jeton APN ou d'envoi de notifications push silencieuses en arrière-plan, ce qui facilite le test dans un simulateur. Cela désactive également le flux de secours reCAPTCHA.

Notez que lorsque la vérification de l'application est désactivée, l'utilisation d'un numéro de téléphone non fictif ne permettra pas de terminer la connexion. Seuls les numéros de téléphone fictifs peuvent être utilisés avec cette API.

Rapide

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

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

Annexe : Utiliser la connexion par téléphone sans swizzling

Firebase Authentication utilise la méthode swizzling pour obtenir automatiquement le jeton APN de votre application, pour gérer les notifications push silencieuses que Firebase envoie à votre application et pour intercepter automatiquement la redirection du schéma personnalisé à partir de la page de vérification reCAPTCHA pendant la vérification.

Si vous préférez ne pas utiliser swizzling, vous pouvez le désactiver en ajoutant le drapeau FirebaseAppDelegateProxyEnabled à au fichier Info.plist de votre application et la mise en NO . Notez que la définition de ce drapeau à NO désactive également swizzling pour d' autres produits, y compris Firebase Firebase Nuage de messagerie.

Si vous désactivez le swizzling, vous devez explicitement transmettre le jeton de l'appareil APNs, les notifications push et l'URL de redirection du schéma personnalisé à Firebase Authentication.

Pour obtenir le jeton de dispositif de APNs, mettre en oeuvre la application:didRegisterForRemoteNotificationsWithDeviceToken: procédé, et en elle, passer le dispositif à jeton à FIRAuth « s setAPNSToken:type: méthode.

Rapide

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

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

Pour gérer les notifications push, dans l' application:didReceiveRemoteNotification:fetchCompletionHandler: méthode, vérifier les notifications connexes Firebase en appelant FIRAuth de canHandleNotification: méthode.

Rapide

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, developer should handle it.
}

Objectif 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, developer should handle it.
}

Pour gérer le système personnalisé URL de redirection, mettre en œuvre l' application:openURL:sourceApplication:annotation: méthode pour les appareils fonctionnant sous iOS 8 et plus, et l' application:openURL:options: méthode pour les appareils fonctionnant sous iOS 9 et plus récents, et en eux, passer la URL à FIRAuth de canHandleURL méthode.

Rapide

// For iOS 9+
func application(_ application: UIApplication, open url: URL,
    options: [UIApplicationOpenURLOptionsKey : Any]) -> Bool {
  if Auth.auth().canHandle(url) {
    return true
  }
  // URL not auth related, developer should handle it.
}

// For iOS 8-
func application(_ application: UIApplication,
                 open url: URL,
                 sourceApplication: String?,
                 annotation: Any) -> Bool {
  if Auth.auth().canHandle(url) {
    Return true
  }
  // URL not auth related, developer should handle it.
}

Objectif c

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

// For iOS 8-
- (BOOL)application:(UIApplication *)application
            openURL:(NSURL *)url
  sourceApplication:(NSString *)sourceApplication
         annotation:(id)annotation {
  if ([[FIRAuth auth] canHandleURL:url]) {
    return YES;
  }
  // URL not auth related, developer should handle it.
}

Si vous utilisez SwiftUI ou UISceneDelegate , pour gérer l'URL de redirection, mettre en œuvre la scene:openURLContexts: méthode, et en eux, passer l'URL à FIRAuth de canHandleURL méthode.

Rapide

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

Objectif c

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

Prochaines étapes

Une fois qu'un utilisateur s'est connecté pour la première fois, un nouveau compte d'utilisateur est créé et lié aux informations d'identification, c'est-à-dire le nom d'utilisateur et le mot de passe, le numéro de téléphone ou les informations du fournisseur d'autorisation, avec lesquelles l'utilisateur s'est connecté. Ce nouveau compte est stocké dans le cadre de votre projet Firebase et peut être utilisé pour identifier un utilisateur dans chaque application de votre projet, quel que soit le mode de connexion de l'utilisateur.

  • Dans vos applications, vous pouvez obtenir des informations de profil de base de l'utilisateur du FIRUser objet. Voir Gérer les utilisateurs .

  • Dans votre base de données et en temps réel Firebase Cloud Storage Les règles de auth sécurité , vous pouvez obtenir la signature dans ID d'utilisateur unique de l' utilisateur de la auth variable et l' utiliser pour contrôler les données d' un accès utilisateur peut.

Vous pouvez permettre aux utilisateurs de se connecter à votre application à l' aide des fournisseurs d'authentification multiples en reliant les informations d' identification de fournisseur auth à un compte d'utilisateur existant.

Pour vous déconnecter un utilisateur, appelez signOut: .

Rapide

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

Objectif c

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

Vous pouvez également ajouter un code de gestion des erreurs pour la gamme complète des erreurs d'authentification. Voir les erreurs de poignée .