Как реализовать onbackpressed() во фрагментах?

Adding and removing fragments

To add a fragment to a , call

on the transaction. This method receives
the ID of the container for the fragment, as well as the class name of the
fragment you wish to add. The added fragment is moved to the
state. It is strongly recommended that the container is a

that is part of the view hierarchy.

To remove a fragment from the host, call
,
passing in a fragment instance that was retrieved from the fragment
manager through or .
If the fragment’s view was previously added to a container, the view is
removed from the container at this point. The removed fragment is moved
to the state.

Use

to replace an existing fragment in a container with an instance of a
new fragment class that you provide. Calling is equivalent to
calling with a fragment in a container and adding a new
fragment to that same container.

The following code snippet shows how you can replace one fragment with another:

In this example, a new instance of replaces the fragment,
if any, that is currently in the layout container identified by
.

By default, the changes made in a are not added to
the back stack. To save those changes, you can call

on the . For more information, see
Fragment manager.

Commit is asynchronous

Calling

doesn’t perform the transaction immediately. Rather, the transaction is
scheduled to run on the main UI thread as soon as it is able to do so. If
necessary, however, you can call

to run the fragment transaction on your UI thread immediately.

Note that is incompatible with . Alternatively,
you can execute all pending submitted by

calls that have not yet run by calling . This approach is compatible with .

For the vast majority of use cases, is all you need.

Operation ordering is significant

The order in which you perform operations within a

is significant, particularly when using . This
method applies the given animations to all fragment operations that
follow it.

5 ответов

Лучший ответ

@Swati согласно вашему комментарию, вы хотите выйти из текущего диалога, а также текущей деятельности. Диалог — это еще один уровень окна, который отображается поверх вашей текущей активности. DialogFragment — это просто оболочка, которая содержит фактический диалог и управляет состоянием, таким как поворот устройства.

Само диалоговое окно также использует backpress. Так что в DialogFragment такого метода обратной печати нет.

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

vsatkh
20 Апр 2017 в 13:33

Следить за этим. Прекрасный пример реализации функциональности в с помощью .

1) Создать абстрактный класс —

2) Внедрите в свой —

Это оно. Ссылка

Community
23 Май 2017 в 10:31

Попробуй это

Nazim ch
20 Апр 2017 в 12:31

При использовании фрагментов в вашем приложении отдельные объекты FragmentTransaction могут представлять изменения контекста, которые следует добавить в задний стек. Например, если вы реализуете основной / подробный поток на телефонной трубке путем замены фрагментов, вы должны убедиться, что нажатие кнопки «Назад» на подробном экране возвращает пользователя на главный экран. Для этого вызовите addToBackStack (), прежде чем совершать транзакцию:

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

pk4393
20 Апр 2017 в 13:29

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

George Hoss
18 Июл 2019 в 13:34

Управление стеком фрагментов

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

Чтобы добавить транзакцию в стек, вызовите метод FragmentTransaction.addToBackStack(String) перед завершением транзакции (commit). Строковый аргумент — опциональное имя для идентификации стека или null. Класс FragmentManager имеет метод popBackStack(), возвращающий предыдущее состояние стека по этому имени.

Если вы вызовете метод addToBackStack() при удалении или замещении фрагмента, то будут вызваны методы фрагмента onPause(), onStop(), onDestroyView().

Когда пользователь нажимает на кнопку возврата, то вызываются методы фрагмента onCreateView(), onActivityCreated(), onStart() и onResume().

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

Теперь в классе фрагмента прописываем метод с нужным кодом.

Более желательным вариантом является использование интерфейсов. В некоторых примерах с фрагментами такой приём используется.

Метод setResult()

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

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

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

Аргументы фрагмента

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

Активность может создать фрагмент и установить аргументы для него
Активность может вызвать методы экземпляра фрагмента
Фрагмент может реализовать интерфейс, который будет использован в активности в виде слушателя

Фрагмент должен иметь только один пустой конструктор без аргументов. Но можно создать статический newInstance с аргументами через метод setArguments().

Доступ к аргументам можно получить в методе onCreate() фрагмента:

Динамически загружаем фрагмент в активность.

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

Вызываем метод в активности:

Если фрагмент должен сообщить о своих действиях активности, то следует реализовать интерфейс.

В активности:

Метод onSaveInstanceState()

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

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

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

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

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

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

finish()

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

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

Примеры использования можно увидеть в статьях Секундомер, и

В API 28 метод вызывается после метода onStop(), в ранних версиях до метода onStop().

Методы транзакции

Мы уже использовали некоторые методы класса FragmentTransaction. Познакомимся с ними поближе

