Włączanie funkcji offline w systemie Android

Trwałość Zachowanie

Poprzez umożliwienie wytrwałości, wszelkie dane, które klient Firebase Realtime Database by zsynchronizować gdy ustąpi internetowych na dysku i jest dostępny w trybie offline, nawet gdy użytkownik lub system operacyjny uruchamia ponownie aplikację. Oznacza to, że aplikacja działa tak, że będzie on-line za pomocą lokalnych danych przechowywanych w pamięci podręcznej. callbacks słuchacz nadal ognia lokalnych aktualizacji.

Klient Firebase Realtime Database automatycznie utrzymuje kolejkę wszystkich operacji zapisu, które są wykonywane w czasie, gdy aplikacja jest w trybie offline. Kiedy wytrwałość jest włączona, to kolejka jest również utrzymywały się na dysku więc wszystkich zapisów są dostępne, gdy użytkownik lub system operacyjny uruchamia ponownie aplikację. Gdy aplikacja odzyskuje łączność, wszystkie operacje są wysyłane do serwera Firebase Realtime Database.

Jeśli aplikacja korzysta z uwierzytelniania Firebase klient Firebase Realtime Baza utrzymuje uwierzytelniania użytkownika tokenu całej ponownym uruchomieniu aplikacji. Jeśli auth tokenu wygasa, gdy aplikacja jest w trybie offline, gdy klient wstrzymuje operacje zapisu aż do swojej aplikacji ponownych uwierzytelnia użytkownika, w przeciwnym razie operacje zapisu może się nie powieść ze względu na zasady bezpieczeństwa.

Utrzymywanie danych Fresh

Firebase Realtime bazy danych synchronizuje i przechowuje lokalną kopię danych dla aktywnych słuchaczy. Ponadto, można zachować określone lokalizacje zsynchronizowane.

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

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

Klient Firebase Realtime Database automatycznie pobiera dane w tych miejscach i utrzymuje ją w synchronizacji nawet jeśli odniesienie ma żadnych aktywnych słuchaczy. Można włączyć synchronizację z powrotem wyłączyć za pomocą następującego wiersza kodu.

scoresRef.keepSynced(false);
OfflineActivity.java

scoresRef.keepSynced(false)
OfflineActivity.kt

Domyślnie 10MB wcześniej zsynchronizowanych danych jest buforowane. To powinno być wystarczające dla większości zastosowań. Jeśli bufor przerasta skonfigurowaną wielkość, Baza Firebase Realtime czyści dane, które zostały użyte przynajmniej ostatnio. Dane, które są przechowywane w synchronizacji nie jest usuwany z pamięci podręcznej.

Pobierania danych offline

Dane Firebase Realtime baza danych przechowuje wrócił z zapytaniem do użytku w trybie offline. W przypadku pytań skonstruowanych w trybie offline, Baza Firebase Realtime kontynuuje pracę na wcześniej załadowanych danych. Jeżeli żądane dane nie zostały załadowane na Firebase Realtime obciążenia bazy danych z lokalnej pamięci podręcznej. Gdy łączność sieciowa jest ponownie dostępny, ładunki danych i będzie odzwierciedlać zapytania.

Na przykład, ten kod zapytań w ciągu ostatnich czterech pozycji w bazie danych Firebase Realtime partytur

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 do dwóch ostatnich pozycji z tej samej lokalizacji. To zapytanie zostanie pomyślnie powrócić ostatnie dwie pozycje, ponieważ aplikacja już załadowane wszystkie cztery elementy w kwerendzie powyżej.

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, Firebase Realtime podnosi klienta bazy danych „dziecko dodana” imprezy dla najwyższej punktacji dwóch dinozaurów, używając utrzymywały cache. Ale to nie podniesie zdarzenie „wartość”, ponieważ aplikacja nie została wykonana, że zapytania w trybie online.

Jeśli aplikacja miała zażądać ostatnie sześć pozycji w trybie offline, to get „dziecko” dodaje imprezy dla czterech buforowanych pozycji od razu. Gdy urządzenie powróci do trybu online, klient Firebase Realtime Database synchronizuje się z serwerem i pobiera dwa ostatnie „dziecko dodanej” i „wartości” zdarzenia z aplikacji.

Obsłudze transakcji Offline

Wszelkie transakcje, które są wykonywane podczas gdy aplikacja jest w trybie offline, są ustawiane w kolejce. Gdy odzyskuje łączności sieciowej aplikacji, transakcje są wysyłane do serwera bazy danych w czasie rzeczywistym.

Jak onDisconnect Works

Podczas nawiązywania onDisconnect() operacji, operacja mieszka na serwerze Firebase Realtime Database. Zabezpieczenie serwer sprawdza, aby upewnić się, że użytkownik może wykonać zdarzenie zapisu wniosek i informuje swoją aplikację, jeżeli jest ona nieważna. Następnie serwer monitoruje połączenia. Jeśli w dowolnym momencie czasy połączeń, lub jest aktywnie zamknięty przez klienta w czasie rzeczywistym danych, bezpieczeństwo Serwer sprawdza po raz drugi (aby upewnić się, że operacja jest nadal ważne), a następnie wywołuje zdarzenie.

Twoja aplikacja może użyć wywołania zwrotnego na operację zapisu w celu zapewnienia onDisconnect został prawidłowo podłą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

onDisconnect zdarzenie może być również anulowana przez wywołanie .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

serwer Sygnatury

Serwery Firebase Realtime Database zapewnić mechanizm wstawiania znaczników czasu generowane na serwerze jako danych. Funkcja ta, w połączeniu z onDisconnect , zapewnia łatwy sposób wiarygodny zanotuj czas, w którym klient bazy danych w czasie rzeczywistym odłączonym:

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

Clock Skew

Choć firebase.database.ServerValue.TIMESTAMP jest znacznie bardziej dokładne i odpowiednie dla większości operacji odczytu / zapisu, może czasami być przydatne do oszacowania zegar klienta skośna w stosunku do serwerów bazy danych w czasie rzeczywistym za Firebase. Można dołączyć wywołania zwrotnego do lokalizacji /.info/serverTimeOffset aby uzyskać wartość w milisekundach, że klienci Firebase Realtime Database dodać do lokalnego czasu zgłosił (czas epoki w milisekundach), aby oszacować czas serwera. Zauważ, że to przesunięcie na dokładność może mieć wpływ na opóźnienia w sieci, a więc jest przydatny głównie do odkrywania 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