Funzionalità offline sulle piattaforme Apple

Le applicazioni Firebase funzionano anche se l'app perde temporaneamente la connessione di rete. Inoltre, Firebase fornisce strumenti per rendere persistenti i dati in locale, gestire la presenza e gestire la latenza.

Persistenza su disco

Le app Firebase gestiscono automaticamente le interruzioni temporanee della rete. I dati memorizzati nella cache sono disponibili offline e Firebase invia nuovamente tutte le scritture quando viene ripristinata la connettività di rete.

Quando abiliti la persistenza su disco, l'app scrive i dati localmente sul dispositivo in modo che possa mantenere lo stato offline, anche se l'utente o il sistema operativo riavvia l'app.

Puoi abilitare la persistenza su disco con una sola riga di codice.

Swift

Nota: questo prodotto Firebase non è disponibile per la destinazione App Clip.

Database.database().isPersistenceEnabled = true

Objective-C

Nota: questo prodotto Firebase non è disponibile per la destinazione App Clip.

[FIRDatabase database].persistenceEnabled = YES;

Comportamento della persistenza

Se abiliti la persistenza, tutti i dati che il client Firebase Realtime Database sincronizzerebbe online vengono resi persistenti su disco e sono disponibili offline, anche quando l'utente o il sistema operativo riavvia l'app. Ciò significa che l'app funziona come se fosse online utilizzando i dati locali memorizzati nella cache. I callback dei listener continueranno a essere attivati per gli aggiornamenti locali.

Il client Firebase Realtime Database mantiene automaticamente una coda di tutte le operazioni di scrittura eseguite mentre l'app è offline. Quando la persistenza è abilitata, questa coda viene resa persistente anche su disco, in modo che tutte le scritture siano disponibili quando l'utente o il sistema operativo riavvia l'app. Quando l'app riacquista la connettività, tutte le operazioni vengono inviate al Firebase Realtime Database server.

Se l'app utilizza Firebase Authentication, il client Firebase Realtime Database rende persistente il token di autenticazione dell'utente durante i riavvii dell'app. Se il token di autenticazione scade mentre l'app è offline, il client mette in pausa le operazioni di scrittura finché l'app non autentica di nuovo l'utente. In caso contrario, le operazioni di scrittura potrebbero non riuscire a causa delle regole di sicurezza.

Mantenere i dati aggiornati

Il Firebase Realtime Database sincronizza e archivia una copia locale dei dati per i listener attivi. Inoltre, puoi mantenere sincronizzate posizioni specifiche in sync.

Swift

Nota: questo prodotto Firebase non è disponibile per la destinazione App Clip.

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

Objective-C

Nota: questo prodotto Firebase non è disponibile per la destinazione App Clip.

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

Il client Firebase Realtime Database scarica automaticamente i dati in queste posizioni e li mantiene sincronizzati anche se il riferimento non ha listener attivi. Puoi disattivare di nuovo la sincronizzazione con la seguente riga di codice.

Swift

Nota: questo prodotto Firebase non è disponibile per la destinazione App Clip.

scoresRef.keepSynced(false)

Objective-C

Nota: questo prodotto Firebase non è disponibile per la destinazione App Clip.

[scoresRef keepSynced:NO];

Per impostazione predefinita, vengono memorizzati nella cache 10 MB di dati sincronizzati in precedenza. Questa quantità dovrebbe essere sufficiente per la maggior parte delle applicazioni. Se la cache supera le dimensioni configurate, i Firebase Realtime Database eliminano i dati utilizzati meno di recente. I dati mantenuti sincronizzati non vengono eliminati dalla cache.

Eseguire query sui dati offline

Il Firebase Realtime Database archivia i dati restituiti da una query per l'utilizzo offline. Per le query create offline, il Firebase Realtime Database continua a funzionare per i dati caricati in precedenza. Se i dati richiesti non sono stati caricati, il Firebase Realtime Database carica i dati dalla cache locale. Quando la connettività di rete è di nuovo disponibile, i dati vengono caricati e rifletteranno la query.

