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

Zachowanie trwałości

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

Klient Firebase Realtime Database automatycznie utrzymuje kolejkę wszystkich operacji zapisu, które są wykonywane, gdy aplikacja jest offline. Gdy trwałość jest włączona, ta kolejka jest również 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 są wysyłane na serwer Firebase Realtime Database.

Jeśli aplikacja korzysta z Uwierzytelniania Firebase, klient Firebase Realtime Database zachowuje token uwierzytelniania użytkownika po ponownym uruchomieniu aplikacji. Jeśli token uwierzytelniania wygaśnie, gdy aplikacja będzie 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ń.

Aktualizowanie danych

Firebase Realtime Database synchronizuje i przechowuje lokalną kopię danych aktywnych detektorów. 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 nie ma aktywnych detektorów odwołania. Możesz wyłączyć synchronizację za pomocą tego wiersza kodu.

scoresRef.keepSynced(false)
OfflineActivity.kt

scoresRef.keepSynced(false);
OfflineActivity.java

Domyślnie w pamięci podręcznej jest przechowywane 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 najdawniej. Dane, które są synchronizowane, nie są usuwane z pamięci podręcznej.

Zapytania 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 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ą wczytane i będą odzwierciedlać zapytanie.

Na przykład ten kod wysyła zapytanie o ostatnie 4 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 utraci połączenie, przejdzie w tryb offline i ponownie uruchomi aplikację. Aplikacja, nadal w trybie offline, 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 powyższym zapytaniu.

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 poprzednim przykładzie klient Firebase Realtime Database wywołuje zdarzenia „child added” dla 2 dinozaurów z najwyższymi wynikami, korzystając z trwałej pamięci podręcznej. Nie wywoła jednak zdarzenia „value”, ponieważ aplikacja nigdy nie wykonała tego zapytania w trybie online.

Jeśli aplikacja zażąda 6 ostatnich elementów w trybie offline, od razu otrzyma zdarzenia „child added” (dodano element podrzędny) dotyczące 4 elementów z pamięci podręcznej. Gdy urządzenie ponownie połączy się z internetem, klient Firebase Realtime Database zsynchronizuje się z serwerem i otrzyma 2 ostatnie zdarzenia „child added” oraz zdarzenie „value” dla aplikacji.

Obsługa transakcji offline

Wszystkie transakcje wykonywane, gdy aplikacja jest offline, są umieszczane w kolejce. Gdy aplikacja odzyska połączenie sieciowe, transakcje zostaną wysłane na serwer Realtime Database.

Jak działa onDisconnect

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

Aplikacja może użyć wywołania zwrotnego w operacji zapisu, aby upewnić się, że obiekt 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

Wydarzenie onDisconnect można też anulować, wywołując funkcję .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 udostępniają mechanizm wstawiania sygnatur czasowych wygenerowanych na serwerze jako danych. Ta funkcja w połączeniu z onDisconnect umożliwia łatwe i niezawodne odnotowanie czasu rozłączenia klienta Realtime Database:

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

Odchylenie zegara

Chociaż firebase.database.ServerValue.TIMESTAMP jest znacznie dokładniejszy i preferowany w przypadku większości operacji odczytu/zapisu, czasami przydatne może być oszacowanie przesunięcia 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ą klienci Firebase Realtime Database dodają do lokalnego zgłoszonego czasu (czasu epoki w milisekundach), aby oszacować czas serwera. Pamiętaj, że na dokładność tego przesunięcia mogą wpływać opóźnienia sieci, dlatego jest ono przydatne głównie do wykrywania dużych (> 1 sekunda) 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