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

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

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

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

  1. หากคุณยังไม่ได้ดำเนินการ เพิ่ม Firebase ลงในโปรเจ็กต์ Android
  2. ในไฟล์ Gradle ของโมดูล (ระดับแอป) (ปกติ <project>/<app-module>/build.gradle.kts หรือ <project>/<app-module>/build.gradle) เพิ่มทรัพยากร Dependency สำหรับไลบรารีการตรวจสอบสิทธิ์ Firebase สำหรับ Android เราขอแนะนำให้ใช้ BoM ของ Firebase Android เพื่อควบคุมการกำหนดเวอร์ชันไลบรารี 
    dependencies {
    // Import the BoM for the Firebase platform
    implementation(platform("com.google.firebase:firebase-bom:33.1.2"))

    // Add the dependency for the Firebase Authentication library
    // When using the BoM, you don't specify versions in Firebase library dependencies
    implementation("com.google.firebase:firebase-auth")
}

    การใช้ Firebase Android BoM แอปจะใช้ไลบรารี Firebase Android เวอร์ชันที่เข้ากันได้เสมอ

    (ทางเลือก) เพิ่มทรัพยากร Dependency ของไลบรารี Firebase โดยไม่ต้องใช้ BoM

    หากเลือกไม่ใช้ Firebase BoM คุณต้องระบุเวอร์ชันไลบรารี Firebase แต่ละเวอร์ชัน ในบรรทัดทรัพยากร Dependency

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

    dependencies {
    // Add the dependency for the Firebase Authentication library
    // When NOT using the BoM, you must specify versions in Firebase library dependencies
    implementation("com.google.firebase:firebase-auth:23.0.0")
}
    หากกำลังมองหาโมดูลไลบรารีสำหรับ Kotlin โดยเฉพาะ จะเริ่มต้นใน ตุลาคม 2023 (Firebase BoM 32.5.0) ทั้งนักพัฒนาซอฟต์แวร์ Kotlin และ Java สามารถ ขึ้นอยู่กับโมดูลไลบรารีหลัก (ดูรายละเอียดได้ที่ คําถามที่พบบ่อยเกี่ยวกับโครงการริเริ่มนี้)
  3. หากยังไม่ได้เชื่อมต่อแอปกับโปรเจ็กต์ Firebase ให้ดำเนินการจาก คอนโซล Firebase
  4. หากคุณยังไม่ได้ตั้งค่าแฮช SHA-1 ของแอปในคอนโซล Firebase แบบนั้น โปรดดู การตรวจสอบสิทธิ์ไคลเอ็นต์เพื่อขอข้อมูลเกี่ยวกับการค้นหา SHA-1 ของแอป แฮช

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

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

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

เปิดใช้การลงชื่อเข้าใช้หมายเลขโทรศัพท์สำหรับโปรเจ็กต์ Firebase

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

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

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

