Как уничтожить фрагмент android
Fragment (Фрагменты). Часть шестая
Удержание состояния фрагментов
В предыдущей статье мы рассмотрели, как сохранять данные при изменении конфигурации и других операциях.
У фрагмента есть свойство retainInstance, которое по умолчанию содержит значение false. Это означает, что при поворотах фрагмент не сохраняется, а уничтожается и создается заново вместе с активностью-хостом. Вызов setRetainInstance(true) сохраняет фрагмент, который не уничтожается вместе с активностью, а передается новой активности в неизменном виде.
Представление фрагмента может уничтожаться и создаваться заново без необходимости уничтожать сам фрагмент. При изменении конфигурации (повороте) FragmentManager сначала уничтожает макет фрагмента в своем списке. Макеты фрагментов всегда уничтожаются и создаются заново по тем же причинам, по которым уничтожаются и создаются заново разметки активности: в новой конфигурации могут потребоваться новые ресурсы. Затем FragmentManager проверяет свойство retainInstance каждого фрагмента. Если оно равно false (по умолчанию), FragmentManager уничтожает экземпляр фрагмента. Фрагмент и его макет будут созданы заново новым экземпляром FragmentManager новой активности.
Если значение retainInstance равно true, макет фрагмента уничтожается, но сам фрагмент остаётся. При создании новой активности новый экземпляр FragmentManager находит сохранённый фрагмент и воссоздаёт его макет.
Сохранённый фрагмент не уничтожается, а отсоединяется (detached) от «умирающей» активности. В сохранённом состоянии фрагмент всё ещё существует, но не имеет активности-хоста.
Переход в сохранённое состояние происходит только при выполнении двух условий:
Сохранённые фрагменты продолжают существовать только при уничтожении активности при изменения конфигурации. Если активность уничтожается из-за того, что системе потребовалось освободить память, то все сохранённые фрагменты также будут уничтожены.
Фрагменты
Существует два основных подхода в использовании фрагментов.
Первый способ основан на замещении родительского контейнера. Создаётся стандартная разметка и в том месте, где будут использоваться фрагменты, размещается контейнер, например, FrameLayout. В коде контейнер замещается фрагментом. При использовании подобного сценария в разметке не используется тег fragment, так как его нельзя менять динамически. Также вам придётся обновлять ActionBar, если он зависит от фрагмента. Здесь показан такой пример.
Второй подход является наиболее гибким и в целом предпочтительным способом использования фрагментов. Активность проверяет в каком режиме (свои размеры) он запущен и использует разную разметку из ресурсов. Графически это выглядит следующим образом.
Основные классы
Сами фрагменты наследуются от androidx.fragment.app.Fragment. Существует подклассы фрагментов: ListFragment, DialogFragment, PreferenceFragment, WebViewFragment и др. Не исключено, что число классов будет увеличиваться, например, появился ещё один класс MapFragment.
Как в любом офисе, спецманагер не делает работу своими руками, а использует помощников. Например, для транзакций (добавление, удаление, замена) используется класс-помощник android.app.FragmentTransaction.
Для сравнения приведу названия классов из библиотеки совместимости:
Как видите, разница в одном классе, который я привёл первым. Он используется вместо стандартного Activity, чтобы система поняла, что придётся работать с фрагментами. На данный момент студия создаёт проект на основе ActionBarActivity, который является подклассом FragmentActivity.
В одном приложении нельзя использовать новые фрагменты и фрагменты из библиотеки совместимости.
В 2018 году Гугл объявила фрагменты из пакета androd.app устаревшими. Заменяйте везде на версию из библиотеки совместимости. В 2020 году уже используют пакет androidx.fragment.app.
В версии Support Library 27.1.0 появились новые методы requireActivity() и requireContext(), которые пригодятся при написании кода, когда требуется наличие активности и нужно избежать ошибки на null.
Общий алгоритм работы с фрагментами будет следующим:
У каждого фрагмента должен быть свой класс. Класс наследуется от класса Fragment или схожих классов, о которых говорилось выше. Это похоже на создание новой активности или нового компонента.
Разметку для фрагмента можно создать программно или декларативно через XML.
Создание разметки для фрагмента ничем не отличается от создания разметки для активности. Вот отрывок кода из метода onCreateView():
Глядя на этот код, вы должные понять, что фрагмент использует разметку из файла res/layout/first_fragment.xml, которая содержит кнопку с идентификатором android:id=»@+id/button_first». Здесь также прослеживается сходство с подключением компонентов в активности. Обратите внимание, что перед методом findViewById() используется view, так как этот метод относится к компоненту, а не к активности, как мы обычно делали в программах, когда просто опускали имя активности. Т.е. в нашем случае мы ищем ссылку на кнопку не среди разметки активности, а внутри разметки самого фрагмента.
Нужно помнить, что в методе inflate() последний параметр должен иметь значение false в большинстве случаев.
FragmentManager
Класс FragmentManager имеет два метода, позволяющих найти фрагмент, который связан с активностью:
findFragmentById(int id) Находит фрагмент по идентификатору findFragmentByTag(String tag) Находит фрагмент по заданному тегу
Методы транзакции
Мы уже использовали некоторые методы класса FragmentTransaction. Познакомимся с ними поближе
add() Добавляет фрагмент к активности remove() Удаляет фрагмент из активности replace() Заменяет один фрагмент на другой hide() Прячет фрагмент (делает невидимым на экране) show() Выводит скрытый фрагмент на экран detach() (API 13) Отсоединяет фрагмент от графического интерфейса, но экземпляр класса сохраняется attach() (API 13) Присоединяет фрагмент, который был отсоединён методом detach()
Методы remove(), replace(), detach(), attach() не применимы к статичным фрагментам.
Перед началом транзакции нужно получить экземпляр FragmentTransaction через метод FragmentManager.beginTransaction(). Далее вызываются различные методы для управления фрагментами.
В конце любой транзакции, которая может состоять из цепочки вышеперечисленных методов, следует вызвать метод commit().
Аргументы фрагмента
Фрагменты должны сохранять свою модульность и не должны общаться друг с другом напрямую. Если один фрагмент хочет докопаться до другого, он должен сообщить об этом своему менеджеру активности, а он уже передаст просьбу другому фрагменту. И наоборот. Это сделано специально для того, чтобы было понятно, что менеджер тут главный и он не зря зарплату получает. Есть три основных способа общения фрагмента с активностью.
Фрагмент должен иметь только один пустой конструктор без аргументов. Но можно создать статический newInstance с аргументами через метод setArguments().
Доступ к аргументам можно получить в методе onCreate() фрагмента:
Динамически загружаем фрагмент в активность.
Вызываем метод в активности:
Если фрагмент должен сообщить о своих действиях активности, то следует реализовать интерфейс.
Управление стеком фрагментов
Фрагменты, как и активности, могут управляться кнопкой Back. Вы можете добавить несколько фрагментов, а потом через кнопку Back вернуться к первому фрагменту. Если в стеке не останется ни одного фрагмента, то следующее нажатие кнопки закроет активность.
Если вы вызовете метод addToBackStack() при удалении или замещении фрагмента, то будут вызваны методы фрагмента onPause(), onStop(), onDestroyView().
Когда пользователь нажимает на кнопку возврата, то вызываются методы фрагмента onCreateView(), onActivityCreated(), onStart() и onResume().
Рассмотрим пример реагирования на кнопку Back в фрагменте без использования стека. Активность имеет метод onBackPressed(), который реагирует на нажатие кнопки. Мы можем в этом методе сослаться на нужный фрагмент и вызвать метод фрагмента.
Теперь в классе фрагмента прописываем метод с нужным кодом.
Более желательным вариантом является использование интерфейсов. В некоторых примерах с фрагментами такой приём используется.
Интеграция Action Bar/Options Menu
Фрагменты могут добавлять свои элементы в панель действий или меню активности. Сначала вы должны вызвать метод Fragment.setHasOptionsMenu() в методе фрагмента onCreate(). Затем нужно задать настройки для методов фрагмента onCreateOptionsMenu() и onOptionsItemSelected(), а также при необходимости для методов onPrepareOptionsMenu(), onOptionsMenuClosed(), onDestroyOptionsMenu(). Работа методов фрагмента ничем не отличается от аналогичных методов для активности.
В активности, которая содержит фрагмент, данные методы автоматически сработают.
Если активность содержит собственные элементы панели действий или меню, то следует позаботиться, чтобы они не мешали вызовам методам фрагментов.
Код для активности:
Связь между фрагментом и активностью
Экземпляр фрагмента связан с активностью. Активность может вызывать методы фрагмента через ссылку на объект фрагмента. Доступ к фрагменту можно получить через методы findFragmentById() или findFragmentByTag().
Fragment (Фрагменты)
Фрагменты немного пугают новичков. Постараюсь объяснить как можно проще, чтобы отдельные фрагменты пазла сложились в единую картину.
Зачем?
Создатели операционной системы Android оказались недальновидными разработчиками. Не посоветовавшись с котами, они разработали систему под маленькие экраны телефонов. Но котам было неудобно пользоваться такими экранами, и тогда придумали планшеты.
Старые программы прекрасно на них запускались, но обнаружилось несколько недостатков. На больших экранах интерфейс выглядел не слишком элегантно, появились большие пустые пространства. И тогда возникла идея объединить два отдельных экрана из смартфона в один экран на планшете. Это самый классический пример применения фрагмента. По сути, это костыль. Возможно, если бы сразу подумали головой, то придумали бы более элегантное решение. Но теперь поздно пить «Боржоми», будем использовать предложенную концепцию.
Фрагменты были представлены в API 11 (Android 3.0), но в целях совместимости была написана специальная библиотека Android Support library для старых устройств. Долгое время существовало два класса Fragment: для новых устройств и для старых устройств. Названия методов и классов были очень похожи, и разработчики часто путались, смешивая в одном проекте два разных несовместимых класса. Спустя некоторое время решили отказаться от странного разделения, класс для новых устройств признали устаревшим, а класс из библиотеки поддержки старых устройств сменил своё полное имя и вошёл в состав AndroidX.
При желании можно было продолжить писать приложения в старом стиле, отслеживая размеры экрана. Но такой код получится слишком сложным. Пришлось бы писать один код для переключения от одной активности к другой при использовании смартфона и другой код, когда взаимодействие между объектами происходит на одном экране в планшете. Чтобы устранить это противоречие, были придуманы фрагменты. Хотя там тоже придётся писать много кода.
В составе активности есть специальный менеджер фрагментов, который может контролировать все классы фрагментов и управлять ими. О нём позже.
Фрагмент может иметь свою разметку, а может обойтись без неё. Также у фрагмента есть свой жизненный цикл, во многом совпадающий с жизненным циклом активности. Пожалуй, это единственное сходство с активностью.
Есть два варианта использования фрагментов в приложении (при желании можно использовать сразу оба варианта). Первый вариант заключается в том, что вы в разметке сразу указываете фрагмент с помощью тега fragment, так же как и с другими компонентами.
Поначалу фрагменты кажутся неудобными, так как количество кода увеличивается. Но если с ними работать постоянно, то станет понятнее их принцип.
Реакция разработчиков на появление фрагментов противоречива. Кто-то активно использует их в своих проектах, а кто-то их не переносит и использует альтернативные варианты. Похоже, в стане Гугла также идёт борьба между двумя группами программистов. Фрагменты постоянно развиваются, меняются и дорабатываются.
Первое знакомство
Для первого знакомства создадим стандартный проект на базе Empty Activity и вручную добавим фрагмент. Итак, после создания проекта выбираем из контекстного меню пакета New | Fragment | Fragment (Blank). В диалоговом окне мастера назначаем имя для фрагмента.
На этом этапе создание нового фрагмента напоминает создание новой активности. Мы создаём новый класс и автоматически генерируется макет для него fragment_cat.xml. Единственное отличие, в манифест ничего не добавляется.
Откроем макет фрагмента и немного отредактируем содержимое, добавив центрирование по центру. Также можно было добавить ImageView с изображением кота. Но не будем пока ничего усложнять.
В res/values/strings.xml содержится ресурс hello_blank_fragment. Изменим текст на что-то понятное:
Приготовления закончены. Осталось добавить фрагмент в активность. Открываем activity_main.xml и добавляем новый элемент.
В элементе fragment в атрибуте android:name указываем полное имя класса фрагмента.
Можно запустить проект и увидеть фрагмент внутри активности.
Жизненный цикл фрагмента
У фрагмента есть жизненный цикл, как у активности. Но число методов цикла гораздо больше. Откроем теперь файла класса фрагмента CatFragment и добавим новый код (выделено жирным).
Чтобы увидеть связь между жизненными циклами фрагмента и активности, добавим логи и в активность.
Снова запускаем проект и смотрим логи.
У фрагментов есть жизненный цикл, который во многом совпадает с жизненным циклом активности, внутри которой они находятся.
Два отдельных фрагмента
Повторим шаги создания нового фрагмента через готовый шаблон Fragment (Blank) и создадим два новых фрагмента KittyFragment и CounterFragment.
Разметку для KittyFragment копируем из старого примера.
Код также копируем с небольшим отличием. Если в активности мы размещали основной код в методе onCreate(), то для фрагмента используем onViewCreated(). Код шаблона для экономии я опущу.
Для счётчика котов (ворон больше считать не будем) напишем продвинутую версию, которая позволить не только увеличивать показания счётчика, но и уменьшать. В конце концов коты имеют привычку гулять сами по себе и пропадают из поля нашего зрения.
Разметка для фрагмента counter_fragment.xml.
Код для класса CounterFragment. Здесь также мы добавляем весь код в onViewCreated().
Осталось разместить два фрагмента в activity_main.xml.
Запускаем проект и видим два приложения в одном. В верхней части мы здороваемся с котёнком, а в нижней считаем котов. Обратите внимание, что весь код сосредоточился в классах фрагментов, а в MainActivity нам вообще ничего не пришлось писать. Фрагменты работают независимо и мы можем писать код в разных модулях.
Полный список
— динамически работаем с фрагментами
Размещать статические фрагменты мы уже умеем. Но, ясно дело, что гораздо интереснее работать с ними динамически. Система позволяет нам добавлять, удалять и заменять фрагменты друг другом. При этом мы можем сохранять все эти манипуляции в 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 для обсуждения проблем производительности и для ваших пожеланий по содержанию курса по этой теме
Русские Блоги
Фрагмент Android все, что вы должны знать
1 Обзор
Прежде всего, давайте кратко рассмотрим. Я полагаю, что все знакомы с Fragment. Для использования Fragment, с одной стороны, Activity необходимо упорядочить положение Fragment в макете, с другой стороны, он должен управлять жизненным циклом Fragment. В Activity есть FragmentManager, который внутренне поддерживает очередь фрагментов и задний стек транзакций фрагментов.
При нормальных обстоятельствах мы добавим Fragment в Activity следующим образом:
Для приведенного выше кода задайте два вопроса:
1. Зачем нам нужно предложение NULL?
Основная причина заключается в том, что когда действие уничтожается системой из-за изменений конфигурации (поворот экрана) или из-за недостатка памяти, наш фрагмент будет сохранен, но будет создан новый FragmentManager, а новый FragmentManager сначала получит его Сохраните очередь фрагментов и перестройте очередь фрагментов, чтобы восстановить предыдущее состояние.
2. Какова роль идентификатора макета в add (R.id.id_fragment_container, mContentFragment)?
С одной стороны, он сообщает FragmentManager о местонахождении этого фрагмента, с другой стороны, он является уникальным идентификатором этого фрагмента, точно так же, как мы просматривали fm.findFragmentById (R.id.id_fragment_container) выше
Ну, краткий обзор основного использования, пожалуйста, обратитесь к блогу или другой информации выше для деталей. Далее, внесите некоторые предложения для использования
2、Fragment Arguments
Далее описывается простой сценарий: например, если кнопка запускает переход «Активность», нам нужно передать параметры фрагменту целевой операции через «намерение». Как этот фрагмент получает текущее значение «намерения»?
Некоторые друзья скажут, это просто? Посмотрите на мой код (код вопроса):
Мы напрямую получаем хост-активность в onCreate of Fragment. Хост-активность может определенно получить Intent через getIntent, а затем через метод get принять параметры так, как вам нравится
Итак? По-другому, мы рекомендуем использовать аргументы для создания фрагментов.
Добавьте метод newInstance во Fragment, передайте необходимые параметры, установите его в bundle, затем setArguments (bundle) и, наконец, получите его в onCreate;
Это завершает разделение между фрагментом и активностью. Конечно, здесь нужно обратить внимание:
3. Фрагмент startActivityForResult
Это все еще простой сценарий: два фрагмента, фрагмент, который отображает список статей (называемый ListTitleFragment), и фрагмент, который отображает подробную информацию (называемую: ContentFragment). Конечно, оба фрагмента имеют свою собственную активность.
Теперь мы нажимаем на элемент списка в фрагменте списка, передаем соответствующие параметры, переходим к фрагменту подробной информации, чтобы отобразить подробную информацию, на странице сведений пользователь может комментировать, когда пользователь щелкает назад, результаты нашего предыдущего обзора отображаются в списке. В элементе списка фрагмента;
Другими словами, мы щелкаем, чтобы перейти к фрагменту соответствующей операции, и надеемся, что он может возвращать параметры, тогда мы должны использовать Fragment.startActivityForResult;
В Fragment есть методы startActivityForResult () и onActivityResult (), но нет метода setResult () для установки возвращаемого намерения, поэтому нам нужно вызвать getActivity (). SetResult (ListTitleFragment.REQUEST_DETAIL, intent) ;.
Опубликовав два фрагмента кода фрагмента, вы можете видеть, что мы используем ListActivityForResult () для перехода к целевому Activity в ListTitleFragment.onListItemClick, получения параметров в Fragment (ContentFragment) целевой Activity, а затем вызываем getActivity (). SetResult (ListTitleFragment. REQUEST_DETAIL, намерение); установить возвращенные данные; наконец получить возвращенные данные в ListTitleFragment.onActivityResult () для echo;
Предоставьте решения для всех, когда они столкнутся с подобными проблемами в будущем, а также проиллюстрируйте проблему: Фрагмент может получить возвращаемый результат из Activity, но его собственные настройки не могут привести к возвращаемому результату, только Activity имеет возвращаемый результат 。
Далее я хочу опубликовать, хост-активность этих двух фрагментов:
Вы обнаружили, что код в этих двух действиях чрезвычайно похож и использует один и тот же файл макета:
Почему я должен опубликовать этот код Acticity? Поскольку в нашем проекте, если мы в принципе будем использовать Fragment, мы найдем много похожего кода, тогда мы сможем абстрагировать Activity и разместить наш Single Fragment.
Смотрите следующий раздел для деталей.
4、SingleFragmentActivity
Итак, абстрагированный код Activity:
Таким образом, с помощью этой функции SingleFragmentActivity наши ContentActivity и ListTitleActivity также могут быть преобразованы.
Это намного более кратко? Я полагаю, что проекты Фрагмента предпочтительны. Есть много подобных действий. Используйте SingleFragmentActivity, чтобы упростить ваш код
Хорошо, этот код взят из книги, рекомендованной в начале статьи, рекомендуем снова
5. FragmentPagerAdapter и FragmentStatePagerAdapter
Я полагаю, что эти два подкласса PagerAdapter не всем знакомы.
С момента появления Fragment существует множество случаев использования ViewPager и любого из приведенных выше примеров для создания домашней страницы приложения
Так в чем же разница между этими двумя классами?
Основное различие заключается в том, уничтожен ли фрагмент или нет, как подробно описано ниже:
FragmentPagerAdapter: для фрагментов, которые больше не нужны, выберите вызов метода detach, который только разрушает представление и не уничтожает экземпляр фрагмента.
FragmentStatePagerAdapter: уничтожит фрагменты, которые больше не нужны. Когда будет отправлена текущая транзакция, фрагмент будет полностью удален из FragmentManager текущей операции. Состояние помечено. При уничтожении информация о пакете в его onSaveInstanceState (Bundle outState) будет сохранена. Когда пользователь переключается обратно, пакет можно восстановить для создания нового фрагмента, то есть вы можете сохранить некоторые данные в методе onSaveInstanceState (Bundle outState) и восстановить их в onCreate.
Как упоминалось выше, использование FragmentStatePagerAdapter, конечно, экономит больше памяти, но для уничтожения нового требуется время. В общем, если вы создаете главную страницу с 3 или 4 вкладками, вы можете использовать FragmentPagerAdapter. Если вы используете ViewPager для отображения большого количества элементов, то рекомендуется использовать FragmentStatePagerAdapter.
По космическим причинам конкретные случаи не будут записаны, и каждый будет проверять это самостоятельно.
6. Передача данных между фрагментами
В приведенном выше 3 мы показали, что общая передача данных между двумя фрагментами.
Затем возникает более частный случай, когда два фрагмента находятся в одном и том же действии: например, нажмите кнопку в текущем фрагменте, появится диалоговое окно (DialogFragment), операцию в диалоговом окне необходимо вернуть в запущенный фрагмент, затем Как насчет передачи данных? Рекомендуется для использования диалоговых окон:Официальная рекомендация Android: DialogFragment для создания диалога
Мы продолжаем изменять наш код: теперь это ListTitleFragment, ContentFragment, добавляем диалоговое окно: EvaluateDialog, когда пользователь нажимает на содержимое ContentFragment, выскакивает список оценки и пользователь выбирает оценку.
Теперь мы сосредоточимся на том, как элегантно вернуть оценку в EvaluateDialog в ContentFragment:
Помните, что мы находимся в Activity, поэтому определенно не используем startActivityForResult, но возвращаемые нами данные все еще принимаются в onActivityResult.
Хорошо посмотри на код:
Некоторый нерелевантный код был удален. Обратите внимание, что мы добавили событие click к текстовому представлению в onCreateView, которое используется для вызова нашего диалога. Обратите внимание на строку кода:
Мы назвали Fragment.setTargetFragment, этот метод обычно используется, когда текущий фрагмент запускается другим фрагментом, и возвращает данные после завершения операции, что отвечает нашим потребностям.
Обратите внимание, что это предложение очень важно.
Далее посмотрите на код EvaluateDialog:
Смысл в том, чтобы посмотреть на setResult после нажатия, сначала мы определяем, установлен ли targetFragment, если он установлен, это означает, что мы хотим вернуть некоторые данные в targetFragment.
Мы создаем намерение инкапсулировать необходимость передачи данных и, наконец, Вручную вызовите onActivityResult для возврата данных
Наконец, мы можем получить его в onActivityResult ContentFragment.
Хорошо, наконец, соберите эти советы вместе, на этом этапе некоторые из рекомендуемых вариантов использования нашего фрагмента закончились
Затем, наконец, предоставьте исходный код, а также опубликуйте диаграмму эффектов следующим образом:
Давайте снова поделимся учебником моего учителя по искусственному интеллекту. Нулевой основе! Легко понять! Смешно и с юмором! Также принесите желтые кусочки! Я надеюсь, что вы присоединитесь к нашей команде искусственного интеллекта!https://blog.csdn.net/jiangjunshow
Интеллектуальная рекомендация
Совместное использование сухих товаров GitHub (высокая степень интеграции страницы руководства APP-DHGuidePageHUD)
Каждое приложение будет использовать страницу руководства APP, которая не важна, но обязательна. Будь то первая установка приложения или обновление версии, это единственное, что будет показано пользов.
Организуйте некоторые элементы управления диаграммами, которые можно использовать в веб-разработке, в основном для клиентских реализаций, таких как Flash, JavaScript, Silverlight; если для создания ст.