Buka konsol

Kapabilitas Offline di iOS

Aplikasi Firebase tetap berfungsi bahkan ketika aplikasi Anda kehilangan koneksi jaringan untuk sementara. Selain itu, Firebase menyediakan fitur untuk menampung data secara lokal, mengelola kehadiran, dan menangani latensi.

Persistensi Disk

Aplikasi Firebase menangani gangguan sementara pada jaringan secara otomatis. Data yang tersimpan di cache akan tersedia saat offline dan Firebase akan mengirim ulang setiap operasi tulis saat konektivitas jaringan pulih.

Jika Anda mengaktifkan persistensi disk, aplikasi Anda akan menulis data secara lokal ke perangkat sehingga aplikasi dapat mempertahankan status saat offline, bahkan saat aplikasi dimulai ulang oleh pengguna atau sistem operasi.

Anda dapat mengaktifkan persistensi disk cukup dengan 1 baris kode.

Swift

Database.database().isPersistenceEnabled = true

Objective-C

[FIRDatabase database].persistenceEnabled = YES;

Perilaku Persistensi

Dengan mengaktifkan persistensi, semua data yang disinkronkan oleh klien Firebase Realtime Database saat online akan tersimpan ke disk dan tersedia secara offline, bahkan saat aplikasi dimulai ulang oleh pengguna atau sistem operasi. Artinya, aplikasi berfungsi seperti saat online dengan menggunakan data lokal yang tersimpan di cache. Callback listener akan terus aktif untuk update lokal.

Klien Firebase Realtime Database secara otomatis menyimpan antrean semua operasi tulis yang dijalankan selagi aplikasi offline. Saat persistensi diaktifkan, antrean ini juga akan disimpan ke disk sehingga semua operasi tulis tersedia saat aplikasi dimulai ulang oleh pengguna atau sistem operasi. Setelah konektivitas aplikasi pulih, semua operasi tersebut akan dikirim ke server Firebase Realtime Database.

Jika aplikasi Anda menggunakan Firebase Authentication, klien Firebase Realtime Database akan menyimpan token autentikasi pengguna setiap kali aplikasi dimulai ulang. Jika masa pakai token autentikasi habis selagi aplikasi offline, klien akan menjeda operasi tulis hingga autentikasi ulang dilakukan. Jika tidak, operasi tulis mungkin akan gagal karena adanya aturan keamanan.

Menjaga Data Tetap Baru

Firebase Realtime Database menyinkronkan dan menyimpan salinan lokal data untuk listener 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 itu tidak memiliki listener aktif. Anda dapat 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 data yang paling lama tidak digunakan. Data yang terus disinkronkan tidak akan dihapus 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 konektivitas jaringan kembali tersedia, data akan dimuat dan mencerminkan kueri tersebut.

Misalnya, kode berikut memproses kueri untuk 4 item terakhir dalam Firebase Realtime Database untuk 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 2 item terakhir dari lokasi yang sama. Kueri ini akan berhasil menampilkan 2 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 'turunan ditambahkan' untuk 2 dinosaurus dengan skor tertinggi lewat cache yang disimpan. Namun itu tidak akan memunculkan peristiwa 'nilai', karena aplikasi tidak pernah mengeksekusi kueri tersebut selagi online.

Jika aplikasi ingin meminta keenam item terakhir itu selagi offline, peristiwa 'turunan ditambahkan' untuk keempat item yang disimpan dalam cache akan langsung dimunculkan. Saat perangkat kembali online, klien Firebase Realtime Database akan melakukan sinkronisasi dengan server dan memunculkan kedua peristiwa terakhir 'turunan ditambahkan' dan 'nilai' 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 realtime, mendeteksi kapan klien membuat dan memutus koneksi sering kali bermanfaat. Misalnya, Anda mungkin ingin menandai pengguna sebagai 'offline' saat kliennya memutus koneksi.

Klien Firebase Database menyediakan primitif sederhana yang dapat Anda gunakan untuk menulis ke database saat klien terputus dari server Firebase Database. Update ini akan terjadi, terlepas dari apakah klien terputus secara rapi atau tidak, sehingga Anda dapat mengandalkannya untuk membersihkan data bahkan saat koneksi terputus atau klien mengalami error. Semua operasi tulis, termasuk menyetel, mengupdate, dan menghapus, dapat dilakukan setelah koneksi terputus.

Berikut adalah 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

Ketika Anda membuat operasi onDisconnect(), operasi tersebut 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 peristiwa tersebut tidak valid. Selanjutnya, server akan memantau koneksinya. Jika sewaktu-waktu koneksi terputus atau ditutup secara aktif oleh klien Realtime Database, server akan memeriksa keamanan untuk kedua kalinya (untuk memastikan operasi tetap valid) dan kemudian memanggil peristiwa tersebut.

Aplikasi Anda dapat menggunakan callback pada 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, aplikasi perlu mengetahui apakah statusnya online atau offline. Firebase Realtime Database menyediakan lokasi khusus di /.info/connected yang diupdate 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 antara klien Realtime Database karena nilainya bergantung pada status klien. Dengan kata lain, jika 1 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 memiliki mekanisme untuk menyisipkan stempel waktu yang dibuat di server sebagai data. Fitur ini, digabungkan dengan onDisconnect, memberikan cara mudah dan andal untuk mencatat kapan koneksi klien Realtime Database terputus:

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 yang terkait dengan 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 (periode waktu 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 membangun sistem kehadiran pengguna. Dalam sistem ini, setiap pengguna menyimpan data di lokasi database untuk menunjukkan apakah klien Realtime Database sedang online atau tidak. Klien akan menetapkan lokasi ini ke 'true' jika mereka online dan ke stempel waktu jika mereka memutuskan koneksi. Stempel waktu ini menunjukkan kapan terakhir kali pengguna tertentu online.

Perlu diperhatikan bahwa aplikasi Anda harus mengantrekan operasi pemutusan koneksi sebelum pengguna ditandai online, untuk menghindari keluaran yang tidak sesuai waktunya jika sewaktu-waktu 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 let connected = snapshot.value as? Bool, connected 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]];
  }
}];