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

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

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

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

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

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

    1. ב-Xcode, כשפרויקט האפליקציה פתוח, עוברים אל קובץ > הוספת חבילות.
    2. כשמופיעה בקשה, מוסיפים את המאגר של Firebase SDK לפלטפורמות של Apple:
      3.   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, פותחים את הקטע Authentication.
  2. בדף Sign-in Method מפעילים את שיטת הכניסה Phone Number.

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

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

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

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

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

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

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

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

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

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

    1. בתוך הפרויקט במסוף Firebase, לוחצים על סמל גלגל השיניים, בוחרים באפשרות Project Settings (הגדרות הפרויקט) ואז בוחרים בכרטיסייה Cloud Messaging (Cloud Messaging).

    2. בקטע APNs authentication key בקטע iOS app configuration, לוחצים על הלחצן Upload.

    3. עוברים למיקום שבו שמרתם את המפתח, בוחרים אותו ולוחצים על פתיחה. מוסיפים את מזהה המפתח (זמין ב- Apple Developer Member Center) ולוחצים על Upload.

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

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

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

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

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

      בסיום, הקטע של הגדרות ה-config אמור להיראות בערך כך (אבל עם הערכים הספציפיים לאפליקציה שלכם):

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

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

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

  1. אחזור של מספר הטלפון של המשתמש.

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

  2. קוראים לפונקציה verifyPhoneNumber(_:uiDelegate:completion:) ומעבירים לה את מספר הטלפון של המשתמש.
    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
  // ...
}];

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

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

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

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

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

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

    SwiftObjective-C
    UserDefaults.standard.set(verificationID, forKey: "authVerificationID")
     
    NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
[defaults setObject:verificationID forKey:@"authVerificationID"];

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

    SwiftObjective-C
    let verificationID = UserDefaults.standard.string(forKey: "authVerificationID")
     
    NSString *verificationID = [defaults stringForKey:@"authVerificationID"];

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

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

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

  1. מקבלים מהמשתמש את קוד האימות.
  2. יוצרים אובייקט FIRPhoneAuthCredential מקוד האימות וממזהה האימות.
    SwiftObjective-C
    let credential = PhoneAuthProvider.provider().credential(
  withVerificationID: verificationID,
  verificationCode: verificationCode
)
     
    FIRAuthCredential *credential = [[FIRPhoneAuthProvider provider]
    credentialWithVerificationID:verificationID
                verificationCode:userInput];
  3. כניסה של המשתמש באמצעות האובייקט 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;
  // ...
}];

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

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

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

מספרי טלפון בדיוניים חייבים לעמוד בדרישות הבאות:

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

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

  1. במסוף Firebase, פותחים את הקטע Authentication.
  2. בכרטיסייה Sign in method (שיטת כניסה), מפעילים את ספק הטלפון, אם עדיין לא עשיתם זאת.
  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 הזה רק עם מספרי טלפון בדיוניים.

SwiftObjective-C
let phoneNumber = "+16505554567"

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

Auth.auth().settings.isAppVerificationDisabledForTesting = TRUE
PhoneAuthProvider.provider().verifyPhoneNumber(phoneNumber, uiDelegate:nil) {
                                                            verificationID, error in
    if (error) {
      // Handles error
      self.handleError(error)
      return
    }
    let credential = PhoneAuthProvider.provider().credential(withVerificationID: verificationID ?? "",
                                                               verificationCode: testVerificationCode)
    Auth.auth().signInAndRetrieveData(with: credential) { authData, error in
      if (error) {
        // Handles error
        self.handleError(error)
        return
      }
      _user = authData.user
    }];
}];
 
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;
    }];
}];

נספח: שימוש בכניסה לחשבון דרך הטלפון בלי החלפה

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

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

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

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

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

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

כדי לטפל בהתראות דחיפה, צריך לבדוק אם יש התראות שקשורות לאימות ב-Firebase בשיטה application(_:didReceiveRemoteNotification:fetchCompletionHandler:):, על ידי קריאה לשיטה canHandleNotification(_:) של 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.
}

כדי לטפל בכתובת ה-URL להפניה אוטומטית של הסכימה בהתאמה אישית, מטמיעים את ה-method‏ application(_:open:options:), ובו מעבירים את כתובת ה-URL ל-method‏ canHandleURL(_:) של 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.
}

אם אתם משתמשים ב-SwiftUI או ב-UISceneDelegate, כדי לטפל בכתובת ה-URL להפניה אוטומטית, צריך להטמיע את השיטה scene(_:openURLContexts:), ובתוכה להעביר את כתובת ה-URL לשיטה canHandleURL(_:) של 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.
  }
}

השלבים הבאים

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

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

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

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

כדי להוציא משתמש מהחשבון, קוראים ל- 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;
}

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