Włączanie funkcji offline na urządzeniach z Androidem

Zachowanie trwałości

Włączenie trwałości powoduje, że wszystkie dane, które klient Firebase Realtime Database synchronizuje w trybie online, są zapisywane na dysku i dostępne w trybie offline, nawet gdy użytkownik lub system operacyjny ponownie uruchomi aplikację. Oznacza to, że aplikacja działa tak samo jak w trybie online, korzystając z lokalnych danych przechowywanych w pamięci podręcznej. Wywołania zwrotne odbiornika będą nadal wywoływane w przypadku lokalnych aktualizacji.

Klient Firebase Realtime Database automatycznie utrzymuje kolejkę wszystkich operacji zapisu wykonywanych, gdy aplikacja jest offline. Gdy trwałość jest włączona, ta kolejka jest też zapisywana na dysku, dzięki czemu wszystkie zapisy są dostępne, gdy użytkownik lub system operacyjny ponownie uruchomi aplikację. Gdy aplikacja odzyska połączenie, wszystkie operacje zostaną wysłane na serwer Firebase Realtime Database.

Jeśli Twoja aplikacja korzysta z Uwierzytelniania Firebase, klient Firebase Realtime Database przechowuje token uwierzytelniania użytkownika między ponownymi uruchomieniami aplikacji. Jeśli token uwierzytelniania wygaśnie, gdy aplikacja jest offline, klient wstrzyma operacje zapisu do czasu ponownego uwierzytelnienia użytkownika przez aplikację. W przeciwnym razie operacje zapisu mogą się nie powieść z powodu reguł zabezpieczeń.

Odświeżanie danych

Firebase Realtime Database synchronizuje i przechowuje lokalną kopię danych dla aktywnych słuchaczy. Możesz też synchronizować konkretne lokalizacje.

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

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

Klient Firebase Realtime Database automatycznie pobiera dane z tych lokalizacji i synchronizuje je, nawet jeśli odwołanie nie ma aktywnych odbiorców. Synchronizację możesz ponownie wyłączyć za pomocą tego wiersza kodu:

scoresRef.keepSynced(false)
OfflineActivity.kt

scoresRef.keepSynced(false);
OfflineActivity.java

Domyślnie w pamięci podręcznej przechowywane jest 10 MB wcześniej zsynchronizowanych danych. Powinno to wystarczyć w przypadku większości aplikacji. Jeśli pamięć podręczna przekroczy skonfigurowany rozmiar, Firebase Realtime Database usunie dane, które były używane najrzadziej. Dane, które są synchronizowane, nie są usuwane z pamięci podręcznej.

Tworzenie zapytań o dane offline

Firebase Realtime Database przechowuje dane zwrócone przez zapytanie do użytku w trybie offline. W przypadku zapytań utworzonych w trybie offline funkcja Firebase Realtime Database nadal działa w odniesieniu do wcześniej wczytanych danych. Jeśli żądane dane nie zostały wczytane, Firebase Realtime Database wczytuje dane z lokalnej pamięci podręcznej. Gdy połączenie sieciowe będzie ponownie dostępne, dane zostaną załadowane i będą odzwierciedlać zapytanie.

Na przykład ten kod wysyła zapytanie o 4 ostatnie elementy w Firebase Realtime Database wyników.

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

    // ...
})
OfflineActivity.kt

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

    // ...
});
OfflineActivity.java

Załóżmy, że użytkownik traci połączenie, przechodzi w tryb offline i ponownie uruchamia aplikację. W trybie offline aplikacja wysyła zapytanie o 2 ostatnie elementy z tej samej lokalizacji. To zapytanie zwróci 2 ostatnie elementy, ponieważ aplikacja wczytała wszystkie 4 elementy w zapytaniu powyżej.

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

    // ...
})
OfflineActivity.kt

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

    // ...
});
OfflineActivity.java

W powyższym przykładzie klient Firebase Realtime Database zgłasza zdarzenia „dodano element podrzędny” w przypadku 2 dinozaurów z najwyższymi wynikami, korzystając z utrwalonego bufora. Nie wywoła jednak zdarzenia „value”, ponieważ aplikacja nigdy nie wykonała tego zapytania w trybie online.

Jeśli aplikacja poprosi o 6 ostatnich elementów w trybie offline, od razu otrzyma zdarzenia „dodano dziecko” dla 4 elementów w pamięci podręcznej. Gdy urządzenie wró do trybu online, klient Firebase Realtime Database zsynchronizuje się z serwerem i otrzyma 2 ostateczne zdarzenia „child added” oraz zdarzenie „value” dla aplikacji.

Obsługa transakcji offline

Wszystkie transakcje przeprowadzane w trybie offline są umieszczane w kolejce. Gdy aplikacja ponownie nawiąże połączenie z siecią, transakcje zostaną wysłane na serwer Realtime Database.

Jak działa funkcja onDisconnect

Gdy utworzysz operację onDisconnect(), będzie ona przechowywana na serwerze Firebase Realtime Database. Serwer sprawdza zabezpieczenia, aby upewnić się, że użytkownik może wykonać żądane zdarzenie zapisu, i informuje aplikację, czy jest ono nieprawidłowe. Serwer monitoruje połączenie. Jeśli w dowolnym momencie połączenie zostanie przerwane lub aktywnie zamknięte przez klienta Realtime Database, serwer po raz drugi sprawdzi bezpieczeństwo (aby upewnić się, że operacja jest nadal ważna), a następnie wywoła zdarzenie.

Aplikacja może używać wywołania zwrotnego w operacji zapisu, aby upewnić się, że onDisconnect został prawidłowo dołączony:

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

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

onDisconnect Wydarzenie można też anulować, dzwoniąc pod numer .cancel():

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

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

Sygnatury czasowe serwera

Serwery Firebase Realtime Database umożliwiają wstawianie sygnatur czasowych generowanych na serwerze jako danych. Ta funkcja w połączeniu z onDisconnect umożliwia łatwe i wiarygodne zapisywanie czasu, w którym klient Realtime Database rozłączył się:

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

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

Clock Skew

Chociaż firebase.database.ServerValue.TIMESTAMP jest znacznie dokładniejszy i preferowany w przypadku większości operacji odczytu i zapisu, czasami może być przydatne oszacowanie odchylenia zegara klienta względem serwerów Firebase Realtime Database. Możesz dołączyć wywołanie zwrotne do lokalizacji /.info/serverTimeOffset, aby uzyskać wartość w milisekundach, którą Firebase Realtime DatabaseklientyFirebase Realtime Database dodają do lokalnego zgłoszonego czasu (czas epoki w milisekundach), aby oszacować czas serwera. Pamiętaj, że na dokładność tego przesunięcia może wpływać opóźnienie sieci, dlatego jest ono przydatne głównie do wykrywania dużych (powyżej 1 sekundy) rozbieżności w czasie zegarowym.

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")
    }
})
OfflineActivity.kt

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");
    }
});
OfflineActivity.java