เปิดใช้การตรวจสอบแอป

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

  • Play Integrity API: หากผู้ใช้มีอุปกรณ์ที่ติดตั้งบริการ Google Play ไว้ และการตรวจสอบสิทธิ์ Firebase สามารถยืนยันว่าอุปกรณ์ถูกต้องด้วย Play Integrity API การลงชื่อเข้าใช้หมายเลขโทรศัพท์จะสามารถดำเนินการต่อ เปิดใช้ Play Integrity API ในโปรเจ็กต์ที่ Google เป็นเจ้าของโดย การตรวจสอบสิทธิ์ Firebase ไม่ได้อยู่ในโปรเจ็กต์ของคุณ ข้อมูลนี้ไม่มีผลต่อ Play Integrity API โควต้าสำหรับโครงการของคุณ การสนับสนุนด้านความสมบูรณ์ของ Play พร้อมให้บริการด้วย SDK การตรวจสอบสิทธิ์เวอร์ชัน 21.2.0 ขึ้นไป (Firebase BoM v31.4.0 ขึ้นไป)

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

  • การยืนยันด้วย reCAPTCHA: ในกรณีที่ใช้ Play Integrity ไม่ได้ เช่น เมื่อผู้ใช้มีอุปกรณ์ไม่ได้ติดตั้งบริการ Google Play ไว้ การตรวจสอบสิทธิ์ Firebase ใช้การยืนยัน reCAPTCHA เพื่อทำตามขั้นตอนการลงชื่อเข้าใช้ทางโทรศัพท์ให้เสร็จสมบูรณ์ ภาพทดสอบ reCAPTCHA มักจะเสร็จสมบูรณ์โดยที่ผู้ใช้ไม่ต้องแก้ไขอะไรเลย โปรดทราบว่าขั้นตอนนี้กำหนดให้ SHA-1 เชื่อมโยงกับแอปพลิเคชันของคุณ ขั้นตอนนี้กําหนดให้คีย์ API ของคุณ ไม่จำกัดหรืออยู่ในรายการที่อนุญาตสำหรับ PROJECT_ID.firebaseapp.com

    ตัวอย่างสถานการณ์ที่ทริกเกอร์ reCAPTCHA มีดังนี้

    • หากอุปกรณ์ของผู้ใช้ปลายทางไม่ได้ติดตั้งบริการ Google Play ไว้
    • หากไม่ได้เผยแพร่แอปผ่าน Google Play Store (ใน Authentication SDK v21.2.0+)
    • หากโทเค็น SafetyNet ที่ได้รับไม่ถูกต้อง (ใน SDK การตรวจสอบสิทธิ์เวอร์ชัน < v21.2.0)

    เมื่อใช้ SafetyNet หรือ Play Integrity สำหรับการยืนยันแอป ช่อง %APP_NAME% ในเทมเพลต SMS จะมีชื่อแอปที่ระบุจาก Google Play Store ในกรณีที่มีการทริกเกอร์ reCAPTCHA ระบบจะป้อนข้อมูล %APP_NAME% เป็น PROJECT_ID.firebaseapp.com

คุณจะบังคับใช้ขั้นตอนการยืนยัน reCAPTCHA ได้ด้วย forceRecaptchaFlowForTesting คุณสามารถปิดใช้การยืนยันแอป (เมื่อใช้หมายเลขโทรศัพท์สมมติ) ได้โดยใช้ setAppVerificationDisabledForTesting

การแก้ปัญหา

  • "ไม่มีสถานะเริ่มต้น" ข้อผิดพลาดเมื่อใช้ reCAPTCHA สําหรับการยืนยันแอป

    ซึ่งอาจเกิดขึ้นเมื่อขั้นตอน reCAPTCHA เสร็จสมบูรณ์ แต่จะไม่เปลี่ยนเส้นทางผู้ใช้กลับไปยังแอปพลิเคชันของระบบ ในกรณีนี้ ระบบจะเปลี่ยนเส้นทางผู้ใช้ไปยัง URL สำรอง PROJECT_ID.firebaseapp.com/__/auth/handler ในเบราว์เซอร์ Firefox การเปิดลิงก์แอปที่มาพร้อมเครื่องจะถูกปิดใช้งานโดยค่าเริ่มต้น หากคุณเห็นข้อผิดพลาดข้างต้นใน Firefox ให้ทำตามขั้นตอนในตั้งค่า Firefox สำหรับ Android ให้เปิดลิงก์ในแอปที่มาพร้อมเครื่องเพื่อเปิดใช้การเปิดลิงก์ของแอป

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

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

จากนั้นส่งหมายเลขโทรศัพท์ของลูกค้าไปยัง PhoneAuthProvider.verifyPhoneNumber เมธอดในการขอให้ Firebase ยืนยันหมายเลขโทรศัพท์ของผู้ใช้ เช่น

Kotlin+KTX

val options = PhoneAuthOptions.newBuilder(auth)
    .setPhoneNumber(phoneNumber) // Phone number to verify
    .setTimeout(60L, TimeUnit.SECONDS) // Timeout and unit
    .setActivity(this) // Activity (for callback binding)
    .setCallbacks(callbacks) // OnVerificationStateChangedCallbacks
    .build()
