Buduj obecność w Cloud Firestore

W zależności od typu aplikacji, którą tworzysz, przydatne może być wykrywanie, którzy użytkownicy lub urządzenia są aktywnie online — zwane inaczej wykrywaniem „obecności”.

Na przykład, jeśli tworzysz aplikację, taką jak sieć społecznościowa lub wdrażasz flotę urządzeń IoT, możesz użyć tych informacji do wyświetlenia listy znajomych, którzy są online i mogą swobodnie rozmawiać, lub posortować urządzenia IoT według „ostatnio widzianych ”.

Cloud Firestore nie obsługuje natywnie obecności, ale możesz wykorzystać inne produkty Firebase do zbudowania systemu obecności.

Rozwiązanie: funkcje chmurowe z bazą danych czasu rzeczywistego

Aby połączyć Cloud Firestore z natywną funkcją obecności Firebase Realtime Database, użyj Cloud Functions.

Użyj bazy danych czasu rzeczywistego, aby zgłosić stan połączenia, a następnie użyj Cloud Functions, aby odzwierciedlić te dane w Cloud Firestore.

Korzystanie z obecności w bazie danych czasu rzeczywistego

Najpierw zastanów się, jak działa tradycyjny system obecności w bazie danych czasu rzeczywistego.

// Fetch the current user's ID from Firebase Authentication.
var uid = firebase.auth().currentUser.uid;

// Create a reference to this user's specific status node.
// This is where we will store data about being online/offline.
var userStatusDatabaseRef = firebase.database().ref('/status/' + uid);

// We'll create two constants which we will write to 
// the Realtime database when this device is offline
// or online.
var isOfflineForDatabase = {
    state: 'offline',
    last_changed: firebase.database.ServerValue.TIMESTAMP,
};

var isOnlineForDatabase = {
    state: 'online',
    last_changed: firebase.database.ServerValue.TIMESTAMP,
};

// Create a reference to the special '.info/connected' path in 
// Realtime Database. This path returns `true` when connected
// and `false` when disconnected.
firebase.database().ref('.info/connected').on('value', function(snapshot) {
    // If we're not currently connected, don't do anything.
    if (snapshot.val() == false) {
        return;
    };

    // If we are currently connected, then use the 'onDisconnect()' 
    // method to add a set which will only trigger once this 
    // client has disconnected by closing the app, 
    // losing internet, or any other means.
    userStatusDatabaseRef.onDisconnect().set(isOfflineForDatabase).then(function() {
        // The promise returned from .onDisconnect().set() will
        // resolve as soon as the server acknowledges the onDisconnect() 
        // request, NOT once we've actually disconnected:
        // https://firebase.google.com/docs/reference/js/firebase.database.OnDisconnect

        // We can now safely set ourselves as 'online' knowing that the
        // server will mark us as offline once we lose connection.
        userStatusDatabaseRef.set(isOnlineForDatabase);
    });
});
index.js

Ten przykład to kompletny system obecności Bazy danych czasu rzeczywistego. Obsługuje wiele rozłączeń, awarii i tak dalej.

Łączenie z Cloud Firestore

Aby zaimplementować podobne rozwiązanie w Cloud Firestore, użyj tego samego kodu Realtime Database, a następnie użyj Cloud Functions, aby zapewnić synchronizację Realtime Database i Cloud Firestore.

Jeśli jeszcze tego nie zrobiłeś, dodaj bazę danych czasu rzeczywistego do swojego projektu i dołącz powyższe rozwiązanie do obsługi obecności.

Następnie zsynchronizujesz stan obecności z Cloud Firestore za pomocą następujących metod:

1. Lokalnie, do pamięci podręcznej Cloud Firestore urządzenia offline, aby aplikacja wiedziała, że ​​jest offline.
2. Globalnie, używając funkcji Cloud, aby wszystkie inne urządzenia uzyskujące dostęp do Cloud Firestore wiedziały, że to konkretne urządzenie jest w trybie offline.

Aktualizowanie lokalnej pamięci podręcznej Cloud Firestore

Przyjrzyjmy się zmianom wymaganym do spełnienia pierwszego problemu - aktualizacji lokalnej pamięci podręcznej Cloud Firestore.

// ...
var userStatusFirestoreRef = firebase.firestore().doc('/status/' + uid);

// Firestore uses a different server timestamp value, so we'll 
// create two more constants for Firestore state.
var isOfflineForFirestore = {
    state: 'offline',
    last_changed: firebase.firestore.FieldValue.serverTimestamp(),
};

var isOnlineForFirestore = {
    state: 'online',
    last_changed: firebase.firestore.FieldValue.serverTimestamp(),
};

firebase.database().ref('.info/connected').on('value', function(snapshot) {
    if (snapshot.val() == false) {
        // Instead of simply returning, we'll also set Firestore's state
        // to 'offline'. This ensures that our Firestore cache is aware
        // of the switch to 'offline.'
        userStatusFirestoreRef.set(isOfflineForFirestore);
        return;
    };

    userStatusDatabaseRef.onDisconnect().set(isOfflineForDatabase).then(function() {
        userStatusDatabaseRef.set(isOnlineForDatabase);

        // We'll also add Firestore set here for when we come online.
        userStatusFirestoreRef.set(isOnlineForFirestore);
    });
});
index.js

