אימות עם Firebase בפלטפורמות של Apple באמצעות מספר טלפון

אפשר להשתמש ב-Firebase Authentication כדי להכניס משתמש לחשבון באמצעות שליחת הודעת SMS לטלפון של המשתמש. המשתמש נכנס לחשבון באמצעות קוד חד-פעמי שמופיע בהודעת ה-SMS.

הדרך הקלה ביותר להוסיף לאפליקציה כניסה באמצעות מספר טלפון היא להשתמש ב-FirebaseUI, שכולל ווידג'ט כניסה מוכן שמטמיע תהליכי כניסה באמצעות מספר טלפון, וגם כניסה באמצעות סיסמה וכניסה מאוחדת. במסמך הזה מוסבר איך להטמיע תהליך כניסה באמצעות מספר טלפון באמצעות Firebase SDK.

לפני שמתחילים

1. אם עדיין לא קישרתם את האפליקציה לפרויקט ב-Firebase, אתם צריכים לעשות את זה דרך מסוף Firebase.

2. משתמשים ב-Swift Package Manager כדי להתקין ולנהל את יחסי התלות של Firebase.

   1. ב-Xcode, כשהפרויקט של האפליקציה פתוח, עוברים אל File > Add Packages (קובץ > הוספת חבילות).
   2. כשמוצגת בקשה, מוסיפים את מאגר ה-SDK של Firebase לפלטפורמות של אפל:

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

   3. בוחרים בספרייה Firebase Authentication.
   4. מוסיפים את הדגל -ObjC לקטע Other Linker Flags (דגלים אחרים של מקשרים) בהגדרות ה-build של היעד.
   5. אחרי שתסיימו, פלטפורמת Xcode תתחיל לטפל ביחסי התלות ולהוריד אותם באופן אוטומטי ברקע.

בעיות אבטחה

אימות באמצעות מספר טלפון בלבד הוא נוח, אבל פחות מאובטח משיטות אחרות, כי קל להעביר את הבעלות על מספר טלפון בין משתמשים. בנוסף, במכשירים עם כמה פרופילי משתמשים, כל משתמש שיכול לקבל הודעות SMS יכול להיכנס לחשבון באמצעות מספר הטלפון של המכשיר.

אם אתם משתמשים באפליקציה בכניסה לחשבון שמבוססת על מספר טלפון, אתם צריכים להציע אותה לצד שיטות כניסה מאובטחות יותר, וליידע את המשתמשים על הפשרות מבחינת האבטחה כשמשתמשים בכניסה לחשבון באמצעות מספר טלפון.

הפעלת כניסה באמצעות מספר טלפון בפרויקט ב-Firebase

כדי לאפשר למשתמשים להיכנס באמצעות SMS, קודם צריך להפעיל את שיטת הכניסה באמצעות מספר טלפון בפרויקט Firebase:

1. במסוף Firebase, נכנסים אל אבטחה > אימות.
2. בכרטיסייה שיטת התחברות, מפעילים את ספק הכניסה Phone.
3. מגדירים מדיניות באזורים שבהם רוצים לאפשר או לאסור שליחת הודעות SMS. הגדרת מדיניות אזורית ל-SMS יכולה לעזור להגן על האפליקציות מפני ניצול לרעה של SMS. בפרויקטים חדשים, מדיניות ברירת המחדל לא מאפשרת אזורים.
   1. במסוף Firebase, נכנסים לכרטיסייה Security ‏> Authentication ‏> Settings.
   2. בקטע מדיניות אזורית בנושא SMS, מגדירים את המדיניות האזורית בנושא SMS.

הפעלת אימות אפליקציות

כדי להשתמש באימות באמצעות מספר טלפון, Firebase צריך להיות מסוגל לאמת שבקשות הכניסה באמצעות מספר טלפון מגיעות מהאפליקציה שלכם. יש שתי דרכים שבהן Firebase Authentication עושה את זה:

• התראות APN שקטות: כשאתה מתחבר למשתמש עם מספר הטלפון שלו בפעם הראשונה במכשיר, Firebase Authentication שולח אסימון למכשיר באמצעות הודעת דחיפה שקטה. אם האפליקציה מקבלת את ההתראה מ-Firebase, אפשר להמשיך בתהליך הכניסה באמצעות מספר הטלפון.

  ב-iOS מגרסה 8.0 ואילך, התראות שקטות לא דורשות הסכמה מפורשת מהמשתמש, ולכן הן לא מושפעות אם המשתמש מסרב לקבל התראות APN באפליקציה. לכן, האפליקציה לא צריכה לבקש הרשאה מהמשתמש כדי לקבל התראות, כשמטמיעים אימות של מספר טלפון ב-Firebase.

