Google is committed to advancing racial equity for Black communities. See how.
หน้านี้ได้รับการแปลโดย Cloud Translation API
Switch to English

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

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

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

ก่อนที่คุณจะเริ่ม

  1. เพิ่ม Firebase ในโปรเจ็กต์ Android ของคุณ หากยังไม่ได้ ทำ
  2. ในโครงการระดับ build.gradle ไฟล์ให้แน่ใจว่าจะรวมถึงพื้นที่เก็บข้อมูล Maven ของ Google ในทั้งสองของคุณ buildscript และ allprojects ส่วน
  3. เพิ่มการอ้างอิงสำหรับไลบรารี Android ของ Firebase Authentication ไปยังโมดูลของคุณ (ระดับแอป) ไฟล์ Gradle (โดยปกติคือ app/build.gradle ):
    implementation 'com.google.firebase:firebase-auth:19.3.2'
  4. หากคุณยังไม่ได้เชื่อมต่อแอปกับโปรเจ็กต์ Firebase ให้ทำจาก คอนโซล Firebase
  5. หากคุณยังไม่ได้ตั้งค่าแฮช SHA-1 ของแอปใน คอนโซล Firebase ให้ดำเนินการดังกล่าว ดูการ พิสูจน์ตัวตนลูกค้าของคุณ สำหรับข้อมูลเกี่ยวกับการค้นหาแฮช SHA-1 ของแอปของคุณ

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

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

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

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

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

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

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

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

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

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

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

ชวา

PhoneAuthProvider.getInstance().verifyPhoneNumber(
        phoneNumber,        // Phone number to verify
        60,                 // Timeout duration
        TimeUnit.SECONDS,   // Unit of timeout
        this,               // Activity (for callback binding)
        mCallbacks);        // OnVerificationStateChangedCallbacks

Kotlin + KTX

PhoneAuthProvider.getInstance().verifyPhoneNumber(
        phoneNumber, // Phone number to verify
        60, // Timeout duration
        TimeUnit.SECONDS, // Unit of timeout
        this, // Activity (for callback binding)
        callbacks) // OnVerificationStateChangedCallbacks

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

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

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

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

ชวา

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

Kotlin + KTX

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

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

ชวา

mCallbacks = new PhoneAuthProvider.OnVerificationStateChangedCallbacks() {

    @Override
    public void onVerificationCompleted(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(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
            // ...
        }

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

        // ...
    }
};

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

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

        // ...
    }
}

การโทรกลับเพื่อยืนยัน

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

onVerificationCompleted (PhoneAuthCredential)

วิธีนี้เรียกว่าในสองสถานการณ์:

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

onVerificationFailed (FirebaseException)

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

onCodeSent (การยืนยันสตริง, PhoneAuthProviderForceResendingToken)

ไม่จำเป็น. วิธีนี้เรียกว่าหลังจากส่งรหัสยืนยันทาง SMS ไปยังหมายเลขโทรศัพท์ที่ให้ไว้

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

onCodeAutoRetrievalTimeOut (String VerificationId)

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

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

สร้างวัตถุ PhoneAuthCredential

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

ในการสร้างวัตถุ PhoneAuthCredential ให้เรียก PhoneAuthProvider.getCredential :

ชวา

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

Kotlin + KTX

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

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

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

ชวา

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

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

ทดสอบกับหมายเลขโทรศัพท์ที่อนุญาตพิเศษ

คุณสามารถเพิ่มหมายเลขโทรศัพท์ที่อนุญาตพิเศษสำหรับการพัฒนาผ่านคอนโซล Firebase หมายเลขโทรศัพท์ที่อนุญาตพิเศษให้ประโยชน์เหล่านี้:

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

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

  1. ตรวจสอบให้แน่ใจว่าคุณใช้ตัวเลขสมมติที่ไม่มีอยู่แล้ว การตรวจสอบสิทธิ์ Firebase ไม่อนุญาตให้คุณอนุญาตหมายเลขโทรศัพท์ที่มีอยู่ซึ่งผู้ใช้จริงใช้ ทางเลือกหนึ่งคือใช้ 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 และบริการอื่น ๆ ได้ในลักษณะเดียวกัน โทเค็น ID ที่สร้างขึ้นในระหว่างกระบวนการนี้มีลายเซ็นเดียวกับผู้ใช้หมายเลขโทรศัพท์จริง

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

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

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

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

ชวา

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.
PhoneAuthProvider.getInstance().verifyPhoneNumber(
        phoneNum, 30L /*timeout*/, TimeUnit.SECONDS,
        this, new PhoneAuthProvider.OnVerificationStateChangedCallbacks() {

            @Override
            public void onCodeSent(String verificationId,
                                   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(PhoneAuthCredential phoneAuthCredential) {
                // Sign in with the credential
                // ...
            }

            @Override
            public void onVerificationFailed(FirebaseException e) {
                 // ...
            }

        });

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.
PhoneAuthProvider.getInstance().verifyPhoneNumber(
        phoneNum, 30L /*timeout*/, TimeUnit.SECONDS,
        this, 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) {
        // ...
    }
})

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

เมื่อ verifyPhoneNumber เรียกว่ามันเป็นต้นเหตุ onVerificationCompleted กับ PhoneAuthCredential โดยตรง ใช้งานได้กับหมายเลขโทรศัพท์ที่อนุญาตพิเศษเท่านั้น

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

ชวา

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

PhoneAuthProvider phoneAuthProvider = PhoneAuthProvider.getInstance();
phoneAuthProvider.verifyPhoneNumber(
        phoneNumber,
        60L,
        TimeUnit.SECONDS,
        this, /* activity */
        new PhoneAuthProvider.OnVerificationStateChangedCallbacks() {
            @Override
            public void onVerificationCompleted(PhoneAuthCredential credential) {
                // Instant verification is applied and a credential is directly returned.
                // ...
            }

            // ...
        });

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 phoneAuthProvider = PhoneAuthProvider.getInstance()
phoneAuthProvider.verifyPhoneNumber(
        phoneNumber,
        60L,
        TimeUnit.SECONDS,
        this, /* activity */
        object : PhoneAuthProvider.OnVerificationStateChangedCallbacks() {
            override fun onVerificationCompleted(credential: PhoneAuthCredential) {
                // Instant verification is applied and a credential is directly returned.
                // ...
            }

            // ...
        })

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

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

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

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

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

ในการออกจากระบบผู้ใช้โทร signOut :

ชวา

FirebaseAuth.getInstance().signOut();

Kotlin + KTX

Firebase.auth.signOut()