Dzięki tym zmianom zapewniliśmy, że lokalny stan Cloud Firestore zawsze będzie odzwierciedlał stan online/offline urządzenia. Oznacza to, że możesz odsłuchać dokument /status/{uid} i użyć danych do zmiany interfejsu użytkownika w celu odzwierciedlenia stanu połączenia.

userStatusFirestoreRef.onSnapshot(function(doc) {
    var isOnline = doc.data().state == 'online';
    // ... use isOnline
});
index.js

Globalna aktualizacja Cloud Firestore

Chociaż nasza aplikacja poprawnie zgłasza sama sobie obecność online, ten status nie będzie jeszcze dokładny w innych aplikacjach Cloud Firestore, ponieważ nasz status „offline” jest zapisywany tylko lokalnie i nie zostanie zsynchronizowany po przywróceniu połączenia. Aby temu przeciwdziałać, użyjemy funkcji chmury, która obserwuje ścieżkę status/{uid} w bazie danych czasu rzeczywistego. Gdy wartość Bazy danych czasu rzeczywistego ulegnie zmianie, wartość zostanie zsynchronizowana z Cloud Firestore, dzięki czemu statusy wszystkich użytkowników będą poprawne.

const functions = require('firebase-functions');
const admin = require('firebase-admin');
admin.initializeApp();

// Since this code will be running in the Cloud Functions environment
// we call initialize Firestore without any arguments because it
// detects authentication from the environment.
const firestore = admin.firestore();

// Create a new function which is triggered on changes to /status/{uid}
// Note: This is a Realtime Database trigger, *not* Firestore.
exports.onUserStatusChanged = functions.database.ref('/status/{uid}').onUpdate(
    async (change, context) => {
      // Get the data written to Realtime Database
      const eventStatus = change.after.val();

      // Then use other event data to create a reference to the
      // corresponding Firestore document.
      const userStatusFirestoreRef = firestore.doc(`status/${context.params.uid}`);

      // It is likely that the Realtime Database change that triggered
      // this event has already been overwritten by a fast change in
      // online / offline status, so we'll re-read the current data
      // and compare the timestamps.
      const statusSnapshot = await change.after.ref.once('value');
      const status = statusSnapshot.val();
      functions.logger.log(status, eventStatus);
      // If the current timestamp for this data is newer than
      // the data that triggered this event, we exit this function.
      if (status.last_changed > eventStatus.last_changed) {
        return null;
      }

      // Otherwise, we convert the last_changed field to a Date
      eventStatus.last_changed = new Date(eventStatus.last_changed);

      // ... and write it to Firestore.
      return userStatusFirestoreRef.set(eventStatus);
    });
index.js

Po wdrożeniu tej funkcji będziesz mieć kompletny system obecności działający z Cloud Firestore. Poniżej znajduje się przykład monitorowania wszystkich użytkowników, którzy przechodzą do trybu online lub przechodzą w tryb offline za pomocą zapytania where() .

firebase.firestore().collection('status')
    .where('state', '==', 'online')
    .onSnapshot(function(snapshot) {
        snapshot.docChanges().forEach(function(change) {
            if (change.type === 'added') {
                var msg = 'User ' + change.doc.id + ' is online.';
                console.log(msg);
                // ...
            }
            if (change.type === 'removed') {
                var msg = 'User ' + change.doc.id + ' is offline.';
                console.log(msg);
                // ...
            }
        });
    });
index.js

Ograniczenia

Korzystanie z bazy danych czasu rzeczywistego w celu dodania obecności do aplikacji Cloud Firestore jest skalowalne i efektywne, ale ma pewne ograniczenia:

• Debouncing — podczas nasłuchiwania zmian w czasie rzeczywistym w Cloud Firestore to rozwiązanie może wywołać wiele zmian. Jeśli te zmiany wywołają więcej zdarzeń niż chcesz, ręcznie odrzucaj zdarzenia Cloud Firestore.
• Łączność — ta implementacja mierzy łączność z bazą danych czasu rzeczywistego, a nie z Cloud Firestore. Jeśli stan połączenia z każdą bazą danych nie jest taki sam, to rozwiązanie może zgłaszać nieprawidłowy stan obecności.
• Android — w systemie Android Baza danych czasu rzeczywistego rozłącza się z zapleczem po 60 sekundach braku aktywności. Brak aktywności oznacza brak otwartych słuchaczy lub oczekujących operacji. Aby połączenie było otwarte, zalecamy dodanie detektora zdarzeń wartości do ścieżki oprócz .info/connected . Na przykład możesz wykonać FirebaseDatabase.getInstance().getReference((new Date()).toString()).keepSynced() na początku każdej sesji. Aby uzyskać więcej informacji, zobacz Wykrywanie stanu połączenia .