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 lui envoyant un message SMS sur son téléphone. L'utilisateur se connecte à l'aide d'un code à usage unique contenu dans le message 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 des 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 que les utilisateurs finaux fournissent pour l'authentification seront envoyés et stockés par Google afin d'améliorer la protection contre le spam et les abus dans les services Google, y compris, mais sans s'y limiter, Firebase. Les développeurs doivent s'assurer d'avoir obtenu le 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, y compris l'importation directe des frameworks et l'utilisation de CocoaPods.
   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 utilisent la version par défaut du SDK (la plus récente), mais vous pouvez choisir une version plus 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 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 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 Authentication (Authentification).
2. Sur la page Sign-in Method (Mode de connexion), activez la méthode de connexion Phone Number (Numéro de téléphone).

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 correctement 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 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: si l'envoi ou la réception d'une notification push silencieuse n'est pas possible, 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 terminer le parcours de connexion par téléphone. Le test reCAPTCHA peut souvent être effectué sans que l'utilisateur 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, reCAPTCHA est utilisé. Ce flux reCAPTCHA nécessite que votre clé API ne soit pas soumise à des restrictions ou qu'elle figure sur 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 suivent 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 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.

Recevoir des notifications silencieuses

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

1. Dans Xcode, activez 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 pour les développeurs Apple.

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

   2. Dans Clés d'authentification d'APN, sous Configuration de l'application iOS, 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 APN, vous pouvez l'importer à la place.

3. Dans Xcode, activez la fonctionnalité Modes en arrière-plan pour votre projet, puis cochez les cases des 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, puis sélectionnez l'onglet Infos et développez la section Types d'URL.
   2. Cliquez sur le bouton +, puis ajoutez votre ID d'application encodé en tant que schéma d'URL. Vous trouverez votre ID d'application encodé sur la page Paramètres généraux de la console Firebase, dans la section de votre application iOS. Laissez les autres champs vides.

      Une fois terminée, votre configuration devrait se présenter comme suit (mais avec vos valeurs propres à l'application):

      
2. Facultatif: Si vous souhaitez personnaliser la manière dont votre application présente 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 à indiquer 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. Obtenez le numéro de téléphone de l'utilisateur.

   Les exigences légales varient, mais il est recommandé d'informer vos utilisateurs qu'ils peuvent recevoir un SMS de validation s'ils utilisent la connexion par téléphone 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.
   SwiftObjective-C
   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
         // ...
     }

   [[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: si vous l'appelez plusieurs fois, par exemple dans la méthode onAppear d'une vue, la méthode verifyPhoneNumber n'envoie 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 envoie un défi 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 de l'ID de validation pour connecter l'utilisateur.

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

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

    // 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 de disposer toujours d'un ID de validation valide si votre application est arrêtée avant que l'utilisateur n'ait terminé le parcours de connexion (par exemple, lors du passage à l'application de SMS).

   Vous pouvez conserver l'ID de validation de quelque manière que ce soit. Le moyen le plus simple consiste à enregistrer l'ID de validation avec l'objet NSUserDefaults:

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

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

   Vous pouvez ensuite restaurer la valeur enregistrée:

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

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

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

Pour éviter les abus, Firebase limite le nombre de SMS pouvant être envoyés à un même numéro de téléphone au cours d'une période donnée. Si vous dépassez cette limite, les demandes de validation 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 la demande 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. Obtenez le code de validation auprès de l'utilisateur.
2. Créez un objet FIRPhoneAuthCredential à partir du code de validation et de l'ID de validation.
   SwiftObjective-C
   let credential = PhoneAuthProvider.provider().credential(
     withVerificationID: verificationID,
     verificationCode: verificationCode
   )

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

3. Connectez l'utilisateur avec l'objet FIRPhoneAuthCredential:
   SwiftObjective-C
   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
       // ...
   }

   [[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. Les tests avec des numéros de téléphone fictifs présentent 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é. Cela réduit le risque de refus lors du processus d'examen de l'App Store si l'examinateur utilise le même numéro de téléphone pour les tests.
• Effectuez des tests facilement dans des environnements de développement sans effort supplémentaire, par exemple la possibilité de développer dans un simulateur iOS ou un émulateur Android sans les services Google Play.
• Écrivez des tests d'intégration sans être bloqué par les vérifications de sécurité normalement appliquées aux numéros de téléphone réels dans un environnement de production.

Les numéros de téléphone fictifs doivent respecter les conditions suivantes:

1. Assurez-vous d'utiliser des numéros de téléphone fictifs qui n'existent pas. Firebase Authentication ne vous permet pas de définir des numéros de téléphone existants utilisés par de véritables utilisateurs comme numéros de test. Vous pouvez utiliser des numéros avec le préfixe 555 comme numéros de téléphone de test aux États-Unis, par exemple : [phone]
2. Les numéros de téléphone doivent être au bon format en termes de longueur et d'autres contraintes. Il sera tout de même soumis à la même procédure de 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/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 la section Authentication (Authentification).
2. Dans l'onglet Méthode de connexion, activez le fournisseur de téléphone si ce n'est pas déjà fait.
3. Ouvrez le menu accordéon Numéros de téléphone à des fins de test.
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. Ajoutez le 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. 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 à partir d'un simulateur iOS ou d'un émulateur Android sans installer les services Google Play.

Lorsque vous fournissez le numéro de téléphone fictif et que vous 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 créé lors de ce processus a la même signature qu'un utilisateur disposant d'un numéro de téléphone réel.

É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 également définir un rôle de test via des revendications personnalisées sur ces utilisateurs pour les identifier comme des utilisateurs fictifs 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 les tests d'authentification par téléphone. Ces API désactivent la validation des applications en désactivant l'exigence reCAPTCHA sur le Web et les notifications push silencieuses sur iOS. Cela permet de tester l'automatisation dans ces flux et de l'implémenter plus facilement. De plus, elles 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. Ce traitement ne nécessite aucun jeton APN ni 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.

SwiftObjective-C

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

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 mélanger les comptes

Firebase Authentication utilise le mélange de méthodes 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 de schéma personnalisé à partir de la page de validation reCAPTCHA lors de la validation.

Si vous préférez ne pas utiliser le forçage de type, 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 définir cet indicateur sur NO désactive également le mélange 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 APN, les notifications push et l'URL de redirection du schéma personnalisé à Firebase Authentication.

Pour obtenir le jeton d'appareil APN, 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é.

SwiftObjective-C

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

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

SwiftObjective-C

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

- (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-lui l'URL à la méthode canHandleURL(_:) de Auth.

SwiftObjective-C

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

- (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-lui l'URL à la méthode canHandleURL(_:) de Auth.

SwiftObjective-C

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

- (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 et mot de passe de l'utilisateur, numéro de téléphone ou informations du fournisseur d'authentification) avec lesquels l'utilisateur 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 profil de base 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:.

SwiftObjective-C

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

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.