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 au téléphone de l'utilisateur. L'utilisateur se connecte à l'aide d'un code à usage unique contenu dans le SMS.

Le moyen le plus simple d'ajouter un numéro de téléphone à votre application est d'utiliser FirebaseUI qui inclut un widget de connexion qui implémente les flux de connexion pour les la connexion avec un numéro, ainsi que la connexion fédérée et basée sur un mot de passe. Ce document explique comment implémenter une procédure 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 abus dans les services Google, y compris, mais sans s'y limiter, Firebase. Les développeurs doivent s'assurer qu'ils ont l'autorisation appropriée de l'utilisateur final avant d'utiliser le numéro de téléphone Firebase Authentication service de connexion.

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, y compris l'importation directe des frameworks et l'utilisation de CocoaPods.
   1. Dans Xcode, ouvrez le projet de votre application, puis accédez à File > 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 du SDK (la plus récente), mais vous pouvez choisissez une version ancienne si nécessaire.
   3. Choisissez la bibliothèque Firebase Authentication.
   4. Ajoutez l'indicateur -ObjC à la section Other Linker Flags (Autres indicateurs Linker) 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 seul numéro de téléphone, bien que pratique, est moins sécurisée que les autres méthodes disponibles, car un numéro de téléphone peut facilement être transféré d'un utilisateur à un autre. De plus, sur les appareils dotés de plusieurs profil, tout utilisateur pouvant recevoir des SMS peut se connecter à un compte en utilisant le 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 l'offrir 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 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 Authentification.
2. Sur la page Sign-in Method (Méthode de connexion), activez le Phone Number (Numéro de téléphone). méthode de connexion.

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 avec un numéro de téléphone proviennent de votre application. Il existe deux façons Voici ce que vous pouvez faire avec Firebase Authentication:

• 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 une à l'appareil à l'aide d'une notification push silencieuse. Si votre application reçoit correctement la notification de Firebase, la connexion par numéro de téléphone peut se poursuivre.

  Sous iOS 8.0 et versions ultérieures, les notifications silencieuses ne nécessitent pas de notifications le consentement de l'utilisateur et n'est donc pas affectée si un utilisateur refuse de recevoir Notifications APN dans l'application. Ainsi, l'application n'a pas besoin de demander à l'utilisateur autorisation de recevoir des notifications push lors de l'implémentation du téléphone Firebase via l'authentification par numéro.

• Validation reCAPTCHA: dans l'éventualité où l'envoi ou la réception une notification push silencieuse n'est pas possible, par exemple lorsque l'utilisateur désactivé l'actualisation en arrière-plan pour votre application ou lorsque vous la testez Le simulateur iOS Firebase Authentication utilise la validation reCAPTCHA pour effectuer la procédure de connexion sur le téléphone. Il est souvent possible de passer un test reCAPTCHA 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, le service reCAPTCHA est utilisé. Ce Le flux reCAPTCHA nécessite que votre clé API ne soit pas restreinte ni ajoutée à la liste d'autorisation pour "${PROJECT_NAME}.firebaseapp.com".

Lorsque les notifications push silencieuses sont correctement configurées, une très petite pourcentage d'utilisateurs découvriront le flux reCAPTCHA. Toutefois, 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 se connecter après avoir terminé 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.

Recevoir des notifications silencieuses

Pour activer les notifications APN pour une utilisation avec Firebase Authentication :

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

2. Importez votre clé d'authentification d'APN dans Firebase. Si vous ne possédez pas encore de clé d'authentification d'APN, veillez à en créer une dans le Centre des membres Apple Developer.

   1. Dans votre projet dans la console Firebase, sélectionnez le l'icône en forme de roue dentée, sélectionnez Paramètres du projet, puis sélectionnez le Onglet Cloud Messaging.

   2. Dans Clé d'authentification APNs sous Configuration de l'application iOS, procédez comme suit : cliquez sur le bouton Importer .

   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 le Apple Developer Member Center) et cliquez sur Importer.

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

