Жизненный цикл деятельности

As a user navigates through, out of, and back to your app, the Activity instances in your app transition through different states in their lifecycle. The Activity class provides a number of callbacks that let the activity know when a state changes or that the system is creating, stopping, or resuming an activity or destroying the process the activity resides in.

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

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

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

В этом документе подробно описывается жизненный цикл активности. Документ начинается с описания парадигмы жизненного цикла. Далее объясняется каждый из коллбэков: что происходит внутри во время их выполнения и что необходимо реализовать в процессе их работы.

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

Для получения информации об обработке жизненных циклов, включая рекомендации по передовым методам, см. раздел «Жизненный цикл в Jetpack Compose и состояниях пользовательского интерфейса» . Чтобы узнать, как спроектировать надежное приложение производственного качества, используя действия в сочетании с архитектурными компонентами, см. раздел «Руководство по архитектуре приложений» .

Концепции жизненного цикла деятельности

Для управления переходами между этапами жизненного цикла активности класс Activity предоставляет основной набор из шести коллбэков: onCreate , onStart , onResume , onPause , onStop и onDestroy . Система вызывает каждый из этих коллбэков, когда активность переходит в новое состояние.

На рисунке 1 представлено визуальное отображение этой парадигмы.

Рисунок 1. Упрощенная иллюстрация жизненного цикла деятельности.

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

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

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

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

Композиция и жизненный цикл

В Compose избегайте размещения бизнес-логики или ручной настройки наблюдателей непосредственно в коллбэках активности, таких как onStart или onResume . Вместо этого используйте эффекты, учитывающие жизненный цикл , и наблюдатели, учитывающие состояние, которые автоматически синхронизируются с присутствием пользовательского интерфейса на экране.

  • Сбор данных с учетом жизненного цикла: используйте collectAsStateWithLifecycle для обработки потоков из вашей ViewModel . Этот API автоматически начинает сбор данных, когда пользовательский интерфейс переходит в состояние Started, и останавливается, когда он переходит в фоновый режим, предотвращая ненужное потребление ресурсов. После сбора потока в качестве состояния вы можете использовать LifecycleEffects для выполнения кода при возникновении события жизненного цикла.
  • Последовательность выполнения логики: Благодаря использованию этих API пользовательский интерфейс естественным образом реагирует на состояние жизненного цикла через дерево композиции, гарантируя, что бизнес-логика выполняется только тогда, когда пользователь активно взаимодействует с компонентом.

Более подробную информацию о Compose и жизненном цикле см. в разделе «Жизненный цикл в Jetpack Compose» .

Обратные вызовы жизненного цикла

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

Некоторые действия следует размещать в методах жизненного цикла активности. Однако код, реализующий действия зависимого компонента, следует размещать в самом компоненте, а не в методе жизненного цикла активности. Для этого необходимо обеспечить учет жизненного цикла зависимого компонента. Чтобы узнать, как обеспечить учет жизненного цикла зависимых компонентов, см. раздел «Жизненный цикл в Jetpack Compose» .

onCreate

Необходимо реализовать этот коллбэк, который срабатывает при первом создании активности системой. При создании активности она переходит в состояние Created . В методе onCreate выполните базовую логику запуска приложения, которая выполняется только один раз за всё время существования активности.

Например, ваша реализация метода onCreate может связывать данные со списками, ассоциировать активность с ViewModel и создавать экземпляры некоторых переменных в области видимости класса. Этот метод принимает параметр savedInstanceState , который представляет собой объект Bundle , содержащий ранее сохраненное состояние активности. Если активность никогда ранее не существовала, значение объекта Bundle равно null.

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

В следующем примере показано, как интегрировать компонент Text в минимально необходимую активность: 

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

        setContent { // In here, we can call composables!
            MaterialTheme {
                Greeting(name = "compose")
            }
        }
    }
}

@Composable
fun Greeting(name: String) {
    Text(text = "Hello $name!")
}

