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

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

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

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

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

    // 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:24.2.0")
}
  3. หากยังไม่ได้เชื่อมต่อแอปกับโปรเจ็กต์ Firebase ให้ดำเนินการจาก Firebaseคอนโซล
  4. หากยังไม่ได้ตั้งค่าแฮช SHA-1 ของแอปในFirebase คอนโซล, ให้ดำเนินการตั้งค่า ดูข้อมูลเกี่ยวกับการค้นหาแฮช SHA-1 ของแอปได้ที่ Authenticating Your Client

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

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

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

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

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

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

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

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

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

    หากต้องการใช้ Play Integrity ให้ระบุลายนิ้วมือ SHA-256 ของแอปหากยังไม่ได้ระบุ

    1. ในคอนโซลFirebase ให้ไปที่แท็บ การตั้งค่า > ทั่วไป
    2. เลื่อนลงไปที่การ์ดแอปของคุณ เลือกแอป Android แล้ว เพิ่มลายนิ้วมือ SHA-256 ในช่องลายนิ้วมือของใบรับรอง SHA

    ดูรายละเอียดเกี่ยวกับวิธีรับลายนิ้วมือ SHA ของแอปได้ที่ Authenticating Your Client

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

    สถานการณ์บางอย่างที่ระบบจะทริกเกอร์ reCAPTCHA

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

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

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

การแก้ปัญหา

  • ข้อผิดพลาด "Missing initial state" เมื่อใช้ reCAPTCHA เพื่อการยืนยันแอป

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

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

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

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

Kotlin

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)

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

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

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

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

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

Kotlin

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

Java

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

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

Kotlin

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

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

Callback การยืนยัน

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

onVerificationCompleted(PhoneAuthCredential)

ระบบจะเรียกใช้เมธอดนี้ใน 2 กรณีดังนี้

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

onVerificationFailed(FirebaseException)

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

onCodeSent(String verificationId, PhoneAuthProvider.ForceResendingToken)

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

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

onCodeAutoRetrievalTimeOut(String verificationId)

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

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

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

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

หากต้องการสร้างออบเจ็กต์ PhoneAuthCredential ให้เรียก PhoneAuthProvider.getCredential ดังนี้

Kotlin

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

Java

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

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

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

Kotlin

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

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

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

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

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

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

  1. ตรวจสอบว่าคุณใช้หมายเลขโทรศัพท์ที่เป็นหมายเลขสมมติและไม่มีอยู่จริง Firebase Authentication ไม่อนุญาตให้คุณตั้งค่าหมายเลขโทรศัพท์ที่มีอยู่ซึ่งผู้ใช้จริงใช้เป็นหมายเลขทดสอบ ตัวเลือกหนึ่งคือการใช้หมายเลขที่ขึ้นต้นด้วย 555 เป็นหมายเลขโทรศัพท์ทดสอบของสหรัฐอเมริกา เช่น: +1 650-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 Authentication ยังมี API ที่ช่วยเขียนการทดสอบการผสานรวม สำหรับการทดสอบการตรวจสอบสิทธิ์ด้วยโทรศัพท์ API เหล่านี้จะปิดใช้การตรวจสอบแอปโดยปิดใช้ข้อกำหนด reCAPTCHA ในการแจ้งเตือนแบบพุชบนเว็บและการแจ้งเตือนแบบพุชเงียบใน iOS ซึ่งจะทำให้การทดสอบอัตโนมัติเป็นไปได้ในขั้นตอนการทำงานเหล่านี้และใช้งานได้ง่ายขึ้น นอกจากนี้ API เหล่านี้ยังช่วยให้ทดสอบขั้นตอนการทำงานของการยืนยันทันทีใน Android ได้

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

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

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

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

Kotlin

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)

นอกจากนี้ คุณยังทดสอบขั้นตอนการทำงานของการดึงข้อมูลอัตโนมัติใน 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);

Kotlin

// 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)

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

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

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

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

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

หากต้องการให้ผู้ใช้ออกจากระบบ ให้เรียก signOut ดังนี้

Kotlin

Firebase.auth.signOut()

Java

FirebaseAuth.getInstance().signOut();