Firebase: ¿Cómo utilizar observeSingleEventOfType para get los últimos datos del server cuando la persistencia está habilitada?

Realmente disfruto codificar con Firebase. Es un gran backend con una variedad de sets de herramientas diferentes. Pero echo de less una manera simple de verificar una ruta de datos actualizados cuando la persistencia está habilitada. Creo que esto no es una exception, ya que a menudo necesito que mi aplicación actúe de cierta manera según los últimos datos del server, que solo deben leerse una vez.

Usualmente uso observeSingleEventOfType , pero es bastante inútil cuando se habilita la perisistancia, ya que nunca recuperará los últimos datos del server . Lo que no entiendo por qué. Debería haber una opción agregada para omitir el caching local y solo search los datos del server.

Deshabilitar la persistencia resuelve este problema y observeSingleEventOfType funcionará como se esperaba. Pero eso significaría que uno necesita reimplementar todas las capacidades fuera de línea por su count.

Primer escenario:

  // chats contain meta information about the chat like last message and count of unread messages let chatRef = ref.child("chats").child(receiverId).child(chatId) chatRef.observeSingleEventOfType(.Value, withBlock: { (snapshot) -> Void in if !snapshot.exists() { print("snapshot does not exist") // the other side has deleted the chat // now delete all messages and member objects ref.child("messages").child(chatId).setValue(nil) ref.child("members").child(chatId).setValue(nil) } else { print("snapshot exists") } }) 

También probé chatRef.keepSynced(true) antes de observar events sin suerte. Lo que no tiene sentido en todas las situaciones de todos modos:

Segundo escenario:

 func removeOlderMessages() { let dateInThePast = NSDate().addDays(-30).timeIntervalSince1970 * 1000 self.messagesRef.queryOrdenetworkingByChild("timestamp") .queryEndingAtValue(dateInThePast) .observeSingleEventOfType(.Value, withBlock: { (snapshot) -> Void in snapshot.ref.removeValue() }) } 

El uso de keepSynced aquí llevaría a la descarga de todos los posts en messagesRef , que no se desea en absoluto.

Entonces, ¿hay una solución inteligente para estos dos escenarios? Cualquier ayuda es apreciada.

Ok, creo que encontré una solución razonable para ambos escenarios:

Solución para el primer escenario:

Usar transactions Solo funcionarán cuando estés en línea. El bloque de completition devolverá los últimos datos del server.

 self.ref.child("chats").child(receiverId).child(chatId).runTransactionBlock({ (currentData) -> FIRTransactionResult in // Actually do nothing with the retrieved data and re-submit it. return FIRTransactionResult.successWithValue(currentData) }) { (error, success, snapshot) in if let error = error { print(error) return } else if !success || snapshot == nil { return } // snapshot contains the latest server data if !snapshot!.exists() { // the other side has deleted the chat // now delete all messages and member objects print("snapshot doesn't exist. deleting messages and members.") ref.child("messages").child(chatId).setValue(nil) ref.child("members").child(chatId).setValue(nil) } else { print("snapshot exists. not deleting all messages and members.") } } 

La desventaja es que tomará mucho más time recuperar los datos en comparación con observeEventType u observeSingleEventOfType .

Solución para el segundo escenario:

Utilice observeEventType(.Value) . En primer lugar, devolverá los datos del server almacenados en caching y luego, si están disponibles. El observador se puede eliminar después de un intervalo de time establecido con NSTimer .

Con todo, estas soluciones provisionales están bien por ahora, pero una function para omitir el caching local cuando se usa observeSingleEventOfType es indispensable.