Управление жизненными циклами с помощью компонентов, учитывающих жизненный цикл (Views)

Основные понятия и реализация Jetpack Compose

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

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

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

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

Представьте, что у нас есть действие, которое показывает местоположение устройства на экране. Вот пример реализации:

Kotlin

internal class MyLocationListener(
        private val context: Context,
        private val callback: (Location) -> Unit
) {

    fun start() {
        // connect to system location service
    }

    fun stop() {
        // disconnect from system location service
    }
}

class MyActivity : AppCompatActivity() {
    private lateinit var myLocationListener: MyLocationListener

    override fun onCreate(...) {
        myLocationListener = MyLocationListener(this) { location ->
            // update UI
        }
    }

    public override fun onStart() {
        super.onStart()
        myLocationListener.start()
        // manage other components that need to respond
        // to the activity lifecycle
    }

    public override fun onStop() {
        super.onStop()
        myLocationListener.stop()
        // manage other components that need to respond
        // to the activity lifecycle
    }
}

Java

class MyLocationListener {
    public MyLocationListener(Context context, Callback callback) {
        // ...
    }

    void start() {
        // connect to system location service
    }

    void stop() {
        // disconnect from system location service
    }
}

class MyActivity extends AppCompatActivity {
    private MyLocationListener myLocationListener;

    @Override
    public void onCreate(...) {
        myLocationListener = new MyLocationListener(this, (location) -> {
            // update UI
        });
    }

    @Override
    public void onStart() {
        super.onStart();
        myLocationListener.start();
        // manage other components that need to respond
        // to the activity lifecycle
    }

    @Override
    public void onStop() {
        super.onStop();
        myLocationListener.stop();
        // manage other components that need to respond
        // to the activity lifecycle
    }
}

Хотя этот пример выглядит нормально, в реальном приложении у вас будет слишком много вызовов, которые управляют пользовательским интерфейсом и другими компонентами в ответ на текущее состояние жизненного цикла. При управлении несколькими компонентами в методах жизненного цикла, таких как onStart() и onStop, размещается значительный объем кода, что затрудняет их поддержку.

Более того, нет гарантии, что компонент запустится до остановки действия или фрагмента. Это особенно важно, если нужно выполнить продолжительную операцию, например проверку конфигурации в onStart. Это может привести к состоянию гонки, когда метод onStop() завершается раньше, чем onStart, и компонент продолжает работать дольше, чем нужно.

Kotlin

class MyActivity : AppCompatActivity() {
    private lateinit var myLocationListener: MyLocationListener

    override fun onCreate(...) {
        myLocationListener = MyLocationListener(this) { location ->
            // update UI
        }
    }

    public override fun onStart() {
        super.onStart()
        Util.checkUserStatus { result ->
            // what if this callback is invoked AFTER activity is stopped?
            if (result) {
                myLocationListener.start()
            }
        }
    }

    public override fun onStop() {
        super.onStop()
        myLocationListener.stop()
    }

}

Java

class MyActivity extends AppCompatActivity {
    private MyLocationListener myLocationListener;

    public void onCreate(...) {
        myLocationListener = new MyLocationListener(this, location -> {
            // update UI
        });
    }

    @Override
    public void onStart() {
        super.onStart();
        Util.checkUserStatus(result -> {
            // what if this callback is invoked AFTER activity is stopped?
            if (result) {
                myLocationListener.start();
            }
        });
    }

    @Override
    public void onStop() {
        super.onStop();
        myLocationListener.stop();
    }
}

Пакет androidx.lifecycle содержит классы и интерфейсы, которые помогают решать эти проблемы надежным и изолированным способом.

Жизненный цикл

Lifecycle – это класс, который содержит информацию о состоянии жизненного цикла компонента (например, действия или фрагмента) и позволяет другим объектам отслеживать это состояние.

Lifecycle использует два основных перечисления для отслеживания статуса жизненного цикла связанного компонента:

Событие

События жизненного цикла, которые отправляются из фреймворка и класса Lifecycle. Эти события сопоставляются с событиями обратного вызова в действиях и фрагментах.

Штат

Текущее состояние компонента, отслеживаемое объектом Lifecycle.

Рисунок 1. Состояния и события жизненного цикла объекта activity в Android.

Представьте, что состояния – это узлы графа, а события – ребра между ними.

Класс может отслеживать статус жизненного цикла компонента, реализуя DefaultLifecycleObserver и переопределяя соответствующие методы, такие как onCreate, onStart и т. д. Затем вы можете добавить наблюдателя, вызвав метод addObserver() класса Lifecycle и передав экземпляр наблюдателя, как показано в следующем примере:

Kotlin

class MyObserver : DefaultLifecycleObserver {
    override fun onResume(owner: LifecycleOwner) {
        connect()
    }

    override fun onPause(owner: LifecycleOwner) {
        disconnect()
    }
}

myLifecycleOwner.getLifecycle().addObserver(MyObserver())

Java

public class MyObserver implements DefaultLifecycleObserver {
    @Override
    public void onResume(LifecycleOwner owner) {
        connect()
    }

    @Override
    public void onPause(LifecycleOwner owner) {
        disconnect()
    }
}

myLifecycleOwner.getLifecycle().addObserver(new MyObserver());

В примере выше объект myLifecycleOwner реализует интерфейс LifecycleOwner, который описан в следующем разделе.

LifecycleOwner

LifecycleOwner – это интерфейс с одним методом, который указывает, что у класса есть Lifecycle. В нем есть один метод – getLifecycle, который должен быть реализован классом. Если вы хотите управлять жизненным циклом всего процесса приложения, ознакомьтесь с информацией о ProcessLifecycleOwner.

Этот интерфейс абстрагирует право собственности на Lifecycle от отдельных классов, таких как Fragment и AppCompatActivity, и позволяет писать компоненты, которые работают с ними. Интерфейс LifecycleOwner может быть реализован в любом пользовательском классе приложения.

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

В примере с отслеживанием местоположения мы можем реализовать интерфейс DefaultLifecycleObserver в классе MyLocationListener, а затем инициализировать его с помощью Lifecycle действия в методе onCreate(). Это позволяет классу MyLocationListener быть самодостаточным, то есть логика реагирования на изменения статуса жизненного цикла объявляется в MyLocationListener, а не в объекте activity. Хранение собственной логики в отдельных компонентах упрощает управление логикой действий и фрагментов.

Kotlin

class MyActivity : AppCompatActivity() {
    private lateinit var myLocationListener: MyLocationListener

    override fun onCreate(...) {
        myLocationListener = MyLocationListener(this, lifecycle) { location ->
            // update UI
        }
        Util.checkUserStatus { result ->
            if (result) {
                myLocationListener.enable()
            }
        }
    }
}

Java

class MyActivity extends AppCompatActivity {
    private MyLocationListener myLocationListener;

    public void onCreate(...) {
        myLocationListener = new MyLocationListener(this, getLifecycle(), location -> {
            // update UI
        });
        Util.checkUserStatus(result -> {
            if (result) {
                myLocationListener.enable();
            }
        });
  }
}

Это позволяет избежать вызова определенных обратных вызовов, если Lifecycle находится в ненадлежащем состоянии. Например, если обратный вызов запускает транзакцию фрагмента после сохранения состояния действия, это приведет к сбою, поэтому мы не хотим вызывать этот обратный вызов.

Чтобы упростить этот сценарий, класс Lifecycle позволяет другим объектам запрашивать текущее состояние.

Kotlin