Ad esempio, questo codice esegue una query sugli ultimi quattro elementi in un Firebase Realtime Database di punteggi

Swift

Nota: questo prodotto Firebase non è disponibile per la destinazione App Clip.

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")")
}

Objective-C

Nota: questo prodotto Firebase non è disponibile per la destinazione App Clip.

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);
    }];

Supponiamo che l'utente perda la connessione, vada offline e riavvii l'app. Mentre è ancora offline, l'app esegue una query sugli ultimi due elementi della stessa posizione. Questa query restituirà correttamente gli ultimi due elementi perché l'app aveva caricato tutti e quattro gli elementi nella query precedente.

Swift

Nota: questo prodotto Firebase non è disponibile per la destinazione App Clip.

scoresRef.queryOrderedByValue().queryLimited(toLast: 2).observe(.childAdded) { snapshot in
  print("The \(snapshot.key) dinosaur's score is \(snapshot.value ?? "null")")
}

Objective-C

Nota: questo prodotto Firebase non è disponibile per la destinazione App Clip.

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

Nell'esempio precedente, il Firebase Realtime Database client genera eventi "child added" per i due dinosauri con il punteggio più alto utilizzando la cache persistente. Tuttavia, non genererà un evento "value", perché l'app non ha mai eseguito questa query online.

Se l'app dovesse richiedere gli ultimi sei elementi offline, riceverebbe gli eventi "child added" per i quattro elementi memorizzati nella cache. Quando il dispositivo torna online, il Firebase Realtime Database client si sincronizza con il server e riceve gli ultimi due eventi "child added" e l' evento "value" per l'app.

Gestire le transazioni offline

Tutte le transazioni eseguite mentre l'app è offline vengono messe in coda. Una volta che l'app riacquista la connettività di rete, le transazioni vengono inviate al server Realtime Database.

Le transazioni non vengono rese persistenti durante i riavvii dell'app

Anche con la persistenza abilitata, le transazioni non vengono rese persistenti durante i riavvii dell'app. Pertanto, non puoi fare affidamento sul fatto che le transazioni eseguite offline vengano eseguite nel tuo Firebase Realtime Database. Per offrire la migliore esperienza utente, l'app deve mostrare che una transazione non è ancora stata salvata in Firebase Realtime Database oppure assicurarsi che l'app le ricordi manualmente e le esegua di nuovo dopo il riavvio.

Il Firebase Realtime Database offre molte funzionalità per gestire gli scenari offline e la connettività di rete. Il resto di questa guida si applica a alla tua app indipendentemente dal fatto che tu abbia abilitato o meno la persistenza.

Gestire la presenza

Nelle applicazioni in tempo reale è spesso utile rilevare quando i client si connettono e si disconnettono. Ad esempio, potresti voler contrassegnare un utente come "offline" quando il suo client si disconnette.

I client di Firebase Database forniscono primitive semplici che puoi utilizzare per scrivere nel database quando un client si disconnette dai server di Firebase Database. Questi aggiornamenti si verificano indipendentemente dal fatto che il client si disconnetta correttamente o meno, quindi puoi fare affidamento su di essi per liberare spazio anche se una connessione viene interrotta o un client si arresta in modo anomalo. È possibile eseguire tutte le operazioni di scrittura, inclusi impostazione, aggiornamento e rimozione, in caso di disconnessione.

Ecco un semplice esempio di scrittura dei dati in caso di disconnessione utilizzando la onDisconnect primitiva:

Swift

Nota: questo prodotto Firebase non è disponibile per la destinazione App Clip.

let presenceRef = Database.database().reference(withPath: "disconnectmessage");
// Write a string when this client loses connection
presenceRef.onDisconnectSetValue("I disconnected!")

