Włączanie funkcji offline w systemie Android

Zachowanie trwałości

Włączając trwałość, 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, jak w trybie online, korzystając z lokalnych danych przechowywanych w pamięci podręcznej. Wywołania zwrotne odbiornika będą nadal uruchamiane w celu uzyskania lokalnych aktualizacji.

Klient bazy danych czasu rzeczywistego Firebase automatycznie tworzy kolejkę wszystkich operacji zapisu, które są wykonywane, gdy aplikacja jest offline. Po włączeniu trwałości ta kolejka jest również utrwalana na dysku, dzięki czemu wszystkie zapisy są dostępne, gdy użytkownik lub system operacyjny ponownie uruchomi aplikację. Gdy aplikacja odzyska łączność, wszystkie operacje są wysyłane do serwera Bazy danych czasu rzeczywistego Firebase.

Jeśli Twoja aplikacja korzysta z uwierzytelniania Firebase , klient Bazy danych czasu rzeczywistego Firebase zachowuje token uwierzytelniania użytkownika podczas ponownego uruchamiania aplikacji. Jeśli token uwierzytelniania wygaśnie, gdy aplikacja jest w trybie offline, klient wstrzymuje operacje zapisu do czasu ponownego uwierzytelnienia użytkownika przez aplikację. W przeciwnym razie operacje zapisu mogą zakończyć się niepowodzeniem ze względu na reguły zabezpieczeń.

Utrzymywanie aktualności danych

Baza danych czasu rzeczywistego Firebase synchronizuje i przechowuje lokalną kopię danych dla aktywnych słuchaczy. Ponadto możesz 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 odwołanie nie ma aktywnych słuchaczy. Możesz ponownie wyłączyć synchronizację za pomocą następującego wiersza kodu.

scoresRef.keepSynced(false)
OfflineActivity.kt

scoresRef.keepSynced(false);
OfflineActivity.java

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

Wyszukiwanie danych w trybie offline

Baza danych czasu rzeczywistego Firebase przechowuje dane zwrócone z zapytania do wykorzystania w trybie offline. W przypadku zapytań tworzonych 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 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 ostatnie cztery elementy w bazie danych wyników w czasie rzeczywistym Firebase

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 zapytania 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(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 Bazy danych czasu rzeczywistego Firebase zgłasza zdarzenia „dodania elementu podrzędnego” dla dwóch dinozaurów o najwyższej punktacji, korzystając z utrwalonej pamięci podręcznej. Nie wywoła to jednak zdarzenia „wartość”, ponieważ aplikacja nigdy nie wykonała tego zapytania w trybie online.

Gdyby aplikacja zażądała ostatnich sześciu elementów w trybie offline, od razu otrzymałaby zdarzenia „dodania podrzędnego” dla czterech elementów w pamięci podręcznej. Kiedy urządzenie wraca do trybu online, klient Firebase Realtime Database synchronizuje się z serwerem i pobiera ostatnie dwa zdarzenia „dodane dziecko” 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ść sieciową, transakcje są wysyłane do serwera bazy danych czasu rzeczywistego.

Jak działa onDisconnect

Po ustanowieniu operacji onDisconnect() operacja działa 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 nieprawidłowa. Następnie serwer monitoruje połączenie. Jeśli w dowolnym momencie połączenie przekroczy limit czasu lub zostanie aktywnie zamknięte przez klienta bazy danych czasu rzeczywistego, serwer sprawdza zabezpieczenia po raz drugi (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 podłą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

Zdarzenie onDisconnect można również 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

Znaczniki czasu serwera

Serwery bazy danych czasu rzeczywistego Firebase zapewniają mechanizm wstawiania znaczników czasu generowanych na serwerze jako dane. Ta funkcja, w połączeniu z onDisconnect , zapewnia łatwy sposób niezawodnego zanotowania czasu, w którym klient bazy danych czasu rzeczywistego 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

Przekrzywienie zegara

Podczas gdy firebase.database.ServerValue.TIMESTAMP jest znacznie dokładniejszy i preferowany 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 zgłaszanego czasu (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 ono przydatne przede wszystkim do wykrywania dużych (> 1 sekundy) 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