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

Оптимизируйте свои подборки Сохраняйте и классифицируйте контент в соответствии со своими настройками.

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

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

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

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

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

Kotlin+KTX

Firebase.database.setPersistenceEnabled(true)

Java

FirebaseDatabase.getInstance().setPersistenceEnabled(true);

Стойкое поведение

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

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

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

Сохранение данных в актуальном состоянии

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

Kotlin+KTX

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

Java

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

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

Kotlin+KTX

scoresRef.keepSynced(false)

Java

scoresRef.keepSynced(false);

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

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

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

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

Kotlin+KTX

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

    // ...
})

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

    // ...
});

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

Kotlin+KTX

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

    // ...
})

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

    // ...
});

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

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

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

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

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

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

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

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

Kotlin+KTX

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

Java

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

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

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

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

Kotlin+KTX

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

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

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

Kotlin+KTX

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

Java

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

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

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

Kotlin+KTX

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

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

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

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

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

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

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

Kotlin+KTX

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

Java

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

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

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

Kotlin+KTX

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

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

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

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

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

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

Kotlin+KTX

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

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(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(DatabaseError error) {
        Log.w(TAG, "Listener was cancelled at .info/connected");
    }
});