Android replace fragment lifecycle

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

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

Список дополнительных методов жизненного цикла фрагментов, которых нет у активности:

onAttach(Activity) Вызывается, когда фрагмент связывается с активностью. С этого момента мы можем получить ссылку на активность через метод getActivity() onCreate() В этом методе можно сделать работу, не связанную с интерфейсом. Например, подготовить адаптер. onCreateView(LayoutInflater, ViewGroup, Bundle) Вызывается для создания компонентов внутри фрагмента onViewCreated() Вызывается сразу после onCreateView() onActivityCreated(Bundle) Вызывается, когда отработает метод активности onCreate(), а значит фрагмент может обратиться к компонентам активности onStart() Вызывается, когда фрагмент видим для пользователя и сразу же срабатывает onStart() активности onDestroyView() onResume() Вызываем после onResume() активности Вызывается, когда набор компонентов удаляется из фрагмента onDetach() Вызывается, когда фрагмент отвязывается от активности

Одноимённые с методами активности методы фрагментов выполняют аналогичные функции. К примеру, метод onResume() вызывается, когда фрагмент вновь становится видимым.

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

Фрагмент всегда связан с активностью. Отдельно фрагмент от активности существовать не может.

Если активность останавливается, то её фрагменты также останавливаются. Если активность уничтожается, то её фрагменты также уничтожаются.

Метод onCreateView() вызывается один раз, когда фрагмент должен загрузить на экран свой интерфейс. В этом методе вы можете «надуть» (inflate) разметку фрагмента через метод inflate() объекта Inflater, который задан в параметре метода. В фрагментах без интерфейса вы можете пропустить надувание.

Метод onActivityCreated() вызывается после метода onCreateView(), когда создаётся активность-хозяйка для фрагмента. Здесь можно объявить объекты, необходимые для Context.

Фрагменты не являются подклассами Context, вам следует использовать метод getActivity(), чтобы получить родительскую активность.

Создадим несколько фрагментов и с помощью логов посмотрим на срабатывание методов. Первоначально пример писался на Java, будет приведён аналог на Kotlin только для первого фрагмента, остальное придётся написать самостоятельно.

FirstFragment

Разметка для первого фрагмента

По аналогии создайте второй фрагмент SecondFragment, заменив тексты и названия идентификаторов там, где это нужно.

Создадим разметку для главной активности с двумя кнопками для переключения между фрагментами.

activity_main.xml

MainActivity.java

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

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

onAttach
onCreate
onCreateView
onActivityCreated
onStart
onResume

Метод onActivityCreated() теперь считается устаревшим.

Нажимаем на кнопку «Home»:

Запустим из списка недавно запущенных программ:

Выходим из программы через кнопку «Back»:

onPause
onStop
onDestroyView
onDestroy
onDetach

При замещении первого фрагмента вторым почти как при закрытии, только нет методов onDestroy и onDetach, а затем повторяются те же методы при старте фрагмента:

// Первый фрагмент onPause
onStop
onDestroyView
// Второй фрагмент onAttach
onCreate
onCreateView
onActivityCreated
onStart
onResume

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

xxv/android-lifecycle — схема жизненного цикла в SVG, PDF, PNG.

Источник

Полный список

— динамически работаем с фрагментами

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

Создадим простое приложение с двумя фрагментами, которое будет уметь:

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

Project name: P1051_FragmentDynamic
Build Target: Android 4.1
Application name: FragmentDynamic
Package name: ru.startandroid.develop.p1051fragmentdynamic
Create Activity: MainActivity

В strings.xml добавим строки:

Создаем фрагменты. Как мы помним из прошлого урока, для этого нам нужны будут layout-файлы и классы, наследующие android.app.Fragment

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

Рисуем основное Activity.

Три кнопки для добавления, удаления и замены фрагментов. Чекбокс для включения использования BackStack. И FrameLayout – это контейнер, в котором будет происходить вся работа с фрагментами. Он должен быть типа ViewGroup. А элементы Fragment, которые мы использовали на прошлом уроке для размещения фрагментов, нам не нужны для динамической работы.

В onCreate создаем пару фрагментов и находим чекбокс.