internal class MyLocationListener(
        private val context: Context,
        private val lifecycle: Lifecycle,
        private val callback: (Location) -> Unit
): DefaultLifecycleObserver {

    private var enabled = false

    override fun onStart(owner: LifecycleOwner) {
        if (enabled) {
            // connect
        }
    }

    fun enable() {
        enabled = true
        if (lifecycle.currentState.isAtLeast(Lifecycle.State.STARTED)) {
            // connect if not connected
        }
    }

    override fun onStop(owner: LifecycleOwner) {
        // disconnect if connected
    }
}

Java

class MyLocationListener implements DefaultLifecycleObserver {
    private boolean enabled = false;
    public MyLocationListener(Context context, Lifecycle lifecycle, Callback callback) {
       ...
    }

    @Override
    public void onStart(LifecycleOwner owner) {
        if (enabled) {
           // connect
        }
    }

    public void enable() {
        enabled = true;
        if (lifecycle.getCurrentState().isAtLeast(STARTED)) {
            // connect if not connected
        }
    }

    @Override
    public void onStop(LifecycleOwner owner) {
        // disconnect if connected
    }
}

Теперь наш класс LocationListener полностью учитывает жизненный цикл. Если нам нужно использовать LocationListener из другого действия или фрагмента, нам просто нужно его инициализировать. Все операции по настройке и демонтажу управляются самим классом.

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

Как реализовать собственный LifecycleOwner

Фрагменты и действия в библиотеке поддержки версии 26.1.0 и более поздних уже реализуют интерфейс LifecycleOwner.

Если у вас есть собственный класс, который вы хотите сделать LifecycleOwner, вы можете использовать класс LifecycleRegistry, но вам нужно будет перенаправлять события в этот класс, как показано в следующем примере кода:

Kotlin

class MyActivity : Activity(), LifecycleOwner {

    private lateinit var lifecycleRegistry: LifecycleRegistry

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        lifecycleRegistry = LifecycleRegistry(this)
        lifecycleRegistry.markState(Lifecycle.State.CREATED)
    }

    public override fun onStart() {
        super.onStart()
        lifecycleRegistry.markState(Lifecycle.State.STARTED)
    }

    override fun getLifecycle(): Lifecycle {
        return lifecycleRegistry
    }
}

Java

public class MyActivity extends Activity implements LifecycleOwner {
    private LifecycleRegistry lifecycleRegistry;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        lifecycleRegistry = new LifecycleRegistry(this);
        lifecycleRegistry.markState(Lifecycle.State.CREATED);
    }

    @Override
    public void onStart() {
        super.onStart();
        lifecycleRegistry.markState(Lifecycle.State.STARTED);
    }

    @NonNull
    @Override
    public Lifecycle getLifecycle() {
        return lifecycleRegistry;
    }
}