• אימות מסוג reCAPTCHA: אם אי אפשר לשלוח או לקבל התראת Push שקטה, למשל כשהמשתמש השבית את הרענון ברקע של האפליקציה, או כשבודקים את האפליקציה בסימולטור של iOS, ‏Firebase Authentication משתמש באימות מסוג reCAPTCHA כדי להשלים את תהליך הכניסה באמצעות הטלפון. לרוב, אפשר להשלים את מבחן ה-reCAPTCHA בלי שהמשתמש יצטרך לפתור שום דבר.

כשההתראות השקטות מוגדרות כמו שצריך, רק אחוז קטן מאוד מהמשתמשים יחוו את תהליך ה-reCAPTCHA. עם זאת, חשוב לוודא שהכניסה באמצעות מספר טלפון פועלת בצורה תקינה, גם אם התראות שקטות זמינות וגם אם לא.

איך מתחילים לקבל התראות שקטות

כדי להפעיל התראות APNs לשימוש עם Firebase Authentication:

1. ב-Xcode, מפעילים התראות בפרויקט.

2. מעלים את מפתח האימות של APNs ל-Firebase. אם עדיין אין לכם מפתח אימות של APNs, הקפידו ליצור מפתח כזה ב-Apple Developer Member Center.

   1. במסוף Firebase, נכנסים אל settings הגדרות > כללי. לאחר מכן לוחצים על הכרטיסייה העברת הודעות בענן.
   2. בקטע APNs authentication key (מפתח אימות של APNs) שמופיע בקטע iOS app configuration (הגדרת אפליקציה ל-iOS), לוחצים על Upload (העלאה) כדי להעלות את מפתח האימות של סביבת הפיתוח, את מפתח האימות של סביבת הייצור או את שניהם. צריך להוסיף לפחות אחד.
   3. עוברים למיקום שבו שמרתם את המפתח, בוחרים אותו ולוחצים על Open. מוסיפים את מזהה המפתח (זמין ב-Apple Developer Member Center) ולוחצים על Upload.

   אם כבר יש לך אישור APNs, אפשר להעלות את האישור במקום זאת.

3. ב-Xcode, מפעילים את היכולת Background Modes בפרויקט, ואז מסמנים את תיבות הסימון של המצבים Background fetch ו-Remote notifications.

הגדרת אימות מסוג reCAPTCHA

כדי לאפשר ל-Firebase SDK להשתמש באימות מסוג reCAPTCHA:

1. מוסיפים סכמות URL בהתאמה אישית לפרויקט Xcode:
   1. פותחים את הגדרות הפרויקט: לוחצים לחיצה כפולה על שם הפרויקט בתצוגת העץ שמימין. בוחרים את האפליקציה בקטע TARGETS, לוחצים על הכרטיסייה Info ומרחיבים את הקטע URL Types.
   2. לוחצים על הלחצן + ומוסיפים את מזהה האפליקציה המקודד כסכמת URL. משאירים את שאר השדות ריקים.

      אפשר למצוא את מזהה האפליקציה המקודד במסוף Firebase: עוברים אל settings הגדרות > הכרטיסייה כללי, ואז גוללים למטה לקטע האפליקציות שלך כדי לראות פרטים על האפליקציה ל-iOS.

      בסיום, קובץ התצורה אמור להיראות בערך כך (אבל עם הערכים הספציפיים לאפליקציה שלכם):

      
2. אופציונלי: אם רוצים להתאים אישית את האופן שבו האפליקציה מציגה את SFSafariViewController כשמציגים את reCAPTCHA למשתמש, יוצרים מחלקה בהתאמה אישית שתואמת לפרוטוקול AuthUIDelegate ומעבירים אותה אל verifyPhoneNumber(_:uiDelegate:completion:).

שליחת קוד אימות לטלפון של המשתמש

כדי להתחיל כניסה באמצעות מספר טלפון, צריך להציג למשתמש ממשק שמבקש ממנו לספק את מספר הטלפון שלו, ואז להתקשר אל verifyPhoneNumber(_:uiDelegate:completion:) כדי לבקש מ-Firebase לשלוח קוד אימות לטלפון של המשתמש באמצעות SMS:

1. מקבלים את מספר הטלפון של המשתמש.

   הדרישות המשפטיות משתנות, אבל כשיטה מומלצת וכדי להגדיר ציפיות למשתמשים, כדאי להודיע להם שאם הם משתמשים בכניסה באמצעות הטלפון, הם עשויים לקבל הודעת SMS לאימות ושתעריפים רגילים חלים.

