Włączanie funkcji offline w systemie Android

Zachowanie wytrwałości

Po włączeniu trwałości wszelkie dane, które klient bazy danych czasu rzeczywistego Firebase zsynchronizowałby w trybie online, pozostają na dysku i są dostępne w trybie offline, nawet po ponownym uruchomieniu aplikacji przez użytkownika lub system operacyjny. Oznacza to, że Twoja aplikacja działa tak, jakby działała online, korzystając z danych lokalnych przechowywanych w pamięci podręcznej. Wywołania zwrotne słuchacza będą nadal uruchamiane w przypadku lokalnych aktualizacji.

Klient bazy danych czasu rzeczywistego Firebase automatycznie przechowuje w kolejce wszystkie operacje zapisu, które są wykonywane, gdy aplikacja jest w trybie offline. Gdy trwałość jest włączona, ta kolejka jest również utrwalana na dysku, dzięki czemu wszystkie zapisy są dostępne po ponownym uruchomieniu aplikacji przez użytkownika lub system operacyjny. Gdy aplikacja odzyska łączność, wszystkie operacje są wysyłane na serwer bazy danych czasu rzeczywistego Firebase.

Jeśli Twoja aplikacja korzysta z uwierzytelniania Firebase , klient bazy danych czasu rzeczywistego Firebase zachowuje token uwierzytelniania użytkownika po ponownym uruchomieniu aplikacji. Jeśli token uwierzytelniania wygaśnie, gdy aplikacja jest w trybie offline, klient wstrzymuje operacje zapisu do momentu ponownego uwierzytelnienia użytkownika przez aplikację, w przeciwnym razie operacje zapisu mogą zakończyć się niepowodzeniem z powodu reguł zabezpieczeń.

Utrzymywanie aktualności danych

Baza danych czasu rzeczywistego Firebase synchronizuje i przechowuje lokalną kopię danych aktywnych słuchaczy. Ponadto możesz synchronizować określone lokalizacje.

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

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

Klient bazy danych czasu rzeczywistego Firebase automatycznie pobiera dane w tych lokalizacjach i synchronizuje je, nawet jeśli odwołanie nie ma aktywnych detektorów. Możesz ponownie wyłączyć synchronizację za pomocą następującego wiersza kodu.

scoresRef.keepSynced(false);
OfflineActivity.java

scoresRef.keepSynced(false)
OfflineActivity.kt

Domyślnie buforowane jest 10 MB wcześniej zsynchronizowanych danych. To powinno wystarczyć dla większości aplikacji. Jeśli pamięć podręczna przekroczy skonfigurowany rozmiar, Baza danych czasu rzeczywistego Firebase usuwa dane, które były ostatnio używane. Dane, które są zsynchronizowane, nie są usuwane z pamięci podręcznej.

Odpytywanie danych w trybie offline

Baza danych czasu rzeczywistego Firebase przechowuje dane zwrócone z zapytania do użytku w trybie offline. W przypadku zapytań utworzonych w trybie offline baza danych czasu rzeczywistego Firebase nadal działa dla wcześniej załadowanych danych. Jeśli żądane dane nie zostały załadowane, baza danych czasu rzeczywistego Firebase ładuje dane z lokalnej pamięci podręcznej. Gdy łączność sieciowa będzie ponownie dostępna, dane zostaną załadowane i będą odzwierciedlać zapytanie.

Na przykład ten kod pyta o ostatnie cztery elementy w bazie danych Firebase Realtime zawierającej wyniki

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

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

Załóżmy, że użytkownik traci połączenie, przechodzi w tryb offline i ponownie uruchamia aplikację. W trybie offline aplikacja wysyła zapytanie o dwa ostatnie elementy z tej samej lokalizacji. To zapytanie pomyślnie zwróci dwa ostatnie elementy, ponieważ aplikacja załadowała wszystkie cztery elementy w powyższym zapytaniu.

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

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

W poprzednim przykładzie klient bazy danych czasu rzeczywistego Firebase wywołuje zdarzenia „dodania dziecka” dla dwóch dinozaurów o najwyższym wyniku, korzystając z trwałej pamięci podręcznej. Ale nie wywoła zdarzenia „value”, ponieważ aplikacja nigdy nie wykonała tego zapytania w trybie online.

Jeśli aplikacja zażądałaby ostatnich sześciu elementów w trybie offline, od razu otrzymałaby zdarzenia „dodania dziecka” dla czterech elementów w pamięci podręcznej. Gdy urządzenie wróci do trybu online, klient bazy danych czasu rzeczywistego Firebase synchronizuje się z serwerem i otrzymuje dwa ostatnie zdarzenia „dodania elementów podrzędnych” i „wartość” dla aplikacji.

Obsługa transakcji offline

Wszelkie transakcje wykonywane, gdy aplikacja jest w trybie offline, są umieszczane w kolejce. Gdy aplikacja odzyska łączność z siecią, transakcje są wysyłane do serwera bazy danych czasu rzeczywistego.

Jak działa onDisconnect

Po ustanowieniu operacji onDisconnect() jest ona aktywna na serwerze bazy danych czasu rzeczywistego Firebase. 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 następnie monitoruje połączenie. Jeśli w dowolnym momencie połączenie zostanie przekroczone lub zostanie aktywnie zamknięte przez klienta Realtime Database, serwer ponownie sprawdza zabezpieczenia (aby upewnić się, że operacja jest nadal prawidłowa), a następnie wywołuje zdarzenie.

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

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

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

Zdarzenie onDisconnect można również anulować, wywołując .cancel() :

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

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

Sygnatury czasowe serwera

Serwery bazy danych czasu rzeczywistego Firebase udostępniają mechanizm wstawiania jako danych znaczników czasu wygenerowanych na serwerze. Ta funkcja, w połączeniu z onDisconnect , zapewnia łatwy sposób na niezawodne zapisanie czasu, w którym klient Bazy danych czasu rzeczywistego rozłączył się:

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

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

Przekrzywiony zegar

Chociaż firebase.database.ServerValue.TIMESTAMP jest znacznie dokładniejsza i preferowana w przypadku większości operacji odczytu/zapisu, czasami może być przydatne oszacowanie przesunięcia zegara klienta w odniesieniu do serwerów bazy danych czasu rzeczywistego Firebase. Możesz dołączyć wywołanie zwrotne do lokalizacji /.info/serverTimeOffset , aby uzyskać wartość w milisekundach, którą klienci bazy danych czasu rzeczywistego Firebase dodają do lokalnego czasu raportowania (czas epoki w milisekundach) w celu oszacowania czasu serwera. Należy zauważyć, że na dokładność tego przesunięcia może mieć wpływ opóźnienie sieci, dlatego jest to przydatne przede wszystkim do wykrywania dużych (> 1 sekunda) rozbieżności w czasie zegara.

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

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