В onClick мы получаем менеджер фрагментов с помощью метода getFragmentManager. Этот объект является основным для работы с фрагментами. Далее, чтобы добавить/удалить/заменить фрагмент, нам необходимо использовать транзакции. Они аналогичны транзакциям в БД, где мы открываем транзакцию, производим операции с БД, выполняем commit. Здесь мы открываем транзакцию, производим операции с фрагментами (добавляем, удаляем, заменяем), выполняем commit.

Итак, мы получили FragmentManager и открыли транзакцию методом beginTransaction. Далее определяем, какая кнопка была нажата:

если Add, то вызываем метод add, в который передаем id контейнера (тот самый FrameLayout из main.xml) и объект фрагмента. В итоге, в контейнер будет помещен Fragment1

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

если Replace, то вызываем метод replace, в который передаем id контейнера и объект фрагмента. В итоге, из контейнера удалится его текущий фрагмент (если он там есть) и добавится фрагмент, указанный нами.

Далее проверяем чекбокс. Если он включен, то добавляем транзакцию в BackStack. Для этого используем метод addToBackStack. На вход можно подать строку-тэг. Я передаю null.

Ну и вызываем commit, транзакция завершена.

Давайте смотреть, что получилось. Все сохраняем, запускаем приложение.

появился первый фрагмент.

Еще раз добавим первый фрагмент – жмем Add. И жмем Replace

первый фрагмент заменился вторым.

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

Снова запускаем приложение и включаем чекбокс add to Back Stack

Выполняем те же операции: Add, Remove, Add, Replace. У нас добавится первый фрагмент, удалится первый фрагмент, добавится первый фрагмент, заменится вторым. В итоге мы снова видим второй фрагмент. Теперь жмем несколько раз кнопку Назад и наблюдаем, как выполняются операции, обратные тем, что мы делали. Когда транзакции, сохраненные в стеке закончатся, кнопка Назад закроет приложение.

Т.е. все достаточно просто и понятно. Скажу еще про пару интересных моментов.

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

Когда мы удаляем фрагмент и не добавляем транзакцию в BackStack, то фрагмент уничтожается. Если же транзакция добавляется в BackStack, то, при удалении, фрагмент не уничтожается (onDestroy не вызывается), а останавливается (onStop).

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

На следующем уроке:

— рассмотрим взаимодействие между Activity и ее фрагментами

Присоединяйтесь к нам в Telegram:

— в канале StartAndroid публикуются ссылки на новые статьи с сайта startandroid.ru и интересные материалы с хабра, medium.com и т.п.

— в чатах решаем возникающие вопросы и проблемы по различным темам: Android, Kotlin, RxJava, Dagger, Тестирование

— ну и если просто хочется поговорить с коллегами по разработке, то есть чат Флудильня

— новый чат Performance для обсуждения проблем производительности и для ваших пожеланий по содержанию курса по этой теме

Источник

Fragment lifecycle while doing .add and .replace

Apr 19, 2020 · 4 min read

As we know, A Fragment represents a behavior or a portion of the user interface in a FragmentActivity. You can combine multiple fragments in a single activity to build a multi-pane UI and reuse a fragment in multiple activities.

This article is about the lifecycle of the fragment while adding and replacing the fragments to the frame layout containers of an Activity. Before starting the fragment we go through fragment lifecycle once. Following diagram has life cycle methods starting from onAttach() to onDetach().

When you add any f ragment to the container then it goes through some life cycle methods. Following is the code for .add fragment transaction with addToBackStack(null).

The significance of the API addToBackStack(null) is when you use this API then fragment transaction will be remembered after it is committed, and will reverse its operation when later popped off the stack.

For example, there is a Fragment A to the activity’s frame layout container then Fragment A goes through life cycle methods from onAttach() to onResume(), when you add Fragment B on top of Fragment A on same container then Fragment B goes through life cycle methods from onAttach() to onResume() same happens when you put Fragment C on top of Fragment B on the same container.

In short when you add a fragment then it calls life cycle methods from onAttach() to onResume().

When you click back press button on an android device then fragment C, fragment B, and Fragment A go through some life cycle methods like below.

In short when you press the back button then all fragments go through onPause() to onDetach() life cycle methods. The fragment is detached and popped off the stack.

