Recursos off-line nas plataformas da Apple

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.

let scoresRef = Database.database().reference(withPath: "scores")
scoresRef.keepSynced(true)

FIRDatabaseReference *scoresRef = [[FIRDatabase database] referenceWithPath:@"scores"];
[scoresRef keepSynced:YES];

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)

[scoresRef keepSynced:NO];

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:

let scoresRef = Database.database().reference(withPath: "scores")
scoresRef.queryOrderedByValue().queryLimited(toLast: 4).observe(.childAdded) { snapshot in
  print("The \(snapshot.key) dinosaur's score is \(snapshot.value ?? "null")")
}

FIRDatabaseReference *scoresRef = [[FIRDatabase database] referenceWithPath:@"scores"];
[[[scoresRef queryOrderedByValue] queryLimitedToLast:4]
    observeEventType:FIRDataEventTypeChildAdded withBlock:^(FIRDataSnapshot *snapshot) {
      NSLog(@"The %@ dinosaur's score is %@", snapshot.key, snapshot.value);
    }];

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.queryOrderedByValue().queryLimited(toLast: 2).observe(.childAdded) { snapshot in
  print("The \(snapshot.key) dinosaur's score is \(snapshot.value ?? "null")")
}

[[[scoresRef queryOrderedByValue] queryLimitedToLast:2]
    observeEventType:FIRDataEventTypeChildAdded withBlock:^(FIRDataSnapshot *snapshot) {
      NSLog(@"The %@ dinosaur's score is %@", snapshot.key, snapshot.value);
    }];

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.onDisconnectRemoveValue { error, reference in
  if let error = error {
    print("Could not establish onDisconnect event: \(error)")
  }
}

[presenceRef onDisconnectRemoveValueWithCompletionBlock:^(NSError *error, FIRDatabaseReference *reference) {
  if (error != nil) {
    NSLog(@"Could not establish onDisconnect event: %@", error);
  }
}];

Um evento onDisconnect também pode ser cancelado ao chamar .cancel():

presenceRef.onDisconnectSetValue("I disconnected")
// some time later when we change our minds
presenceRef.cancelDisconnectOperations()

[presenceRef onDisconnectSetValue:@"I disconnected"];
// some time later when we change our minds
[presenceRef cancelDisconnectOperations];

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:

let userLastOnlineRef = Database.database().reference(withPath: "users/morgan/lastOnline")
userLastOnlineRef.onDisconnectSetValue(ServerValue.timestamp())

FIRDatabaseReference *userLastOnlineRef = [[FIRDatabase database] referenceWithPath:@"users/morgan/lastOnline"];
[userLastOnlineRef onDisconnectSetValue:[FIRServerValue timestamp]];

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.

let offsetRef = Database.database().reference(withPath: ".info/serverTimeOffset")
offsetRef.observe(.value, with: { snapshot in
  if let offset = snapshot.value as? TimeInterval {
    print("Estimated server time in milliseconds: \(Date().timeIntervalSince1970 * 1000 + offset)")
  }
})

FIRDatabaseReference *offsetRef = [[FIRDatabase database] referenceWithPath:@".info/serverTimeOffset"];
[offsetRef observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
  NSTimeInterval offset = [(NSNumber *)snapshot.value doubleValue];
  NSTimeInterval estimatedServerTimeMs = [[NSDate date] timeIntervalSince1970] * 1000.0 + offset;
  NSLog(@"Estimated server time: %0.3f", estimatedServerTimeMs);
}];