Aplikasi Firebase tetap berfungsi bahkan ketika aplikasi Anda kehilangan koneksi jaringan untuk sementara. Selain itu, Firebase menyediakan alat untuk mempertahankan data secara lokal, mengelola kehadiran, dan menangani latensi.
Persistensi Disk
Aplikasi Firebase secara otomatis menangani gangguan sementara pada jaringan. Data yang tersimpan di cache akan tersedia saat offline, dan Firebase akan mengirim ulang setiap operasi tulis saat terhubung kembali ke jaringan.
Jika persistensi disk diaktifkan, aplikasi Anda akan menulis data secara lokal ke perangkat agar dapat mempertahankan status saat offline, bahkan saat aplikasi dimulai ulang oleh pengguna atau sistem operasi.
Anda dapat mengaktifkan persistensi disk hanya dengan satu baris kode.
Swift
Database.database().isPersistenceEnabled = true
Objective-C
[FIRDatabase database].persistenceEnabled = YES;
Perilaku Persistensi
Dengan mengaktifkan persistensi, data apa pun yang disinkronkan oleh klien Firebase Realtime Database saat online akan dipertahankan di disk dan tersedia secara offline, bahkan saat aplikasi dimulai ulang oleh pengguna atau sistem operasi. Artinya, aplikasi Anda berfungsi seperti halnya ketika online dengan menggunakan data lokal yang disimpan dalam cache. Callback pemroses akan terus aktif untuk pembaruan lokal.
Klien Firebase Realtime Database secara otomatis menyimpan antrean semua operasi tulis yang dijalankan saat aplikasi sedang offline. Saat persistensi diaktifkan, antrean ini juga akan dipertahankan di disk sehingga semua operasi tulis akan tersedia saat aplikasi dimulai ulang oleh pengguna atau sistem operasi. Setelah aplikasi kembali terhubung, semua operasi tersebut akan dikirim ke server Firebase Realtime Database.
Jika aplikasi Anda menggunakan Firebase Authentication, klien Firebase Realtime Database akan mempertahankan token autentikasi pengguna setiap kali aplikasi dimulai ulang. Jika masa berlaku token autentikasi habis selagi aplikasi offline, klien akan menjeda operasi tulis hingga aplikasi Anda mengautentikasi ulang pengguna. Jika tidak, operasi tulis mungkin akan gagal akibat aturan keamanan.
Menjaga Data Tetap Baru
Firebase Realtime Database menyinkronkan dan menyimpan salinan lokal data untuk pemroses aktif. Selain itu, Anda dapat terus menyinkronkan lokasi tertentu.
Swift
let scoresRef = Database.database().reference(withPath: "scores") scoresRef.keepSynced(true)
Objective-C
FIRDatabaseReference *scoresRef = [[FIRDatabase database] referenceWithPath:@"scores"]; [scoresRef keepSynced:YES];
Klien Firebase Realtime Database akan otomatis mendownload data di lokasi tersebut dan terus menyinkronkannya meskipun referensi tidak memiliki pemroses aktif. Anda dapat kembali menonaktifkan sinkronisasi dengan baris kode berikut.
Swift
scoresRef.keepSynced(false)
Objective-C
[scoresRef keepSynced:NO];
Secara default, data sebesar 10 MB yang telah disinkronkan sebelumnya akan disimpan ke dalam cache. Jumlah ini tentunya cukup untuk sebagian besar aplikasi. Jika ukuran cache melebihi ukuran yang dikonfigurasi, Firebase Realtime Database akan menghapus permanen data yang paling lama tidak digunakan. Data yang terus disinkronkan tidak akan dihapus secara permanen dari cache.
Memproses Kueri Data secara Offline
Firebase Realtime Database menyimpan data yang ditampilkan dari kueri untuk digunakan saat offline. Untuk kueri yang dibuat saat offline, Firebase Realtime Database akan terus berfungsi untuk data yang dimuat sebelumnya. Jika data yang diminta belum dimuat, Firebase Realtime Database akan memuat data dari cache lokal. Setelah koneksi jaringan kembali tersedia, data akan dimuat dan mencerminkan kueri tersebut.
Misalnya, kode berikut memproses kueri untuk empat item terakhir dalam Firebase Realtime Database skor
Swift
let scoresRef = Database.database().reference(withPath: "scores") scoresRef.queryOrderedByValue().queryLimited(toLast: 4).observe(.childAdded) { snapshot in print("The \(snapshot.key) dinosaur's score is \(snapshot.value ?? "null")") }
Objective-C
FIRDatabaseReference *scoresRef = [[FIRDatabase database] referenceWithPath:@"scores"]; [[[scoresRef queryOrderedByValue] queryLimitedToLast:4] observeEventType:FIRDataEventTypeChildAdded withBlock:^(FIRDataSnapshot *snapshot) { NSLog(@"The %@ dinosaur's score is %@", snapshot.key, snapshot.value); }];
Asumsikan pengguna kehilangan koneksi, statusnya menjadi offline, dan memulai ulang aplikasi. Selagi masih offline, aplikasi akan memproses kueri untuk dua item terakhir dari lokasi yang sama. Kueri ini akan berhasil menampilkan dua item terakhir karena keempat item telah dimuat dalam kueri di atas.
Swift
scoresRef.queryOrderedByValue().queryLimited(toLast: 2).observe(.childAdded) { snapshot in print("The \(snapshot.key) dinosaur's score is \(snapshot.value ?? "null")") }
Objective-C
[[[scoresRef queryOrderedByValue] queryLimitedToLast:2] observeEventType:FIRDataEventTypeChildAdded withBlock:^(FIRDataSnapshot *snapshot) { NSLog(@"The %@ dinosaur's score is %@", snapshot.key, snapshot.value); }];
Pada contoh sebelumnya, klien Firebase Realtime Database memunculkan peristiwa 'child added' untuk dua dinosaurus dengan skor tertinggi lewat cache yang disimpan. Namun, klien tidak akan memunculkan peristiwa 'value', karena aplikasi tidak pernah menjalankan kueri tersebut selagi online.
Jika ingin meminta keenam item terakhir selagi offline, aplikasi akan langsung mendapatkan peristiwa 'child added' untuk keempat item yang disimpan dalam cache. Saat perangkat kembali online, klien Firebase Realtime Database akan melakukan sinkronisasi dengan server dan mendapatkan dua peristiwa 'child added' dan 'value' terakhir untuk aplikasi.
Menangani Transaksi saat Offline
Setiap transaksi yang dijalankan sewaktu aplikasi offline akan dimasukkan ke dalam antrean. Setelah aplikasi kembali online, transaksi akan dikirim ke server Realtime Database.
Mengelola Kehadiran
Pada aplikasi real-time, mendeteksi kapan klien membuat dan memutus koneksi sering kali bermanfaat. Misalnya, mungkin Anda ingin menandai pengguna sebagai 'offline' saat kliennya memutus koneksi.
Klien Firebase Database menyediakan sejumlah primitif sederhana yang dapat Anda gunakan untuk menulis ke database saat suatu klien memutuskan koneksi ke server Firebase Database. Update ini akan terjadi, terlepas dari apakah klien memutuskan koneksi secara bersih atau tidak, sehingga Anda dapat mengandalkan update ini untuk membersihkan data, meskipun koneksi terputus atau klien mengalami error. Semua operasi tulis, termasuk penyetelan, update, dan penghapusan, dapat dilakukan setelah koneksi terputus.
Berikut contoh sederhana penulisan data setelah koneksi terputus menggunakan primitif onDisconnect
:
Swift
let presenceRef = Database.database().reference(withPath: "disconnectmessage"); // Write a string when this client loses connection presenceRef.onDisconnectSetValue("I disconnected!")
Objective-C
FIRDatabaseReference *presenceRef = [[FIRDatabase database] referenceWithPath:@"disconnectmessage"]; // Write a string when this client loses connection [presenceRef onDisconnectSetValue:@"I disconnected!"];
Cara Kerja onDisconnect
Saat Anda membuat operasi onDisconnect()
, operasi tersebut akan berlangsung di server Firebase Realtime Database. Server akan memeriksa keamanan untuk memastikan
bahwa pengguna dapat menjalankan peristiwa tulis yang diminta, dan memberi tahu
aplikasi Anda jika operasi tersebut tidak valid. Selanjutnya, server akan
memantau koneksinya. Jika waktu koneksi habis, atau koneksi ditutup secara aktif
oleh klien Realtime Database, server akan memeriksa keamanan
sekali lagi (untuk memastikan operasi masih valid), kemudian memanggil
peristiwa tersebut.
Aplikasi Anda dapat menggunakan callback di operasi tulis untuk memastikan onDisconnect
terpasang dengan benar:
Swift
presenceRef.onDisconnectRemoveValue { error, reference in if let error = error { print("Could not establish onDisconnect event: \(error)") } }
Objective-C
[presenceRef onDisconnectRemoveValueWithCompletionBlock:^(NSError *error, FIRDatabaseReference *reference) { if (error != nil) { NSLog(@"Could not establish onDisconnect event: %@", error); } }];
Peristiwa onDisconnect
juga dapat dibatalkan dengan memanggil .cancel()
:
Swift
presenceRef.onDisconnectSetValue("I disconnected") // some time later when we change our minds presenceRef.cancelDisconnectOperations()
Objective-C
[presenceRef onDisconnectSetValue:@"I disconnected"]; // some time later when we change our minds [presenceRef cancelDisconnectOperations];
Mendeteksi Status Koneksi
Untuk banyak fitur yang terkait dengan kehadiran, ada baiknya jika aplikasi mengetahui
apakah status koneksi sedang online atau offline. Firebase Realtime Database
menyediakan lokasi khusus di /.info/connected
yang
diperbarui setiap kali status koneksi klien Firebase Realtime Database
berubah. Berikut ini contohnya:
Swift
let connectedRef = Database.database().reference(withPath: ".info/connected") connectedRef.observe(.value, with: { snapshot in if snapshot.value as? Bool ?? false { print("Connected") } else { print("Not connected") } })
Objective-C
FIRDatabaseReference *connectedRef = [[FIRDatabase database] referenceWithPath:@".info/connected"]; [connectedRef observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { if([snapshot.value boolValue]) { NSLog(@"connected"); } else { NSLog(@"not connected"); } }];
/.info/connected
adalah nilai boolean yang tidak disinkronkan antarklien Realtime Database karena nilainya bergantung pada status klien. Dengan kata lain, jika satu klien membaca /.info/connected
sebagai 'false', tidak ada jaminan bahwa klien lain juga akan membacanya sebagai 'false'.
Menangani Latensi
Stempel Waktu Server
Server Firebase Realtime Database memberikan mekanisme
untuk menyisipkan stempel waktu yang dibuat di server sebagai data. Fitur ini, bersama dengan onDisconnect
, memberikan cara mudah dan andal untuk mencatat kapan koneksi klien Realtime Database diputus:
Swift
let userLastOnlineRef = Database.database().reference(withPath: "users/morgan/lastOnline") userLastOnlineRef.onDisconnectSetValue(ServerValue.timestamp())
Objective-C
FIRDatabaseReference *userLastOnlineRef = [[FIRDatabase database] referenceWithPath:@"users/morgan/lastOnline"]; [userLastOnlineRef onDisconnectSetValue:[FIRServerValue timestamp]];
Clock Skew
Meskipun firebase.database.ServerValue.TIMESTAMP
jauh lebih akurat
dan lebih cocok untuk sebagian besar operasi baca/tulis,
terkadang ada baiknya memperkirakan clock skew klien
terhadap server Firebase Realtime Database. Anda
dapat menambahkan callback ke lokasi /.info/serverTimeOffset
untuk mendapatkan nilai, dalam milidetik, yang ditambahkan oleh klien Firebase Realtime Database
ke waktu lokal yang dilaporkan (waktu epoch dalam milidetik) untuk memperkirakan
waktu server. Perlu diperhatikan bahwa akurasi selisih ini dapat dipengaruhi oleh latensi jaringan, sehingga hanya bermanfaat untuk menemukan selisih waktu jam yang besar (> 1 detik).
Swift
let offsetRef = Database.database().reference(withPath: ".info/serverTimeOffset") offsetRef.observe(.value, with: { snapshot in if let offset = snapshot.value as? TimeInterval { print("Estimated server time in milliseconds: \(Date().timeIntervalSince1970 * 1000 + offset)") } })
Objective-C
FIRDatabaseReference *offsetRef = [[FIRDatabase database] referenceWithPath:@".info/serverTimeOffset"]; [offsetRef observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { NSTimeInterval offset = [(NSNumber *)snapshot.value doubleValue]; NSTimeInterval estimatedServerTimeMs = [[NSDate date] timeIntervalSince1970] * 1000.0 + offset; NSLog(@"Estimated server time: %0.3f", estimatedServerTimeMs); }];
Contoh Aplikasi Kehadiran
Dengan menggabungkan operasi pemutusan koneksi dengan pemantauan status koneksi dan stempel waktu server, Anda dapat membuat suatu sistem kehadiran pengguna. Dalam sistem ini, setiap pengguna menyimpan data di lokasi basis data untuk menunjukkan apakah klien Realtime Database sedang online atau tidak. Klien akan menetapkan lokasi ini ke benar (true) ketika mulai online dan ke stempel waktu ketika memutuskan koneksi. Stempel waktu ini menunjukkan kapan terakhir kali pengguna tersebut online.
Perlu diperhatikan bahwa aplikasi Anda harus mengantrekan operasi pemutusan koneksi sebelum pengguna ditandai sebagai online, untuk menghindari kondisi race yang dapat terjadi jika koneksi jaringan klien terputus sebelum kedua perintah dapat dikirimkan ke server.
Berikut adalah contoh sederhana dari sistem kehadiran pengguna:
Swift
// 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 let myConnectionsRef = Database.database().reference(withPath: "users/morgan/connections") // stores the timestamp of my last disconnect (the last time I was seen online) let lastOnlineRef = Database.database().reference(withPath: "users/morgan/lastOnline") let connectedRef = Database.database().reference(withPath: ".info/connected") connectedRef.observe(.value, with: { snapshot in // only handle connection established (or I've reconnected after a loss of connection) guard snapshot.value as? Bool ?? false else { return } // add this device to my connections list let con = myConnectionsRef.childByAutoId() // when this device disconnects, remove it. con.onDisconnectRemoveValue() // The onDisconnect() call is before the call to set() itself. This is to avoid a race condition // where you set the user's presence to true and the client disconnects before the // onDisconnect() operation takes effect, leaving a ghost user. // this value could contain info about the device or a timestamp instead of just true con.setValue(true) // when I disconnect, update the last time I was seen online lastOnlineRef.onDisconnectSetValue(ServerValue.timestamp()) })
Objective-C
// 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 FIRDatabaseReference *myConnectionsRef = [[FIRDatabase database] referenceWithPath:@"users/morgan/connections"]; // stores the timestamp of my last disconnect (the last time I was seen online) FIRDatabaseReference *lastOnlineRef = [[FIRDatabase database] referenceWithPath:@"users/morgan/lastOnline"]; FIRDatabaseReference *connectedRef = [[FIRDatabase database] referenceWithPath:@".info/connected"]; [connectedRef observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { if([snapshot.value boolValue]) { // connection established (or I've reconnected after a loss of connection) // add this device to my connections list FIRDatabaseReference *con = [myConnectionsRef childByAutoId]; // when this device disconnects, remove it [con onDisconnectRemoveValue]; // The onDisconnect() call is before the call to set() itself. This is to avoid a race condition // where you set the user's presence to true and the client disconnects before the // onDisconnect() operation takes effect, leaving a ghost user. // this value could contain info about the device or a timestamp instead of just true [con setValue:@YES]; // when I disconnect, update the last time I was seen online [lastOnlineRef onDisconnectSetValue:[FIRServerValue timestamp]]; } }];