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

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

Le moyen le plus simple d'ajouter la connexion par numéro de téléphone à votre application consiste à utiliser FirebaseUI, qui inclut un widget de connexion intégré qui implémente les flux de connexion pour la connexion par numéro de téléphone, ainsi que la connexion par mot de passe et la connexion fédérée. Ce document explique comment implémenter un flux de connexion par numéro de téléphone à l'aide du SDK Firebase.

Les numéros de téléphone fournis par les utilisateurs finaux pour l'authentification seront envoyés et stockés par Google afin d'améliorer la prévention du spam et des utilisations abusives dans les services Google, y compris, mais sans s'y limiter, Firebase. Les développeurs doivent s'assurer qu'ils disposent du consentement approprié de l'utilisateur final avant d'utiliser le service de connexion par numéro de téléphone Firebase Authentication.

Avant de commencer

1. Si vous n'avez pas encore associé votre application à votre projet Firebase, faites-le depuis la console Firebase.

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

   Consultez notre guide d'installation pour découvrir les différentes façons d'ajouter des SDK Firebase à votre projet Apple.
   1. Dans Xcode, à partir de votre projet d'application ouvert, accédez à File > Add Packages (Fichier > Ajouter des packages).
   2. Lorsque vous y êtes invité, ajoutez le dépôt du SDK des plates-formes Firebase pour Apple :

     https://github.com/firebase/firebase-ios-sdk.git

   Remarque : Les nouveaux projets doivent utiliser la version par défaut (la plus récente) du SDK, mais vous pouvez choisir une version plus ancienne si nécessaire.
   3. Choisissez la bibliothèque Firebase Authentication.
   4. Ajoutez l'option -ObjC à la section Other Linker Flags (Autres options de l'éditeur de liens) des paramètres de compilation de votre cible.
   5. Lorsque vous avez terminé, Xcode commence à résoudre et à télécharger automatiquement vos dépendances en arrière-plan.

Problèmes de sécurité

L'authentification à l'aide d'un numéro de téléphone, bien que pratique, est moins sécurisée 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 utilisateur, tout utilisateur pouvant recevoir des SMS peut se connecter à un compte à l'aide du numéro de téléphone de l'appareil.

Si vous utilisez la connexion par numéro de téléphone dans votre application, vous devez la proposer en plus de 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 des 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, accédez à Sécurité > Authentification.
2. Dans l'onglet Mode de connexion, activez le fournisseur de connexion Téléphone.
3. Définissez une règle sur les régions vers lesquelles vous souhaitez autoriser ou refuser l'envoi de SMS. Définir une règle de région pour les SMS peut vous aider à protéger vos applications contre l'utilisation abusive des SMS. Pour les nouveaux projets, la règle par défaut n'autorise aucune région.
   1. Dans la console Firebase, accédez à l'onglet Sécurité > Authentification > Paramètres.
   2. Dans la section Règles pour les SMS par région, configurez vos règles pour les SMS par région.

Activer la validation des applications

Pour utiliser l'authentification par numéro de téléphone, Firebase doit pouvoir vérifier que les demandes de connexion par numéro de téléphone proviennent de votre application. Firebase Authentication y parvient de deux manières :

• Notifications APN silencieuses : lorsque vous connectez un utilisateur avec son numéro de téléphone pour la première fois sur un appareil, Firebase Authentication envoie un jeton à l'appareil à l'aide d'une notification push silencieuse. Si votre application reçoit la notification de Firebase, la connexion par numéro de téléphone peut continuer.

  Pour iOS 8.0 et versions ultérieures, les notifications silencieuses ne nécessitent pas le consentement utilisateur explicite. Elles ne sont donc pas affectées par le refus de l'utilisateur de recevoir des notifications APN dans l'application. Par conséquent, l'application n'a pas besoin de demander l'autorisation de l'utilisateur pour recevoir des notifications push lors de l'implémentation de l'authentification par numéro de téléphone Firebase.

• Validation reCAPTCHA : s'il n'est pas possible d'envoyer ou de recevoir une notification push silencieuse, par exemple lorsque l'utilisateur a désactivé l'actualisation en arrière-plan pour votre application ou lorsque vous testez votre application sur un simulateur iOS, Firebase Authentication utilise la validation reCAPTCHA pour finaliser le flux de connexion par téléphone. Le test reCAPTCHA peut souvent être effectué sans que l'utilisateur n'ait à résoudre quoi que ce soit.
L'authentification par téléphone sur iOS utilise des notifications push silencieuses pour la validation de l'application cliente. En cas d'échec, il utilise reCAPTCHA. Ce flux reCAPTCHA nécessite que votre clé API ne soit pas limitée ou qu'elle soit ajoutée à la liste d'autorisation pour "${PROJECT_NAME}.firebaseapp.com".

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

Pour vous assurer que les deux scénarios fonctionnent correctement, testez votre application sur un appareil physique avec l'actualisation de l'application en arrière-plan activée et désactivée. Lorsque l'actualisation de l'application en arrière-plan est désactivée, vous devriez pouvoir vous connecter après avoir réussi le test reCAPTCHA. Vous pouvez également tester le flux reCAPTCHA en exécutant votre application sur un simulateur iOS, qui utilise toujours le flux reCAPTCHA.

Commencer à recevoir des notifications silencieuses

Pour activer les notifications APN à utiliser avec Firebase Authentication :

1. Dans Xcode, activez les notifications push pour votre projet.

2. Importez votre clé d'authentification APNs dans Firebase. Si vous ne possédez pas encore de clé d'authentification APNs, veillez à en créer une dans l'Apple Developer Member Center.

   1. Dans la console Firebase, accédez à Paramètres > Général. Cliquez ensuite sur l'onglet Cloud Messaging.
   2. Dans Clé d'authentification APNs sous Configuration de l'application iOS, cliquez sur Importer pour importer votre clé d'authentification de développement, votre clé d'authentification de production ou les deux. Veuillez inclure au moins l'un des trois.
   3. Accédez à l'emplacement où vous avez enregistré votre clé, sélectionnez-la, puis cliquez sur Ouvrir. Ajoutez l'ID de la clé (disponible dans l'Apple Developer Member Center), puis cliquez sur Importer.

   Si vous possédez déjà un certificat APNs, vous pouvez l'importer.

3. Dans Xcode, activez la fonctionnalité "Modes d'arrière-plan" pour votre projet, puis cochez les cases correspondant aux modes Récupération en arrière-plan et Notifications à distance.

Configurer la validation reCAPTCHA

Pour permettre au SDK Firebase d'utiliser la validation reCAPTCHA :

1. Ajoutez des schémas d'URL personnalisés à votre projet Xcode :
   1. Ouvrez la configuration de votre projet : double-cliquez sur le nom du projet dans l'arborescence de gauche. Sélectionnez votre application dans la section TARGETS (CIBLES), puis sélectionnez l'onglet Info et développez la section URL Types (Types d'URL).
   2. Cliquez sur le bouton +, puis ajoutez l'ID d'application encodé en tant que schéma d'URL. Laissez les autres champs vides.

      Vous trouverez l'ID d'application encodé dans la console Firebase : accédez à Paramètres > onglet Général, puis faites défiler la page jusqu'à la section Vos applications pour afficher les détails de votre application iOS.

      Une fois l'opération terminée, votre configuration devrait ressembler à ce qui suit (mais avec les valeurs spécifiques à votre application) :

      
2. Facultatif : Si vous souhaitez personnaliser la façon dont votre application présente le SFSafariViewController lors de l'affichage de reCAPTCHA à l'utilisateur, créez une classe personnalisée conforme au protocole AuthUIDelegate et transmettez-la à verifyPhoneNumber(_:uiDelegate:completion:).

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

Pour lancer la connexion par numéro de téléphone, présentez à l'utilisateur une interface qui l'invite à fournir son numéro de téléphone, puis appelez verifyPhoneNumber(_:uiDelegate:completion:) pour demander à Firebase d'envoyer un code d'authentification au téléphone de l'utilisateur par SMS :

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

   Les obligations légales varient, mais il est recommandé d'informer vos utilisateurs que s'ils se connectent par téléphone, ils peuvent recevoir un SMS de validation et que les tarifs standards s'appliquent.

2. Appelez verifyPhoneNumber(_:uiDelegate:completion:) en lui transmettant le numéro de téléphone de l'utilisateur.

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

   Remarque : Selon votre forfait, vous pouvez être limité à un quota quotidien de SMS envoyés. Consultez les limites de Firebase Authentication.

   La méthode verifyPhoneNumber est réentrante : si vous l'appelez plusieurs fois, par exemple dans la méthode onAppear d'une vue, la méthode verifyPhoneNumber n'enverra pas de deuxième SMS, sauf si la requête d'origine a expiré.

   Lorsque vous appelez verifyPhoneNumber(_:uiDelegate:completion:), Firebase envoie une notification push silencieuse à votre application ou émet un test reCAPTCHA pour l'utilisateur. Une fois que votre application a reçu la notification ou que l'utilisateur a terminé le test reCAPTCHA, Firebase envoie un SMS contenant un code d'authentification au numéro de téléphone spécifié et transmet un ID de validation à votre fonction de complétion. Vous aurez besoin du code de validation et de l'ID de validation pour connecter l'utilisateur.

   Le SMS envoyé par Firebase peut également être localisé en spécifiant la langue d'authentification via la propriété languageCode de votre instance Auth.

   Swift

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

   Objective-C

    // Change language code to french.
    [FIRAuth auth].languageCode = @"fr";

3. Enregistrez l'ID de validation et restaurez-le lorsque votre application se charge. Vous pouvez ainsi vous assurer que vous disposez toujours d'un ID de validation valide si votre application est arrêtée avant que l'utilisateur ne termine le processus de connexion (par exemple, lors du passage à l'application de SMS).

   Vous pouvez conserver l'ID de validation comme vous le souhaitez. Un moyen simple consiste à enregistrer l'ID de validation avec l'objet NSUserDefaults :

   Swift

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

   Objective-C

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

   Vous pouvez ensuite restaurer la valeur enregistrée :

   Swift

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

   Objective-C

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

Si l'appel de verifyPhoneNumber(_:uiDelegate:completion:) aboutit, vous pouvez inviter l'utilisateur à saisir le code de validation lorsqu'il le reçoit par SMS.

Pour éviter les abus, Firebase limite le nombre de SMS pouvant être envoyés à un même numéro de téléphone sur une période donnée. Si vous dépassez cette limite, les demandes de vérification du numéro de téléphone peuvent être limitées. Si vous rencontrez ce problème pendant le développement, utilisez un autre numéro de téléphone pour les tests ou réessayez plus tard.

Connecter l'utilisateur avec le code de validation

Une fois que l'utilisateur a fourni à votre application le code de validation reçu par SMS, connectez-le en créant un objet FIRPhoneAuthCredential à partir du code de validation et de l'ID de validation, puis en transmettant cet objet à signInWithCredential:completion:.

1. Demandez le code de validation à l'utilisateur.
2. Créez un objet FIRPhoneAuthCredential à partir du code de validation et de l'ID de validation.

   Swift

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

   Objective-C

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

3. Connectez l'utilisateur avec l'objet 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;
     // ...
   }];

Tester avec des numéros de téléphone fictifs

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

• Testez l'authentification par numéro de téléphone sans consommer votre quota d'utilisation.
• Testez l'authentification par numéro de téléphone sans envoyer de SMS.
• Exécutez des tests consécutifs avec le même numéro de téléphone sans subir de limitation. Cela réduit le risque de refus lors du processus d'examen de la plate-forme de téléchargement d'applications si l'examinateur utilise le même numéro de téléphone pour les tests.
• Testez facilement vos applications dans des environnements de développement sans effort supplémentaire, par exemple en développant dans un simulateur iOS ou un Android Emulator sans les services Google Play.
• Écrivez des tests d'intégration sans être bloqué par les contrôles de sécurité normalement appliqués aux numéros de téléphone réels 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 fictifs qui n'existent pas déjà. Firebase Authentication 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 des numéros de téléphone de test américains commençant par le préfixe 555, par exemple : [phone].
2. Les numéros de téléphone doivent être correctement formatés en termes de longueur et d'autres contraintes. Ils seront soumis à 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 modifiez-les fréquemment.

Créer des numéros de téléphone et des codes de validation fictifs

1. Dans la console Firebase, accédez à Sécurité > Authentification.
2. Dans l'onglet Mode de connexion, activez le fournisseur de connexion Téléphone si ce n'est pas déjà fait.
3. Développez la section Numéros de téléphone pour les tests.
4. Indiquez le numéro de téléphone que vous souhaitez tester, par exemple : [phone].
5. Indiquez le code de validation à six chiffres correspondant à ce numéro, par exemple : 654321.
6. Cliquez sur Ajouter pour chaque numéro. Si nécessaire, vous pouvez supprimer le numéro de téléphone et son code en pointant sur la ligne correspondante et en cliquant sur l'icône de la corbeille.

Tests manuels

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

Lorsque vous fournissez le numéro de téléphone fictif et envoyez le code de validation, aucun SMS n'est envoyé. Vous devez plutôt fournir le code de validation précédemment configuré pour vous connecter.

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 utilisateur de numéro de téléphone réel, et peut accéder à Realtime Database/Cloud Firestore et à d'autres services de la même manière. Le jeton d'ID créé au cours de ce processus possède la même signature que celui d'un utilisateur disposant d'un vrai numéro de téléphone.

Étant donné que le jeton d'ID du numéro de téléphone fictif possède la même signature que celui d'un utilisateur de numéro de téléphone réel, il est important de stocker ces numéros de manière sécurisée et de les recycler en continu.

Vous pouvez également définir un rôle de test via des revendications personnalisées sur ces utilisateurs pour les différencier en tant que faux utilisateurs si vous souhaitez restreindre davantage l'accès.

Tests d'intégration

En plus des tests manuels, Firebase Authentication fournit des API pour vous aider à écrire des tests d'intégration pour l'authentification par téléphone. Ces API désactivent la validation de l'application en désactivant l'exigence reCAPTCHA dans les notifications push Web et silencieuses sous iOS. Cela permet de tester l'automatisation dans ces flux et de l'implémenter plus facilement. De plus, ils permettent de tester les flux de validation instantanée sur Android.

Assurez-vous que la validation de l'application n'est pas désactivée pour les applications de production et qu'aucun numéro de téléphone fictif n'est codé en dur dans votre application de production.

Sur iOS, le paramètre appVerificationDisabledForTesting doit être défini sur TRUE avant d'appeler verifyPhoneNumber. Cette opération est traitée sans nécessiter de jeton APNs ni envoyer de notifications push silencieuses en arrière-plan, ce qui facilite les tests dans un simulateur. Cela désactive également le flux de remplacement reCAPTCHA.

Notez que lorsque la validation de l'application est désactivée, l'utilisation d'un numéro de téléphone non fictif ne permet pas de se connecter. Seuls des numéros de téléphone fictifs peuvent être utilisés avec cette API.

Swift

let phoneNumber = "[phone]"

// 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 = @"[phone]";

// 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 APNs de votre application, gérer les notifications push silencieuses que Firebase envoie à votre application et intercepter automatiquement la redirection du schéma personnalisé depuis la page de validation reCAPTCHA lors de la validation.

Si vous préférez ne pas utiliser le swizzling, vous pouvez le désactiver en ajoutant l'indicateur FirebaseAppDelegateProxyEnabled au fichier Info.plist de votre application et en le définissant sur NO. Notez que la définition de cette option sur NO désactive également le swizzling pour d'autres produits Firebase, y compris Firebase Cloud Messaging.

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

Si vous créez une application SwiftUI, vous devez également transmettre explicitement le jeton d'appareil APNs, les notifications push et l'URL de redirection du schéma personnalisé à Firebase Authentication.

Pour obtenir le jeton d'appareil APNs, implémentez la méthode application(_:didRegisterForRemoteNotificationsWithDeviceToken:) et transmettez-y le jeton d'appareil à la méthode setAPNSToken(_:type:) de Auth.

Remarque : Les applications SwiftUI doivent utiliser les wrappers de propriété UIApplicationDelegateAdaptor ou NSApplicationDelegateAdaptor pour fournir un type correspondant au protocole de délégué d'application approprié.

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

Pour gérer les notifications push, dans la méthode application(_:didReceiveRemoteNotification:fetchCompletionHandler:):, recherchez les notifications liées à l'authentification Firebase en appelant la méthode canHandleNotification(_:) de 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.
}

Pour gérer l'URL de redirection du schéma personnalisé, implémentez la méthode application(_:open:options:) et transmettez l'URL à la méthode canHandleURL(_:) de 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.
}

Si vous utilisez SwiftUI ou UISceneDelegate, pour gérer l'URL de redirection, implémentez la méthode scene(_:openURLContexts:) et transmettez l'URL à la méthode canHandleURL(_:) de 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.
  }
}

Étapes suivantes

Lorsqu'un utilisateur se connecte pour la première fois, un compte utilisateur est créé et associé aux identifiants (nom d'utilisateur et mot de passe, numéro de téléphone ou informations du fournisseur d'authentification) avec lesquels il s'est connecté. Ce nouveau compte est stocké dans votre projet Firebase et peut être utilisé pour identifier un utilisateur dans toutes les applications de votre projet, quelle que soit la manière dont il se connecte.

• Dans vos applications, vous pouvez obtenir les informations de base du profil de l'utilisateur à partir de l'objet User . Consultez Gérer les utilisateurs.

• Dans vos règles de sécurité Firebase Realtime Database et Cloud Storage, vous pouvez obtenir l'ID utilisateur unique de l'utilisateur connecté à partir de la variable auth et l'utiliser pour contrôler les données auxquelles un utilisateur peut accéder.

Vous pouvez autoriser les utilisateurs à se connecter à votre application à l'aide de plusieurs fournisseurs d'authentification en associant les identifiants du fournisseur d'authentification à un compte utilisateur existant.

Pour déconnecter un utilisateur, appelez 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;
}

Vous pouvez également ajouter du code de gestion des erreurs pour l'ensemble des erreurs d'authentification. Consultez Gérer les erreurs.