add(): Добавляет фрагмент к активности
remove(): Удаляет фрагмент из активности
replace(): Заменяет один фрагмент на другой
hide(): Прячет фрагмент (делает невидимым на экране)
show(): Выводит скрытый фрагмент на экран
detach() (API 13): Отсоединяет фрагмент от графического интерфейса, но экземпляр класса сохраняется
attach() (API 13): Присоединяет фрагмент, который был отсоединён методом detach()

Методы remove(), replace(), detach(), attach() не применимы к статичным фрагментам.

Перед началом транзакции нужно получить экземпляр FragmentTransaction через метод FragmentManager.beginTransaction(). Далее вызываются различные методы для управления фрагментами.

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

Основные классы

Сами фрагменты наследуются от androidx.fragment.app.Fragment. Существует подклассы фрагментов: ListFragment, DialogFragment, PreferenceFragment, WebViewFragment и др. Не исключено, что число классов будет увеличиваться, например, появился ещё один класс MapFragment.

Для взаимодействия между фрагментами используется класс android.app.FragmentManager — специальный менеджер по фрагментам.

Как в любом офисе, спецманагер не делает работу своими руками, а использует помощников. Например, для транзакций (добавление, удаление, замена) используется класс-помощник android.app.FragmentTransaction.

Для сравнения приведу названия классов из библиотеки совместимости:

android.support.v4.app.FragmentActivity
android.support.v4.app.Fragment
android.support.v4.app.FragmentManager
android.support.v4.app.FragmentTransaction

Как видите, разница в одном классе, который я привёл первым. Он используется вместо стандартного Activity, чтобы система поняла, что придётся работать с фрагментами. На данный момент студия создаёт проект на основе ActionBarActivity, который является подклассом FragmentActivity.

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

В 2018 году Гугл объявила фрагменты из пакета androd.app устаревшими. Заменяйте везде на версию из библиотеки совместимости. В 2020 году уже используют пакет androidx.fragment.app.

В версии Support Library 27.1.0 появились новые методы requireActivity() и requireContext(), которые пригодятся при написании кода, когда требуется наличие активности и нужно избежать ошибки на null.

Общий алгоритм работы с фрагментами будет следующим:

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

Также, как в активности, вы создаёте различные методы типа onCreate() и т.д. Если фрагмент имеет разметку, то используется метод onCreateView() — считайте его аналогом метода setContentView(), в котором вы подключали разметку активности. При этом метод onCreateView() возвращает объект View, который является корневым элементом разметки фрагмента.

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

Создание разметки для фрагмента ничем не отличается от создания разметки для активности. Вот отрывок кода из метода onCreateView():

Глядя на этот код, вы должные понять, что фрагмент использует разметку из файла res/layout/first_fragment.xml, которая содержит кнопку с идентификатором android:id=»@+id/button_first». Здесь также прослеживается сходство с подключением компонентов в активности

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

в нашем случае мы ищем ссылку на кнопку не среди разметки активности, а внутри разметки самого фрагмента.

Нужно помнить, что в методе inflate() последний параметр должен иметь значение false в большинстве случаев.

Allow reordering of fragment state changes

Each should use :

For behavior compatibility, the reordering flag is not enabled by default.
It is required, however, to allow to properly execute
your , particularly when it operates on the back stack
and runs animations and transitions. Enabling the flag ensures that if
multiple transactions are executed together, any intermediate fragments
(i.e. ones that are added and then immediately replaced) do not go through
lifecycle changes or have their animations or transitions executed. Note that
this flag affects both the initial execution of the transaction and reversing
the transaction with .

Метод onActivityResult()

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

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

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

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

Метод startActivityForResult()

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

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

Attaching and detaching fragments

The method

detaches the fragment from the UI, destroying its view hierarchy. The fragment
remains in the same state () as when it is put on the back stack.
This means that the fragment was removed from the UI but is still managed by
the fragment manager.

The

method reattaches a fragment from which it was previously detached.
This causes its view hierarchy to be recreated, attached to the UI,
and displayed.

As a is treated as a single atomic set of operations,
calls to both and on the same fragment instance in the
same transaction effectively cancel each other out, thus avoiding the
destruction and immediate recreation of the fragment’s UI. Use separate
transactions, separated by if using ,
if you want to detach and then immediately re-attach a fragment.

Методы

Чтобы сгенерировать метод в 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, поэтому код в этих двух методах должен быть или небольшим по объему (чтобы не замедлять работу приложения во время выполнения), или порождать дополнительные потоки, если требуется
выполнение задач, занимающих длительное время.

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

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

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