2. קוראים ל-verifyPhoneNumber(_:uiDelegate:completion:) ומעבירים אליה את מספר הטלפון של המשתמש.

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

   השיטה verifyPhoneNumber היא reentrant: אם קוראים לה כמה פעמים, למשל בשיטה onAppear של תצוגה, השיטה verifyPhoneNumber לא תשלח הודעת SMS שנייה, אלא אם הזמן הקצוב לתפוגה של הבקשה המקורית חלף.

   כשמפעילים את verifyPhoneNumber(_:uiDelegate:completion:), Firebase שולחת התראה שקטה לאפליקציה, או מציגה מבחן reCAPTCHA למשתמש. אחרי שהאפליקציה מקבלת את ההתראה או שהמשתמש משלים את מבחן reCAPTCHA, ‏Firebase שולחת הודעת SMS עם קוד אימות למספר הטלפון שצוין, ומעבירה מזהה אימות לפונקציית ההשלמה. כדי להכניס את המשתמש, צריך גם את קוד האימות וגם את מזהה האימות.

   אפשר גם להתאים את הודעת ה-SMS שנשלחת על ידי Firebase לשפה המקומית, על ידי ציון שפת האימות באמצעות המאפיין languageCode במכונה של Auth.

   Swift

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

   Objective-C

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

3. שומרים את מזהה האימות ומשחזרים אותו כשהאפליקציה נטענת. כך תוכלו לוודא שעדיין יש לכם מזהה אימות תקין אם האפליקציה נסגרת לפני שהמשתמש משלים את תהליך הכניסה (לדוגמה, בזמן המעבר לאפליקציית הסמס).

   אתם יכולים לשמור את מזהה האימות בכל דרך שתרצו. דרך פשוטה לעשות זאת היא לשמור את מזהה האימות עם האובייקט NSUserDefaults:

   Swift

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

   Objective-C

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

   אחר כך אפשר לשחזר את הערך השמור:

   Swift

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

   Objective-C

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

אם הקריאה ל-verifyPhoneNumber(_:uiDelegate:completion:) תצליח, תוכלו לבקש מהמשתמש להקליד את קוד האימות כשהוא יקבל אותו בהודעת ה-SMS.

המשתמש נכנס לחשבון באמצעות קוד האימות

אחרי שהמשתמש מזין באפליקציה את קוד האימות מהודעת ה-SMS, יוצרים אובייקט FIRPhoneAuthCredential מקוד האימות וממזהה האימות ומעבירים את האובייקט הזה אל signInWithCredential:completion: כדי להכניס את המשתמש לחשבון.

1. מקבלים את קוד האימות מהמשתמש.
2. יוצרים אובייקט FIRPhoneAuthCredential מקוד האימות וממזהה האימות.

   Swift

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

   Objective-C

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

3. מכניסים את המשתמש לחשבון באמצעות האובייקט 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;
     // ...
   }];

בדיקה עם מספרי טלפון פיקטיביים

אפשר להגדיר מספרי טלפון פיקטיביים לפיתוח באמצעות מסוף Firebase. לבדיקה עם מספרי טלפון פיקטיביים יש כמה יתרונות:

• בודקים את האימות של מספר הטלפון בלי לנצל את מכסת השימוש.
• בודקים את האימות של מספר הטלפון בלי לשלוח הודעת SMS בפועל.
• להריץ בדיקות ברצף עם אותו מספר טלפון בלי שהמערכת תגביל אתכם. כך אפשר לצמצם את הסיכון לדחייה במהלך תהליך הבדיקה של חנות האפליקציות, אם הבודק משתמש באותו מספר טלפון לבדיקה.
• אפשר לבצע בדיקות בקלות בסביבות פיתוח בלי מאמץ נוסף, למשל לפתח בסימולטור של iOS או באמולטור Android בלי Google Play Services.
• לכתוב בדיקות שילוב בלי להיחסם על ידי בדיקות אבטחה שבדרך כלל מופעלות על מספרי טלפון אמיתיים בסביבת ייצור.

מספרי טלפון פיקטיביים צריכים לעמוד בדרישות הבאות:

1. חשוב להשתמש במספרי טלפון שהם באמת פיקטיביים ולא קיימים כבר. ב-Firebase Authentication אי אפשר להגדיר מספרי טלפון קיימים של משתמשים אמיתיים כמספרי בדיקה. אפשרות אחת היא להשתמש במספרים עם הקידומת 555 כמספרי טלפון לבדיקה בארה"ב, לדוגמה: ‎+1 650-555-3434
2. מספרי הטלפון צריכים להיות בפורמט הנכון מבחינת האורך ומגבלות אחרות. הם עדיין יעברו את אותו תהליך אימות כמו מספר טלפון של משתמש אמיתי.
3. אפשר להוסיף עד 10 מספרי טלפון לפיתוח.
4. השתמשו במספרי טלפון או בקודים לבדיקה שקשה לנחש, והחליפו אותם לעיתים קרובות.