PhoneAuthProvider.verifyPhoneNumber(options)
PhoneAuthActivity.kt

Java

PhoneAuthOptions options = 
  PhoneAuthOptions.newBuilder(mAuth) 
      .setPhoneNumber(phoneNumber)       // Phone number to verify
      .setTimeout(60L, TimeUnit.SECONDS) // Timeout and unit
      .setActivity(this)                 // (optional) Activity for callback binding
      // If no activity is passed, reCAPTCHA verification can not be used.
      .setCallbacks(mCallbacks)          // OnVerificationStateChangedCallbacks
      .build();
  PhoneAuthProvider.verifyPhoneNumber(options);     
PhoneAuthActivity.java

เมธอด verifyPhoneNumber เป็นแอปใหม่ นั่นคือ หากคุณเรียกว่า หลายครั้ง เช่น ในเมธอด onStart ของกิจกรรม ค่า เมธอด verifyPhoneNumber จะไม่ส่ง SMS ครั้งที่ 2 เว้นแต่ คำขอเดิมหมดเวลาแล้ว

คุณสามารถใช้ลักษณะการทำงานนี้เพื่อดำเนินการลงชื่อเข้าใช้หมายเลขโทรศัพท์ต่อได้ หาก ปิดแอปก่อนที่ผู้ใช้จะลงชื่อเข้าใช้ได้ (เช่น ขณะที่ผู้ใช้กำลังใช้ แอป SMS ของพวกเขา) หลังจากโทรหา verifyPhoneNumber ให้ติดธงว่า แสดงว่าอยู่ระหว่างการยืนยัน จากนั้นบันทึกการทำเครื่องหมายใน "กิจกรรม" onSaveInstanceState และคืนค่าสถานะใน onRestoreInstanceState. สุดท้าย ใน "กิจกรรม" onStart ให้ตรวจสอบว่าการยืนยันอยู่ระหว่างดำเนินการหรือไม่ และ หากเป็นเช่นนั้น โปรดโทรหา verifyPhoneNumber อีกครั้ง อย่าลืมล้างธงเมื่อ การยืนยันเสร็จสมบูรณ์หรือล้มเหลว (โปรดดู การยืนยันทางโทรศัพท์)

เพื่อให้จัดการกับการหมุนหน้าจอและอินสแตนซ์อื่นๆ ของการรีสตาร์ทกิจกรรมได้อย่างง่ายดาย ส่งกิจกรรมของคุณไปยังเมธอด verifyPhoneNumber Callback จะถอดออกโดยอัตโนมัติเมื่อกิจกรรมหยุด เพื่อให้คุณสามารถเขียน UI ได้อย่างอิสระ ในเมธอด Callback

ข้อความ SMS ที่ส่งโดย Firebase ยังสามารถแปลได้โดยระบุ การตรวจสอบสิทธิ์ภาษาผ่านเมธอด setLanguageCode ในการตรวจสอบสิทธิ์ของคุณ อินสแตนซ์

Kotlin+KTX

auth.setLanguageCode("fr")
// To apply the default app language instead of explicitly setting it.
// auth.useAppLanguage()
MainActivity.kt

Java

auth.setLanguageCode("fr");
// To apply the default app language instead of explicitly setting it.
// auth.useAppLanguage();
MainActivity.java

เมื่อโทรหา PhoneAuthProvider.verifyPhoneNumber คุณต้อง มีอินสแตนซ์ OnVerificationStateChangedCallbacks ซึ่ง มีการใช้งานฟังก์ชัน Callback ที่จัดการผลลัพธ์ของ คำขอ เช่น

Kotlin+KTX