Objective-C

Nota: questo prodotto Firebase non è disponibile per la destinazione App Clip.

FIRDatabaseReference *presenceRef = [[FIRDatabase database] referenceWithPath:@"disconnectmessage"];
// Write a string when this client loses connection
[presenceRef onDisconnectSetValue:@"I disconnected!"];

Come funziona onDisconnect

Quando stabilisci un'operazione onDisconnect(), l'operazione risiede sul server Firebase Realtime Database. Il server controlla la sicurezza per assicurarsi che l'utente possa eseguire l'evento di scrittura richiesto e informa l'app se non è valido. Il server monitora quindi la connessione. Se in un determinato momento la connessione va in timeout o viene chiusa attivamente dal client Realtime Database, il server controlla di nuovo la sicurezza (per assicurarsi che l'operazione sia ancora valida) e poi richiama l'evento.

L'app può utilizzare il callback sull'operazione di scrittura per assicurarsi che onDisconnect sia stato collegato correttamente:

Swift

Nota: questo prodotto Firebase non è disponibile per la destinazione App Clip.

presenceRef.onDisconnectRemoveValue { error, reference in
  if let error = error {
    print("Could not establish onDisconnect event: \(error)")
  }
}

Objective-C

Nota: questo prodotto Firebase non è disponibile per la destinazione App Clip.

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

Un evento onDisconnect può essere annullato anche chiamando .cancel():

Swift

Nota: questo prodotto Firebase non è disponibile per la destinazione App Clip.

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

Objective-C

Nota: questo prodotto Firebase non è disponibile per la destinazione App Clip.

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

Rilevare lo stato della connessione

Per molte funzionalità correlate alla presenza, è utile che l'app sappia quando è online o offline. Firebase Realtime Database fornisce una posizione speciale in /.info/connected che viene aggiornata ogni volta che lo stato della connessione del client Firebase Realtime Database cambia. Ecco un esempio:

Swift

Nota: questo prodotto Firebase non è disponibile per la destinazione App Clip.

let connectedRef = Database.database().reference(withPath: ".info/connected")
connectedRef.observe(.value, with: { snapshot in
  if snapshot.value as? Bool ?? false {
    print("Connected")
  } else {
    print("Not connected")
  }
})

Objective-C

Nota: questo prodotto Firebase non è disponibile per la destinazione App Clip.

FIRDatabaseReference *connectedRef = [[FIRDatabase database] referenceWithPath:@".info/connected"];
[connectedRef observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
  if([snapshot.value boolValue]) {
    NSLog(@"connected");
  } else {
    NSLog(@"not connected");
  }
}];

/.info/connected è un valore booleano che non viene sincronizzato tra i client Realtime Database perché il valore dipende dallo stato del client. In altre parole, se un client legge /.info/connected come false, non è garantito che un client separato leggerà anche false.

Gestire la latenza

Timestamp del server

I server Firebase Realtime Database forniscono un meccanismo per inserire i timestamp generati sul server come dati. Questa funzionalità, combinata con onDisconnect, offre un modo semplice per annotare in modo affidabile l'ora in cui un Realtime Database client si è disconnesso:

Swift

Nota: questo prodotto Firebase non è disponibile per la destinazione App Clip.

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

Objective-C

Nota: questo prodotto Firebase non è disponibile per la destinazione App Clip.

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

Sfasatura dell'orologio

Sebbene firebase.database.ServerValue.TIMESTAMP sia molto più preciso e preferibile per la maggior parte delle operazioni di lettura/scrittura, a volte può essere utile stimare la sfasatura dell'orologio del client rispetto ai server Firebase Realtime Database. Puoi collegare un callback alla posizione /.info/serverTimeOffset per ottenere il valore, in millisecondi, che i client aggiungono all'ora locale segnalata (ora di epoca in millisecondi) per stimare l'ora del server.Firebase Realtime Database Tieni presente che la precisione di questo offset può essere influenzata dalla latenza di rete, quindi è utile principalmente per rilevare discrepanze di grandi dimensioni (> 1 secondo) nell'ora dell'orologio.