Ваша активность не остаётся в состоянии Created. После завершения выполнения метода onCreate активность переходит в состояние Started , и система быстро вызывает методы onStart и onResume .

onStart

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

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

Метод onStart завершается быстро, и, как и в случае с состоянием Created, активность не остается в состоянии Started. После завершения этого обратного вызова активность переходит в состояние Resumed , и система вызывает метод onResume .

onResume

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

When the activity moves to the Resumed state, any lifecycle-aware component tied to the activity's lifecycle receives the ON_RESUME event. This is where the lifecycle components can enable any functionality that needs to run while the component is visible and in the foreground, such as starting a camera preview.

При возникновении прерывающего события активность переходит в состояние "Приостановлено" , и система вызывает функцию обратного вызова onPause .

Если активность возвращается из состояния "Приостановлено" в состояние "Возобновлено", система снова вызывает метод onResume . Поэтому реализуйте onResume для инициализации компонентов, которые вы освобождаете во время onPause , а также для выполнения любых других инициализаций, которые должны происходить каждый раз, когда активность переходит в состояние "Возобновлено".

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

class CameraComponent : LifecycleObserver {
    ...
    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    fun initializeCamera() {
        if (camera == null) {
            getCamera()
        }
    }
    ...
}

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

If you want the camera active only when the app is Resumed (visible and active in the foreground), then initialize the camera after the ON_RESUME event demonstrated previously. If you want to keep the camera active while the activity is Paused but visible, such as in multi-window mode, then initialize the camera after the ON_START event.

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

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

Независимо от того, какое событие инициализации вы выберете для выполнения операции, обязательно используйте соответствующее событие жизненного цикла для освобождения ресурса. Если вы инициализируете что-либо после события ON_START , освободите или завершите это после события ON_STOP . Если вы инициализируете что-либо после события ON_RESUME , освободите после события ON_PAUSE .

Приведённый выше фрагмент кода размещает код инициализации камеры в компоненте, учитывающем жизненный цикл. Вместо этого вы можете поместить этот код непосредственно в коллбэки жизненного цикла активности, такие как onStart и onStop , но мы не рекомендуем этого делать. Добавление этой логики в независимый компонент, учитывающий жизненный цикл, позволяет повторно использовать компонент в нескольких активностях без дублирования кода. Чтобы узнать, как создать компонент, учитывающий жизненный цикл, см. раздел «Жизненный цикл в Jetpack Compose» .

onPause

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

  • Событие, прерывающее выполнение приложения, как описано в разделе о функции обратного вызова onResume , приостанавливает текущую активность. Это наиболее распространенный случай.
  • В многооконном режиме в любой момент времени в фокусе находится только одно приложение, а все остальные приложения система приостанавливает.
  • Открытие нового, полупрозрачного элемента, например диалогового окна, приостанавливает работу элемента, который оно закрывает. Пока элемент частично виден, но не находится в фокусе, он остается приостановленным.

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

Используйте метод onPause для приостановки или корректировки операций, которые не могут быть продолжены или могут быть продолжены в умеренном объеме, пока Activity находится в состоянии Paused, и которые вы ожидаете возобновить в ближайшее время.

Также можно использовать метод onPause для освобождения системных ресурсов, дескрипторов датчиков (например, GPS) или любых ресурсов, влияющих на время работы батареи, пока ваша активность приостановлена ​​и пользователь в них не нуждается.

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

Следующий пример реакции LifecycleObserver на событие ON_PAUSE является аналогом предыдущего примера с событием ON_RESUME , освобождая камеру, которая инициализируется после получения события ON_RESUME :

class CameraComponent : LifecycleObserver {
    ...
    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    fun releaseCamera() {
        camera?.release()
        camera = null
    }
    ...
}

В этом примере код освобождения камеры размещается после получения событием ON_PAUSE объектом LifecycleObserver .

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

