Обновить активити android studio

Содержание
  1. Обновление данных в activity
  2. Что такое Activity и его жизненный цикл в Android
  3. Жизненный цикл Activity
  4. Методы жизненного цикла
  5. Запуск Activity
  6. Запуск Activity без ожидаемого результата
  7. Запуск Activity на результат
  8. Пример запуска Activity
  9. Прерывание Activity
  10. Стадия экземпляра Activity
  11. Заключение
  12. Перезагрузить активность в Android
  13. 14 ответов
  14. Жизненный цикл Android
  15. Жизненный цикл Android
  16. Начнем
  17. Понимание роли жизненного цикла приложений
  18. Изучение жизненного цикла активности
  19. Заметка
  20. Понимание колбэков жизненного цикла активити
  21. Заметка
  22. Сохранение и восстановление состояния экземпляра активити
  23. Сохранение состояния экземпляра
  24. Заметка
  25. Восстановление состояния
  26. Заметка
  27. Заметка
  28. Передача данных между экранами
  29. Разбираем данные объекта Intent
  30. Изучение жизненного цикла фрагмента
  31. Понимание обратных вызовов жизненного цикла фрагмента
  32. Использование ViewModel для хранения данных пользовательского интерфейса

Обновление данных в activity

Всем доброй ночи!
Как обновить данные в активити при возврате из диалога или из другой активити, т.е. когда фокус возвращается на активити?
Блин, запутанно получилось.
Вообщем, есть код, который выполняет обновление представления, выполняет поиск данных и обновляет ViewPager, куда его поместить, чтобы это происходило каждый раз, когда активити становиться активной вновь: закрытие диалога, подтверждение в диалоге с последующим закрытием, нажатие кнопки «назад» или в ActionBar, возвращающее на данную активити из другой. Вообщем при каждом возврате фокуса к данной активити.

Обновление данных Activity при нажатии на кнопку
Приветствую всех. Проблема такая: необходимо обновлять данные(ImageView, TextView и т.п.) в.

Android — Передача данных с одного Activity на другое Activity
Здравствуйте , возникла необходимость получения числовых (int и float ну или double) данных в одном.

Как изменить кнопку на втором Activity с первого Activity в Android Studio?
Общая задача сделать уровни для игры, по окончанию первого уровня, появляется кнопка «выбор уровня».

Как в Android Studio изменять объект одного Activity из другого Activity?
Есть два Activity, в одном кнопка и элемент editText. Во втором activity есть элемент TextView.

Но при закрытии диалога эти события не возникают.

Источник

Что такое Activity и его жизненный цикл в Android

Russian (Pусский) translation by Ellen Nelson (you can also view the original English article)

Из моей предыдущей статьи вы узнали, что Intents позволяют отправлять сообщения с одного компонента Android на другой. А очень важным компонентом является Activity.

Activities являются основной частью разработки приложений для Android. И невозможно понять Activity, не понимая их жизненных циклов. В этом материале вы узнаете всё о жизненном цикле Activity.

Жизненный цикл Activity

Activity — это отдельный экран в Android. Это как окно в приложении для рабочего стола, или фрейм в программе на Java. Activity позволяет вам разместить все ваши компоненты пользовательского интерфейса или виджеты на этом экране.

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

Методы жизненного цикла

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

onCreate() : вызывается при первой инициализации Activity. Вам нужно выполнить этот метод для выполнения любой инициализации в вашей Activity.

onStart() : это вызывается, когда Activity готова и отображается пользователю в первый раз, так как Activity готовится стать интерактивной и выйти на передний план. После завершения вызова этого метода, будет вызван метод onResume() .

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

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

onStop() : этот метод вызывается, если Activity больше не видна в приложении. Такое может случится, если подгружена другая Activity и она занимает весь экран устройства. Когда вызывает этот метод, Activity сообщается перейти в состояние прекращения работы. В этом состоянии, система либо вызывает onRestart() для возврата взаимодействия с Activity, либо вызывает метод onDestroy() , чтобу убрать Activity.

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

onRestart() : это вызывается, если Activity перезапускается, после того, как было остановлено.

Запуск Activity

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

Необходимо связывать Activity друг с другом, если требуется чтобы одна Activity запускала другую. Для запуска Activity используйте либо startActivity() , либо startActivityForResult() . В обоих случаях вы должны передать Intent.

Запуск Activity без ожидаемого результата