Swift

Nota: questo prodotto Firebase non è disponibile per la destinazione App Clip.

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)")
  }
})

Objective-C

Nota: questo prodotto Firebase non è disponibile per la destinazione App Clip.

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);
}];

App di esempio per la presenza

Combinando le operazioni di disconnessione con il monitoraggio dello stato della connessione e timestamp del server, puoi creare un sistema di presenza degli utenti. In questo sistema, ogni utente archivia i dati in una posizione del database per indicare se un Realtime Database client è online o meno. I client impostano questa posizione su true quando vanno online e un timestamp quando si disconnettono. Questo timestamp indica l'ultima volta che l'utente specificato è stato online.

Tieni presente che l'app deve mettere in coda le operazioni di disconnessione prima che un utente venga contrassegnato come online, per evitare condizioni di race nel caso in cui la connessione di rete del client venga persa prima che entrambi i comandi possano essere inviati al server.

Ecco un semplice sistema di presenza degli utenti:

Swift

Nota: questo prodotto Firebase non è disponibile per la destinazione App Clip.

// since I can connect from multiple devices, we store each connection instance separately
// any time that connectionsRef's value is null (i.e. has no children) I am offline
let myConnectionsRef = Database.database().reference(withPath: "users/morgan/connections")

// stores the timestamp of my last disconnect (the last time I was seen online)
let lastOnlineRef = Database.database().reference(withPath: "users/morgan/lastOnline")

let connectedRef = Database.database().reference(withPath: ".info/connected")

connectedRef.observe(.value, with: { snapshot in
  // only handle connection established (or I've reconnected after a loss of connection)
  guard snapshot.value as? Bool ?? false else { return }

  // add this device to my connections list
  let con = myConnectionsRef.childByAutoId()

  // when this device disconnects, remove it.
  con.onDisconnectRemoveValue()

  // The onDisconnect() call is before the call to set() itself. This is to avoid a race condition
  // where you set the user's presence to true and the client disconnects before the
  // onDisconnect() operation takes effect, leaving a ghost user.

  // this value could contain info about the device or a timestamp instead of just true
  con.setValue(true)

  // when I disconnect, update the last time I was seen online
  lastOnlineRef.onDisconnectSetValue(ServerValue.timestamp())
})

Objective-C

Nota: questo prodotto Firebase non è disponibile per la destinazione App Clip.

// since I can connect from multiple devices, we store each connection instance separately
// any time that connectionsRef's value is null (i.e. has no children) I am offline
FIRDatabaseReference *myConnectionsRef = [[FIRDatabase database] referenceWithPath:@"users/morgan/connections"];

// stores the timestamp of my last disconnect (the last time I was seen online)
FIRDatabaseReference *lastOnlineRef = [[FIRDatabase database] referenceWithPath:@"users/morgan/lastOnline"];

FIRDatabaseReference *connectedRef = [[FIRDatabase database] referenceWithPath:@".info/connected"];
[connectedRef observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
  if([snapshot.value boolValue]) {
    // connection established (or I've reconnected after a loss of connection)

    // add this device to my connections list
    FIRDatabaseReference *con = [myConnectionsRef childByAutoId];

    // when this device disconnects, remove it
    [con onDisconnectRemoveValue];

    // The onDisconnect() call is before the call to set() itself. This is to avoid a race condition
    // where you set the user's presence to true and the client disconnects before the
    // onDisconnect() operation takes effect, leaving a ghost user.

    // this value could contain info about the device or a timestamp instead of just true
    [con setValue:@YES];


    // when I disconnect, update the last time I was seen online
    [lastOnlineRef onDisconnectSetValue:[FIRServerValue timestamp]];
  }
}];