2) Fragment .replace Transaction

When you replace one fragment with another fragment, with the following code which has .replace fragment transaction with addToBackStack(null).

Let’s say you are replacing Fragment A with Fragment B then first Fragment B’s life methods onAttach() and onCreate() gets called then Fragment A’s life cycle methods get called from onPause() to onDestroyView(), here Fragment A won’t be detached from the stack it is remembered by the stack.

Let’s check the below example in which Fragment B is replacing Fragment A and after that Fragment C is replacing Fragment B.

Let’s check what happens when we click back press button

When you click back press button on an android device then fragment C, fragment B, and Fragment A go through some life cycle methods like below.

So, when you click back press button on an android device then first Fragment C goes through onPause() to onDetach() with Fragment B’s onCreateView() to onResume(), please do check the sequence first Fragment C will get called then Fragment B. On second back press click Fragment B goes through onPause() to onDetach() with Fragment A’s onCreateView() to onResume(). On third back press click Fragment A goes through onPause() to onDetach() and activity on which fragments were loaded that activity will be finished.

In short when you press the back button then all fragments go through onPause() to onDetach() life cycle methods. The fragments are detached and popped off the stack.

Important note when you use addToBackStack() API then only fragment transactions will be remembered to the stack after their commit(), if you don’t use addToBackStack() API then fragments won’t be remembered to the stack.

That’s all on the Fragment lifecycle while doing .add and .replace transactions.

Источник

Fragment in Android(Add,Delete and Replace)

A fragment is a chunk part of an Activity which is used for achieving Panel Based Designing, to achieve reusability of GUI as well as to show effective GUI(large screen).

• It is added after Honeycomb 11.
• It is always associated with an Activity.
• We can use more than one fragment.
• It has its own layout and behavior.
• It has its own life cycle.
• It can be added or removed at run time.
• Multiple fragments can be combined in a single activity.
• It can be used in multiple activities.

There are 2 types of fragment:-

1. @android.app.Fragment
2. @android.support.V4.Fragment

LIFECYCLE OF FRAGMENT

1. onAttach()- attaches fragment to activity.
2. onCreate()-Initialisation or allocation of memory
3. onCreateView()-like setcontentView(), for providing the view
4. onActivityCreated()- provides an Acknowledgement that our task is complete.
5. Start
6. Resume
7. Pause
8. Stop
9. onDestroyView()- first destroy all views
10. onDestroy()-destroy all allocated resources
11. onDetach()-separate out fragment from an Activity.

SOME IMPORTANT TERMS:-

Fragmentmanager

A FragmentManager manages Fragments in Android, specifically it handles transactions between fragments. A transaction is a way to add, replace, or remove fragments.

FragmentTransaction

FragmentTransaction gives us methods to add, replace, or remove fragments in Android. It gives us an interface for interacting with fragments.

addToBackStack(null)

The method, addToBackOfStack(String name), adds this transaction to the back stack, this can be used so that Fragments are remembered and can be used again by the Activity

Let’s create an application using Fragment:-

1. Create a new fragment frag1 by Right click on App>select New>select Fragment>select Fragment (Blank). It will automatically create its JAVA and corresponding XML file.

2. Create another fragment frag2 using same procedure of above

3. Open the fragment_frag1.xml and copy the below the code.

4. Open the fragment_frag2.xml file and follow the below code. In this fragment, we have given red colour.

5. Frag1.java

6. frag2.java

7. This is main screen of our page, open activity_main.xml and copy the below code.

8. In main activity, we will create three buttons: ADD A FRAGMENT, DELETE A FRAGMENT, REPLACE A FRAGMENT.

THREE FRAGMENT IN ANDROID

1. TO ADD A FRAGMENT

It adds a fragment frag1() to the fragment layout which has id f1. Also, add this fragment to Backstack to maintain a record of added fragments.

2. TO DELETE A FRAGMENT

It deletes one fragment which is on the top of the Stack.

3. TO REPLACE A FRAGMENT

It replaces one fragement to another like fragment 2 is replaced with fragment which is already placed on the layout of id f1.

This was a simple tutorial on how to add , delete and replace fragments in an Android Application.

You can access full code on github by clicking on the below link and For any Query, Comment down below

Источник