Включение автономных возможностей на Android

Приложения Firebase работают, даже если ваше приложение временно теряет сетевое соединение. Кроме того, Firebase предоставляет инструменты для локального сохранения данных, управления присутствием и обработки задержек.

Сохранение данных на диске

Приложения Firebase автоматически обрабатывают временные сбои в работе сети. Кэшированные данные доступны в автономном режиме, а Firebase повторно отправляет любые записи при восстановлении сетевого подключения.

При включении сохранения на диске ваше приложение записывает данные локально на устройство, чтобы приложение могло сохранять свое состояние в автономном режиме, даже если пользователь или операционная система перезапускают приложение.

Вы можете включить сохранение данных на диске с помощью всего одной строки кода.

Kotlin

Firebase.database.setPersistenceEnabled(true)
OfflineActivity.kt

Java

FirebaseDatabase.getInstance().setPersistenceEnabled(true);
OfflineActivity.java

Поведение настойчивости

При включении сохранения любые данные, которые клиент Firebase Realtime Database будет синхронизировать в режиме онлайн, сохраняются на диске и доступны в автономном режиме, даже если пользователь или операционная система перезапускают приложение. Это означает, что ваше приложение работает так же, как и в режиме онлайн, используя локальные данные, хранящиеся в кэше. Обратные вызовы прослушивателя будут продолжать срабатывать для локальных обновлений.

Клиент Firebase Realtime Database автоматически сохраняет очередь всех операций записи, которые выполняются, пока ваше приложение находится в автономном режиме. Когда сохранение включено, эта очередь также сохраняется на диске, поэтому все ваши записи доступны, когда пользователь или операционная система перезапускают приложение. Когда приложение восстанавливает подключение, все операции отправляются на сервер Firebase Realtime Database .

Если ваше приложение использует Firebase Authentication , клиент Firebase Realtime Database сохраняет токен аутентификации пользователя при перезапусках приложения. Если токен аутентификации истекает, когда ваше приложение находится в автономном режиме, клиент приостанавливает операции записи до тех пор, пока ваше приложение повторно не аутентифицирует пользователя, в противном случае операции записи могут завершиться ошибкой из-за правил безопасности.

Поддержание актуальности данных

Firebase Realtime Database синхронизирует и хранит локальную копию данных для активных слушателей. Кроме того, вы можете синхронизировать определенные местоположения.

Kotlin

val scoresRef = Firebase.database.getReference("scores")
scoresRef.keepSynced(true)
OfflineActivity.kt

Java

DatabaseReference scoresRef = FirebaseDatabase.getInstance().getReference("scores");
scoresRef.keepSynced(true);
OfflineActivity.java

Клиент Firebase Realtime Database автоматически загружает данные в эти расположения и синхронизирует их, даже если у ссылки нет активных слушателей. Вы можете отключить синхронизацию с помощью следующей строки кода.

Kotlin

scoresRef.keepSynced(false)
OfflineActivity.kt

Java

scoresRef.keepSynced(false);
OfflineActivity.java

По умолчанию кэшируются 10 МБ ранее синхронизированных данных. Этого должно быть достаточно для большинства приложений. Если кэш превышает заданный размер, Firebase Realtime Database очищает данные, которые использовались реже всего. Данные, которые поддерживаются в синхронизации, не очищаются из кэша.

Запрос данных в автономном режиме

Firebase Realtime Database хранит данные, возвращаемые запросом, для использования в автономном режиме. Для запросов, созданных в автономном режиме, Firebase Realtime Database продолжает работать с ранее загруженными данными. Если запрошенные данные не были загружены, Firebase Realtime Database загружает данные из локального кэша. Когда сетевое подключение снова станет доступно, данные загрузятся и будут отражать запрос.

Например, этот код запрашивает последние четыре элемента в Firebase Realtime Database с оценками.

Kotlin

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

Java

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

Предположим, что пользователь теряет соединение, переходит в автономный режим и перезапускает приложение. Пока приложение находится в автономном режиме, оно запрашивает последние два элемента из того же местоположения. Этот запрос успешно вернет последние два элемента, поскольку приложение загрузило все четыре элемента в запросе выше.

Kotlin

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

Java

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

В предыдущем примере клиент Firebase Realtime Database вызывает события «child added» для двух динозавров с наивысшим рейтингом, используя сохраняемый кэш. Но он не вызовет событие «value», поскольку приложение никогда не выполняло этот запрос в режиме онлайн.

Если бы приложение запросило последние шесть элементов в автономном режиме, оно бы сразу получило события «child added» для четырех кэшированных элементов. Когда устройство снова подключается к сети, клиент Firebase Realtime Database синхронизируется с сервером и получает последние два события «child added» и «value» для приложения.

Обработка транзакций в автономном режиме

Любые транзакции, которые выполняются, пока приложение находится в автономном режиме, ставятся в очередь. Как только приложение восстанавливает сетевое подключение, транзакции отправляются на сервер Realtime Database .

Транзакции не сохраняются при перезапуске приложения.

Даже при включенном сохранении транзакции не сохраняются при перезапуске приложения. Поэтому вы не можете полагаться на то, что транзакции, выполненные в автономном режиме, будут зафиксированы в вашей Firebase Realtime Database . Чтобы обеспечить наилучший пользовательский опыт, ваше приложение должно показывать, что транзакция еще не сохранена в вашей Firebase Realtime Database , или убедиться, что ваше приложение запоминает их вручную и выполняет снова после перезапуска приложения.

Firebase Realtime Database имеет множество функций для работы с офлайн-сценариями и сетевым подключением. Остальная часть этого руководства применима к вашему приложению независимо от того, включено ли у вас сохранение.

Управление присутствием

В приложениях реального времени часто бывает полезно определять, когда клиенты подключаются и отключаются. Например, вы можете захотеть пометить пользователя как «офлайн», когда его клиент отключается.

Клиенты Firebase Database предоставляют простые примитивы, которые можно использовать для записи в базу данных, когда клиент отключается от серверов Firebase Database. Эти обновления происходят независимо от того, отключается ли клиент чисто или нет, поэтому вы можете положиться на них для очистки данных, даже если соединение разорвано или клиент завис. Все операции записи, включая настройку, обновление и удаление, можно выполнять при отключении.

Вот простой пример записи данных при отключении с использованием примитива onDisconnect :

Kotlin

val presenceRef = Firebase.database.getReference("disconnectmessage")
// Write a string when this client loses connection
presenceRef.onDisconnect().setValue("I disconnected!")
OfflineActivity.kt

Java

DatabaseReference presenceRef = FirebaseDatabase.getInstance().getReference("disconnectmessage");
// Write a string when this client loses connection
presenceRef.onDisconnect().setValue("I disconnected!");
OfflineActivity.java

Как работает onDisconnect

Когда вы устанавливаете операцию onDisconnect() , операция находится на сервере Firebase Realtime Database . Сервер проверяет безопасность, чтобы убедиться, что пользователь может выполнить запрошенное событие записи, и сообщает вашему приложению, если оно недействительно. Затем сервер отслеживает соединение. Если в какой-либо момент время ожидания соединения истекло или оно активно закрыто клиентом Realtime Database , сервер проверяет безопасность во второй раз (чтобы убедиться, что операция все еще действительна), а затем вызывает событие.

Ваше приложение может использовать обратный вызов при операции записи, чтобы убедиться, что onDisconnect был правильно присоединен:

Kotlin

presenceRef.onDisconnect().removeValue { error, reference ->
    error?.let {
        Log.d(TAG, "could not establish onDisconnect event: ${error.message}")
    }
}
OfflineActivity.kt

Java

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

Событие onDisconnect также можно отменить, вызвав .cancel() :

Kotlin

val onDisconnectRef = presenceRef.onDisconnect()
onDisconnectRef.setValue("I disconnected")
// ...
// some time later when we change our minds
// ...
onDisconnectRef.cancel()
OfflineActivity.kt

Java

OnDisconnect onDisconnectRef = presenceRef.onDisconnect();
onDisconnectRef.setValue("I disconnected");
// ...
// some time later when we change our minds
// ...
onDisconnectRef.cancel();
OfflineActivity.java

Определение состояния соединения

Для многих функций, связанных с присутствием, вашему приложению полезно знать, когда оно находится в сети или офлайн. Firebase Realtime Database предоставляет специальное местоположение в /.info/connected , которое обновляется каждый раз, когда состояние подключения клиента Firebase Realtime Database изменяется. Вот пример:

Kotlin

val connectedRef = Firebase.database.getReference(".info/connected")
connectedRef.addValueEventListener(object : ValueEventListener {
    override fun onDataChange(snapshot: DataSnapshot) {
        val connected = snapshot.getValue(Boolean::class.java) ?: false
        if (connected) {
            Log.d(TAG, "connected")
        } else {
            Log.d(TAG, "not connected")
        }
    }

    override fun onCancelled(error: DatabaseError) {
        Log.w(TAG, "Listener was cancelled")
    }
})
OfflineActivity.kt

Java

DatabaseReference connectedRef = FirebaseDatabase.getInstance().getReference(".info/connected");
connectedRef.addValueEventListener(new ValueEventListener() {
    @Override
    public void onDataChange(@NonNull DataSnapshot snapshot) {
        boolean connected = snapshot.getValue(Boolean.class);
        if (connected) {
            Log.d(TAG, "connected");
        } else {
            Log.d(TAG, "not connected");
        }
    }

    @Override
    public void onCancelled(@NonNull DatabaseError error) {
        Log.w(TAG, "Listener was cancelled");
    }
});
OfflineActivity.java

/.info/connected — это логическое значение, которое не синхронизируется между клиентами Realtime Database , поскольку значение зависит от состояния клиента. Другими словами, если один клиент считывает /.info/connected как false, это не гарантирует, что другой клиент также считывает false.

На Android Firebase автоматически управляет состоянием соединения, чтобы сократить пропускную способность и использование батареи. Когда у клиента нет активных слушателей, нет ожидающих операций записи или onDisconnect и он явно не отключен методом goOffline , Firebase закрывает соединение после 60 секунд бездействия.

Обработка задержек

Временные метки сервера

Серверы Firebase Realtime Database предоставляют механизм для вставки временных меток, сгенерированных на сервере, в качестве данных. Эта функция в сочетании с onDisconnect обеспечивает простой способ надежного запоминания времени отключения клиента Realtime Database :

Kotlin

val userLastOnlineRef = Firebase.database.getReference("users/joe/lastOnline")
userLastOnlineRef.onDisconnect().setValue(ServerValue.TIMESTAMP)
OfflineActivity.kt

Java

DatabaseReference userLastOnlineRef = FirebaseDatabase.getInstance().getReference("users/joe/lastOnline");
userLastOnlineRef.onDisconnect().setValue(ServerValue.TIMESTAMP);
OfflineActivity.java

Перекос часов

Хотя firebase.database.ServerValue.TIMESTAMP гораздо точнее и предпочтительнее для большинства операций чтения/записи, иногда может быть полезно оценить смещение часов клиента относительно серверов Firebase Realtime Database . Вы можете прикрепить обратный вызов к расположению /.info/serverTimeOffset , чтобы получить значение в миллисекундах, которое клиенты Firebase Realtime Database добавляют к локальному сообщенному времени (время эпохи в миллисекундах) для оценки времени сервера. Обратите внимание, что на точность этого смещения может влиять сетевая задержка, поэтому оно полезно в первую очередь для обнаружения больших (> 1 секунды) расхождений во времени часов.

Kotlin

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

Java

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

Пример приложения присутствия

Объединив операции отключения с мониторингом состояния подключения и временными метками сервера, вы можете создать систему присутствия пользователя. В этой системе каждый пользователь хранит данные в расположении базы данных, чтобы указать, находится ли клиент Realtime Database в сети. Клиенты устанавливают это расположение в значение true, когда они подключаются к сети, и временную метку, когда они отключаются. Эта временная метка указывает последнее время, когда данный пользователь был в сети.

Обратите внимание, что ваше приложение должно поставить операции отключения в очередь до того, как пользователь будет отмечен как находящийся в сети, чтобы избежать состояний гонки в случае, если сетевое соединение клиента будет потеряно до того, как обе команды будут отправлены на сервер.

Вот простая система присутствия пользователя:

Kotlin

// 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
val database = Firebase.database
val myConnectionsRef = database.getReference("users/joe/connections")

// Stores the timestamp of my last disconnect (the last time I was seen online)
val lastOnlineRef = database.getReference("/users/joe/lastOnline")

val connectedRef = database.getReference(".info/connected")
connectedRef.addValueEventListener(object : ValueEventListener {
    override fun onDataChange(snapshot: DataSnapshot) {
        val connected = snapshot.getValue<Boolean>() ?: false
        if (connected) {
            val con = myConnectionsRef.push()

            // When this device disconnects, remove it
            con.onDisconnect().removeValue()

            // When I disconnect, update the last time I was seen online
            lastOnlineRef.onDisconnect().setValue(ServerValue.TIMESTAMP)

            // Add this device to my connections list
            // this value could contain info about the device or a timestamp too
            con.setValue(java.lang.Boolean.TRUE)
        }
    }

    override fun onCancelled(error: DatabaseError) {
        Log.w(TAG, "Listener was cancelled at .info/connected")
    }
})
OfflineActivity.kt

Java

// 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
final FirebaseDatabase database = FirebaseDatabase.getInstance();
final DatabaseReference myConnectionsRef = database.getReference("users/joe/connections");

// Stores the timestamp of my last disconnect (the last time I was seen online)
final DatabaseReference lastOnlineRef = database.getReference("/users/joe/lastOnline");

final DatabaseReference connectedRef = database.getReference(".info/connected");
connectedRef.addValueEventListener(new ValueEventListener() {
    @Override
    public void onDataChange(@NonNull DataSnapshot snapshot) {
        boolean connected = snapshot.getValue(Boolean.class);
        if (connected) {
            DatabaseReference con = myConnectionsRef.push();

            // When this device disconnects, remove it
            con.onDisconnect().removeValue();

            // When I disconnect, update the last time I was seen online
            lastOnlineRef.onDisconnect().setValue(ServerValue.TIMESTAMP);

            // Add this device to my connections list
            // this value could contain info about the device or a timestamp too
            con.setValue(Boolean.TRUE);
        }
    }

    @Override
    public void onCancelled(@NonNull DatabaseError error) {
        Log.w(TAG, "Listener was cancelled at .info/connected");
    }
});
OfflineActivity.java