Рубрики
Без рубрики

Создание четкого понимания фрагментов Android

Вступление Эта серия будет посвящена основам разработки для Android…. С тегами java, android, новички, тристан.

  • Эта серия будет посвящена основам разработки для Android. Присоединяйтесь ко мне, и давайте попробуем создать и понять несколько интересных вещей. Все ресурсы, которые я использовал для создания этого поста, можно найти в ticket note или ЗДЕСЬ . С учетом сказанного давайте начнем.

Версия на YouTube

  • Доступна версия на YouTube здесь

Что такое Фрагмент?

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

Модульность фрагментов

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

Создание фрагмента

  • При создании базового фрагмента существует 5 шагов что мы будем следовать

1) Создайте класс, который расширяться класс Фрагмент |/.

2) Добавьте представление контейнера фрагментов в XML-файл действия хостинга

3) Создайте XML-файл фрагмента

4) Увеличьте вид фрагмента

5) Добавьте фрагмент с помощью fragmenttransaction

1) Создайте класс, который расширяет класс Fragment

public class ExampleFragment extends Fragment {


}
  • Все, что мы здесь делаем, – это создаем обычный класс Java, а затем расширяем класс фрагмента Android. Это позволяет ОС Android распознавать класс как действие, и это позволяет нам использовать нашу собственную логику приложения для любых переопределенных методов фрагмента. Позже мы добавим конструктор для расширения представления, но пока просто оставим все как есть.

2) Добавьте представление контейнера фрагментов в XML-файл действия хостинга
  • Сначала я хочу, чтобы вы поняли, что это находится внутри Основного действия . Причина этого заключается в том, что фрагмент не может существовать вне действия. Фрагмент не заменяет действие, он просто усиливает его. Далее обратите внимание на Представление контейнера фрагмента , это определяет, где фрагмент будет размещен в иерархии представлений действия. Возможно, вы видели FrameLayout используется вместо представления FragmentContainer но сейчас это обесценилось. В документации конкретно указано, Настоятельно рекомендуется всегда использовать представление контейнера фрагментов в качестве контейнера для фрагментов, поскольку FragmentContainerView включает исправления, специфичные для фрагментов, которые другие группы представлений, такие как FrameLayout, не предоставляют. . Поэтому, если вы видите какие-либо учебные пособия, в которых используется FrameLayout, обязательно замените их Fragmentcontainer View.

3) Создайте XML-файл фрагмента

fragment_example.xml
  • Когда мы позже будем раздувать представление для нашего фрагмента, мы будем использовать этот XML-файл. Так же, как и для действия, фрагменту все еще нужен XML-файл для определения дизайна пользовательского интерфейса. Давайте перейдем к следующему шагу.

4) Увеличьте вид фрагмента

public class ExampleFragment extends Fragment {

    public ExampleFragment(){
        super(R.layout.fragment_example);
    }
}

  • Обратите внимание, что все, что мы делаем, это добавляем XML-файл нашего фрагмента в суперконструктор нашего ранее определенного класса ExampleFragment. Мы можем это сделать, потому что класс Fragment имеет альтернативный конструктор, который можно вызвать для предоставления макета по умолчанию. Это идеально вписывается в нашу простую планировку. Однако, если у вас более сложный макет с дополнительной логикой, скажем, вам нужно добавить TextWatcher в TextView. Если это так, то вы можете раздуть представление внутри метода onCreateView(). Просто убедитесь, что вы раздуваете только внутри этого метода. Логика должна быть перенесена в метод onViewCreated().

  • Теперь, прежде чем мы перейдем к пятому и последнему шагу, нам нужно поговорить о нескольких вещах. Нам нужно понять, что такое FragmentManager , FragmentTransaction , и немного разобраться в жизненном цикле фрагмента .

Что такое Менеджер фрагментов?

  • Этот класс отвечает за выполнение действий с фрагментами нашего приложения, таких как добавление, замена и удаление фрагментов в back stack . Если вы не знакомы с обратным стеком это просто структура данных, которая используется для организации фрагментов, и она работает на основе типичного понятия стека/| первый вход последний выход . Благодаря обратному стеку пользователь может перемещаться с помощью кнопки "Назад". С точки зрения жизненного цикла фрагмента менеджер фрагментов отвечает за определение того, в каком состоянии должен находиться фрагмент, а затем за его перемещение в это состояние.

Что такое Фрагментная транзакция?

  • Таким образом, во время выполнения мы можем использовать класс FragmentManager для добавления, удаления, замены или других действий с фрагментами. Каждый набор изменений фрагмента, который мы фиксируем, называется транзакцией фрагмента . Мы сохраняем каждую транзакцию в резервном стеке, который управляется менеджером фрагментов. Как вы увидите позже, мы создаем фрагмент транзакции, вызывая beginTransaction() .

  • Теперь, когда мы определили эти термины, давайте перейдем к шагу 5.