startActivity() используется, если недавно запущенная Activity не должна возвращать результат.

Следующий фрагмент кода показывает как начать другую Activity, используя этот метод:

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

Запуск Activity на результат

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

Вы получите результат от Activity в методе onActivityResult(int requestCode, int resultCode, Intent data) . Результат будет возвращен в качестве Intent.

Пример запуска Activity

Вот пример, который показывает как работает запуск Activity

Во-первых создайте MainActivity с вашим методом onCreate() , файл макета и кодом запроса.

В методе onCreate() вы создадите новый экземпляр намерения (intent) чтобы запустить вторую Activity.

Когда будете готовы к запуску Activity, скажем в ответ на нажатие кнопки, вы вызовете startActivityForResult() , которая передаст свеже-созданное намерение и код запроса.

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

Вот как это должно выглядеть:

Теперь создайте вашу SecondActivity . Это должно быть похоже на код ниже.

Прерывание Activity

Перед завершением Activity, будут вызваны соответствующие методы жизненного цикла.

Метод onPause() должен остановить все «слушания» и обновления интерфейса. Метод onStop() должен сохранять данные приложения. И наконец, метод onDestroy() высвободит любые ресурсы, выделенные для Activity.

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

Стадия экземпляра Activity

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

Читайте также:  Прошивка для android gps

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

Чтобы сохранить состояние Activity, можно переопределить метод onSaveInstanceState(). Этот метод передаёт объект Bundle , в качестве параметра. Пакет (bundle) может содержать строки, простые типы данных или объекты. В этом методе, просто добавьте любые данные о важном состоянии в пакет (bundle). Позже этот пакет вернется Activity, так что вы сможете восстановить состояние Activity.

Чтобы извлечь сохраненное состояние из пакета и восстановить его (состояние), примените метод onRestoreInstanceState() . Этот callback вызывается между методами жизненного цикла onStart() и onResume() .

Мы получше рассмотрим состояние экземпляра Activity в будущих статьях.

Заключение

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

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

Источник

Перезагрузить активность в Android

это хорошая практика, чтобы перезагрузить Activity на Android?

что было бы лучшим способом сделать это? this.finish а то this.startActivity активность Intent ?

14 ответов

Вы можете просто использовать

обновление Activity изнутри.

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

это по существу заставляет активность перерисовывать себя.

обновление: лучший способ сделать это-вызвать recreate() метод. Это приведет к воссозданию активности.

для тех, кто не хочет видеть, что мигает после recreate () метод просто использовать

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

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

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

Источник

Жизненный цикл Android

Жизненный цикл Android

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

Когда дело доходит до создания приложения на Android, активити и фрагменты являются ключевыми компонентами для создания пользовательского интерфейса (UI). Когда пользователь перемещается по приложению, эти компоненты проходят через разные состояния жизненного цикла Android.

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

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

  • Роль жизненного цикла в Android приложениях.
  • Основы жизненных циклов активити и фрагментов, а также колбэки (обратные вызовы), вызываемые, когда действие перемещается между состояниями жизненного цикла.
  • Как сохранить и восстановить состояние экземпляра активити.
  • Процесс передачи данных между активити и фрагментами.
  • Как ViewModel может помочь вам хранить и управлять данными, связанными с пользовательским интерфейсом с учетом жизненного цикла.

Для этого урока вам понадобится Android Studio и Android-устройство или эмулятор.

Начнем

Для начала загрузите материалы. Откройте стартовый проект в Android Studio. Как только проект откроется, дайте ему запуститься и синхронизироваться, и вы будете готовы к работе!

Запустите приложение и проверьте его возможности:

В приложении два экрана:

  • Главный экран: позволяет подсчитывать собак разных размеров. Вы можете нажимать на карточки или на кнопки «плюс» и «минус», чтобы обновить счетчики. На верхней панели у вас есть две кнопки: первая сбрасывает значения, а вторая открывает экран «Share» (Поделиться).
  • Экран Share: показывает количество ваших собак. Нажмите на «Share», чтобы открыть диалоговое окно, в котором вас спросят, хотите ли вы поделиться своим счетом. В этом туториале вы не реализуете эту логику, но можете притвориться, что она существует. :]

Затем ознакомьтесь со структурой проекта:

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

  • DogCount: класс модели для ваших данных.
  • SplashActivity: активити, которая открывается при запуске приложения.
  • PuppyCounterApplication: класс приложения.

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