יצירת מספרי טלפון וקודי אימות פיקטיביים

1. במסוף Firebase, נכנסים אל אבטחה > אימות.
2. בכרטיסייה שיטת התחברות, מפעילים את ספק הכניסה Phone, אם הוא עדיין לא מופעל.
3. מרחיבים את הקטע מספרי טלפון לבדיקה.
4. מזינים את מספר הטלפון שרוצים לבדוק, לדוגמה: +1 650-555-3434.
5. מזינים את קוד האימות בן 6 הספרות של המספר הספציפי הזה, לדוגמה: 654321.
6. לוחצים על הוספה לכל מספר. אם צריך, אפשר למחוק את מספר הטלפון והקוד שלו. כדי לעשות את זה, מעבירים את העכבר מעל השורה המתאימה ולוחצים על סמל פח האשפה.

בדיקה ידנית

אתם יכולים להתחיל להשתמש במספר טלפון פיקטיבי ישירות באפליקציה. כך תוכלו לבצע בדיקות ידניות בשלבי הפיתוח בלי להיתקל בבעיות של מכסות או הגבלת קצב. אפשר גם לבדוק ישירות מסימולטור של iOS או מאמולטור Android בלי להתקין את Google Play Services.

כשמזינים את מספר הטלפון הפיקטיבי ושולחים את קוד האימות, לא נשלחת הודעת SMS אמיתית. במקום זאת, צריך להזין את קוד האימות שהוגדר קודם כדי להשלים את הכניסה.

בסיום הכניסה, נוצר משתמש Firebase עם מספר הטלפון הזה. המשתמש מתנהג כמו משתמש עם מספר טלפון אמיתי ויש לו את אותם מאפיינים, והוא יכול לגשת אל Realtime Database/Cloud Firestore ולשירותים אחרים באותו אופן. לטוקן של המזהה שנוצר בתהליך הזה יש את אותה חתימה כמו למשתמש אמיתי עם מספר טלפון.

אפשרות נוספת היא להגדיר תפקיד בדיקה באמצעות הצהרות מותאמות אישית למשתמשים האלה כדי להבדיל אותם כמשתמשים מזויפים, אם רוצים להגביל עוד יותר את הגישה.

בדיקת אינטגרציה

בנוסף לבדיקה ידנית, Firebase Authentication מספק ממשקי API שעוזרים לכתוב בדיקות שילוב לבדיקת אימות באמצעות הטלפון. ממשקי ה-API האלה משביתים את אימות האפליקציה על ידי השבתת הדרישה ל-reCAPTCHA באינטרנט ובהתראות שקטות ב-iOS. כך אפשר לבצע בדיקות אוטומטיות בתהליכים האלה וקל יותר להטמיע אותן. בנוסף, הם מאפשרים לבדוק תהליכי אימות מיידי ב-Android.

ב-iOS, צריך להגדיר את appVerificationDisabledForTesting לערך TRUE לפני שקוראים ל-verifyPhoneNumber. העיבוד מתבצע בלי צורך באסימון APNs או בשליחת התראות שקטות ברקע, כך שקל יותר לבדוק את זה בסימולטור. הפעולה הזו גם משביתה את תהליך הגיבוי של reCAPTCHA.

שימו לב: אם אימות האפליקציה מושבת, לא תוכלו להשלים את הכניסה באמצעות מספר טלפון אמיתי. אפשר להשתמש ב-API הזה רק עם מספרי טלפון פיקטיביים.

let phoneNumber = "+16505554567"

// This test verification code is specified for the given test phone number in the developer console.
let testVerificationCode = "123456"

Auth.auth().settings.isAppVerificationDisabledForTesting = true
PhoneAuthProvider.provider().verifyPhoneNumber(phoneNumber, uiDelegate:nil) {
                                                            verificationID, error in
    if 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
    };
};

NSString *phoneNumber = @"+16505554567";

// This test verification code is specified for the given test phone number in the developer console.
NSString *testVerificationCode = @"123456";

[FIRAuth auth].settings.appVerificationDisabledForTesting = YES;
[[FIRPhoneAuthProvider provider] verifyPhoneNumber:phoneNumber
                                        completion:^(NSString *_Nullable verificationID,
                                                     NSError *_Nullable error) {
    if (error) {
      // Handles error
      [self handleError:error];
      return;
    }
    FIRAuthCredential *credential =
        [FIRPhoneAuthProvider credentialWithVerificationID:verificationID
                                          verificationCode:testVerificationCode];
    [FIRAuth auth] signInWithAndRetrieveDataWithCredential:credential
                                                completion:^(FIRUser *_Nullable user,
                                                             NSError *_Nullable error) {
      if (error) {
        // Handles error
        [self handleError:error];
        return;
      }
      _user = user;
    }];
}];

נספח: שימוש בכניסה באמצעות מספר טלפון בלי swizzling

‫Firebase Authentication משתמש בשינוי פונקציונליות של שיטה כדי לקבל באופן אוטומטי את טוקן ה-APNs של האפליקציה, לטפל בהתראות השקטות ש-Firebase שולח לאפליקציה, וליירט באופן אוטומטי את ההפניה האוטומטית של הסכימה בהתאמה אישית מדף האימות מסוג reCAPTCHA במהלך האימות.

אם אתם מעדיפים לא להשתמש ב-swizzling, אתם יכולים להשבית אותו על ידי הוספת הדגל FirebaseAppDelegateProxyEnabled לקובץ Info.plist של האפליקציה והגדרתו כ-NO. חשוב לדעת: הגדרת הדגל הזה לערך NO משביתה את ה-swizzling גם במוצרי Firebase אחרים, כולל Firebase Cloud Messaging.

אם משביתים את ה-swizzling, צריך להעביר באופן מפורש ל-Firebase Authentication את טוקן המכשיר של APNs, את ההתראות ואת כתובת ה-URL להפניה מחדש של הסכימה בהתאמה אישית.

אם אתם מפתחים אפליקציית SwiftUI, אתם צריכים גם להעביר באופן מפורש ל-Firebase Authentication את אסימון המכשיר של APNs, את ההתראות וכתובת ה-URL להפניה מחדש של הסכימה בהתאמה אישית.

כדי לקבל את טוקן המכשיר של APNs, מטמיעים את ה-method‏ application(_:didRegisterForRemoteNotificationsWithDeviceToken:), ובתוכה מעבירים את טוקן המכשיר ל-method‏ setAPNSToken(_:type:) של Auth.

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

כדי לטפל בהתראות, ב-method‏ application(_:didReceiveRemoteNotification:fetchCompletionHandler:):, בודקים אם יש התראות שקשורות לאימות ב-Firebase באמצעות קריאה ל-method‏ canHandleNotification(_:) של Auth.

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

כדי לטפל בכתובת ה-URL להפניה אוטומטית של הסכימה בהתאמה אישית, מטמיעים את ה-method‏ application(_:open:options:), ובתוכה מעבירים את כתובת ה-URL ל-method‏ canHandleURL(_:) של Auth.

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

אם אתם משתמשים ב-SwiftUI או ב-UISceneDelegate, כדי לטפל בכתובת ה-URL להפניה אוטומטית, אתם צריכים להטמיע את השיטה scene(_:openURLContexts:), ובתוכה להעביר את כתובת ה-URL לשיטה canHandleURL(_:) של Auth.

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

השלבים הבאים

אחרי שמשתמש נכנס לחשבון בפעם הראשונה, נוצר חשבון משתמש חדש שמקושר לפרטי הכניסה – כלומר, שם המשתמש והסיסמה, מספר הטלפון או פרטי ספק האימות – שאיתם המשתמש נכנס לחשבון. החשבון החדש הזה נשמר כחלק מהפרויקט ב-Firebase, ואפשר להשתמש בו כדי לזהות משתמש בכל אפליקציה בפרויקט, בלי קשר לאופן שבו המשתמש נכנס לחשבון.

• באפליקציות, אתם יכולים לקבל את פרטי הפרופיל הבסיסיים של המשתמש מהאובייקט User . ניהול משתמשים

• בכללי האבטחה של Firebase Realtime Database ו-Cloud Storage, אפשר לקבל את מזהה המשתמש הייחודי של המשתמש המחובר מהמשתנה auth, ולהשתמש בו כדי לקבוע לאילו נתונים המשתמש יכול לגשת.

אתם יכולים לאפשר למשתמשים להיכנס לאפליקציה באמצעות כמה ספקי אימות, על ידי קישור פרטי הכניסה של ספק האימות לחשבון משתמש קיים.

כדי להוציא משתמש מהחשבון, מפעילים את signOut:.

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

כדאי גם להוסיף קוד לטיפול בשגיאות לכל מגוון שגיאות האימות. איך מטפלים בשגיאות