การเปิดใช้งานความสามารถออฟไลน์บน Android

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

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

การคงอยู่ของดิสก์

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

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

คุณสามารถเปิดใช้งานการคงอยู่ของดิสก์ด้วยโค้ดเพียงบรรทัดเดียว

Kotlin+KTX

Firebase.database.setPersistenceEnabled(true)

Java

FirebaseDatabase.getInstance().setPersistenceEnabled(true);

พฤติกรรมคงอยู่

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

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

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

การรักษาข้อมูลให้สดใหม่

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

Kotlin+KTX

val scoresRef = Firebase.database.getReference("scores")
scoresRef.keepSynced(true)

Java

DatabaseReference scoresRef = FirebaseDatabase.getInstance().getReference("scores");
scoresRef.keepSynced(true);

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

Kotlin+KTX

scoresRef.keepSynced(false)

Java

scoresRef.keepSynced(false);

ตามค่าเริ่มต้น 10MB ของข้อมูลที่ซิงค์ก่อนหน้านี้จะถูกแคชไว้ นี่น่าจะเพียงพอสำหรับแอปพลิเคชันส่วนใหญ่ หากแคชโตกว่าขนาดที่กำหนดค่าไว้ Firebase Realtime Database จะลบข้อมูลที่มีการใช้งานล่าสุดออก ข้อมูลที่ซิงค์ไว้จะไม่ถูกลบออกจากแคช

การสืบค้นข้อมูลออฟไลน์

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

ตัวอย่างเช่น โค้ดนี้ค้นหาสี่รายการล่าสุดในฐานข้อมูล Firebase Realtime ของคะแนน

Kotlin+KTX

val scoresRef = Firebase.database.getReference("scores")
scoresRef.orderByValue().limitToLast(4).addChildEventListener(object : ChildEventListener {
    override fun onChildAdded(snapshot: DataSnapshot, previousChild: String?) {
        Log.d(TAG, "The ${snapshot.key} dinosaur's score is ${snapshot.value}")
    }

    // ...
})

Java

DatabaseReference scoresRef = FirebaseDatabase.getInstance().getReference("scores");
scoresRef.orderByValue().limitToLast(4).addChildEventListener(new ChildEventListener() {
    @Override
    public void onChildAdded(@NonNull DataSnapshot snapshot, String previousChild) {
        Log.d(TAG, "The " + snapshot.getKey() + " dinosaur's score is " + snapshot.getValue());
    }

    // ...
});

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

Kotlin+KTX

scoresRef.orderByValue().limitToLast(2).addChildEventListener(object : ChildEventListener {
    override fun onChildAdded(snapshot: DataSnapshot, previousChild: String?) {
        Log.d(TAG, "The ${snapshot.key} dinosaur's score is ${snapshot.value}")
    }

    // ...
})

Java

scoresRef.orderByValue().limitToLast(2).addChildEventListener(new ChildEventListener() {
    @Override
    public void onChildAdded(@NonNull DataSnapshot snapshot, String previousChild) {
        Log.d(TAG, "The " + snapshot.getKey() + " dinosaur's score is " + snapshot.getValue());
    }

    // ...
});

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

หากแอปขอหกรายการสุดท้ายขณะออฟไลน์ แอปจะได้รับเหตุการณ์ 'เพิ่มลูก' สำหรับสี่รายการที่แคชไว้ทันที เมื่ออุปกรณ์กลับมาออนไลน์ ไคลเอนต์ Firebase Realtime Database จะซิงโครไนซ์กับเซิร์ฟเวอร์และรับเหตุการณ์ 'เพิ่มลูก' และ 'ค่า' สองรายการสุดท้ายสำหรับแอป

การจัดการธุรกรรมออฟไลน์

การทำธุรกรรมใด ๆ ที่ดำเนินการในขณะที่แอปออฟไลน์จะถูกจัดคิว เมื่อแอปเชื่อมต่อเครือข่ายได้อีกครั้ง ธุรกรรมจะถูกส่งไปยังเซิร์ฟเวอร์ฐานข้อมูลเรียลไทม์

การจัดการการแสดงตน

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

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

นี่คือตัวอย่างง่ายๆ ของการเขียนข้อมูลเมื่อขาดการเชื่อมต่อโดยใช้ onDisconnect ดั้งเดิม:

Kotlin+KTX

val presenceRef = Firebase.database.getReference("disconnectmessage")
// Write a string when this client loses connection
presenceRef.onDisconnect().setValue("I disconnected!")

Java

DatabaseReference presenceRef = FirebaseDatabase.getInstance().getReference("disconnectmessage");
// Write a string when this client loses connection
presenceRef.onDisconnect().setValue("I disconnected!");

วิธีการตัดการเชื่อมต่อทำงานอย่างไร

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

แอปของคุณสามารถใช้การเรียกกลับในการเขียนเพื่อให้แน่ใจว่า onDisconnect ถูกแนบอย่างถูกต้อง:

Kotlin+KTX

presenceRef.onDisconnect().removeValue { error, reference ->
    error?.let {
        Log.d(TAG, "could not establish onDisconnect event: ${error.message}")
    }
}

Java

presenceRef.onDisconnect().removeValue(new DatabaseReference.CompletionListener() {
    @Override
    public void onComplete(DatabaseError error, @NonNull DatabaseReference reference) {
        if (error != null) {
            Log.d(TAG, "could not establish onDisconnect event:" + error.getMessage());
        }
    }
});

เหตุการณ์ onDisconnect สามารถยกเลิกได้โดยการโทร .cancel() :

Kotlin+KTX

val onDisconnectRef = presenceRef.onDisconnect()
onDisconnectRef.setValue("I disconnected")
// ...
// some time later when we change our minds
// ...
onDisconnectRef.cancel()

Java

OnDisconnect onDisconnectRef = presenceRef.onDisconnect();
onDisconnectRef.setValue("I disconnected");
// ...
// some time later when we change our minds
// ...
onDisconnectRef.cancel();

การตรวจจับสถานะการเชื่อมต่อ

สำหรับคุณลักษณะที่เกี่ยวข้องกับการแสดงตนหลายๆ อย่าง แอปของคุณจะรู้ว่าเมื่อใดออนไลน์หรือออฟไลน์จะมีประโยชน์ Firebase Realtime Database จัดเตรียมตำแหน่งพิเศษที่ /.info/connected ซึ่งจะอัปเดตทุกครั้งที่สถานะการเชื่อมต่อของไคลเอ็นต์ Firebase Realtime Database เปลี่ยนไป นี่คือตัวอย่าง:

Kotlin+KTX

val connectedRef = Firebase.database.getReference(".info/connected")
connectedRef.addValueEventListener(object : ValueEventListener {
    override fun onDataChange(snapshot: DataSnapshot) {
        val connected = snapshot.getValue(Boolean::class.java) ?: false
        if (connected) {
            Log.d(TAG, "connected")
        } else {
            Log.d(TAG, "not connected")
        }
    }

    override fun onCancelled(error: DatabaseError) {
        Log.w(TAG, "Listener was cancelled")
    }
})

Java

DatabaseReference connectedRef = FirebaseDatabase.getInstance().getReference(".info/connected");
connectedRef.addValueEventListener(new ValueEventListener() {
    @Override
    public void onDataChange(@NonNull DataSnapshot snapshot) {
        boolean connected = snapshot.getValue(Boolean.class);
        if (connected) {
            Log.d(TAG, "connected");
        } else {
            Log.d(TAG, "not connected");
        }
    }

    @Override
    public void onCancelled(@NonNull DatabaseError error) {
        Log.w(TAG, "Listener was cancelled");
    }
});

/.info/connected เป็นค่าบูลีนซึ่งไม่ซิงโครไนซ์ระหว่างไคลเอ็นต์ Realtime Database เนื่องจากค่าดังกล่าวขึ้นอยู่กับสถานะของไคลเอ็นต์ กล่าวอีกนัยหนึ่ง ถ้าไคลเอนต์หนึ่งอ่าน /.info/connected เป็นเท็จ สิ่งนี้ไม่รับประกันว่าไคลเอนต์ที่แยกจากกันจะอ่านเป็นเท็จ

ใน Android Firebase จะจัดการสถานะการเชื่อมต่อโดยอัตโนมัติเพื่อลดการใช้แบนด์วิธและแบตเตอรี่ เมื่อไคลเอ็นต์ไม่มี Listener ที่ใช้งานอยู่ ไม่มีการดำเนินการเขียนหรือ onDisconnect ดำเนินการ และไม่ได้ตัดการเชื่อมต่ออย่างชัดแจ้งด้วยวิธี goOffline Firebase จะปิดการเชื่อมต่อหลังจากไม่มีการใช้งานเป็นเวลา 60 วินาที

การจัดการเวลาแฝง

การประทับเวลาของเซิร์ฟเวอร์

เซิร์ฟเวอร์ Firebase Realtime Database มีกลไกในการแทรกการประทับเวลาที่สร้างขึ้นบนเซิร์ฟเวอร์เป็นข้อมูล คุณลักษณะนี้เมื่อรวมกับ onDisconnect เป็นวิธีง่ายๆ ในการจดบันทึกเวลาที่ไคลเอ็นต์ Realtime Database ตัดการเชื่อมต่อ:

Kotlin+KTX

val userLastOnlineRef = Firebase.database.getReference("users/joe/lastOnline")
userLastOnlineRef.onDisconnect().setValue(ServerValue.TIMESTAMP)

Java

DatabaseReference userLastOnlineRef = FirebaseDatabase.getInstance().getReference("users/joe/lastOnline");
userLastOnlineRef.onDisconnect().setValue(ServerValue.TIMESTAMP);

นาฬิกาเอียง

แม้ว่า firebase.database.ServerValue.TIMESTAMP จะแม่นยำกว่ามาก และเป็นที่นิยมมากกว่าสำหรับการดำเนินการอ่าน/เขียนส่วนใหญ่ แต่บางครั้งอาจมีประโยชน์ในการประมาณการเอียงของนาฬิกาของไคลเอ็นต์เมื่อเทียบกับเซิร์ฟเวอร์ของ Firebase Realtime Database คุณสามารถแนบการเรียกกลับไปที่ตำแหน่ง /.info/serverTimeOffset เพื่อรับค่าเป็นมิลลิวินาที ที่ไคลเอ็นต์ Firebase Realtime Database เพิ่มลงในเวลาที่รายงานในเครื่อง (เวลาของยุคในหน่วยมิลลิวินาที) เพื่อประเมินเวลาเซิร์ฟเวอร์ โปรดทราบว่าความแม่นยำของออฟเซ็ตนี้อาจได้รับผลกระทบจากเวลาแฝงของเครือข่าย และจะเป็นประโยชน์ในการค้นหาความคลาดเคลื่อนอย่างมาก (> 1 วินาที) ของเวลานาฬิกา

Kotlin+KTX

val offsetRef = Firebase.database.getReference(".info/serverTimeOffset")
offsetRef.addValueEventListener(object : ValueEventListener {
    override fun onDataChange(snapshot: DataSnapshot) {
        val offset = snapshot.getValue(Double::class.java) ?: 0.0
        val estimatedServerTimeMs = System.currentTimeMillis() + offset
    }

    override fun onCancelled(error: DatabaseError) {
        Log.w(TAG, "Listener was cancelled")
    }
})

Java

DatabaseReference offsetRef = FirebaseDatabase.getInstance().getReference(".info/serverTimeOffset");
offsetRef.addValueEventListener(new ValueEventListener() {
    @Override
    public void onDataChange(@NonNull DataSnapshot snapshot) {
        double offset = snapshot.getValue(Double.class);
        double estimatedServerTimeMs = System.currentTimeMillis() + offset;
    }

    @Override
    public void onCancelled(@NonNull DatabaseError error) {
        Log.w(TAG, "Listener was cancelled");
    }
});

ตัวอย่างการแสดงตน App

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

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

นี่คือระบบการแสดงตนของผู้ใช้อย่างง่าย:

Kotlin+KTX

// Since I can connect from multiple devices, we store each connection instance separately
// any time that connectionsRef's value is null (i.e. has no children) I am offline
val database = Firebase.database
val myConnectionsRef = database.getReference("users/joe/connections")

// Stores the timestamp of my last disconnect (the last time I was seen online)
val lastOnlineRef = database.getReference("/users/joe/lastOnline")

val connectedRef = database.getReference(".info/connected")
connectedRef.addValueEventListener(object : ValueEventListener {
    override fun onDataChange(snapshot: DataSnapshot) {
        val connected = snapshot.getValue<Boolean>() ?: false
        if (connected) {
            val con = myConnectionsRef.push()

            // When this device disconnects, remove it
            con.onDisconnect().removeValue()

            // When I disconnect, update the last time I was seen online
            lastOnlineRef.onDisconnect().setValue(ServerValue.TIMESTAMP)

            // Add this device to my connections list
            // this value could contain info about the device or a timestamp too
            con.setValue(java.lang.Boolean.TRUE)
        }
    }

    override fun onCancelled(error: DatabaseError) {
        Log.w(TAG, "Listener was cancelled at .info/connected")
    }
})

Java

// Since I can connect from multiple devices, we store each connection instance separately
// any time that connectionsRef's value is null (i.e. has no children) I am offline
final FirebaseDatabase database = FirebaseDatabase.getInstance();
final DatabaseReference myConnectionsRef = database.getReference("users/joe/connections");

// Stores the timestamp of my last disconnect (the last time I was seen online)
final DatabaseReference lastOnlineRef = database.getReference("/users/joe/lastOnline");

final DatabaseReference connectedRef = database.getReference(".info/connected");
connectedRef.addValueEventListener(new ValueEventListener() {
    @Override
    public void onDataChange(DataSnapshot snapshot) {
        boolean connected = snapshot.getValue(Boolean.class);
        if (connected) {
            DatabaseReference con = myConnectionsRef.push();

            // When this device disconnects, remove it
            con.onDisconnect().removeValue();

            // When I disconnect, update the last time I was seen online
            lastOnlineRef.onDisconnect().setValue(ServerValue.TIMESTAMP);

            // Add this device to my connections list
            // this value could contain info about the device or a timestamp too
            con.setValue(Boolean.TRUE);
        }
    }

    @Override
    public void onCancelled(DatabaseError error) {
        Log.w(TAG, "Listener was cancelled at .info/connected");
    }
});