5) Добавьте фрагмент с помощью транзакции фрагмента

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        if(savedInstanceState == null){
            getSupportFragmentManager().beginTransaction()
                    .setReorderingAllowed(true)
                    .add(R.id.fragment_container_view,ExampleFragment.class,null)
                    .commit();
        }
    }
}

  • Обычно наш фрагмент должен быть встроен в класс FragmentActivity, чтобы иметь возможность вносить часть пользовательского интерфейса в макет этого действия. Однако AppCompatActivity на самом деле является подклассом FragmentActivity, поэтому мы все равно наследуем от FragmentActivity. AppCompatActivity не только предоставляет нам методы FragmentActivity, но и позволяет старым устройствам Android получать доступ к новым функциям, таким как встроенное переключение между светлым и темным режимами. Затем мы проверяем, имеет ли сохраненный экземпляр значение null, зачем мы это делаем? Что ж, это гарантирует, что фрагмент будет добавлен только один раз при первом создании действия. Когда происходит что-то вроде изменения конфигурации (переключение экрана) и сохраненный экземпляр больше не является нулевым, фрагмент будет автоматически восстановлен из savedInstanceState.

  • Затем у нас есть классический метод onCreate(), который вызывается во время создания действия. Ему передается объект Bundle , который содержит любое ранее сохраненное состояние. super.onCreate(savedInstanceState); предназначен для того, чтобы убедиться, что вызывается исходный метод onCreate(), несмотря на то, что мы его переопределяем. setContentView(R.layout.activity_main) задает вид действия. Теперь давайте объясним некоторые из этих странно выглядящих вызовов методов.

getSupportFragmentManager()

  • предоставленный нам классом FragmentActivity, помните, что AppCompatActivity является подклассом FragmentActivity. Мы можем получить доступ к методу getSupportFragmentManager() с помощью динамической отправки Java. getSupportFragmentManager() вернет FragmentManager для взаимодействия с фрагментами, связанными с этим действием

beginTransaction()

  • Как только у нас будет экземпляр FragmentManager, мы можем вызвать beginTransaction(), который запустит серию операций редактирования фрагментов, связанных с этим FragmentManager. Фрагмент может быть добавлен только через транзакцию фрагмента.

setReorderingAllowed(true)

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

..добавить(R.id.fragment_container_view,ExampleFragment.class ,ноль)

  • Этот метод вызывается, когда мы хотим добавить фрагмент в диспетчер фрагментов для обработки. Предусмотрено 3 параметра.

1) : идентификатор контейнера фрагмента.

2) : фрагмент, который нужно добавить. Этот фрагмент еще не должен быть добавлен в действие.

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

  • Новый ExampleFragment.class обращается к экземпляру этого класса в памяти. Это означает, что для любого класса, который мы создаем, Java автоматически создаст и сохранит его экземпляр в памяти. Так что ExampleFragment.class получаем ли мы доступ к сохраненному экземпляру в памяти

фиксация()

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

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

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

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

ИНИЦИАЛИЗИРОВАН

СОЗДАНО

НАЧАТО

ВОЗОБНОВЛЕНО

УНИЧТОЖЕН

  • Каждое из этих состояний имеет определенные методы обратного вызова, которые соответствуют каждому из изменений в жизненном цикле фрагмента. На сегодня мы рассмотрим только ИНИЦИАЛИЗИРОВАННЫЕ, СОЗДАННЫЕ и ЗАПУЩЕННЫЕ состояния. Если вы заинтересованы и хотите получить более глубокое представление о жизненном цикле фрагмента, ознакомьтесь с документацией здесь

Фрагменты и FragmentManager

  • Когда фрагмент инициализируется, он начинается в состоянии INITIALIZED . В этом состоянии вызываются методы onCreateView() и onViewCreated(). В нашем примере мы не используем эти методы, но мы все равно должны заметить, что они вызываются. Для того чтобы фрагмент мог пройти оставшуюся часть своего жизненного цикла, он должен быть добавлен в fragmentmanager. Менеджер фрагментов отвечает за определение того, в каком состоянии должен находиться фрагмент, а затем за его перемещение в это состояние. Как только фрагмент был добавлен в диспетчер фрагментов, он переходит в состояние CREATED . Это состояние, в котором мы хотели бы восстановить любое ранее сохраненное состояние.

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

  • Следующий шаг заключается в создании нашего представления. Поскольку мы предоставили нашему конструктору фрагментов XML-файл, наше представление автоматически раздувается для нас. Мы сделали это еще на шаге 4:
public class ExampleFragment extends Fragment {

    public ExampleFragment(){
        super(R.layout.fragment_example);
    }
}

Фрагмент запущен

  • Как только представление раздувается, наш фрагмент переходит в состояние “НАЧАТО”, это состояние гарантирует, что представление фрагмента доступно. Если бы у нас был вложенный фрагмент, это было бы состояние, в котором мы могли бы безопасно выполнять транзакции с ним.
  • Спасибо, что нашли время в свой рабочий день, чтобы прочитать этот мой пост в блоге. Если у вас есть какие-либо вопросы или сомнения, пожалуйста, прокомментируйте ниже или свяжитесь со мной по адресу Твиттер .

Оригинал: “https://dev.to/theplebdev/creating-a-solid-understanding-of-android-fragments-i1g”

Читайте ещё по теме: