หน้านี้ได้รับการแปลโดย Cloud Translation API

ตรวจสอบสิทธิ์ด้วย Firebase โดยใช้หมายเลขโทรศัพท์และ C++

คุณใช้การตรวจสอบสิทธิ์ Firebase เพื่อลงชื่อเข้าใช้ผู้ใช้ได้โดยส่งข้อความ SMS ไปยังโทรศัพท์ของผู้ใช้ ผู้ใช้จะลงชื่อเข้าใช้ด้วยรหัสแบบใช้ครั้งเดียวที่อยู่ในข้อความ SMS

เอกสารนี้อธิบายวิธีใช้ขั้นตอนการลงชื่อเข้าใช้หมายเลขโทรศัพท์ด้วย Firebase SDK

Google จะส่งและจัดเก็บหมายเลขโทรศัพท์ที่ผู้ใช้ปลายทางให้สำหรับการตรวจสอบสิทธิ์ไว้เพื่อปรับปรุงการป้องกันสแปมและการละเมิดในบริการต่างๆ ของ Google ซึ่งรวมถึงแต่ไม่จำกัดเพียง Firebase นักพัฒนาซอฟต์แวร์ควรตรวจสอบว่าได้รับความยินยอมที่เหมาะสมจากผู้ใช้ปลายทางก่อนใช้บริการลงชื่อเข้าใช้ด้วยหมายเลขโทรศัพท์สำหรับการตรวจสอบสิทธิ์ Firebase

ก่อนเริ่มต้น

เพิ่ม Firebase ไปยังโปรเจ็กต์ C++
หากยังไม่ได้เชื่อมต่อแอปกับโปรเจ็กต์ Firebase ให้เชื่อมต่อจากคอนโซล Firebase
ทำความเข้าใจข้อกำหนดของแพลตฟอร์มสำหรับการลงชื่อเข้าใช้ด้วยหมายเลขโทรศัพท์
- การลงชื่อเข้าใช้ด้วยหมายเลขโทรศัพท์มีไว้สำหรับแพลตฟอร์มอุปกรณ์เคลื่อนที่เท่านั้น
- ใน iOS การลงชื่อเข้าใช้หมายเลขโทรศัพท์ต้องใช้อุปกรณ์จริงและไม่สามารถใช้กับเครื่องจำลองได้

ข้อกังวลด้านความปลอดภัย

แต่การตรวจสอบสิทธิ์โดยใช้หมายเลขโทรศัพท์เพียงอย่างเดียวนั้นสะดวกกว่าวิธีการอื่นๆ ที่มีให้บริการ เนื่องจากการครอบครองหมายเลขโทรศัพท์นั้นสามารถโอนระหว่างผู้ใช้ได้อย่างง่ายดาย นอกจากนี้ บนอุปกรณ์ที่มีโปรไฟล์ผู้ใช้หลายโปรไฟล์ ผู้ใช้ทุกคนที่สามารถรับข้อความ SMS จะสามารถลงชื่อเข้าใช้บัญชีโดยใช้หมายเลขโทรศัพท์ของอุปกรณ์ได้

หากคุณใช้การลงชื่อเข้าใช้ด้วยหมายเลขโทรศัพท์ในแอป คุณควรเสนอการลงชื่อเข้าใช้ด้วยหมายเลขโทรศัพท์ควบคู่กับวิธีการลงชื่อเข้าใช้ที่ปลอดภัยมากขึ้น และแจ้งให้ผู้ใช้ทราบถึงข้อดีด้านความปลอดภัยของการลงชื่อเข้าใช้ด้วยหมายเลขโทรศัพท์

หากต้องการลงชื่อเข้าใช้ให้ผู้ใช้ทาง SMS คุณต้องเปิดใช้วิธีการลงชื่อเข้าใช้หมายเลขโทรศัพท์สำหรับโปรเจ็กต์ Firebase ก่อน ดังนี้

ในคอนโซล Firebase ให้เปิดส่วนการตรวจสอบสิทธิ์
ในหน้าวิธีการลงชื่อเข้าใช้ ให้เปิดใช้วิธีการลงชื่อเข้าใช้หมายเลขโทรศัพท์

โควต้าคำขอลงชื่อเข้าใช้หมายเลขโทรศัพท์ของ Firebase สูงพอที่แอปส่วนใหญ่จะไม่ได้รับผลกระทบ อย่างไรก็ตาม หากคุณต้องการลงชื่อเข้าใช้ให้ผู้ใช้จำนวนมากด้วยการตรวจสอบสิทธิ์ทางโทรศัพท์ คุณอาจต้องอัปเกรดแพ็กเกจราคา ดูหน้าราคา

เริ่มรับการแจ้งเตือน APN (แพลตฟอร์มของ Apple)

หากต้องการใช้การตรวจสอบสิทธิ์หมายเลขโทรศัพท์ในแพลตฟอร์ม Apple แอปของคุณต้องรับการแจ้งเตือน AAP จาก Firebase ได้ เมื่อคุณลงชื่อเข้าใช้ผู้ใช้ด้วยหมายเลขโทรศัพท์เป็นครั้งแรกบนอุปกรณ์ การตรวจสอบสิทธิ์ Firebase จะส่งข้อความ Push แบบไม่มีเสียงไปยังอุปกรณ์เพื่อยืนยันว่าคำขอลงชื่อเข้าใช้หมายเลขโทรศัพท์มาจากแอปของคุณ (ด้วยเหตุนี้ จึงไม่สามารถลงชื่อเข้าใช้ด้วยหมายเลขโทรศัพท์บนเครื่องจำลองได้)

หากต้องการเปิดใช้การแจ้งเตือน APN เพื่อใช้กับการตรวจสอบสิทธิ์ Firebase ให้ทำดังนี้

ใน Xcode ให้ เปิดใช้ข้อความ Push สำหรับโปรเจ็กต์
อัปโหลดใบรับรอง APNs ไปยัง Firebase หากคุณยังไม่มีใบรับรอง APNs โปรดสร้างในศูนย์สมาชิกนักพัฒนาซอฟต์แวร์ของ Apple
1. ภายในโปรเจ็กต์ในคอนโซล Firebase ให้เลือก ไอคอนรูปเฟือง เลือก การตั้งค่าโปรเจ็กต์ แล้วเลือกแท็บ Cloud Messaging
2. เลือกปุ่มอัปโหลดใบรับรองสำหรับใบรับรองการพัฒนา ใบรับรองเวอร์ชันที่ใช้งานจริง หรือทั้ง 2 อย่าง โดยต้องระบุอย่างน้อย 1 รายการ
3. สำหรับใบรับรองแต่ละรายการ ให้เลือกไฟล์ .p12 และใส่รหัสผ่าน (หากมี) ตรวจสอบว่ารหัสชุดสำหรับใบรับรองนี้ตรงกับรหัสชุดของแอป เลือกบันทึก

ส่งรหัสยืนยันไปยังโทรศัพท์ของผู้ใช้

หากต้องการเริ่มลงชื่อเข้าใช้หมายเลขโทรศัพท์ ให้แสดงอินเทอร์เฟซที่แจ้งให้ผู้ใช้ระบุหมายเลขโทรศัพท์ของตน แล้วโทรไปที่ PhoneAuthProvider::VerifyPhoneNumber เพื่อขอให้ Firebase ส่งรหัสการตรวจสอบสิทธิ์ไปยังโทรศัพท์ของผู้ใช้ทาง SMS โดยทำดังนี้

ดูหมายเลขโทรศัพท์ของผู้ใช้

ข้อกำหนดทางกฎหมายอาจแตกต่างกันออกไป แต่แนวทางปฏิบัติแนะนำและเพื่อกำหนดความคาดหวังของผู้ใช้ คุณควรแจ้งให้ผู้ใช้ทราบว่าหากผู้ใช้ลงชื่อเข้าใช้ทางโทรศัพท์ ผู้ใช้อาจได้รับข้อความ SMS สำหรับการยืนยัน และอาจต้องเสียค่าใช้จ่ายตามอัตรามาตรฐาน
โทรหา PhoneAuthProvider::VerifyPhoneNumber เพื่อโอนสายไปยังหมายเลขโทรศัพท์ของผู้ใช้
```
class PhoneListener : public PhoneAuthProvider::Listener {
 public:
  ~PhoneListener() override {}

  void OnVerificationCompleted(PhoneAuthCredential credential) override {
    // Auto-sms-retrieval or instant validation has succeeded (Android only).
    // No need for the user to input the verification code manually.
    // `credential` can be used instead of calling GetCredential().
  }

  void OnVerificationFailed(const std::string& error) override {
    // Verification code not sent.
  }

  void OnCodeSent(const std::string& verification_id,
                  const PhoneAuthProvider::ForceResendingToken&
                      force_resending_token) override {
    // Verification code successfully sent via SMS.
    // Show the Screen to enter the Code.
    // Developer may want to save that verification_id along with other app states in case
    // the app is terminated before the user gets the SMS verification code.
  }
};

PhoneListener phone_listener;
PhoneAuhtOptions options;
options.timeout_milliseconds = kAutoVerifyTimeOut;
options.phone_number = phone_number;
PhoneAuthProvider& phone_provider = PhoneAuthProvider::GetInstance(auth);
phone_provider->VerifyPhoneNumber(options, &phone_listener);
```
เมื่อโทรหา PhoneAuthProvider::VerifyPhoneNumber, Firebase
- (บน iOS) จะส่งข้อความ Push แบบไม่มีเสียงไปยังแอปของคุณ
- ส่งข้อความ SMS ที่มีรหัสการตรวจสอบสิทธิ์ไปยังหมายเลขโทรศัพท์ที่ระบุ และส่งรหัสการยืนยันไปยังฟังก์ชันการเสร็จสมบูรณ์ คุณจะต้องมีทั้งรหัสยืนยันและรหัสยืนยันเพื่อลงชื่อเข้าใช้ให้ผู้ใช้
  หมายเหตุ: ระบบอาจจำกัดปริมาณข้อความ SMS ที่ส่งต่อวันไม่เกินโควต้ารายวัน ทั้งนี้ขึ้นอยู่กับแพ็กเกจการเรียกเก็บเงินที่ใช้ ดูขีดจำกัดการตรวจสอบสิทธิ์ของ Firebase
บันทึกรหัสการยืนยันและคืนค่ารหัสเมื่อแอปของคุณโหลด การทำเช่นนี้จะช่วยให้คุณมีรหัสการยืนยันที่ถูกต้องหากแอปถูกสิ้นสุดการดำเนินงานก่อนที่ผู้ใช้จะลงชื่อเข้าใช้เสร็จสมบูรณ์ (เช่น ขณะเปลี่ยนไปใช้แอป SMS)

คุณจะยืนยันรหัสการยืนยันได้ตามต้องการ หากคุณเขียนโดยใช้เฟรมเวิร์ก C++ ข้ามแพลตฟอร์ม ระบบก็ควรมีการแจ้งเตือนสำหรับการสิ้นสุดและการกู้คืนแอป คุณจะบันทึกและคืนค่ารหัสการยืนยันตามลำดับได้ในเหตุการณ์เหล่านี้

หากการเรียกไปยัง VerifyPhoneNumber ส่งผลให้มีการเรียก OnCodeSent บน Listener ของคุณ คุณสามารถแจ้งให้ผู้ใช้พิมพ์รหัสยืนยันเมื่อได้รับรหัสในข้อความ SMS ได้

ในทางกลับกัน หากการเรียกไปยัง VerifyPhoneNumber ทำให้เกิด OnVerificationCompleted แสดงว่าการยืนยันอัตโนมัติสำเร็จและตอนนี้คุณจะมี PhoneAuthCredential ที่ใช้ได้ตามที่อธิบายไว้ด้านล่าง

Firebase บังคับให้จำกัดจำนวนข้อความ SMS ที่ส่งไปยังหมายเลขโทรศัพท์เดียวได้ภายในระยะเวลาที่กำหนดเพื่อป้องกันการละเมิด หากคุณใช้เกินขีดจำกัดนี้ คำขอยืนยันหมายเลขโทรศัพท์อาจถูกควบคุม หากคุณพบปัญหานี้ระหว่างการพัฒนา ให้ใช้หมายเลขโทรศัพท์อื่นสำหรับการทดสอบหรือลองส่งคำขออีกครั้งในภายหลัง