callbacks = object : PhoneAuthProvider.OnVerificationStateChangedCallbacks() {

    override fun onVerificationCompleted(credential: PhoneAuthCredential) {
        // This callback will be invoked in two situations:
        // 1 - Instant verification. In some cases the phone number can be instantly
        //     verified without needing to send or enter a verification code.
        // 2 - Auto-retrieval. On some devices Google Play services can automatically
        //     detect the incoming verification SMS and perform verification without
        //     user action.
        Log.d(TAG, "onVerificationCompleted:$credential")
        signInWithPhoneAuthCredential(credential)
    }

    override fun onVerificationFailed(e: FirebaseException) {
        // This callback is invoked in an invalid request for verification is made,
        // for instance if the the phone number format is not valid.
        Log.w(TAG, "onVerificationFailed", e)

        if (e is FirebaseAuthInvalidCredentialsException) {
            // Invalid request
        } else if (e is FirebaseTooManyRequestsException) {
            // The SMS quota for the project has been exceeded
        } else if (e is FirebaseAuthMissingActivityForRecaptchaException) {
            // reCAPTCHA verification attempted with null Activity
        }

        // Show a message and update the UI
    }

    override fun onCodeSent(
        verificationId: String,
        token: PhoneAuthProvider.ForceResendingToken,
    ) {
        // The SMS verification code has been sent to the provided phone number, we
        // now need to ask the user to enter the code and then construct a credential
        // by combining the code with a verification ID.
        Log.d(TAG, "onCodeSent:$verificationId")

        // Save verification ID and resending token so we can use them later
        storedVerificationId = verificationId
        resendToken = token
    }
}
PhoneAuthActivity.kt

Java

mCallbacks = new PhoneAuthProvider.OnVerificationStateChangedCallbacks() {

    @Override
    public void onVerificationCompleted(@NonNull PhoneAuthCredential credential) {
        // This callback will be invoked in two situations:
        // 1 - Instant verification. In some cases the phone number can be instantly
        //     verified without needing to send or enter a verification code.
        // 2 - Auto-retrieval. On some devices Google Play services can automatically
        //     detect the incoming verification SMS and perform verification without
        //     user action.
        Log.d(TAG, "onVerificationCompleted:" + credential);

        signInWithPhoneAuthCredential(credential);
    }

    @Override
    public void onVerificationFailed(@NonNull FirebaseException e) {
        // This callback is invoked in an invalid request for verification is made,
        // for instance if the the phone number format is not valid.
        Log.w(TAG, "onVerificationFailed", e);

        if (e instanceof FirebaseAuthInvalidCredentialsException) {
            // Invalid request
        } else if (e instanceof FirebaseTooManyRequestsException) {
            // The SMS quota for the project has been exceeded
        } else if (e instanceof FirebaseAuthMissingActivityForRecaptchaException) {
            // reCAPTCHA verification attempted with null Activity
        }

        // Show a message and update the UI
    }

    @Override
    public void onCodeSent(@NonNull String verificationId,
                           @NonNull PhoneAuthProvider.ForceResendingToken token) {
        // The SMS verification code has been sent to the provided phone number, we
        // now need to ask the user to enter the code and then construct a credential
        // by combining the code with a verification ID.
        Log.d(TAG, "onCodeSent:" + verificationId);

        // Save verification ID and resending token so we can use them later
        mVerificationId = verificationId;
        mResendToken = token;
    }
};
PhoneAuthActivity.java

การติดต่อกลับสำหรับการยืนยัน

ในแอปส่วนใหญ่ คุณจะใช้ onVerificationCompleted onVerificationFailed และ onCodeSent Callback คุณ อาจใช้ onCodeAutoRetrievalTimeOut ได้เช่นกัน ทั้งนี้ขึ้นอยู่กับ ข้อกำหนดของแอป

onการยืนยันเสร็จสมบูรณ์(PhoneAuthCredential)

วิธีการนี้จะเรียกใช้ใน 2 กรณีดังนี้

  • การยืนยันทันที: ในบางกรณี หมายเลขโทรศัพท์อาจทำได้ในทันที ได้รับการยืนยันโดยไม่ต้องส่งหรือป้อนรหัสยืนยัน
  • เรียกอัตโนมัติ: ในอุปกรณ์บางรุ่น บริการ Google Play สามารถ ตรวจสอบ SMS ยืนยันขาเข้าโดยอัตโนมัติและดำเนินการ การยืนยันโดยที่ผู้ใช้ไม่ต้องดำเนินการใดๆ (ความสามารถนี้อาจไม่พร้อมใช้งาน กับผู้ให้บริการบางราย) การทำงานนี้ใช้ SMS Retriever API ประกอบด้วยแฮช 11 อักขระที่ท้ายข้อความ SMS
