Глубокое понимание и применение Android Jetpack Lifecycle

Автор: Отдохни во второй половине дня.

предисловие

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

Что такое жизненный цикл?

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

Жизненный цикл — это компонент Android Jetpack, который управляет жизненным циклом компонентов приложения Android (таких как Activity и Fragment). Он основан на шаблоне Observer, реализованном через интерфейсы LifecycleOwner и LifecycleObserver. Когда происходит событие жизненного цикла объекта LifecycleOwner, он уведомляет все зарегистрированные объекты LifecycleObserver, чтобы они могли отреагировать на соответствующее событие.

Анализ принципа жизненного цикла

1. Реестр жизненного цикла

В основе Lifecycle лежит класс LifecycleRegistry. Это класс, реализующий интерфейс Lifecycle, предоставляющий некоторые методы для управления жизненным циклом компонентов.

LifecycleRegistry имеет свойство currentState для получения текущего состояния. Он имеет пять состояний:

• INITIALIZED: Исходное состояние, указывающее, что компонент создан, но еще не запущен.
• СОЗДАН: Компонент создан.
• ЗАПУЩЕН: Компонент запущен.
• RESUMED: работа компонента возобновлена ​​(т.е. находится на переднем плане).
• DESTROYED: Компонент был уничтожен.

LifecycleRegistry также имеет метод addListener(), который используется для добавления объекта LifecycleObserver в список наблюдателей и уведомления его о событиях жизненного цикла компонента.

2. Владелец жизненного цикла

LifecycleOwner — это интерфейс маркера, используемый для идентификации компонентов с жизненным циклом. Общий LifecycleOwner — это Activity и Fragment, которые указывают, что у них есть жизненный цикл, реализуя этот интерфейс.

LifecycleOwner имеет метод getLifecycle(), который возвращает связанный объект Lifecycle, являющийся экземпляром LifecycleRegistry. Таким образом, LifecycleOwner может управлять собственным жизненным циклом через LifecycleRegistry.

3. Наблюдатель за жизненным циклом

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

LifecycleObserver отмечает события жизненного цикла, за которыми необходимо наблюдать, аннотируя @OnLifecycleEvent. Например, @OnLifecycleEvent(Lifecycle.Event.ON_CREATE) указывает, что метод должен выполняться, когда происходит событие onCreate() компонента.

4. Резюме

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

Легко использовать

Теперь давайте рассмотрим несколько простых вариантов использования Lifecycle в разработке для Android:

1. Интеграция LiveData и жизненного цикла

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

class MyActivity : AppCompatActivity() {
    
    

    private lateinit var myLiveData: LiveData<String>

    override fun onCreate(savedInstanceState: Bundle?) {
    
    
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        myLiveData = MyRepository.getData().observe(this) {
    
     data ->
            // 在 LiveData 数据更新时执行操作
        }
    }
}

2. Интеграция ViewModel и жизненного цикла

ViewModel — это компонент, используемый для сохранения данных при изменении конфигурации компонента, например при повороте экрана. Интегрируя ViewModel с Lifecycle, вы можете гарантировать, что жизненный цикл ViewModel согласуется со связанным LifecycleOwner (например, Activity или Fragment), тем самым избегая повторного создания и уничтожения данных ViewModel.

class MyActivity : AppCompatActivity() {

    private lateinit var myViewModel: MyViewModel

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        myViewModel = ViewModelProvider(this).get(MyViewModel::class.java)
        myViewModel.getData().observe(this) { data ->
            // 在 ViewModel 数据更新时执行操作
        }
    }
}

Расширенное использование

Теперь давайте рассмотрим некоторые расширенные варианты использования Lifecycle в разработке для Android:

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

Вот пример, показывающий, как настроить простой класс Lifecycle:

import androidx.lifecycle.Lifecycle
import androidx.lifecycle.LifecycleObserver
import androidx.lifecycle.OnLifecycleEvent
import androidx.lifecycle.LifecycleOwner

class MyLifecycle : Lifecycle {
    
    

    private var lifecycleRegistry: MyLifecycleRegistry = MyLifecycleRegistry()

    // 自定义 LifecycleObserver
    private val myObserver = object : LifecycleObserver {
    
    
        @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
        fun onCreate() {
    
    
            // 在自定义生命周期中的 onCreate() 事件中执行操作
            println("Custom Lifecycle - onCreate()")
        }

        @OnLifecycleEvent(Lifecycle.Event.ON_START)
        fun onStart() {
    
    
            // 在自定义生命周期中的 onStart() 事件中执行操作
            println("Custom Lifecycle - onStart()")
        }

        @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
        fun onResume() {
    
    
            // 在自定义生命周期中的 onResume() 事件中执行操作
            println("Custom Lifecycle - onResume()")
        }

        @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
        fun onPause() {
    
    
            // 在自定义生命周期中的 onPause() 事件中执行操作
            println("Custom Lifecycle - onPause()")
        }

        @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
        fun onStop() {
    
    
            // 在自定义生命周期中的 onStop() 事件中执行操作
            println("Custom Lifecycle - onStop()")
        }

        @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
        fun onDestroy() {
    
    
            // 在自定义生命周期中的 onDestroy() 事件中执行操作
            println("Custom Lifecycle - onDestroy()")
        }
    }