หลังจากที่ผู้ใช้ให้รหัสยืนยันจากข้อความ SMS แก่แอปของคุณแล้ว ให้ลงชื่อเข้าใช้ผู้ใช้ด้วยการสร้างออบเจ็กต์ PhoneAuthCredential จากรหัสยืนยันและรหัสการยืนยัน แล้วส่งออบเจ็กต์นั้นไปยัง Auth::SignInWithCredential

รับรหัสยืนยันจากผู้ใช้
สร้างออบเจ็กต์ Credential จากรหัสยืนยันและรหัสการยืนยัน
```
PhoneAuthCredential credential = phone_auth_provider->GetCredential(
    verification_id_.c_str(), verification_code.c_str());
    
```

ลงชื่อเข้าใช้ผู้ใช้ด้วยออบเจ็กต์ Credential:

Future<User> future = auth_->SignInWithCredential(credential);
future.OnCompletion(
    [](const Future<User*>& result, void*) {
      if (result.error() == kAuthErrorNone) {
        // Successful.
        // User is signed in.
        User user = *result.result();

        // This should display the phone number.
        printf("Phone number: %s", user.phone_number().c_str());

        // The phone number provider UID is the phone number itself.
        printf("Phone provider uid: %s", user.uid().c_str());

        // The phone number providerID is 'phone'
        printf("Phone provider ID: %s", user.provider_id().c_str());
      } else {
        // Error.
        printf("Sign in error: %s", result.error_message().c_str());
      }
    },
    nullptr);

ขั้นตอนถัดไป

หลังจากผู้ใช้ลงชื่อเข้าใช้เป็นครั้งแรก ระบบจะสร้างบัญชีผู้ใช้ใหม่และลิงก์กับข้อมูลเข้าสู่ระบบ ซึ่งก็คือชื่อผู้ใช้และรหัสผ่าน หมายเลขโทรศัพท์ หรือข้อมูลของผู้ให้บริการการตรวจสอบสิทธิ์ ซึ่งผู้ใช้ที่ลงชื่อเข้าใช้ด้วย ระบบจะจัดเก็บบัญชีใหม่นี้เป็นส่วนหนึ่งของโปรเจ็กต์ Firebase และสามารถใช้เพื่อระบุผู้ใช้ในทุกแอปในโปรเจ็กต์ได้ ไม่ว่าผู้ใช้จะลงชื่อเข้าใช้ด้วยวิธีใด

ในแอป คุณสามารถดูข้อมูลโปรไฟล์พื้นฐานของผู้ใช้จากออบเจ็กต์ firebase::auth::User ได้โดยทำดังนี้

firebase::auth::User user = auth->current_user();
if (user.is_valid()) {
  std::string name = user.display_name();
  std::string email = user.email();
  std::string photo_url = user.photo_url();
  // The user's ID, unique to the Firebase project.
  // Do NOT use this value to authenticate with your backend server,
  // if you have one. Use firebase::auth::User::Token() instead.
  std::string uid = user.uid();
}

ในกฎความปลอดภัยของ Firebase Realtime Database และ Cloud Storage คุณจะรับรหัสผู้ใช้ที่ไม่ซ้ำของผู้ใช้ที่ลงชื่อเข้าใช้จากตัวแปร auth ได้ และใช้รหัสดังกล่าวเพื่อควบคุมข้อมูลที่ผู้ใช้เข้าถึงได้

คุณอนุญาตให้ผู้ใช้ลงชื่อเข้าใช้แอปโดยใช้ผู้ให้บริการการตรวจสอบสิทธิ์หลายรายได้โดยลิงก์ข้อมูลเข้าสู่ระบบของผู้ให้บริการการตรวจสอบสิทธิ์กับบัญชีผู้ใช้ที่มีอยู่

หากต้องการนำผู้ใช้ออกจากระบบ โปรดโทรหา SignOut():

auth->SignOut();