Como ativar recursos off-line no Android

Comportamento da persistência

Ao ativar a persistência, quaisquer dados que o cliente do Firebase Realtime Database sincronizar on-line permanecerão no disco e estarão disponíveis off-line, mesmo quando o usuário ou o sistema operacional reiniciar o app. Isso significa que o app funciona como se estivesse on-line usando os dados locais armazenados no cache. As callbacks dos listeners continuam a ser acionados nas 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 app está off-line. Quando a persistência é ativada, essa fila também é mantida no disco para que todas as gravações estejam disponíveis quando o usuário ou o sistema operacional reiniciar o app. Quando o app recupera a conectividade, todas as operações são enviadas ao servidor do Firebase Realtime Database.

Se o app usa o Firebase Authentication, o cliente do Firebase Realtime Database mantém o token de autenticação do usuário entre as reinicializações do app. Se o token de autenticação expirar enquanto o app estiver off-line, o cliente pausará as operações de gravação até o app reautenticar o usuário. Caso contrário, as operações de gravação poderão falhar devido às regras de segurança.

Como manter os dados atualizados

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

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 faz o download automático dos dados nesses locais e os mantém sincronizados, mesmo que a referência não tenha listeners ativos. A sincronização pode ser desativada novamente com a linha de código a seguir.

scoresRef.keepSynced(false)
OfflineActivity.kt

scoresRef.keepSynced(false);
OfflineActivity.java

Por padrão, 10 MB de dados previamente sincronizados são armazenados em cache. Isso é suficiente para a maioria dos apps. Se o cache ultrapassa o tamanho configurado, o Firebase Realtime Database limpa os dados que foram usados menos recentemente. Os dados mantidos em sincronia não são limpos no cache.

Como consultar dados off-line

O Firebase Realtime Database armazena os dados retornados de uma consulta para uso off-line. Nas consultas criadas off-line, o Firebase Realtime Database continua funcionando com os dados já carregados. Se os dados solicitados não foram carregados, o Firebase Realtime Database os carrega do cache local. Quando a conectividade de rede estiver novamente disponível, 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 off-line e reinicie o app. Enquanto está off-line, o app consulta os dois últimos itens no mesmo local. Essa consulta retorna com êxito os dois últimos itens porque o app carregou todos os quatro itens na 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 "child added" para os dois dinossauros com pontuação mais alta usando o cache mantido. Porém, isso não gera um evento value (valor), já que o app nunca executou essa consulta enquanto estava on-line.

Se o app tivesse que solicitar os últimos seis itens enquanto estivesse off-line, ele receberia eventos child added para os quatro itens em cache imediatamente. Quando o dispositivo fica on-line novamente, o cliente do Firebase Realtime Database é sincronizado com o servidor e recebe os dois eventos child added finais e os eventos value para o app.

Como gerenciar transações off-line

Todas as transações que são executadas enquanto o app está off-line são colocadas em fila. Assim que o app recupera a conectividade de rede, as transações são enviadas ao servidor do Realtime Database.

Como o onDisconnect funciona

Quando você estabelece uma operação onDisconnect(), ela fica no servidor do 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 app se ele for inválido. Em seguida, o servidor monitora a conexão. Se, a qualquer momento, o tempo limite da conexão se esgotar ou ela for ativamente encerrada pelo cliente do Realtime Database, o servidor verificará a segurança mais uma vez para garantir que a operação ainda seja válida e, depois, invocará o evento.

O app usa o retorno de chamada na operação de gravação para garantir que o onDisconnect foi corretamente anexado:

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 ao chamar .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/hora do servidor

Os servidores do Firebase Realtime Database têm um mecanismo para inserir carimbos de data/hora gerados no servidor como dados. Combinado com o onDisconnect, esse recurso é uma maneira fácil e segura de armazenar o horário 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

Defasagem horária

Embora firebase.database.ServerValue.TIMESTAMP seja muito mais preciso e indicado para a maioria das operações de leitura/gravação, em algumas situações, é importante estimar a defasagem horária dos clientes em relação aos servidores do Firebase Realtime Database. Anexe um callback ao local /.info/serverTimeOffset para receber o valor, em milissegundos, que os clientes do Firebase Realtime Database adicionam ao horário local informado (tempo de época em milissegundos) para estimar o horário do servidor. A precisão dessa diferença pode ser afetada pela latência da rede. Portanto, ela é útil principalmente para descobrir grandes discrepâncias de mais de um segundo no horário 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