Жизненный цикл активити kotlin

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

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

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

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

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

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

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

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

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

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

В далёком 2011 году зарубежные пользователи предлагали заменить значок Logcat на изображение кота и создали отдельную петицию. К сожалению, Гугл проигнорировал баг-репорт.

Добавим аналогичный вызов в метод onCreate().

 override fun onCreate(savedInstanceState: Bundle?)

Запустим приложение (желательно в эмуляторе), откроем вкладку Logсat и установим наблюдение. В окне Logcat будет слишком много сообщений, которые будут нам мешать. Когда смотришь на бесконечный поток сообщений с какими-то веб-адресами и прочими записями, создаётся впечатление, что студия сливает всю информацию о банковских счетах, семейном положении, недвижимости в ЦРУ, ФБР, ФСБ, КГБ, Моссад одновременно. Говорят, что у котов усы (вибриссы) служат антеннами для связи с космосом. Не удивлюсь, если и эти пушистые засранцы передают информацию о своём хозяине и поток информации также льётся такой же бесконечной лентой. Когда коты решат захватить мир, у человечества не будет шансов.

Когда чувство паранойи немного отпустит, продолжим работу. Чтобы сократить число мешающих сообщений, выберите на вкладке пункт Show only selected application. Также следите, чтобы на второй вкладке отображалось название пакета вашего приложения. Дальше можно сократить число сообщений, если выбрать в другой вкладке пункт Info вместо Verbose. И наконец, в строке поиска можно ввести строку I/Main (если недостаточно, до вводите больше символов, вплоть до I/MainActivity), чтобы отсечь вообще всё лишнее. Теперь ничего нам не будет мешать.

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

 I/MainActivity: onCreate() called I/MainActivity: onStart() called 

Перед записью идёт временная метка (дата, время). Можете иногда смотреть на эти показания, если вам интересно.

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

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

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

Следует запомнить: за 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 вы можете использовать в любых удобных местах, чтобы посмотреть, как отработал код, результат которого не виден на экране. Так вы всегда можете проверить, что всё идёт по плану.

Источник

Android Activity Lifecycle with example in Kotlin

Android Activity Lifecycle: is managing the state of Activity like when its start, stop, user, using, not in front of the user, no more longer. So that all states are managing by call back methods in action. You can override those methods and can do a particular operation to do the best output of your application.

Like your application is going in the background and you want to save some data, in this case, you have to know about Android Activity Lifecycle.

Why Use Activity Lifecycle callback methods?

If you do a good implementation of Lifecycle call-backs methods in your android app it will avoid many problems, Like :

• If the user files the form and suddenly rotates the screen so all filled data will be lost, It’s not good.
• Android limited resources can crash your app if you didn’t release it on time
• Losing the user’s progress if they leave your app and return to it at a later time.

Many more problems you can save by just using the proper guideline of Activity Lifecycle.

Activity has six states

Activity lifecycle has seven methods

• onCreate()
• onStart()
• onResume()
• onPause()
• onStop()
• onRestart()
• onDestroy()

Practical Situations :

Lets see what happens when activity going through deferents state

• When open the app
  onCreate() –> onStart() –> onResume()
• When back button pressed and exit the app
  onPaused() — > onStop() –> onDestory()
• When home button pressed
  onPaused() –> onStop()
• After pressed home button when again open app from recent task list or clicked on app icon
  onRestart() –> onStart() –> onResume()
• When open app another app from notification bar or open settings
  onPaused() –> onStop()
• Back button pressed from another app or settings then used can see our app
  onRestart() –> onStart() –> onResume()
• When any dialog open on screen
  onPause()
• After dismiss the dialog or back button from dialog
  onResume()
• Any phone is ringing and user in the app
  onPause() –> onResume()
• When user pressed phone’s answer button
  onPause()
• After call end
  onResume()
• When phone screen off
  onPaused() –> onStop()
• When screen is turned back on
  onRestart() –> onStart() –> onResume()

Let’s come into deep: Lifecycle callbacks

onCreate()

When the android system first creates the activity, it will call onCreate(). Used to initialize the activity, for example, create the user interface.

onStart()

When the activity enters the Started state, the system invokes this callback. The onStart() call makes the activity visible to the user, as the app prepares for the activity to enter the foreground and become interactive.

onResume()

When the activity enters the Resumed state, it comes to the foreground, and then the system invokes the onResume() callback. This is the state in which the app interacts with the user.

onPause()

The system calls this method as the first indication that the user is leaving your activity (though it does not always mean the activity is being destroyed); it indicates that the activity is no longer in the foreground (though it may still be visible if the user is in multi-window mode).

onStop()

When your activity is no longer visible to the user, it has entered the Stopped state, and the system invokes the onStop() callback. This may occur, for example, when a newly launched activity covers the entire screen.

onRestart()

From the Stopped state, the activity either comes back to interact with the user, or the activity is finished running and goes away. If the activity comes back, the system invokes onRestart()

onDestroy()

Android system invokes onDestroy() method before the activity is destroyed. Activity is destroyed because of :

1. the activity is finishing (due to the user completely dismissing the activity or due to finish() being called on the activity), or
2. the system is temporarily destroying the activity due to a configuration change (such as device rotation or multi-window mode)
3. or a memory issue in the app

Some more callbacks methods added in activity lifecycle for saving and retrieving data :

onSaveInstanceState(Bundle outState)

As your activity begins to stop, the system calls the method onSaveInstanceState() so your activity can save state information to an instance state bundle.

onRestoreInstanceState(Bundle savedInstanceState)

When your activity is recreated after it was previously destroyed, you can recover your saved instance state from the Bundle that the system passes to your activity. Both the onCreate() and onRestoreInstanceState() callback methods receive the same Bundle that contains the instance state information.

Check the code :

Step 1. Create new project “ Build Your First Android App in Kotlin “

Step 2. Open MainActivity.kt kotlin class and override callbacks methods

add a print method with a log.

package `in`.eyehunt.androidactivitylifecyclekotlin import android.support.v7.app.AppCompatActivity import android.os.Bundle import android.util.Log class MainActivity : AppCompatActivity() < override fun onCreate(savedInstanceState: Bundle?) < super.onCreate(savedInstanceState) setContentView(R.layout.activity_main) print("onCreate") >override fun onStart() < super.onStart() print("onStart") >override fun onResume() < super.onResume() print("onResume") >override fun onPause() < super.onPause() print("onPause") >override fun onStop() < super.onStop() print("onStop") >override fun onRestart() < super.onRestart() print("onRestart") >override fun onDestroy() < super.onDestroy() print("onDestroy") >fun print(msg: String) < Log.d("Activity State ",msg) >>

Step 3. Run the application, in the emulator or On your Android device

See how to Logcat show

You can test all state. Do every situation as mentioned before in this tutorial.

Download Android activity lifecycle source code in kotlin :

Note: This example (Project) is developed in Android Studio 3.0.1, tested on Android 7.1.1 ( Android Nougat), compile SDK version API 26: Android 8.0 (Oreo)

MinSdkVersion=”15″

TargetSdkVersion=”26″

Coding in Kotlin

Источник