Рекомендации по работе с компонентами, учитывающими жизненный цикл

  • Контроллеры пользовательского интерфейса (действия и фрагменты) должны быть как можно более простыми. Они не должны пытаться получить собственные данные. Вместо этого используйте ViewModel и наблюдайте за объектом LiveData, чтобы отразить изменения в представлениях.
  • Попробуйте написать пользовательский интерфейс, управляемый данными, в котором контроллер пользовательского интерфейса отвечает за обновление представлений по мере изменения данных или уведомляет ViewModel о действиях пользователя.
  • Добавьте логику данных в класс ViewModel. ViewModel должен служить связующим звеном между контроллером пользовательского интерфейса и остальной частью приложения. Однако будьте осторожны: ViewModel не отвечает за получение данных (например, из сети). Вместо этого ViewModel должен вызывать соответствующий компонент для получения данных, а затем возвращать результат контроллеру пользовательского интерфейса.
  • Используйте привязку данных, чтобы поддерживать чистый интерфейс между представлениями и контроллером пользовательского интерфейса. Это позволяет сделать представления более декларативными и минимизировать код обновления, который нужно писать в действиях и фрагментах. Если вы предпочитаете использовать язык программирования Java, воспользуйтесь библиотекой, например Butter Knife, чтобы избежать шаблонного кода и улучшить абстракцию.
  • Если у вас сложный интерфейс, подумайте о создании класса presenter для обработки изменений интерфейса. Это может быть трудоемкой задачей, но она может упростить тестирование компонентов пользовательского интерфейса.
  • Не ссылайтесь на контекст View или Activity в ViewModel. Если ViewModel существует дольше, чем действие (например, при изменении конфигурации), происходит утечка действия, и сборщик мусора не может правильно его удалить.
  • Используйте сопрограммы Kotlin для управления длительными задачами и другими операциями, которые могут выполняться асинхронно.

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

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

  • Переключение между приблизительными и точными уведомлениями о местоположении. Используйте компоненты, учитывающие жизненный цикл, чтобы включить точное определение местоположения, когда приложение открыто, и приблизительное, когда оно работает в фоновом режиме. LiveData – это компонент, учитывающий жизненный цикл. Он позволяет приложению автоматически обновлять интерфейс, когда пользователь меняет местоположение.
  • Остановка и запуск буферизации видео. Используйте компоненты с поддержкой жизненного цикла, чтобы начать буферизацию видео как можно раньше, но отложить воспроизведение до полного запуска приложения. Вы также можете использовать компоненты, учитывающие жизненный цикл, чтобы прекратить буферизацию при удалении приложения.
  • Включение и отключение сетевого подключения. Используйте компоненты, учитывающие жизненный цикл, чтобы включить обновление данных из сети в реальном времени (потоковую передачу), когда приложение находится на переднем плане, и автоматически приостанавливать его, когда приложение переходит в фоновый режим.
  • Приостановка и возобновление анимированных объектов Drawable. Используйте компоненты, учитывающие жизненный цикл, чтобы приостанавливать анимированные графические объекты, когда приложение работает в фоновом режиме, и возобновлять их работу, когда приложение работает в активном режиме.

Обработка событий остановки

Если Lifecycle принадлежит AppCompatActivity или Fragment, то при вызове onSaveInstanceState() для AppCompatActivity или Fragment статус Lifecycle меняется на CREATED и отправляется событие ON_STOP.

Когда состояние Fragment или AppCompatActivity сохраняется с помощью onSaveInstanceState, его интерфейс считается неизменным, пока не будет вызван метод ON_START. Попытка изменить интерфейс после сохранения состояния может привести к несоответствиям в состоянии навигации приложения. Поэтому FragmentManager выдает исключение, если приложение запускает FragmentTransaction после сохранения состояния. Более подробные сведения приведены в описании элемента commit().

LiveData предотвращает эту проблему, не вызывая наблюдателя, если связанный с ним Lifecycle не находится хотя бы в состоянии STARTED. В фоновом режиме он вызывает isAtLeast(), прежде чем решить, вызывать ли наблюдателя.

К сожалению, метод onStop() класса AppCompatActivity вызывается после onSaveInstanceState, из-за чего возникает промежуток, когда изменения состояния интерфейса не разрешены, но Lifecycle ещё не перешел в состояние CREATED.

Чтобы избежать этой проблемы, класс Lifecycle в версии beta2 и более ранних помечает состояние как CREATED без отправки события. Таким образом, любой код, проверяющий текущее состояние, получает реальное значение, даже если событие не отправляется до тех пор, пока система не вызовет onStop().

К сожалению, у этого решения есть две основные проблемы:

  • На уровне API 23 и ниже система Android сохраняет состояние действия, даже если оно частично перекрыто другим действием. Другими словами, система Android вызывает onSaveInstanceState(), но не обязательно вызывает onStop. Это создает потенциально длинный интервал, в течение которого наблюдатель по-прежнему считает, что жизненный цикл активен, хотя состояние пользовательского интерфейса изменить нельзя.
  • Любой класс, который должен вести себя так же, как класс LiveData, должен реализовывать обходное решение, предусмотренное в Lifecycle версии beta 2 и ниже.

Дополнительные ресурсы

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

Практические работы

Блоги