ในทั้ง 2 กรณี หมายเลขโทรศัพท์ของผู้ใช้ได้รับการยืนยันเรียบร้อยแล้ว และ คุณสามารถใช้ออบเจ็กต์ PhoneAuthCredential ที่ส่งไปยัง Callback เพื่อลงชื่อเข้าใช้ผู้ใช้

onการยืนยันล้มเหลว(FirebaseException)

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

onCodeSent(String VerificationId, PhoneAuthProvider.ForceปลอดภัยingToken)

ไม่บังคับ ระบบจะเรียกวิธีการนี้หลังจากส่งรหัสยืนยันแล้ว ทาง SMS ไปยังหมายเลขโทรศัพท์ที่ระบุไว้

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

onCodeAutoRetrievalTimeOut(สตริงการยืนยันรหัส)

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

แอปบางแอปบล็อกข้อมูลจากผู้ใช้จนกว่าระยะเวลาการยืนยันอัตโนมัติจะหมดลง จากนั้นจะแสดง UI ที่แจ้งให้ผู้ใช้พิมพ์รหัสยืนยันเท่านั้น จากข้อความ SMS (ไม่แนะนำ)

สร้างออบเจ็กต์ PhoneAuthCredential

หลังจากที่ผู้ใช้ป้อนรหัสยืนยันที่ Firebase ส่งไปให้ผู้ใช้ สร้างออบเจ็กต์ PhoneAuthCredential โดยใช้การยืนยันในโทรศัพท์ และรหัสยืนยันที่ส่งไปยัง onCodeSent หรือ onCodeAutoRetrievalTimeOut Callback (เมื่อ โทรหา onVerificationCompleted แล้ว คุณจะได้รับ PhoneAuthCredential โดยตรงเพื่อให้ข้ามขั้นตอนนี้ได้)

หากต้องการสร้างออบเจ็กต์ PhoneAuthCredential โปรดเรียก PhoneAuthProvider.getCredential:

Kotlin+KTX

val credential = PhoneAuthProvider.getCredential(verificationId!!, code)
PhoneAuthActivity.kt

Java

PhoneAuthCredential credential = PhoneAuthProvider.getCredential(verificationId, code);
PhoneAuthActivity.java

ลงชื่อเข้าใช้ผู้ใช้

หลังจากได้รับออบเจ็กต์ PhoneAuthCredential ไม่ว่าจะเป็นใน onVerificationCompleted ขอให้โทรกลับหรือด้วยการโทร PhoneAuthProvider.getCredential ดำเนินการขั้นตอนการลงชื่อเข้าใช้ให้เสร็จสิ้นโดย กำลังส่งออบเจ็กต์ PhoneAuthCredential ไปยัง FirebaseAuth.signInWithCredential:

Kotlin+KTX

private fun signInWithPhoneAuthCredential(credential: PhoneAuthCredential) {
    auth.signInWithCredential(credential)
        .addOnCompleteListener(this) { task ->
            if (task.isSuccessful) {
                // Sign in success, update UI with the signed-in user's information
                Log.d(TAG, "signInWithCredential:success")

                val user = task.result?.user
            } else {
                // Sign in failed, display a message and update the UI
                Log.w(TAG, "signInWithCredential:failure", task.exception)
                if (task.exception is FirebaseAuthInvalidCredentialsException) {
                    // The verification code entered was invalid
                }
                // Update UI
            }
        }
}
PhoneAuthActivity.kt

Java