3. Dans Xcode, activez la fonctionnalité "Modes d'arrière-plan" pour votre projet, puis cochez les cases les 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 le dans l'arborescence de gauche. Sélectionnez votre application dans la section CIBLES, puis Sélectionnez l'onglet Infos, puis développez la section Types d'URL.
   2. Cliquez sur le bouton +, puis ajoutez votre ID d'application encodé en tant qu'URL. d'un schéma. Vous trouverez l'ID d'application encodé dans la Généralités Paramètres de la console Firebase, dans la section dédiée à votre iOS l'application. Laissez les autres champs vides.

      Une fois l'opération terminée, votre configuration doit ressembler à l'exemple (mais avec les valeurs propres à votre application):

      
2. Facultatif: Si vous souhaitez personnaliser la façon dont votre application présente les SFSafariViewController lorsque le reCAPTCHA est présenté à l'utilisateur, créez un classe conforme au protocole AuthUIDelegate, puis transmettez-la à verifyPhoneNumber(_:uiDelegate:completion:)

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

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

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

   Les obligations légales varient, mais il est recommandé et de définir les attentes de vos utilisateurs, vous devez les informer que s'ils utilisent connexion par téléphone, il est possible qu'il reçoive un SMS de validation et s'appliquent.

2. Appeler 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 : En fonction de votre forfait, vous pouvez être limité à un quota quotidien de SMS envoyés. Consultez la section Limites Firebase Authentication.

   La méthode verifyPhoneNumber est réentrante, c'est-à-dire si vous l'appelez plusieurs fois (par exemple, Dans la méthode onAppear d'une vue, la méthode verifyPhoneNumber ne envoyez un second SMS à moins que la demande initiale n'ait expiré.

   Lorsque vous appelez verifyPhoneNumber(_:uiDelegate:completion:), Firebase envoie une notification push silencieuse à votre application ou émet une reCAPTCHA à 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 validation à votre fonction de finalisation. Vous aurez besoin du code de validation et du code de validation pour connecter l'utilisateur.

   Le SMS envoyé par Firebase peut également être localisé en spécifiant le la langue auth via la propriété languageCode de votre Auth. Compute Engine.

   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 lors du chargement de votre application. Ce faisant, vous pouvez vous assurer que vous disposez toujours d'un ID de validation valide si votre application est est interrompue avant que l'utilisateur ne termine le processus de connexion (par exemple, en passant à l'application SMS).

   Vous pouvez conserver l'ID de validation comme vous le souhaitez. Un moyen simple consiste à enregistrez 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 à verifyPhoneNumber(_:uiDelegate:completion:) réussit, vous pouvez inviter l'utilisateur à saisir le code de vérification lorsqu'il le recevoir par SMS.

Pour éviter les abus, Firebase limite le nombre de SMS qui peuvent être envoyés à un seul numéro de téléphone dans un certain laps de temps. Si vous dépassez cette limite, les demandes de validation de numéro de téléphone risquent d'ê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 la requête plus tard.

Connecter l'utilisateur avec le code de validation

Une fois que l'utilisateur a fourni à votre application le code de validation du message 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éer un objet FIRPhoneAuthCredential à partir de la validation et l'identifiant 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 via la console Firebase. Test avec un téléphone fictif offrent les avantages suivants:

• Testez l'authentification par numéro de téléphone sans utiliser 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 être limité. Ce 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 à des fins de test.
• Effectuez des tests facilement dans des environnements de développement, sans effort supplémentaire la possibilité de développer dans un simulateur iOS ou un émulateur Android sans les services Google Play.
• Écrire des tests d'intégration sans être bloqué par des 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 respecter les exigences suivantes:

1. Assurez-vous d'utiliser des numéros de téléphone fictifs et 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 des utilisateurs réels en tant que numéros de test. Vous pouvez, par exemple, utiliser les numéros préfixés 555 comme numéros de téléphone de test aux États-Unis: [phone]
2. Le format des numéros de téléphone doit respecter les règles de longueur de contraintes. Ils seront toujours soumis à la même validation que le numéro de téléphone de l'utilisateur réel.
3. Vous pouvez ajouter jusqu'à 10 numéros de téléphone pour le développement.
4. Utilisez des numéros/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, ouvrez le section Authentification.
2. Dans l'onglet Mode de connexion, activez l'opérateur téléphonique, si ce n'est pas déjà fait.
3. Ouvrez le menu de l'accordéon Numéros de téléphone à tester.
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 spécifique, par exemple: 654321.
6. Ajoutez le numéro. Si nécessaire, vous pouvez supprimer le numéro de téléphone et en plaçant le pointeur de la souris 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. Vous pouvez ainsi 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 depuis un simulateur iOS ou un émulateur Android sans les services Google Play. installés.

Lorsque vous indiquez 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 effectué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 à Realtime Database/Cloud Firestore et à d'autres services de la même manière. Le jeton d'ID généré pendant ce processus a la même signature qu’un vrai utilisateur de numéro de téléphone.

Étant donné que le jeton d'identification du numéro de téléphone fictif a la même signature que celle 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 aussi définir un rôle de test via des revendications sur ces utilisateurs afin de les différencier en tant que faux utilisateurs si vous souhaitez y accéder.

Tests d'intégration

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

Assurez-vous que la validation des applications n'est pas désactivée pour les applications en production et qu'aucun numéro de téléphone fictif ne soit 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 étape est traitée sans nécessiter un jeton APNs ou l'envoi de notifications push silencieuses en arrière-plan, ce qui facilite les tests dans un simulateur. Cette opération désactive également le flux de remplacement reCAPTCHA.

Notez que lorsque la validation de l'application est désactivée, la connexion ne peut pas être effectuée avec un numéro de téléphone non fictif. 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 (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 = @"[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 les Jeton APNs, pour gérer les notifications push silencieuses envoyées par Firebase votre application, et d'intercepter automatiquement la redirection du schéma personnalisé à partir de 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 la définissant sur NO. Notez que si vous définissez cet indicateur sur NO, désactive également le swizzling pour d'autres produits Firebase, y compris Firebase Cloud Messaging

Si vous désactivez le forçage de l'ordre des éléments, vous devez transmettre explicitement le jeton d'appareil APN, 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é vers Firebase Authentication.

Pour obtenir le jeton d'appareil APNs, implémentez la application(_:didRegisterForRemoteNotificationsWithDeviceToken:) et de transmettre le jeton d'appareil à l'instance Auth setAPNSToken(_:type:).

Remarque: Les applications SwiftUI doivent utiliser UIApplicationDelegateAdaptor ou Les wrappers de propriété NSApplicationDelegateAdaptor pour fournir un type correspondant à protocole de délégation 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, application(_:didReceiveRemoteNotification:fetchCompletionHandler:): , vérifiez 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, dans celle-ci, transmettez l'URL aux classes Auth. canHandleURL(_:).

Swift

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

Objective-C

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

Si vous utilisez SwiftUI ou UISceneDelegate, pour gérer l'URL de redirection, implémentez la méthode scene(_:openURLContexts:), puis transmettez l'URL à la méthode Auth. canHandleURL(_:).

Swift

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

Objective-C

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

Étapes suivantes

Lorsqu'un utilisateur se connecte pour la première fois, un compte utilisateur est créé et associés aux identifiants, c'est-à-dire au nom d'utilisateur et au mot de passe, ou des informations sur le fournisseur d'authentification, c'est-à-dire l'utilisateur avec lequel il s'est connecté. Cette nouvelle est stocké dans votre projet Firebase et peut servir à identifier un utilisateur dans toutes les applications de votre projet, quelle que soit la façon dont l'utilisateur se connecte.

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

• Dans votre Firebase Realtime Database et votre Cloud Storage Règles de sécurité, vous pouvez obtenez 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 appli à l'aide de plusieurs authentifications fournisseurs en associant leurs identifiants 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 la section Gérer les erreurs.