Вместо этого выполняйте операции завершения работы с высокой нагрузкой во время onStop . Дополнительную информацию о подходящих операциях для выполнения во время onStop см. в следующем разделе. Дополнительную информацию о сохранении данных см. в разделе о сохранении и восстановлении состояния .

Завершение выполнения метода onPause не означает, что активность выходит из состояния «Приостановлено». Скорее, активность остается в этом состоянии до тех пор, пока не возобновится или не станет полностью невидимой для пользователя. Если активность возобновляется, система снова вызывает обратный вызов onResume .

Если активность возвращается из состояния «Приостановлено» в состояние «Возобновлено», система сохраняет экземпляр Activity в памяти, вызывая его при вызове onResume . В этом сценарии нет необходимости повторно инициализировать компоненты, созданные во время выполнения каких-либо методов обратного вызова, предшествующих состоянию «Возобновлено». Если активность становится полностью невидимой, система вызывает onStop .

onStop

Когда ваша активность перестаёт быть видимой для пользователя, она переходит в состояние «Остановлено» , и система вызывает функцию обратного вызова onStop . Это может произойти, когда недавно запущенная активность занимает весь экран. Система также вызывает onStop , когда активность завершает работу и собирается быть завершена.

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

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

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

override fun onStop() {
    super.onStop()

    // Delegate the save operation to the ViewModel, which handles the
    // background thread operations (e.g., using Kotlin Coroutines and Room).
    noteViewModel.saveDraft()
}

Когда ваша активность переходит в состояние «Остановлено», объект Activity остается в памяти: он хранит всю информацию о состоянии и членах класса, но не привязан к менеджеру окон. При возобновлении активности он восстанавливает эту информацию.

Из состояния «Остановлено» активность либо возобновляет взаимодействие с пользователем, либо завершает выполнение и исчезает. Если активность возобновляет работу, система вызывает onRestart . Если Activity завершает выполнение, система вызывает onDestroy .

onDestroy

onDestroy вызывается перед уничтожением активности. Система вызывает этот коллбэк по одной из двух причин:

  1. Действие завершается либо из-за полного закрытия пользователем этого действия, либо из-за вызова функции finish действия.
  2. Система временно прерывает работу из-за изменения конфигурации, например, поворота устройства или перехода в многооконный режим.

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

Вместо того чтобы добавлять логику в Activity для определения причины её уничтожения, используйте объект ViewModel для хранения соответствующих данных представления для вашей Activity . Если Activity создаётся заново из-за изменения конфигурации, ViewModel не нужно ничего делать, поскольку он сохраняется и передаётся следующему экземпляру Activity .

Если Activity не создается заново, то вызывается метод onCleared в ViewModel , который позволяет очистить необходимые данные перед уничтожением. Различить эти два сценария можно с помощью метода isFinishing .

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

Функция обратного вызова onDestroy освобождает все ресурсы, не освобожденные предыдущими функциями обратного вызова, такими как onStop .

Состояние активности и извлечение из памяти

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

Вероятность быть убитым

Состояние процесса

Заключительное состояние активности

Самый низкий

Передний план (находящийся в фокусе или вот-вот окажется в фокусе)

Возобновлено

Низкий

Видно (без фокуса)

Начато/Приостановлено

Выше

Фон (невидимый)

Остановлено

Высший

Пустой

Уничтожен

Таблица 1. Взаимосвязь между жизненным циклом процесса и состоянием деятельности.

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

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

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

Сохранение и восстановление временного состояния пользовательского интерфейса

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

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

Когда системные ограничения приводят к сбою активности, сохраните временное состояние пользовательского интерфейса, используя комбинацию ViewModel (для сложной бизнес-логики и состояния экрана), API Jetpack Compose rememberSaveable (для легковесного состояния пользовательского интерфейса) и/или локального хранилища. Чтобы узнать больше об ожиданиях пользователя по сравнению с поведением системы и о том, как лучше всего сохранять сложные данные о состоянии пользовательского интерфейса при инициированных системой действиях и завершении процессов, см. раздел «Сохранение состояний пользовательского интерфейса» .

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