private void signInWithPhoneAuthCredential(PhoneAuthCredential credential) {
    mAuth.signInWithCredential(credential)
            .addOnCompleteListener(this, new OnCompleteListener<AuthResult>() {
                @Override
                public void onComplete(@NonNull Task<AuthResult> task) {
                    if (task.isSuccessful()) {
                        // Sign in success, update UI with the signed-in user's information
                        Log.d(TAG, "signInWithCredential:success");

                        FirebaseUser user = task.getResult().getUser();
                        // Update UI
                    } else {
                        // Sign in failed, display a message and update the UI
                        Log.w(TAG, "signInWithCredential:failure", task.getException());
                        if (task.getException() instanceof FirebaseAuthInvalidCredentialsException) {
                            // The verification code entered was invalid
                        }
                    }
                }
            });
}
PhoneAuthActivity.java

ทดสอบด้วยหมายเลขโทรศัพท์สมมติ

คุณตั้งค่าหมายเลขโทรศัพท์สมมติสำหรับการพัฒนาได้ผ่านคอนโซล Firebase การทดสอบด้วยโทรศัพท์สมมติ ตัวเลขมีประโยชน์ดังนี้

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

หมายเลขโทรศัพท์สมมติต้องเป็นไปตามข้อกำหนดเหล่านี้

  1. ตรวจสอบว่าคุณใช้หมายเลขโทรศัพท์ที่สมมติขึ้นจริงๆ และหมายเลขไม่มีอยู่จริง การตรวจสอบสิทธิ์ Firebase ไม่อนุญาตให้คุณตั้งค่าหมายเลขโทรศัพท์ที่มีอยู่ซึ่งผู้ใช้จริงใช้เป็นหมายเลขทดสอบ ทางเลือกหนึ่งคือการใช้หมายเลข 555 นำหน้าเป็นหมายเลขโทรศัพท์ทดสอบในสหรัฐอเมริกา ตัวอย่างเช่น +6650-555-3434
  2. หมายเลขโทรศัพท์ต้องมีรูปแบบที่ถูกต้องสำหรับความยาวและหมายเลขอื่นๆ ข้อจำกัด ผู้ใช้จะยังผ่านขั้นตอนการตรวจสอบเดียวกับหมายเลขโทรศัพท์ของผู้ใช้จริง
  3. คุณเพิ่มหมายเลขโทรศัพท์สำหรับการพัฒนาได้สูงสุด 10 หมายเลข
  4. ใช้หมายเลขโทรศัพท์/รหัสทดสอบที่คาดเดาและเปลี่ยนแปลงได้ยาก เหล่านั้นบ่อยๆ

สร้างหมายเลขโทรศัพท์และรหัสยืนยันสมมติ

  1. ในคอนโซล Firebase ให้เปิด การตรวจสอบสิทธิ์
  2. ในแท็บวิธีการลงชื่อเข้าใช้ ให้เปิดใช้ผู้ให้บริการโทรศัพท์หากยังไม่ได้เปิดใช้
  3. เปิดเมนูหมายเลขโทรศัพท์สำหรับการทดสอบ
  4. ระบุหมายเลขโทรศัพท์ที่ต้องการทดสอบ เช่น +1 650-555-3434
  5. ระบุรหัสยืนยัน 6 หลักสำหรับหมายเลขนั้นๆ เช่น 654321
  6. เพิ่มหมายเลข หากมีความจำเป็น คุณสามารถลบหมายเลขโทรศัพท์นั้นแล้ว โดยวางเมาส์เหนือแถวที่เกี่ยวข้องแล้วคลิกไอคอนถังขยะ

การทดสอบด้วยตนเอง

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

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

เมื่อลงชื่อเข้าใช้เสร็จแล้ว ระบบจะสร้างผู้ใช้ Firebase ด้วยหมายเลขโทรศัพท์ดังกล่าว ผู้ใช้มีพฤติกรรมและพร็อพเพอร์ตี้เหมือนกับผู้ใช้หมายเลขโทรศัพท์จริง และสามารถเข้าถึง Realtime Database/Cloud Firestore และบริการอื่นๆ ในลักษณะเดียวกัน โทเค็นรหัสที่สร้างในระหว่าง กระบวนการนี้จะมีลายเซ็นเหมือนกับผู้ใช้หมายเลขโทรศัพท์จริง

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

หากต้องการทริกเกอร์ขั้นตอน reCAPTCHA สำหรับการทดสอบด้วยตนเอง ให้ใช้ forceRecaptchaFlowForTesting() วิธี 

