Как остановить приложение android studio

Обновлено: 06.01.2025

Методы
Метод addContentView()
Метод findViewById()
Метод finish()
Метод getFragmentManager()
Метод onSaveInstanceState()
Метод onRestoreInstanceState()
Метод onActivityResult()
Метод onPostCreate()
Метод overridePendingTransition()
Метод onWindowFocusChanged()
Метод onBackPressed()
Метод requestWindowFeature()
Метод setContentView()
Метод setFeatureDrawableResource()
Метод setRequestedOrientation()
Метод onConfigurationChanged()
Метод onKeyShortcut()
Метод startActivity()
Метод startActivityForResult()
Метод setResult()

Методы

Чтобы сгенерировать метод в Android Studio, щёлкните правой кнопкой мыши в области исходного кода и в контекстном меню выберите команду Generate. (Alt+Insert) | Override Methods… . В появившемся диалоговом окне отображаются методы, которые могут быть переопределены или реализованы в классе. Либо можете набирать первые символы нужного метода, используя автодополнение.

При переходе активности от одного состояния к другому, она получает уведомления через защищенные методы:

protected void onCreate(Bundle savedInstanceState);
protected void onStart();
protected void onRestart();
protected void onResume();
protected void onPause();
protected void onStop();
protected void onDestroy()

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

При реализации любого из этих методов необходимо всегда сначала вызывать версию этого метода из суперкласса. Например:

Семь перечисленных методов определяют весь жизненный цикл активности. Есть три вложенных цикла, которые вы можете отслеживать в классе активности:

полное время жизни (entire lifetime) — время с момента первого вызова метода onCreate() до вызова onDestroy() . Активность делает всю начальную установку своего глобального состояния в методе onCreate() и освобождает все остающиеся ресурсы в onDestroy() . Например, если активность порождает дополнительный поток, выполняющийся в фоновом режиме, можно создать этот поток в методе onCreate() и затем остановить поток в методе onDestroy() ;
видимое время жизни (visible lifetime) — время между вызовом метода onStart() и вызовом onStop() . В это время пользователь может видеть окно активности на экране, хотя окно может не быть на переднем плане и может не взаимодействовать с пользователем. Между этими двумя методами вы можете поддерживать в коде ресурсы, которые необходимы, чтобы отображать активность пользователю;
активное время жизни (foreground lifetime) — время между вызовами onResume() и onPause() . В это время окно активности находится на переднем плане и взаимодействует с пользователем. Активность в процессе работы приложения может часто переходить между состояниями active и paused, поэтому код в этих двух методах должен быть или небольшим по объему (чтобы не замедлять работу приложения во время выполнения), или порождать дополнительные потоки, если требуется выполнение задач, занимающих длительное время.

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

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

Методы жизненного цикла описаны в отдельной статье. Здесь их опишем кратко и рассмотрим другие методы.

Метод addContentView()

Метод addContentView() добавляет компонент к уже существующей разметке. Пример смотрите здесь.

Метод findViewById()

Метод findViewById() позволяет получить ссылку на View , которая размещена в разметке через его идентификатор.

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

Не путать с одноимённым методом для класса View .

Метод finish()

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

Метод getFragmentManager()

Каждая активность включает в себя Менеджер фрагментов для управления фрагментами, если они используются. Метод getFragmentManager() позволяет получить доступ к данному менеджеру. На сайте есть отдельные статьи, посвящённые фрагментам.

Метод onSaveInstanceState()

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

Сам метод вызывается прямо перед методом onPause() . Он предоставляет возможность сохранять состояние пользовательского интерфейса активности в объект Bundle , который потом будет передаваться в методы onCreate() и onRestoreInstanceState() . В объект Bundle можно записать параметры, динамическое состояние активности как пары имя-значение. Когда активность будет снова вызвана, объект Bundle передается системой в качестве параметра в метод onCreate() и в метод onRestoreInstanceState(), которыЙ вызывается после onStart(), чтобы один из них или они оба могли установить активность в предыдущее состояние. Прежде чем передавать изменённый параметр Bundle в обработчик родительского класса, сохраните значения с помощью методов getXXX() и putXXX().