Состояние экземпляра

Существует несколько сценариев, в которых ваша активность уничтожается из-за обычного поведения приложения, например, когда пользователь нажимает кнопку «Назад» или когда ваша активность сигнализирует о собственном уничтожении, вызывая метод finish .

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

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

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

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

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

Чтобы сохранить даже очень небольшой объем данных, используйте комбинированный подход, сочетающий постоянное локальное хранилище, класс ViewModel и поднятие состояния Compose, как описано в разделе «Сохранение состояний пользовательского интерфейса» .

Сохраняйте простое и легковесное состояние пользовательского интерфейса с помощью rememberSaveable.

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

Для сохранения пользовательской, легковесной информации о состоянии (например, о прогрессе пользователя в игре) объявите состояние с помощью rememberSaveable . Фреймворк Compose обрабатывает сериализацию в пакет состояния экземпляра на уровне интерфейса: 

var userTypedQuery by rememberSaveable(typedQuery, stateSaver = TextFieldValue.Saver) {
    mutableStateOf(
        TextFieldValue(text = typedQuery, selection = TextRange(typedQuery.length))
    )
}

To save persistent data, such as user preferences or data for a database, take appropriate opportunities when your activity is in the foreground. If no such opportunity arises, save persistent data during the onStop method.

Восстановите состояние пользовательского интерфейса активности, используя сохраненное состояние экземпляра.

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

var userTypedQuery by rememberSaveable(typedQuery, stateSaver = TextFieldValue.Saver) {
    mutableStateOf(
        TextFieldValue(text = typedQuery, selection = TextRange(typedQuery.length))
    )
}

Действия и навигация

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

Чтобы узнать, как реализовать современную навигацию, основанную на Compose, см. руководство по библиотеке Jetpack Compose Navigation 3 .

Начало одного действия с другого.

В какой-то момент одной активности может потребоваться запустить другую активность. Такая необходимость возникает, например, когда приложению нужно перейти с текущего экрана на новый.

В зависимости от того, требуется ли вашей активности получить результат от новой активности, которую она собирается запустить, вы запускаете новую активность, используя либо метод startActivity , либо метод startActivityForResult . В любом случае, вы передаете объект Intent .

Объект Intent указывает либо точное действие, которое вы хотите запустить, либо описывает тип действия, которое вы хотите выполнить. Система выбирает подходящее действие за вас, которое может даже быть из другого приложения. Объект Intent также может содержать небольшой объем данных, используемых запускаемым действием. Для получения дополнительной информации о классе Intent см. разделы «Intents» и «Intent Filters» .

начало активности

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

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

val context = LocalContext.current

Button(onClick = {
    val intent = Intent(context, SignInActivity::class.java)
    context.startActivity(intent)
}) {
    Text("Sign In")
}

Начало внешних мероприятий

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

Для этого используется объект Intent , описывающий тип действия, которое вы хотите выполнить, и система запускает соответствующее действие из другого приложения.

Например, если вы хотите разрешить пользователю отправить электронное письмо, вы можете создать следующий интент:

val intent = Intent(Intent.ACTION_SEND).apply {
    putExtra(Intent.EXTRA_EMAIL, recipientArray)
}
startActivity(intent)

Если вам нужно запустить внешнюю активность и получить от неё результат (например, попросить приложение камеры сделать снимок и вернуть изображение), используйте современные API для работы с результатами Activity а не устаревший коллбэк startActivityForResult .

Координация деятельности

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

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

  1. Выполняется метод onPause объекта Activity A.
  2. Методы onCreate , onStart и onResume Activity B выполняются последовательно. Теперь Activity B находится в фокусе пользователя.
  3. Если Activity A больше не отображается на экране, выполняется его метод onStop .

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

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

Чтобы узнать больше о жизненном цикле деятельности, ознакомьтесь со следующими дополнительными материалами:

Просмотры контента