// Force reCAPTCHA flow
FirebaseAuth.getInstance().getFirebaseAuthSettings().forceRecaptchaFlowForTesting();

การทดสอบการผสานรวม

นอกจากการทดสอบด้วยตนเองแล้ว การตรวจสอบสิทธิ์ Firebase ยังมี API ที่จะช่วยเขียนการทดสอบการผสานรวม สำหรับการทดสอบการตรวจสอบสิทธิ์ทางโทรศัพท์ API เหล่านี้จะปิดใช้การตรวจสอบแอปโดยการปิดใช้ reCAPTCHA ข้อกำหนดบนเว็บและข้อความ Push แบบปิดเสียงใน iOS จึงทําให้สามารถทดสอบการทำงานอัตโนมัติได้ใน ดำเนินการตามขั้นตอนเหล่านี้ได้ และปรับใช้ง่ายขึ้น นอกจากนี้ยังช่วยให้สามารถทดสอบ ขั้นตอนการยืนยันบน Android

ใน Android ให้โทรหา setAppVerificationDisabledForTesting() ก่อน signInWithPhoneNumber สาย การดำเนินการนี้จะปิดใช้การตรวจสอบแอปโดยอัตโนมัติ ทำให้คุณสามารถส่งหมายเลขโทรศัพท์ได้โดยไม่ต้องแก้ปัญหาด้วยตนเอง แม้ว่า ระบบปิดใช้ Play Integrity และ reCAPTCHA หากใช้หมายเลขโทรศัพท์จริงไม่สำเร็จ ลงชื่อเข้าใช้ให้เสร็จสิ้น ใช้ได้เฉพาะหมายเลขโทรศัพท์สมมติเท่านั้นกับ API นี้ 

// Turn off phone auth app verification.
FirebaseAuth.getInstance().getFirebaseAuthSettings()
   .setAppVerificationDisabledForTesting();

การเรียกใช้ verifyPhoneNumber ด้วยหมายเลขสมมติจะทริกเกอร์ onCodeSent ซึ่งคุณจะต้องทำการยืนยันที่เกี่ยวข้อง โค้ด การดำเนินการนี้ช่วยให้ทดสอบใน Android Emulator ได้

Java

String phoneNum = "+16505554567";
String testVerificationCode = "123456";

// Whenever verification is triggered with the whitelisted number,
// provided it is not set for auto-retrieval, onCodeSent will be triggered.
FirebaseAuth auth = FirebaseAuth.getInstance();
PhoneAuthOptions options = PhoneAuthOptions.newBuilder(auth)
        .setPhoneNumber(phoneNum)
        .setTimeout(60L, TimeUnit.SECONDS)
        .setActivity(this)
        .setCallbacks(new PhoneAuthProvider.OnVerificationStateChangedCallbacks() {
            @Override
            public void onCodeSent(@NonNull String verificationId,
                                   @NonNull PhoneAuthProvider.ForceResendingToken forceResendingToken) {
                // Save the verification id somewhere
                // ...

                // The corresponding whitelisted code above should be used to complete sign-in.
                MainActivity.this.enableUserManuallyInputCode();
            }

            @Override
            public void onVerificationCompleted(@NonNull PhoneAuthCredential phoneAuthCredential) {
                // Sign in with the credential
                // ...
            }

            @Override
            public void onVerificationFailed(@NonNull FirebaseException e) {
                // ...
            }
        })
        .build();
PhoneAuthProvider.verifyPhoneNumber(options);
MainActivity.java

Kotlin+KTX

val phoneNum = "+16505554567"
val testVerificationCode = "123456"