Понимание роли жизненного цикла приложений

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

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

Самый распространенный компонент приложения — Activity. Каждое приложение для Android имеет одно или несколько активити. Когда пользователь перемещается по приложению, действия проходят через разные состояния жизненного цикла.

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

Изучение жизненного цикла активности

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

  • Initialized: создается экземпляр активити и инициализируются его свойства.
  • Created: активити теперь полностью инициализировано и готово к настройке своего пользовательского интерфейса.
  • Started: активити видна пользователю.
  • Resumed: активити видна пользователю и находится в фокусе. В этом состоянии пользователь, скорее всего, взаимодействует с активити.
  • Destroyed: активити уничтожена, и ОС может освободить свою память.

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

Прежде чем объяснять каждый колбэк, проверьте их в действии. Откройте MainActivity.kt и добавьте логирование в onCreate() и onResume() . Также переопределите другие колбэки:

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

Читайте также:  Сервер сбербанка для quik android

Скомпилируйте и запустите приложение. Затем проверьте логи. Чтобы просмотреть логи в Android Studio, откройте инструмент Logcat, щелкнув Logcat внизу на странице. Введите PuppyCounter в историю поиска, чтобы показать результаты:

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

Заметка

В логах вы не увидите сообщение «Back button clicked» (Нажата кнопка назад). Мы добавили это в изображение, чтобы вам было легче заметить нажатия кнопок.

Понимание колбэков жизненного цикла активити

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

На приведенной выше диаграмме представлен жизненный цикл активити:

  • onCreate(): активити переходит в состояние Создано. Здесь вы выполняете логику, которая должна выполняться только один раз за все время активити. Сюда можно включить настройку контент вью, связывание активити с ViewModel, создание экземпляров некоторых переменных области класса и т.д.
  • onStart(): активити переходит в состояние Начато. Этот вызов делает активити видимой для пользователя, поскольку приложение готовится к тому, чтобы активити перешла на передний план и стала интерактивной.
  • onResume(): активити переходит в состояние Возобновлено. Теперь пользователь может взаимодействовать с активити. Здесь вы можете включить любую функциональность, которая должна работать, пока компонент виден и находится на переднем плане.
  • onPause(): активити переходит в состояние Приостановлено. Этот вызов указывает на то, что активити больше не находится на переднем плане, хотя она может быть видна, например, если пользователь находится в многооконном режиме. В это время вам следует приостановить или настроить операции, которые не должны продолжаться или должны продолжаться в модерации. Действие остается в этом состоянии до возобновления активити, например, открытия или закрытия нижнего листа в действии, или до тех пор, пока оно не станет полностью невидимым для пользователя, например, при открытии другого действия.
  • onStop(): активити переходит в состояние Остановлено. Активити больше не видна пользователю. Здесь вы должны освободить или настроить ресурсы, которые не нужны, пока активити не видна пользователю. Вы также должны использовать эту возможность для выполнения операций выключения для задач, которые относительно интенсивно загружают процессор, например, для операций с базой данных.
  • onDestroy(): активити переходит в состояние Уничтожено. На этом работа заканчивается. Это может быть потому, что:
  • Пользователь полностью закрывает активити.
  • finish() вызывается для активити.
  • Система временно прерывает активити из-за изменения конфигурации, например поворота устройства или многооконного режима.

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

Заметка

Дополнительные сведения о жизненном цикле Activity смотрите в Android Developer documentation.

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

Если вы немного поиграли с приложением, то возможно, заметили пару ошибок. Счетчик увеличивается при нажатии карточек на главном экране.

Теперь поверните устройство, чтобы изменить ориентацию экрана. Если на дисплее вашего устройства включен автоповорот, вы увидите что-то вроде этого:

Состояние счетчика обнулилось при смене ориентации экрана. Посмотрим логи:

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

Скоро мы это исправим!

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

Откройте MainActivity.kt и добавьте следующий код:

Когда активити начинает останавливаться, ОС вызывает onSaveInstanceState() , чтобы действие сохранило любую информацию о состоянии в бандле сохранения состояния. Некоторые вью Android обрабатывают по умолчанию — EditText для текста и ListView для позиции прокрутки.

Заметка

OnSaveInstanceState() не вызывается, когда пользователь явно закрывает активити или когда вызывается finish() .

Чтобы сохранить состояние dogCount , вы переопределили onSaveInstanceState() и сохранили состояние в Bundle как пару ключ-значение с помощью outState.putParcelable() . В качестве ключа вы использовали STATE_DOG_COUNT , который уже был определен в классе.

Проверьте класс DogCount . Вы заметите, что он реализует Parcelable . Если вы не знакомы с Parcelable — это интерфейс, концептуально похожий Serializable в Java . Классы, реализующие Parcelable , могут быть записаны и восстановлены из Parcel , который разработан для высокопроизводительного транспорта IPC (IPC transport). Проще говоря, он позволяет хранить простые структуры данных в Bundle .

Восстановление состояния

Прекрасно! Теперь у вас есть логика для сохранения состояния, но в ней нет пользы, пока у вас нет логики для ее получения. В MainActivity.kt добавьте следующий код ниже onSaveInstanceState() :

Любое состояние, которое вы сохраняете в onSaveInstanceState() , вы можете восстановить в onRestoreInstanceState() . onRestoreInstanceState() получает Bundle , который содержит пары ключ-значение, которые вы можете прочитать. Здесь вы использовали saveInstanceState.getParcelable() для получения состояния DogCount . Обратите внимание, что вы использовали тот же ключ, что и для сохранения состояния: STATE_DOG_COUNT .

Заметка

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

Запустите приложение. Увеличьте значения счетчиков и поменяйте ориентацию экрана:

Также проверьте логи, когда все колбеки будут вызваны, вы увидите следующую картину:

Заметка

Не путайте onSaveInstanceState() и onRestoreInstanceState() с колбеками жизненного цикла активности. ОС вызывает эти методы только в тот момент, когда это нужно.

Отлично! Теперь, когда вы исправили ошибку в приложении, пора перейти к следующей. 🙂

Передача данных между экранами

Увеличьте значения счетчиков на главном экране, а затем откройте экран «Share». Вы заметите, что значения экрана «Share» не совпадают со значениями на главном экране.

В MainActivity.kt измените showShareScreen() следующим образом:

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

В ShareActivity.kt добавьте следующий метод:

Этот метод извлекает объект Intent , который запустил это действие, и пытается получить дополнительные данные, которые были переданы с ним. В этом конкретном случае он попытается получить состояние DogCount .

Чтобы завершить логику получения, вызовите этот метод в onCreate() в ShareActivity.kt:

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

Супер! Запустите приложение. Увеличьте значения счетчиков и откройте экран «Share». Вы увидите что-то вроде этого:

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

Обратите внимание, как ОС создает ShareActivity сразу после вызова onPause() MainActivity. Как упоминалось ранее, приложение вызывает onStop() , когда активити больше не видна пользователю. После вызова onPause() MainActivity вы можете увидеть серию колбэков жизненного цикла ShareActivity, которые включают чтение intent данных. После возобновления ShareActivity полностью виден пользователю, и может быть вызвана функция MainActivity onStop() , за которой следует onSaveInstanceState() .

Разбираем данные объекта Intent

Измените ориентацию экрана на экране Share и обратите внимание на то, что происходит. Вы увидите, что приложение сохранило состояние dogCount . Как это возможно, если вы не реализовали логику для сохранения и получения состояния экземпляра?

Читайте также:  Flac чем открыть андроид

Вы уже знакомы с тем, как состояние может быть потеряно во время изменения конфигурации. В этом случае обратите внимание на то, что лог readExtras() снова присутствует, когда приложение создает новый ShareActivity. Но если вы проверите код, вы увидите, что вы распечатываете этот лог, только если intent.extras отличается от null — или, другими словами, Intent содержит некоторые данные.

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

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

ShareActivity приостановлен, а старая портретная активность MainActivity уничтожена. Затем создается и возобновляется новая горизонтальная MainActivity . Наконец, приложение вызывает onStop() и onDestroy() ShareActivity.

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

Изучение жизненного цикла фрагмента

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

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

В предыдущем разделе вы поиграли с двумя активити и увидели, как меняется их жизненный цикл при перемещении между экранами. В этом примере вы реализуете те же экраны с фрагментами. Вы можете найти два фрагмента, которые представляют каждый экран в пакете фрагментов: MainFragment.kt и ShareFragment.kt. Также есть одна активити контейнера и пакет viewmodels. Пока не обращайте внимания на пакет viewmodels. Он понадобится вам в следующем разделе.

