Buka konsol

Mengaktifkan Data Offline

Cloud Firestore mendukung persistensi data offline. Operasi ini meng-cache salinan data Cloud Firestore yang digunakan secara aktif oleh aplikasi Anda, sehingga aplikasi dapat mengakses data saat perangkat sedang offline. Anda bisa menulis, membaca, mendeteksi, dan membuat kueri data yang disimpan di cache. Saat perangkat kembali online, Cloud Firestore menyinkronkan semua perubahan lokal yang dibuat oleh aplikasi pada data yang disimpan dari jarak jauh di Cloud Firestore.

Untuk menggunakan persistensi data offline, Anda tidak perlu membuat perubahan pada kode yang Anda gunakan untuk mengakses data Cloud Firestore. Dengan diaktifkannya persistensi data offline, library klien Cloud Firestore akan mengelola akses data online dan offline secara otomatis, serta menyinkronkan data lokal saat perangkat kembali online.

Mengonfigurasikan persistensi data offline

Saat Anda menginisialisasi Cloud Firestore, Anda dapat mengaktifkan atau menonaktifkan persistensi data offline:

  • Untuk Android dan iOS, persistensi data offline diaktifkan secara default. Untuk menonaktifkan persistensi data, setel opsi PersistenceEnabled menjadi false.
  • Untuk web, persistensi data offline dinonaktifkan secara default. Untuk mengaktifkan persistensi, panggil metode enablePersistence. Cache Cloud Firestore tidak dihapus secara otomatis di antara sesi. Oleh karena itu, jika aplikasi web Anda menangani informasi sensitif, pastikan pengguna menggunakan perangkat tepercaya sebelum mengaktifkan persistensi.
Web
firebase.initializeApp({
  apiKey: '### FIREBASE API KEY ###',
  authDomain: '### FIREBASE AUTH DOMAIN ###',
  projectId: '### CLOUD FIRESTORE PROJECT ID ###',
}
);

firebase.firestore().enablePersistence()
  .then(function() {
      // Initialize Cloud Firestore through firebase
      var db = firebase.firestore();
  })
  .catch(function(err) {
      if (err.code == 'failed-precondition') {
          // Multiple tabs open, persistence can only be enabled
          // in one tab at a a time.
          // ...
      } else if (err.code == 'unimplemented') {
          // The current browser does not support all of the
          // features required to enable persistence
          // ...
      }
  });
  
Android
FirebaseFirestoreSettings settings = new FirebaseFirestoreSettings.Builder()
        .setPersistenceEnabled(true)
        .build();
db.setFirestoreSettings(settings);
  
Swift
let settings = FirestoreSettings()
settings.isPersistenceEnabled = true

// Any additional options
// ...

// Enable offline data persistence
let db = Firestore.firestore()
db.settings = settings
Objective-C
FIRFirestoreSettings *settings = [[FIRFirestoreSettings alloc] init];
settings.persistenceEnabled = YES;

// Any additional options
// ...

// Enable offline data persistence
FIRFirestore *db = [FIRFirestore firestore];
db.settings = settings;
  

Mendeteksi data offline

Saat perangkat sedang offline, jika Anda telah mengaktifkan persistensi data offline, listener akan menerima peristiwa deteksi saat terjadi perubahan pada data yang di-cache secara lokal. Anda dapat mendeteksi dokumen, koleksi, dan kueri.

Untuk memeriksa apakah Anda menerima data dari server atau cache, gunakan properti fromCache pada SnapshotMetadata di peristiwa snapshot Anda. Jika fromCache adalah true, artinya data berasal dari cache dan mungkin sudah usang atau tidak lengkap. Jika fromCache adalah false, artinya data sudah lengkap dan terkini dengan update yang terbaru di server.

Secara default, tidak ada peristiwa yang dipicu jika hanya SnapshotMetadata yang diubah. Jika Anda mengandalkan nilai fromCache, tentukan opsi pendeteksi includeMetadataChanges saat memasang penangan deteksi Anda.

Web
db.collection("cities").where("state", "==", "CA")
  .onSnapshot({ includeQueryMetadataChanges: true }, function(snapshot) {
      snapshot.docChanges.forEach(function(change) {
          if (change.type === "added") {
              console.log("New city: ", change.doc.data());
          }

          var source = snapshot.metadata.fromCache ? "local cache" : "server";
          console.log("Data came from " + source);
      });
  });
 
Android
db.collection("cities").whereEqualTo("state", "CA")
        .addSnapshotListener(new EventListener<QuerySnapshot>() {
            @Override
            public void onEvent(@Nullable QuerySnapshot querySnapshot,
                                @Nullable FirebaseFirestoreException e) {
                if (e != null) {
                    Log.w(TAG, "Listen error", e);
                    return;
                }

                for (DocumentChange change : querySnapshot.getDocumentChanges()) {
                    if (change.getType() == Type.ADDED) {
                        Log.d(TAG, "New city:" + change.getDocument().getData());
                    }

                    String source = querySnapshot.getMetadata().isFromCache() ?
                            "local cache" : "server";
                    Log.d(TAG, "Data fetched from " + source);
                }

            }
        });
Swift
// Listen to metadata updates to receive a server snapshot even if
// the data is the same as the cached data.
let options = QueryListenOptions()
options.includeQueryMetadataChanges(true)

db.collection("cities").whereField("state", isEqualTo: "CA")
    .addSnapshotListener(options: options) { querySnapshot, error in
        guard let snapshot = querySnapshot else {
            print("Error retreiving snapshot: \(error!)")
            return
        }

        for diff in snapshot.documentChanges {
            if diff.type == .added {
                print("New city: \(diff.document.data())")
            }
        }

        let source = snapshot.metadata.isFromCache ? "local cache" : "server"
        print("Metadata: Data fetched from \(source)")
}
Objective-C
// Listen to metadata updates to receive a server snapshot even if
// the data is the same as the cached data.
FIRQueryListenOptions *options = [FIRQueryListenOptions options];
[options includeQueryMetadataChanges:YES];
[[[db collectionWithPath:@"cities"] queryWhereField:@"state" isEqualTo:@"CA"]
    addSnapshotListenerWithOptions:options
    listener:^(FIRQuerySnapshot *snapshot, NSError *error) {
      if (snapshot == nil) {
        NSLog(@"Error retreiving snapshot: %@", error);
        return;
      }
      for (FIRDocumentChange *diff in snapshot.documentChanges) {
        if (diff.type == FIRDocumentChangeTypeAdded) {
          NSLog(@"New city: %@", diff.document.data);
        }
      }

      NSString *source = snapshot.metadata.isFromCache ? @"local cache" : @"server";
      NSLog(@"Metadata: Data fetched from %@", source);
    }];
  

Mendapatkan data offline

Jika Anda mendapatkan dokumen saat perangkat sedang offline, Cloud Firestore akan menampilkan data dari cache. Jika cache tidak berisi data untuk dokumen tersebut, atau dokumen tidak ada, panggilan 'get' akan menampilkan error.

Membuat kueri data offline

Pembuatan kueri berfungsi dengan persistensi data offline. Anda dapat mengambil hasil pembuatan kueri dengan cara mendapatkannya secara langsung atau dengan mendeteksinya, seperti yang dijelaskan di bagian sebelumnya. Anda juga dapat membuat kueri baru pada data yang disimpan secara lokal saat perangkat sedang offline, namun pada awalnya pembuatan kueri hanya akan berjalan pada dokumen yang disimpan dalam cache.