// Whenever verification is triggered with the whitelisted number,
// provided it is not set for auto-retrieval, onCodeSent will be triggered.
val options = PhoneAuthOptions.newBuilder(Firebase.auth)
    .setPhoneNumber(phoneNum)
    .setTimeout(30L, TimeUnit.SECONDS)
    .setActivity(this)
    .setCallbacks(object : PhoneAuthProvider.OnVerificationStateChangedCallbacks() {

        override fun onCodeSent(
            verificationId: String,
            forceResendingToken: PhoneAuthProvider.ForceResendingToken,
        ) {
            // Save the verification id somewhere
            // ...

            // The corresponding whitelisted code above should be used to complete sign-in.
            this@MainActivity.enableUserManuallyInputCode()
        }

        override fun onVerificationCompleted(phoneAuthCredential: PhoneAuthCredential) {
            // Sign in with the credential
            // ...
        }

        override fun onVerificationFailed(e: FirebaseException) {
            // ...
        }
    })
    .build()
PhoneAuthProvider.verifyPhoneNumber(options)
MainActivity.kt

นอกจากนี้ คุณสามารถทดสอบขั้นตอนการเรียกข้อมูลอัตโนมัติใน Android ได้โดยการตั้งค่าหมายเลขสมมติและ รหัสยืนยันที่เกี่ยวข้องสำหรับเรียกอัตโนมัติด้วยการโทร setAutoRetrievedSmsCodeForPhoneNumber.

เมื่อverifyPhoneNumberคือ เรียกใช้ onVerificationCompleted ด้วย PhoneAuthCredential โดยตรง วิธีนี้ใช้ได้เฉพาะกับหมายเลขโทรศัพท์สมมติเท่านั้น

โปรดตรวจสอบว่าปิดใช้แล้วและไม่มีการฮาร์ดโค้ดหมายเลขโทรศัพท์สมมติ เมื่อเผยแพร่แอปพลิเคชันไปยัง Google Play Store

Java

// The test phone number and code should be whitelisted in the console.
String phoneNumber = "+16505554567";
String smsCode = "123456";

FirebaseAuth firebaseAuth = FirebaseAuth.getInstance();
FirebaseAuthSettings firebaseAuthSettings = firebaseAuth.getFirebaseAuthSettings();

// Configure faking the auto-retrieval with the whitelisted numbers.
firebaseAuthSettings.setAutoRetrievedSmsCodeForPhoneNumber(phoneNumber, smsCode);

PhoneAuthOptions options = PhoneAuthOptions.newBuilder(firebaseAuth)
        .setPhoneNumber(phoneNumber)
        .setTimeout(60L, TimeUnit.SECONDS)
        .setActivity(this)
        .setCallbacks(new PhoneAuthProvider.OnVerificationStateChangedCallbacks() {
            @Override
            public void onVerificationCompleted(@NonNull PhoneAuthCredential credential) {
                // Instant verification is applied and a credential is directly returned.
                // ...
            }

            // ...
        })
        .build();
PhoneAuthProvider.verifyPhoneNumber(options);
MainActivity.java

Kotlin+KTX

// The test phone number and code should be whitelisted in the console.
val phoneNumber = "+16505554567"
val smsCode = "123456"

val firebaseAuth = Firebase.auth
val firebaseAuthSettings = firebaseAuth.firebaseAuthSettings

// Configure faking the auto-retrieval with the whitelisted numbers.
firebaseAuthSettings.setAutoRetrievedSmsCodeForPhoneNumber(phoneNumber, smsCode)

val options = PhoneAuthOptions.newBuilder(firebaseAuth)
    .setPhoneNumber(phoneNumber)
    .setTimeout(60L, TimeUnit.SECONDS)
    .setActivity(this)
    .setCallbacks(object : PhoneAuthProvider.OnVerificationStateChangedCallbacks() {
        override fun onVerificationCompleted(credential: PhoneAuthCredential) {
            // Instant verification is applied and a credential is directly returned.
            // ...
        }

        // ...
    })
    .build()
PhoneAuthProvider.verifyPhoneNumber(options)
MainActivity.kt

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

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

  • ในแอป คุณสามารถดูข้อมูลโปรไฟล์พื้นฐานของผู้ใช้ได้จาก FirebaseUser โปรดดู จัดการผู้ใช้

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

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

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

Kotlin+KTX

Firebase.auth.signOut()
MainActivity.kt

Java

FirebaseAuth.getInstance().signOut();
MainActivity.java