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 Databasezsynchronizowałby w trybie online, są przechowywane na dysku i są 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 danych lokalnych przechowywanych w pamięci podręcznej. W przypadku lokalnych aktualizacji nadal będą wywoływane procedury obsługi wywołań z zewnętrznych źródeł.

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

Jeśli Twoja aplikacja korzysta z usługi Uwierzytelnianie Firebase, klient Firebase Realtime Database przechowuje token uwierzytelniający użytkownika po ponownym uruchomieniu aplikacji. Jeśli token uwierzytelniania wygaśnie, gdy aplikacja jest offline, klient wstrzyma operacje zapisu do czasu ponownego uwierzytelnienia użytkownika. W przeciwnym razie operacje zapisu mogą się nie udać z powodu reguł zabezpieczeń.

Utrzymywanie aktualności danych

Firebase Realtime Database synchronizuje i przechowuje lokalną kopię danych dla aktywnych słuchaczy. Możesz też synchronizować określone 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 utrzymuje je w synchronizacji, nawet jeśli referencja nie ma aktywnych słuchaczy. 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 jest przechowywanych 10 MB wcześniej zsynchronizowanych danych. Powinna to być wystarczająca wartość w większości przypadków. Jeśli rozmiar pamięci podręcznej 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.

Wysyłanie zapytań do danych 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 przypadku wcześniej załadowanych danych. Jeśli żądane dane nie zostały załadowane, Firebase Realtime Database wczyta dane z lokalnej pamięci podręcznej. Gdy połączenie z siecią zostanie przywrócone, dane zostaną załadowane i odzwierciedlą zapytanie.

Ten kod na przykład wypisuje Firebase Realtime Database najnowszych 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 tego samego miejsca. To zapytanie zwróci 2 ostatnie pozycje, ponieważ aplikacja wczytała wszystkie 4 pozycje z zapytania 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 wywołuje zdarzenia „child added” dla 2 dinozaurów z najwyższą liczbą punktów, korzystając z trwałej pamięci podręcznej. Nie wywoła ono jednak zdarzenia „value”, ponieważ aplikacja nigdy nie wykonała tego zapytania w trybie online.

Jeśli aplikacja poprosi o ostatnie 6 elementów w trybie offline, od razu otrzyma zdarzenia „child added” dotyczące 4 elementów z pamięci podręcznej. Gdy urządzenie znów połączy się z internetem, klient Firebase Realtime Database zsynchronizuje się z serwerem i otrzyma w aplikacji 2 ostateczne zdarzenia „child added” i „value”.

Obsługa transakcji offline

Wszystkie transakcje przeprowadzane, gdy aplikacja jest offline, są umieszczane w kolejce. Gdy aplikacja ponownie nawiąże połączenie z internetem, transakcje zostaną wysłane do serwera 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. Następnie serwer monitoruje połączenie. Jeśli w jakimś momencie połączenie zostanie przerwane lub klient Realtime Database zamknie je aktywnie, serwer sprawdza zabezpieczenia po raz drugi (aby upewnić się, że operacja jest nadal ważna), a następnie wywołuje zdarzenie.

Aplikacja może użyć wywołania zwrotnego 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

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 zapisywanie informacji o czasie odłą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

Zniekształcenie zegara

Funkcja firebase.database.ServerValue.TIMESTAMP jest znacznie dokładniejsza i preferowana w przypadku większości operacji odczytu/zapisu, ale czasami może być przydatna do oszacowania odchylenia zegara klienta względem serwerów Firebase Realtime Database. Do lokalizacji /.info/serverTimeOffset możesz dołączyć funkcję wywołania zwrotnego, aby uzyskać wartość w milisekundach, którą klienci Firebase Realtime Database dodają do lokalnego czasu zgłoszonego (czas epoki w milisekundach), aby oszacować czas serwera. Pamiętaj, że dokładność tego przesunięcia może być zależna od opóźnienia w sieci, dlatego jest przydatna głównie do wykrywania dużych (> 1 sekunda) rozbieżności w czasie zegara.

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