Изучаем жизненный цикл активности и Logcat

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

Данная статья применима и к классическому подходу и к примерам на Compose. Небольшие различия будут указаны явно.

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

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

Также log имеет другое обычное значение - бревно. Следовательно, logcat можно перевести как бревенчатый кот, чтобы это не значило. Слово "бревно" обыгрывается в другой библиотеке Timber, который является продвинутым вариантом Logcat. "Timber" переводится как лесозаготовки, брус - т.е. уже обработанное бревно.

onCreate()

Начнём с самого простого. Вы уже привыкли, что у активности есть метод onCreate(), в котором мы обычно пишем код для инициализации компонентов и что-то ещё. Это метод жизненного цикла активности и он явно присутствует в нашем коде.

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

private const val TAG = "MainActivity"

class MainActivity : ComponentActivity() {
    @OptIn(ExperimentalMaterial3Api::class)
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        Log.d(TAG, "onCreate вызван")
        
        enableEdgeToEdge()
        setContent {
           // Тут ваш код
        }
}

Подробнее о методах Log можно почитать в отдельно статье. Для большинства случае достаточно запомнить одну конструкцию с методом d (debug), в котором указывают два строковых параметра. В первом параметре обычно указывают имя класса, а во втором - пояснение о событии, за которым мы наблюдаем. Если проект сложный и состоит из множества активностей, то первый параметр поможет быстро понять, откуда пришло сообщение.

Запустите пример и откройте панель LogCat,нажав на значок с котом! Даже если приложение пустое, оно ведь было создано. И это событие должно быть отражено в журнале. По умолчанию студия может выводить много лишней информации, которая нас сейчас не интересует. Лучше сразу установить фильтр package:mine tag:MainActivity , чтобы видеть только сообщения с тегом MainActivity.

Когда приложение запустится, то на панели мы увидим единственную надпись "OnCreate вызван".

onStart()

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

Возьмём метод onStart(). Он вызывается после onCreate(). Как в этом убедиться? Сразу после метода onCreate() начинаем печатать название метода onStart(). Четырёх символов вполне достаточно, чтобы увидеть нужный метод в списке подсказок и нажать Enter, чтобы получить заготовку.

override fun onStart() {
    super.onStart()
}

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

override fun onStart() {
    super.onStart()

    Log.d(TAG, "onStart вызван")
}

Запустим снова приложение и установим наблюдение на вкладке Logсat.

Мы видим, что сначала был вызван метод onCreate(), затем onStart().

Не закрывая приложение, поверните устройство (в эмуляторе есть специальные значки для поворота) и наблюдайте за сообщениями в Logcat. Вы снова увидите пару строк, как при запуске приложения.

Наверное, вы уже подумали, что onStart() всегда вызывается после onCreate(). Рано успокаиваться. Не закрывая приложение, попробуйте вызвать другое приложение, которое бы закрыло ваше приложение. Это можно сделать следующим способом. Сверните приложение через среднюю кнопку навигации, запустите любое приложение, закройте запущенное приложение, через правую кнопку навигации откройте список недавно запущенных приложений и запустите своё приложение. Если посмотреть на сообщения, то увидите, что появится только строка "onStart() вызван", а строка "onCreate() вызван" не появится.

// запустили приложение
MainActivity: onCreate() вызван
MainActivity: onStart() вызван
// повернули устройство
MainActivity: onCreate() вызван
MainActivity: onStart() вызван
// запустили и закрыли другое приложение, заново восстановили своё приложение
MainActivity: onStart() вызван

Следует запомнить: за onCreate() всегда следует вызов onStart(), но перед onStart() не обязательно должен идти onCreate(), так как onStart() может вызываться и для возобновления работы приостановленного приложения (приложение останавливается методом onStop()). При вызове onStart() окно ещё не видно пользователю, но вскоре будет видно.

Когда это может пригодиться? Допустим, мы используем датчик освещения. Его можно зарегистрировать в onStart(), так как он всегда будет вызван после onCreate(). Если приложение временно приостановлено, мы снимаем регистрацию датчика для экономии ресурсов, а при возобновлении работы снова включаем датчик. Такой подход позволяет грамотно распределять ресурсы приложения.

Другие методы

Настало время познакомиться с другими методами жизненного цикла. Для удобства мы повторим прошлый манёвр и добавим вызов сообщений в Logcat.

package ru.alexanderklimov.hellokot

import android.os.Bundle
import android.util.Log
import androidx.appcompat.app.AppCompatActivity

class MainActivity : AppCompatActivity() {

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

        setContentView(R.layout.activity_main)
        Log.i("MainActivity", "onCreate() called")
    }

    override fun onStart() {
        super.onStart()
        Log.i("MainActivity", "onStart() called")
    }

    override fun onRestart() {
        super.onRestart()
        Log.i("MainActivity", "onRestart() called")
    }

    override fun onResume() {
        super.onResume()
        Log.i("MainActivity", "onResume() called")
    }

    override fun onPause() {
        super.onPause()
        Log.i("MainActivity", "onPause() called")
    }

    override fun onStop() {
        super.onStop()
        Log.i("MainActivity", "onStop() called")
    }

    override fun onDestroy() {
        super.onDestroy()
        Log.i("MainActivity", "onDestroy() called")
    }
}

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

Жизненный цикл фрагментов

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

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

Дополнительное чтение

Реклама