    override fun addObserver(observer: LifecycleObserver) {
    
    
        lifecycleRegistry.addObserver(observer)
    }

    override fun removeObserver(observer: LifecycleObserver) {
    
    
        lifecycleRegistry.removeObserver(observer)
    }

    override fun getCurrentState(): State {
    
    
        return lifecycleRegistry.currentState
    }

    // 在适当的时机调用相应的生命周期方法，例如在创建自定义 Lifecycle 的实例时调用
    fun onCreate() {
    
    
        lifecycleRegistry.currentState = State.CREATED
        lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE)
    }

    fun onStart() {
    
    
        lifecycleRegistry.currentState = State.STARTED
        lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START)
    }

    fun onResume() {
    
    
        lifecycleRegistry.currentState = State.RESUMED
        lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME)
    }

    fun onPause() {
    
    
        lifecycleRegistry.currentState = State.STARTED
        lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    }

    fun onStop() {
    
    
        lifecycleRegistry.currentState = State.CREATED
        lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP)
    }

    fun onDestroy() {
    
    
        lifecycleRegistry.currentState = State.DESTROYED
        lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY)
        lifecycleRegistry.clear()
    }

    // 自定义 LifecycleRegistry，用于管理 LifecycleObserver
    private class MyLifecycleRegistry : LifecycleRegistry() {
    
    
        override fun addObserver(observer: LifecycleObserver) {
    
    
            super.addObserver(observer)
        }

        override fun removeObserver(observer: LifecycleObserver) {
    
    
            super.removeObserver(observer)
        }
    }
}

В приведенном выше примере мы создали собственный класс Lifecycle с именем MyLifecycle. В этом классе мы реализуем интерфейс Lifecycle и используем внутренний объект LifecycleRegistry для управления LifecycleObserver. Затем мы определяем набор настраиваемых методов жизненного цикла и вызываем соответствующие события жизненного цикла в нужное время, тем самым запуская зарегистрированный LifecycleObserver для выполнения операций.

Теперь мы можем использовать MyLifecycle в любом классе, чтобы иметь возможность осознавать жизнь, не ограничиваясь Activity и Fragment:

class MyCustomClass {
    
    

    private val myLifecycle = MyLifecycle()

    fun doSomething() {
    
    
        // 在合适的时机调用自定义生命周期方法
        myLifecycle.onCreate()
        myLifecycle.onStart()

        // 执行自己的操作

        myLifecycle.onStop()
        myLifecycle.onDestroy()
    }
}

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

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

Подведем итог

В этой статье мы в простой форме представили принцип использования Android Jetpack Lifecycle. Жизненный цикл — один из основных компонентов Android Jetpack, реализующий управление жизненным циклом компонентов в режиме наблюдателя. Мы узнали о взаимосвязи между LifecycleRegistry, LifecycleOwner и LifecycleObserver и о том, как использовать Lifecycle на продвинутом уровне. Благодаря глубокому пониманию принципов жизненного цикла вы сможете более гибко управлять жизненным циклом компонентов приложения Android, делая приложение более стабильным и эффективным.

Заметки об исследовании Android

Оптимизация производительности Android: https://qr18.cn/FVlo89
Транспортное средство Android: https://qr18.cn/F05ZCM
Android Reverse Security Примечания к исследованию: https://qr18.cn/CQ5TcL
Принципы Android Framework: https://qr18.cn/AQpN4J
Аудио и видео Android: https://qr18.cn/Ei3VPD
Jetpack (включая Compose): https://qr18.cn/A0gajp
Kotlin: https://qr18.cn/CdjtAF
Gradle: https://qr18.cn/DzrmMB
OkHttp Примечания к анализу исходного кода: https://qr18.cn/Cw0pBD
Flutter: https://qr18.cn/DIvKma
Android Eight Knowledge Body: https://qr18.cn/CyxarU
Android Core Notes: https://qr21.cn/CaZQLo
Android Прошлые вопросы на собеседовании: https://qr18.cn/CKV8OZ
2023 Последняя коллекция вопросов на собеседовании по Android: https://qr18.cn/CgxrRy
Android Vehicle Development Упражнения на собеседовании: https://qr18.cn/FTlyCJ
аудио- и видео-вопросы на собеседовании:https://qr18.cn/AcV6Ap