Habilitando recursos off-line no Android

Comportamento de Persistência

Ao ativar a persistência, todos os dados que o cliente do Firebase Realtime Database sincronizaria enquanto on-line persistiriam no disco e ficariam disponíveis off-line, mesmo quando o usuário ou o sistema operacional reiniciasse o aplicativo. Isso significa que seu aplicativo funciona como funcionaria online, usando os dados locais armazenados no cache. Os retornos de chamada do ouvinte continuarão a ser acionados para atualizações locais.

O cliente do Firebase Realtime Database mantém automaticamente uma fila de todas as operações de gravação executadas enquanto o aplicativo está off-line. Quando a persistência está habilitada, essa fila também é persistida no disco para que todas as suas gravações estejam disponíveis quando o usuário ou sistema operacional reiniciar o aplicativo. Quando o aplicativo recupera a conectividade, todas as operações são enviadas para o servidor Firebase Realtime Database.

Se o seu aplicativo usar o Firebase Authentication , o cliente do Firebase Realtime Database manterá o token de autenticação do usuário durante as reinicializações do aplicativo. Se o token de autenticação expirar enquanto seu aplicativo estiver offline, o cliente pausará as operações de gravação até que seu aplicativo autentica novamente o usuário, caso contrário, as operações de gravação poderão falhar devido a regras de segurança.

Mantendo os dados atualizados

O Firebase Realtime Database sincroniza e armazena uma cópia local dos dados para listeners ativos. Além disso, você pode manter locais específicos sincronizados.

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

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

O cliente do Firebase Realtime Database baixa automaticamente os dados nesses locais e os mantém sincronizados mesmo que a referência não tenha listeners ativos. Você pode desativar a sincronização com a seguinte linha de código.

scoresRef.keepSynced(false)
OfflineActivity.kt

scoresRef.keepSynced(false);
OfflineActivity.java

Por padrão, 10 MB de dados sincronizados anteriormente são armazenados em cache. Isso deve ser suficiente para a maioria das aplicações. Se o cache ultrapassar o tamanho configurado, o Firebase Realtime Database limpará os dados que foram usados ​​menos recentemente. Os dados mantidos sincronizados não são eliminados do cache.

Consultando dados off-line

O Firebase Realtime Database armazena dados retornados de uma consulta para uso off-line. Para consultas construídas off-line, o Firebase Realtime Database continua funcionando para dados carregados anteriormente. Se os dados solicitados não forem carregados, o Firebase Realtime Database carrega os dados do cache local. Quando a conectividade de rede estiver disponível novamente, os dados serão carregados e refletirão a consulta.

Por exemplo, este código consulta os últimos quatro itens em um Firebase Realtime Database de pontuações

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

Suponha que o usuário perca a conexão, fique offline e reinicie o aplicativo. Enquanto ainda está off-line, o aplicativo consulta os dois últimos itens do mesmo local. Esta consulta retornará com êxito os dois últimos itens porque o aplicativo carregou todos os quatro itens da consulta acima.

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

No exemplo anterior, o cliente do Firebase Realtime Database gera eventos 'filho adicionado' para os dois dinossauros com pontuação mais alta, usando o cache persistente. Mas não gerará um evento de 'valor', pois o aplicativo nunca executou essa consulta enquanto estava online.

Se o aplicativo solicitasse os últimos seis itens enquanto estava off-line, ele obteria eventos de 'criança adicionada' para os quatro itens armazenados em cache imediatamente. Quando o dispositivo fica on-line novamente, o cliente do Firebase Realtime Database sincroniza com o servidor e obtém os dois eventos finais de 'filho adicionado' e de 'valor' para o aplicativo.

Tratamento de transações off-line

Todas as transações realizadas enquanto o aplicativo está offline serão enfileiradas. Depois que o aplicativo recuperar a conectividade de rede, as transações serão enviadas ao servidor do Realtime Database.

Como funciona o onDisconnect

Quando você estabelece uma operação onDisconnect() , a operação reside no servidor Firebase Realtime Database. O servidor verifica a segurança para garantir que o usuário possa executar o evento de gravação solicitado e informa ao seu aplicativo se ele for inválido. O servidor então monitora a conexão. Se em algum momento a conexão atingir o tempo limite ou for fechada ativamente pelo cliente do Realtime Database, o servidor verificará a segurança uma segunda vez (para garantir que a operação ainda seja válida) e, em seguida, invocará o evento.

Seu aplicativo pode usar o retorno de chamada na operação de gravação para garantir que onDisconnect foi anexado corretamente:

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

Um evento onDisconnect também pode ser cancelado chamando .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

Carimbos de data e hora do servidor

Os servidores do Firebase Realtime Database fornecem um mecanismo para inserir carimbos de data/hora gerados no servidor como dados. Esse recurso, combinado com onDisconnect , fornece uma maneira fácil de anotar com segurança o momento em que um cliente do Realtime Database se desconectou:

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

Inclinação do relógio

Embora firebase.database.ServerValue.TIMESTAMP seja muito mais preciso e preferível para a maioria das operações de leitura/gravação, ocasionalmente pode ser útil estimar a distorção do relógio do cliente em relação aos servidores do Firebase Realtime Database. Você pode anexar um retorno de chamada ao local /.info/serverTimeOffset para obter o valor, em milissegundos, que os clientes do Firebase Realtime Database adicionam ao horário local relatado (tempo de época em milissegundos) para estimar o horário do servidor. Observe que a precisão desse deslocamento pode ser afetada pela latência da rede e, portanto, é útil principalmente para descobrir grandes discrepâncias (> 1 segundo) no tempo do relógio.

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