Если вы проверите MainFragment.kt, вы заметите много общего с MainActivity.kt. У них одинаковая логика управления состояниями, но MainFragment.kt содержит еще несколько колбэков жизненного цикла.

Перед запуском приложения откройте SplashActivity.kt и обновите startFirstActivity() , чтобы он запускал ActivityWithFragments вместо MainActivity :

Отлично! Теперь соберите и запустите приложение. Затем осмотрите логи.

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

Далее нажмите назад и снова наблюдайте за логами.

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

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

Понимание обратных вызовов жизненного цикла фрагмента

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

  • onCreate(): фрагмент достигает состояния Created. Подобно onCreate() активити, этот колбэк получает Bundle , содержащий любое состояние, ранее сохраненное onSaveInstanceState() .
  • onCreateView(): вызывается для расширения или создания вью фрагмента.
  • onViewCreated(): вью фрагмента создается с ненулевым объектом View. Это представление устанавливается для фрагмента и может быть получено с помощью getView() .
  • onStart(): фрагмент переходит в состояние Started. В этом состоянии гарантируется, что вью фрагмента доступно и безопасно выполнить FragmentTransaction для дочернего FragmentManager фрагмента.
  • onResumed(): фрагмент переходит в состояние Resumed. Он становится видимым после завершения всех эффектов Animator и Transition . Теперь пользователь может взаимодействовать с фрагментом.
  • onPause(): фрагмент возвращается в состояние Started. ОС вызывает этот колбэк, когда пользователь начинает покидать фрагмент, пока фрагмент все еще виден.
  • onStop(): фрагмент возвращается в состояние Created и больше не отображается.
  • onDestroyView(): запускается после завершения всех анимаций выхода и переходов, когда представление фрагмента было отделено от окна. На этом этапе все ссылки на представление фрагмента должны быть удалены, что позволит очистить представление фрагмента от мусора.
  • onDestroy(): фрагмент переходит в состояние Destroyed. Это происходит при удалении фрагмента или при уничтожении FragmentManager . На этом этапе жизненный цикл фрагмента подошел к концу.

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

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

Использование ViewModel для хранения данных пользовательского интерфейса

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

Во-первых, замените логику сохранения и восстановления состояния в MainFragment.kt подходом, использующим ViewModel .

В пакете viewmodels создайте новый класс с именем MainViewModel.kt.

Это будет ViewModel для вашего главного экрана. Вы будете использовать его для сохранения состояния DogCount . Используйте _dogCount для отслеживания состояния и dogCount для отображения его наблюдателям. Для обновления состояния используйте setDogCount() .

Если вы хотите узнать больше о LiveData , обратитесь к Android Developer documentation.

В MainFragment.kt добавьте следующее:

Добавьте следующую строку выше onCreate() :

Таким образом, вы добавили код для создания MainViewModel для MainFragment .

Затем добавьте в MainFragment.kt следующий метод:

Этот метод позволяет вам подписаться на наблюдаемое состояние в MainViewModel . Каждый раз, когда состояние dogCount изменяется, приложение передает новое состояние во вью, и с новым состоянием вызывается renderDogCount() , в результате чего пользовательский интерфейс обновляется.

Затем измените onViewCreated() , чтобы подписаться на MainViewModel после вызова суперкласса:

Вам также понадобится логика, которая обновит состояние в MainViewModel . Измените updateDogCount() следующим образом:

Этот метод вызывается всякий раз, когда пользователь обновляет счетчики. Он обновит MainViewModel с новым состоянием. MainViewModel протолкнет это состояние через dogCount , и MainFragment получит уведомление, поскольку он подписан на MainViewModel .

Наконец, в MainFragment удалите onSaveInstanceState() , вызов renderDogCount (dogCount) из onResume() и код saveInstanceState? .Run <. >в onCreate() . Вам это больше не нужно. 🙂

Скомпилируйте и запустите приложение. Коснитесь счетчиков пару раз и поверните экран. Вы должны увидеть что-то вроде этого:

На приведенном ниже рисунке можно увидеть время жизни ViewModel рядом с соответствующим жизненным циклом действия.

Объекты ViewModel привязаны к Lifecycle , передаваемому ViewModelProvider при получении ViewModel . Он остается в памяти до тех пор, пока Lifecycle , на который он рассчитан, не исчезнет навсегда. В случае активити это происходит, когда она завершена. Для фрагмента это происходит, когда он отсоединяется.

Источник

Оцените статью