Используйте обработчик onSaveInstanceState() для сохранения состояния интерфейса (например, состояния флажков, текущего выделенного элемента или введенных, но не сохраненных данных), чтобы объект Activity при следующем входе в активное состояние мог вывести на экран тот же UI. Рассчитывайте, что перед завершением работы процесса во время активного состояния будут вызваны обработчики onSaveInstanceState и onPause .

В отличие от базовых методов, методы onSaveInstanceState() и onRestoreInstanceState() не относятся к методам жизненного цикла активности. Система будет вызывать их не во всех случаях. Например, Android вызывает onSaveinstancestate() прежде, чем активность становится уязвимой к уничтожению системой, но не вызывает его, когда экземпляр активности разрушается пользовательским действием (при нажатии клавиши BACK). В этом случае нет никаких причин для сохранения состояния активности.

Метод onSaveInstanceState() вызывается системой в случае изменения конфигурации устройства в процессе выполнения приложения (например, при вращении устройства пользователем или выдвижении физической клавиатуры устройства.

Поскольку метод onSaveinstanceState() вызывается не во всех случаях, его необходимо использовать только для сохранения промежуточного состояния активности. Для сохранения данных лучше использовать метод onPause() .

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

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

Примеры использования можно увидеть в статьях Программное удаление пункта меню и Прячем и показываем ActionBar

Метод onRestoreInstanceState()

У метода onRestoreInstanceState() есть такой же параметр Bundle , как у onCreate() , и вы можете восстанавливать сохранённые значения из метода onSaveInstanceState().

Метод вызывается после метода onStart(). Система вызывает метод onRestoreInstanceState() только в том случае, если имеются сохранённые данные для восстановления. Таким образом вам не нужно проверять Bundle на null, как в методе onCreate() :

Метод onActivityResult()

Дочерняя активность может произвольно возвратить назад объект Intent , содержащий любые дополнительные данные. Вся эта информация в родительской активности появляется через метод обратного вызова Activity.onActivityResult() , наряду с идентификатором, который она первоначально предоставила.

Если дочерняя активность завершится неудачно или будет закрыта пользователем без подтверждения ввода через кнопку Back, то родительская активность получит результат с кодом RESULT_CANCELED .

Метод принимает несколько параметров:

Код запроса - тот код, который использовался для запуска дочерней активности, возвращающий результат.
Результирующий код - код результата, поступающий от дочерней активности, как правило, RESULT_OK или RESULT_CANCELED
Данные - намерение может включать в себя различные данные в виде параметра extras внутри намерения.

Метод onPostCreate()

Новый метод, который появился в API 21. Он вызывается позже onCreate() и в нём можно получить значения размеров компонентов, которые недоступны при построении интерфейса в методе onCreate() .

Метод overridePendingTransition()

Метод overridePendingTransition() позволяет задать анимацию при переходе от одной активности к другой. Пример смотрите здесь.

Метод onWindowFocusChanged()

Метод позволяет определить момент получения фокуса вашим приложением.

Метод может быть полезен, так как он срабатывает позже метода onCreate() . Например, для вычисления размеров кнопки на экране этот метод предпочтительнее, так как уже известно, что все элементы загрузились и доступны, тогда как в onCreate() могут возвратиться пустые значения ширины и высоты кнопки. Пример использования.

Другой пример: Получить координаты компонента

Метод onBackPressed()

Метод, позволяющий отследить нажатине на кнопку Back. Появился в Android 2.0 (API 5). Пример использования можно посмотреть в статье Кнопка Back: Вы уверены, что хотите выйти из программы?.

Метод requestWindowFeature()

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

Метод setContentView()

Изначально экран активности пуст. Чтобы разместить пользовательский интерфейс, необходимо вызвать метод setContentView() . У метода есть две перегруженные версии. Вы можете передать в параметре либо экземпляр компонента (View), либо идентификатор ресурса (наиболее распространённый способ).

Пример с использованием экземпляра компонента:

В этом примере вы увидите на экране текстовое поле с текстом. Но при таком способе вы можете использовать только один компонент. А если экран состоит из множества кнопок и прочих элементов управления, то нужно использовать разметку.

Метод setFeatureDrawableResource()

С помощью данного метода можно вывести значки в правой части заголовка. Смотри пример.

Метод setRequestedOrientation()

Метод позволяет программно изменить ориентацию экрана. Пример использования.

Метод onConfigurationChanged()

Метод, который вызывается при изменении конфигурации устройства. Если в манифесте были установлены специальные параметры у атрибута android:configChanges , то данный метод не будет вызван.

Метод onKeyShortcut()

Смотри Горячие клавиши в меню

Метод startActivity()

Чтобы запустить новую активность, используется метод startActivity(Intent) . Этот метод принимает единственный параметр — объект Intent , описывающий активность, которая будет запускаться. Смотри пример Activity.

Метод startActivityForResult()

Иногда требуется вернуть результат активности, когда она закрывается. Например, можно запустить активность, которая позволяет пользователю выбирать человека в списке контактов. При закрытии активность возвращает данные человека, который был выбран: его полное имя и телефон. В этом случае необходимо вызвать метод startActivityForResult()

Метод startActivityForResult(Intent, int) со вторым параметром, идентифицирующим запрос позволяет возвращать результат. Когда дочерняя активность закрывается, то в родительской активности срабатывает метод onActivityResult(int, int, Intent) , который содержит возвращённый результат, определённый в родительской активности.

Метод setResult()

Когда активность завершится, вы можете вызвать метод setResult(int) , чтобы возвратить данные назад в родительскую активность (до метода finish() ). Этот метод возвращает код результата закрытия активности, который может быть стандартными результатами Activity.RESULT_CANCELED , Activity.RESULT_OK или определяемым пользователем результатом RESULT_FiRST_USER (можете придумать любую константу с целочисленным значением).

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

Если метод finish() вызвать раньше метода setResult() , то результирующий код установится в RESULT_CANCELED автоматически, а возвращённое намерение покажет значение null.

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

Activity класс предоставляет два метода жизненного цикла, onStop() и onRestart() , которые позволяют специально обрабатывать то, как ваша activity будет останавливаться и перезапускаться. В отличие от состояния приостановки, которое означает частичное перекрытие элементов пользовательского интерфейса, состояние остановки vгарантирует, что пользовательский интерфейс больше не виден и фокус пользователя находится в другой activity (или совершенно другом приложении).

Примечание: Поскольку система удерживает ваш Activity экземпляр в системной памяти, когда он остановлен, вполне возможно, что вам не нужно реализовывать onStop() и onRestart() (или даже onStart() методы вообще. Для большинства activity , которые относительно простые, activity будет остановлена и перезапущена вполне нормально, и вы, возможно, должны использовать только onPause() для приостановки текущих действий и отсоединения от системных ресурсов.

Рисунок 1. Когда пользователь покидает вашу activity , система вызывает onStop() для прекращения activity (1). Если пользователь возвращается по время остановки activity , система вызывает onRestart() (2), а затем быстро onStart() (3) и onResume() (4). Обратите внимание, что независимо от того, какой сценарий вызывает остановку activity , система всегда вызывает onPause() перед вызовом onStop() .

Остановка вашей activity

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

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

Например, вот реализация onStop() , который сохраняет содержимое черновика записки в постоянное хранилище:

super . onStop ( ) ; // Always call the superclass method first // Save the note's current draft, because the activity is stopping // and we want to be sure the current note progress isn't lost. values . put ( NotePad . Notes . COLUMN_NAME_NOTE , getCurrentNoteText ( ) ) ; values . put ( NotePad . Notes . COLUMN_NAME_TITLE , getCurrentNoteTitle ( ) ) ; values , // The map of column names and new values to apply to them.

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

Примечание: Даже если система разрушает вашу activity , когда она остановлена, она все еще сохраняет состояние View объектов (например, текста в EditText ) в Bundle (в блобе с парами ключ-значение), и восстанавливает их, если пользователь переходит обратно в тот же экземпляр activity ( cледующий урок рассказывает больше об использовании Bundle для сохранения других данных состояния в случае, если ваша activity уничтожена и создана заново).

Запуск/перезапуск вашей activity

Когда ваша activity возвращается на первый план из остановленного состояния, она получает вызов onRestart() . Система также вызывает onStart() метод, который происходит каждый раз, когда ваша activity становится видимой пользователю (будь то перезапуск или объект создан впервые). onRestart() метод, однако, вызывается только когда activity возобновляется из остановленного состояния, так что вы можете использовать его для выполнения специальных реставрационных работ, которые могут быть необходимы, только если activity была ранее остановлена, но не уничтожена.

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

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

Иногда в приложении встречаются ошибки, которые нельзя увидеть даже после запуска. Например, код компилируется, проект запускается, но результат далёк от желаемого: приложение падает или вдруг появляется какая-то ошибка (баг). В таких случаях приходится «запасаться логами», «брать в руки отладчик» и искать ошибки.

Часто процесс поиска и исправления бага состоит из трёх шагов:

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

Если приложение не падает и чтение логов ничего не даёт, то найти точное место ошибки в коде помогает дебаггер (отладчик) — инструмент среды разработки.

Чтобы посмотреть на логи и воспользоваться дебаггером, давайте напишем простое тестовое (и заведомо неправильное) приложение, которое даст нам все возможности для поиска ошибок.

Это будет приложение, которое сравнивает два числа. Если числа равны, то будет выводиться результат «Равно», и наоборот. Начнём с простых шагов:

Открываем Android Studio.
Создаём проект с шаблоном Empty Activity.
Выбираем язык Java, так как его, как правило, знают больше людей, чем Kotlin.

Нам автоматически откроются две вкладки: activity_main.xml и MainActivity.java. Сначала нарисуем макет: просто замените всё, что есть в activity_main.xml, на код ниже:

Можете запустить проект и посмотреть, что получилось:

Теперь оживим наше приложение. Скопируйте в MainActivity этот код:

В этом коде всё просто:

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

Запустим приложение и введём буквы вместо чисел:

Нажмём на кнопку, и приложение упадёт! Время читать логи. Открываем внизу слева вкладку «6: Logcat» и видим:

Конечно, метод parseInt может принимать только числовые значения, но никак не буквенные! Даже в его описании это сказано — и мы можем увидеть, какой тип ошибки этот метод выбрасывает (NumberFormatException).

Здесь мы привели один из примеров. Типов ошибок может быть огромное количество, все мы рассматривать не будем. Но все ошибки в Logcat’е указываются по похожему принципу:

красный текст;
тип ошибки — в нашем случае это NumberFormatException;
пояснение — у нас это For input string: "f";
ссылка на строку, на которой произошла ошибка — здесь видим MainActivity.java:26.

Исправим эту ошибку и обезопасим себя от некорректного ввода. Добавим в наши поля ввода android:inputType="number", а остальной код оставим без изменений:

Теперь можем вводить только числа. Проверим, как работает равенство: введём одинаковые числа в оба поля. Всё в порядке:

На равенство проверили. Введём разные числа:

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

Воспроизведём ошибку: да, ошибка воспроизводится стабильно с любыми двумя разными числами.
Подумаем, где может быть ошибка: наверняка там, где сравниваются числа. Туда и будем смотреть.
Исправим ошибку: сначала найдём её с помощью дебаггера, а когда поймём, в чём проблема, — будем исправлять.

И здесь на помощь приходит отладчик. Для начала поставим точки останова сразу в трёх местах:

Чтобы поставить или снять точку останова, достаточно кликнуть левой кнопкой мыши справа от номера строки или поставить курсор на нужную строку, а затем нажать CTRL+F8. Почему мы хотим остановить программу именно там? Чтобы посмотреть, правильные ли числа сравниваются, а затем определить, в какую ветку в нашем ветвлении заходит программа дальше. Запускаем программу с помощью сочетания клавиш SHIFT+F9 или нажимаем на кнопку с жучком:

Появится дополнительное окно, в котором нужно выбрать ваш девайс и приложение:

Вы в режиме дебага. Обратите внимание на две вещи:

Точки останова теперь помечены галочками. Это значит, что вы находитесь на экране, где стоят эти точки, и что дебаггер готов к работе.
Открылось окно дебага внизу: вкладка «5: Debug». В нём будет отображаться необходимая вам информация.

Введём неравные числа и нажмём кнопку «РАВНО?». Программа остановилась на первой точке:

Как видим, значения именно такие, какие мы и ввели. Значит, проблема не в получении чисел из полей. Давайте двигаться дальше — нам нужно посмотреть, в правильную ли ветку мы заходим. Для этого можно нажать F8 (перейти на следующую строку выполнения кода). А если следующая точка останова далеко или в другом классе, можно нажать F9 — программа просто возобновит работу и остановится на следующей точке. В интерфейсе эти кнопки находятся здесь:

Остановить дебаггер, если он больше не нужен, можно через CTRL+F2 или кнопку «Стоп»:

В нашем случае неважно, какую кнопку нажимать (F9 или F8). Мы сразу переходим к следующей точке останова программы:

Ветка правильная, то есть логика программы верна, числа firstInt и secondInt не изменились. Зато мы сразу видим, что подпись некорректная! Вот в чём была ошибка. Исправим подпись и проверим программу ещё раз.

Мы уже починили два бага: падение приложения с помощью логов и некорректную логику (с помощью отладчика). Хеппи пас (happy path) пройден. То есть основная функциональность при корректных данных работает. Но нам надо проверить не только хеппи пас — пользователь может ввести что угодно. И программа может нормально работать в большинстве случаев, но вести себя странно в специфических состояниях. Давайте введём числа побольше и посмотрим, что будет:

Не сработало — программа хочет сказать, что 1000 не равна 1000, но это абсурд. Запускаем приложение в режиме отладки. Точка останова уже есть. Смотрим в отладчик:

Числа одинаковые, что могло пойти не так? Обращаем внимание на тип переменной — Integer. Так вот в чём проблема! Это не примитивный тип данных, а ссылочный. Ссылочные типы нельзя сравнивать через ==, потому что будут сравниваться ссылки объектов, а не они сами. Но для Integer в Java есть нюанс: Integer может кешироваться до 127, и если мы вводим по единице в оба поля числа до 127, то фактически сравниваем просто int. А если вводим больше, то получаем два разных объекта. Адреса у объектов не совпадают, а именно так Java сравнивает их.

Есть два решения проблемы:

Изменить тип Integer на примитив int.
Сравнивать как объекты.

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

Всё работает. Наконец-то! Хотя… Давайте посмотрим, что будет, если пользователь ничего не введёт, но нажмёт на кнопку? Приложение опять упало… Смотрим в логи:

Опять NumberFormatException, при этом строка пустая. Давайте поставим точку останова на 26-й строке и заглянем с помощью отладчика глубже.

Нажмём F8 — и перейдём в глубины операционной системы:

Интересно! Давайте обернём код в try/catch и посмотрим ошибке в лицо. Если что, поправим приложение. Выделяем код внутри метода onClick() и нажимаем Ctrl+Alt+T:

Выбираем try / catch, среда разработки сама допишет код. Поставим точку останова. Получим:

Запускаем приложение и ловим ошибку:

Действительно, как и в логах, — NumberFormatException. Метод parseInt выбрасывает исключение, если в него передать пустую строку. Как обрабатывать такую проблему — решать исключительно вам. Два самых простых способа:

Проверять получаемые строки first.getText().toString() и second.getText().toString() на пустые значения. И если хоть одно значение пустое — говорить об этом пользователю и не вызывать метод parseInt.
Или использовать уже готовую конструкцию try / catch:

Теперь-то точно всё в порядке! Хотя профессиональным тестировщикам это приложение никто не отдавал: поищете ещё ошибки? :)

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

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

Ни для кого не секрет, что процесс может быть убит системой. А вы интересовались, реально ли сымитировать это? Можно попробовать“натравить” систему на свое приложение, запуская кучу других приложений, съедающих знатный кусок памяти, а затем надеяться, что система таки снизошла до нас убив нужное приложение. Прямо какой-то шаманизм получается, а это стезя админов, но никак не программистов. Меня заинтересовало, как можно легко и быстро убить приложение, да так, будто это сделала система для освобождения ресурсов. Ведь если получится повторить подобное поведение в “лабораторных условиях”, можно будет отлавливать множество ошибок ещё на стадии разработки, либо с лёгкостью воспроизвести их для выявления причин.

Как оказалось, нужный механизм уже имеется в SDK, и это… барабанная дробь… Кнопка «Terminate Application».

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

Используя Android Stidio запустить приложение;
Свернуть приложение нажатием кнопки «Home»;
В Android Studio, перейти на вкладку Android, выбрать приложение и нажать кнопку «Terminate Application»;
Развернуть свернутое приложение.

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

Ситуация 1: Статик — это не надёжно

Представим такую ситуацию: В одной Activity мы вводим некий набор данных, например имя и фамилию. Эта Activity строго следит за правильностью ввода данных, поэтому можно с твёрдой уверенностью гарантировать их «корректность», и вообще то, что они были введены.
После нажатия кнопки “Next” создается объект хранящий введенные данные и записывается в статик ссылку, а затем открывается вторая Activity, которая показывает эти данные в подобающем виде. Например, пишет: «Вас зовут Владимир Путин».

Как видно из кода, в первой Activity разработчик решил не “заморачиваться” и поместил данные в статические переменные. Это весьма соблазнительно, когда нужно передать достаточно неординарный объект, не поддающийся простой сериализации. Над второй Activity он тоже не долго думал и не сделал проверки на нул. Зачем, когда первая Activity всё уже сделала?

Проделываем описанную ранее последовательность по корректному уничтожению процесса на второй Activity. Приложение падает.

Что случилось?
Проблема тут не в отсутствии проверки на null. Самая страшная проблема — это потеря пользовательских данных. Статические объекты не должны быть хранилищем данных, особенно если это их единственное место. Касается это как обычных переменных так и синглтонов. Так что если в статике хранится что-то важное, будьте готовы это важное потерять в любой момент.

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

Волшебная сила Application
Как часто я вижу советы использовать класс Application как синглтон либо инициализировать синглтон в методе onCreate() класса Application. Якобы после этого он станет круче чем Ленин, то есть будет живее всех живых при любых обстоятельствах. Возможно, это частный случай заблуждения встретившийся только мне. Причем, все публикации которые я находил, явно не заявляют о подобных свойствах синглтона. В некоторых из них говорится, что синглтон может быть уничтожен сборщиком мусора если инициировать его в классе Activity (что для меня звучит немного дико). В других пугают выгрузкой класса из класслоадера (а это уже похоже на правду).

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

Ситуация 2: setRetainInstance как решение всех проблем

Допустим, некий программист решил повторить пример с именем и фамилией, но с использованием диалог фрагментов.
Итак, есть DialogFragment с текстовым полем для ввода фамилии и имени. Этому фрагменту можно установить слушатель на ввод данных. Для того что бы не потерять ссылку на слушатель в onCreate() вызывается setRetainInstance(true).

На экране есть кнопка, при нажатии на которую этот диалог отображается.

Такая реализация — стойка к любым вращениям экрана. Все будет работать как часы. До поры до времени…
Применим последовательность действий для хитрого уничтожения процесса, когда диалог открыт. При разворачивании ничего не произойдет. Однако, при вызове invokePersonChoose приложение вылетит с NullPointerException.

Что случилось?
setRetainInstance(true) не позволяло диалогу уничтожиться. После уничтожения процесса диалог все-таки был уничтожен. Activity восстанавливает фрагмент насколько это возможно. К сожалению, слушатель не восстанавливается, так как он был установлен совершенно в другом месте для совершенно другого объекта. Когда в диалоге, в методе invokePersonChoose, происходит обращение к слушателю, выбрасывается исключение. И беда тут не в отсутствии проверки на null. Поставить проверку на null без должной реакции на пустую ссылку будет еще более худшим решением.

Еще пара слов про setRetainInstance
Замечу, это лишь частный случай с setRetainInstance. Количество проблем которые он может скрыть(а не решить) немного больше. Вместе со слушателями также теряются и все остальные переменные. Все, что не было сохранено в методе onSaveInstanceState, будет потеряно.
Также, он скрывает проблему когда класс диалога анонимный. Допустим, в момент создания нового объекта диалога, переопределен какой либо метод, в этом случае создастся объект анонимного класса.

Если этот диалог будет уничтожен и система попытается его восстановить выбросится исключение ClassNotFoundException.

Ситуация 3: Разорванные нити

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

Если запустить этот код и не дожидаясь его завершения свернуть приложение, а затем вырубить процесс, то при разворачивании ничего не предвещает беды, приложение не падает, а диалог показывается. Ждём немножко… Ещё ждём… Потом ещё ждём… Диалог не закрывается, хоть и должен был сделать это уже давно.

Что случилось?
При уничтожении процесса останавливаются все его потоки, а при восстановлении запускается только главный поток. Так что если ваш поток работает слишком долго, будьте готовы к тому, что он будет остановлен. Причём не обязательно делать что-то долго, на эти грабли можно наступить и при использовании wait notify. Особенно забавно будет, если в качестве объекта для блокировки использовать public static final Object, ведь мы то уже знаем, что статик объекты не исключение при уничтожении процесса.

Что делать?
Если задача занимает много времени вынести ее в отдельный сервис и запустить в новом процессе, плюс вывести foreground Notification, иначе процесс все равно будет убит. В случае с wait notify все немного сложнее и зависит от конкретной ситуации. Вообще, тема работы с потоками достаточно обширна, и давать какой-то конкретный совет тут неуместно. Разве что не усложнять и не лезть в дебри, из которых не сможешь вылезти.

Ситуация 4: Письмо в никуда

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

При возвращении на первую Activity цвет View будет изменен.

Однако, если перейти на вторую Activity, свернуть приложение, убить процесс, а затем развернуть приложение, случится кое-что не предвиденное. Сколько бы раз вы не нажимали на кнопку смены цвета, при возвращении на первую Activity ее View будет белоснежной.

Заключение

“Бывалым кодерам” эти ситуации могут показаться очевидными, а примеры на столько не естественными, что просто воротит. Однако, все мы когда-то начинали с нуля и писали код от которого сейчас было бы стыдно. Знай я об этих граблях в самом начале своего пути, шишек на лбу было бы меньше. Надеюсь, эта статья поможет наставить на путь истинный большое количество начинающих Android программистов. От “Бывалых” буду рад увидеть комментарии. А еще лучше если вы дополните список или напишете, помогла ли эта статья в ловле багов из разряда “Как?! Такого не может быть!”.

На этом закончу. Спасибо за внимание. Напоследок замечу, в рукаве у меня еще остался один неординарный случай. Он еще не изучен мной до конца, но я надеюсь в скором времени расколоть этот крепкий орешек. Так что ждите продолжения.

Читайте также: