Using navigation on android

Navigation Component: An Overview

In which I introduce some fundamental concepts of the Navigation component tool and APIs

This article is the first in hopefully many articles in an ongoing series we are calling MAD Skills. We will be posting video episodes in the MAD Skills playlist on the Android Developers YouTube channel. When there is not an existing article for any given video episode, we’ll post one with similar content (like this one!), for those who prefer to read about this stuff (also because it tends to be easier to copy/paste code from text than from a video).

If you prefer your content in video form, here’s the thing to watch:

MAD Skills: Navigation Overview

This article provides a quick, high-level overview of Navigation component, including how to create a new application with navigation capability, details on the containment hierarchy of a navigation-enabled UI, and an explanation of some of the major APIs and pieces involved in making Navigation component work.

Note that there is already good introductory material on Navigation component, such as the Get started guide and Ian Lake’s recent video. The reason for this overview article is more to sync with the video content, and also to lay down some of the groundwork that I will rely on in upcoming episodes.

So if you want to learn more, there are plenty of opportunities to, er, navigate your way through the material.

Introduction

Navigation component is the API and the design tool in Android Studio that makes it much easier to create and edit navigation flows throughout your application. Before Navigation component, navigation tasks in an application were created very manually. You’d add a listener in your code for whatever UI element triggered a navigation action and then write the code to, say, launch an intent to show a new activity. Or transition to a Fragment.

You also needed to correctly handle the Back and Up actions, when the user clicked on the device’s Back button or the Up button in the ActionBar. The way these two related-but-different actions were handled created… inconsistencies between applications.

With the Navigation component, we now have standard APIs, plus a visual tool in the IDE, to help make the entire process clearer, easier, and more consistent. You use the design tool to create navigation destinations and define the navigation paths, or actions, that take the user between destinations in your graph. Then you add the code which connects user interaction in your app with those actions to navigate appropriately.

Let’s see what it actually looks like in the tool and in the code. Let’s build an application.

Navigation Templates

One of the useful new features in recent Android Studio releases, starting with version 3.6, is the integration of templates for creating new applications that come with navigation built in. This facility isn’t necessary for using the Navigation component library, but it does make it a lot easier when you are building a new application, because it pulls in all of the necessary pieces to start with.

We’re going to use one of these templates by creating a new application with the Basic Activity template. A few of the templates come with navigation built-in, but we’ll start with this one for now.

This template creates a new application for us with the basic structure of a navigation-enabled application. We get two destinations as well as a navigation graph that defines the navigation paths between them.

Once the application is loaded and ready in the IDE, go to the navigation resource file, nav_graph.xml View this file with the Design option (vs Code or Split), so you see what the current navigation graph of the application looks like.

You can see two destinations: FirstFragment , which has been set up as the initial, or home, destination, and SecondFragment , which is another destination we can navigation to and from.

Clicking on these destinations, you can see the information about them in the property sheet on the right, which shows information like the Fragment class that is used for that destination.

You can also see, in the navigation view shown in the previous figure, arrows between the two destinations. These are the actions, which define the navigations that are possible in this graph. There is a navigation from FirstFragment to SecondFragment , and from SecondFragment back to FirstFragment .

The actions define the navigations that are possible, but they do not specify when those navigations occur; that logic lives in your code. So when the user clicks on an item that should trigger a navigation, that’s where you call the navigation APIs that navigate to a destination in the graph using one of these actions.

Actions are also useful for defining things like values to pass to the destination as well as transition animations to use when entering and exiting the source and destination. We’ll see more about some of these properties in later episodes, or you can read about them in the navigation docs.

We can use the navigation tool to define new destinations, which can be placeholders, if we do not yet have the Fragment class written for a destination, or they can use existing Fragment classes for each destination. By defining destinations and the actions that take us between destinations, you can design the entire flow between screens of your application, in a much more visual and intuitive way than before.

But Where’s the Code?

So far, we’ve been doing all of this in the visual tool. But like all resource files in Android Studio, it is backed by XML code, which you can view and edit directly. If you switch to Code view in the tool, you’ll see the underlying XML:

Here you can see that the structure of the navigation graph is pretty simple. There is the navigation element itself, which contains the rest of the structure and defines which destination is the start, or home destination. Each of the destinations in the graph are fragment s, and each destination holds zero or more action s, which define navigation to other destinations in the graph.

The Basic Activity template also creates placeholder code to navigate between the two destinations. For example, FirstFragment has this code, which is triggered when the user clicks the button in the UI:

The call to navigate() , using the action_FirstFragment_to_SecondFragment defined in the navigation graph file, causes the application to navigate to the second destination.

You can run the application and click the buttons (or the Back button, which is automatically plugged in to navigate back) to see the result:

Источник

Знакомьтесь, компонент Navigation в Android!

Что такое компонент Navigation?

Всем известно, что навигация между экранами является одним из фундаментальных принципов в приложениях Android. Как правило, мы осуществляем ее при помощи Intents или Event Bus. Но как быть в сложных ситуациях, например с боковым навигационным меню (navigation drawer) или меню, расположенным внизу (bottom navigation), когда необходимо выделить выбранную вкладку, сохранив отображение панели вкладок и синхронно изменить экран на тот, что соответствует вкладке, не говоря уже об управлении бэкстеком. Для реализации этих задач нам явно потребуется что-то получше.

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

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

Давайте рассмотрим три главные части компонента Navigation:

1. Навигационный граф. Эторесурс XML, содержащий всю навигационную информацию в одном централизованном месте. Он включает в себя все отдельные области контента в приложении, называемые пунктами назначения (destinations), а также возможные пути навигации по приложению, доступные для пользователя.

2. NavHost. Этопустой контейнер, отображающий пункты назначения из навигационного графа.

3. NavController. Это объект, управляющий навигацией приложения в NavHost. Он координирует смену контента пунктов назначения в NavHost в процессе перемещения пользователя по приложению.

Обратим внимание еще на два понятия, которые мы будем часто использовать:

• Пункты назначения. Это не что иное, каквсе области контента в приложении, такие какактивности(activities), фрагменты (fragments), диалоговые окна и т. д.
• Действия (actions). Онииспользуются для создания навигации, имеющей атрибут destination , в котором можно указать id конечной заставки.

Когда мы осуществляем навигацию по приложению с использованием NavController, то он показывает соответствующий пункт назначения в NavHost.

Компонент Navigation обеспечивает еще ряд полезных возможностей, среди которых:

• упрощенная настройка стандартных шаблонов навигации;
• обработка транзакций фрагментов;
• безопасность типов при передаче информации в процессе навигации;
• обработка анимации переходов;
• централизация и визуализация навигации;
• корректная обработка действий “верх” (Up) и “назад” (Back) по умолчанию;
• предоставление стандартизированных ресурсов для анимации и переходов;
• реализация и обработка глубоких ссылок (deep links).

Итак, мы познакомились с компонентом Navigation и его возможностями. Теперь пора приступить к реализации базового процесса навигации.

Что же у нас в планах?

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

Требования:

• базовые знания Kotlin;
• Android Studio 3.2 или более новые версии;
• эмулятор или устройство с API 14+.

После создания базового проекта Android добавьте приведенную ниже зависимость в файл сборки верхнего уровня build.gradle.

Теперь добавьте ниже указанные зависимости в файл build.gradle модуля app. Как только вы это сделали, сразу щелкните Sync now для синхронизации!

Safe Arguments. Safe Args является плагином Gradle, который используется для передачи данных между пунктами назначения. Главное его преимущество состоит в том, что некоторые проверки, происходящие в среде выполнения, теперь будут осуществляться во время компиляции.

Подготовительная работа окончена — продолжаем!

Сначала создадим навигационный граф для нашего приложения.

Как же нам это сделать?

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

Этапы создания навигационного графа:

1. В окне Project щелкните правой кнопкой мыши на директорию res и выберите New > Android Resource File в директорииnavigation. Если вы ее еще не создали, то пора это сделать.
2. В директории navigation создаем новый файл navigation resource.В нашем примере он получил названиеnavigation,но вы можете назвать его, как пожелаете.
3. Выбираем Navigation в выпадающем списке Resource type и нажимаем OK.

Теперь мы изменим activity_main.xml и заменим

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

Выполнив это действие, мы должны увидеть хост (activity_main), добавленный в навигационный граф (в navigation.xml).

Теперь можно добавить новый пункт назначения, щелкнув на опцию ‘Click to add a destination’ (Щелкните, чтобы добавить пункт назначения) в центре навигационного графа. Затем выберите опцию ‘Create new destination’ (Создать новый пункт назначения), вслед за этим откроется диалоговое окно Android New Component, где мы можем создать новый фрагмент.

Для нашего примера создадим два фрагмента, а именно SignupFragment и LoginFragment. После этого щелкнем на один фрагмент и присоединим его к другому. Навигационный граф будет выглядеть следующим образом:

Для выше указанного навигационного графа navigation.xml примет следующий вид:

Здесь корневым тегом будет navigation с атрибутом startDestination , в котором мы укажем id первоначально загружаемого фрагмента, за которым следуют пункты назначения (фрагменты, диалоговые окна и т. д.) с одним из атрибутов name , значение которого будет названием вашего пункта назначения.

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

У макета SignupFragment будет две кнопки (Buttons) с id signupBtn и gotoLoginBtn, а также три компонента EditText с id signupUsername, signupPassword и otherInfo.

Типобезопасная зависимость создаст класс в формате name_of_file_Directions (в нашем случае исходный фрагмент SignupFragmentDirections), состоящий из в файле навигации (navigation).

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

Посмотрим на код XML во вкладке навигации для создания графа по типу указанного выше.

Готово: в вашем приложении реализована базовая навигация. Теперь вы сможете переместиться к LoginFragment.

Освоив базовую реализацию, можем переходить к реализации навигации с аргументами (Navigation With Arguments):

Для этого существуют два возможных способа:

1. Использование объектов bundle.
2. Использование SafeArgs.

Ниже я представлю вам два способа реализации и объясню, почему лучше передавать данные, используя SafeArgs вместо Bundle.

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

bundleOf() является методом расширенияandroidx. Для этого нам нужно добавить ниже указанную зависимость в файл build.gradle модуля app:

Получаем данные во фрагменте назначения как:

Вот таким образом мы осуществили передачу данных от одного фрагмента к другому, используя bundle. Однако предчувствую вполне закономерный вопрос с вашей стороны: “Зачем же нам использовать SafeArgs, если мы так легко справились с задачей с помощью выше указанного способа?”.

Конечно, можно передавать данные, используя bundle. Но бывают ситуации, когда мы пытаемся получить данные в пункте назначения, которые никогда не передавались в качестве дополнительных параметров bundle, что вызывает в среде выполнения NullPointerException. Для избежания подобных проблем архитектурные компоненты предоставляют типобезопасный способ.

Как же использовать Safe Arguments для передачи данных?

Так как в нашем проекте есть активный плагин safe args, посмотрим, как его можно использовать.

Сначала укажем аргументы, необходимые для пункта назначения в navigation.xml, как показано ниже:

Мы отправляем данные также из исходного файла как:

Получаем данные также во фрагменте назначения как:

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

Ура. Двигаемся дальше.

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

Навигация с Deeplink:

В Android глубокая ссылка означает ссылку, по которой вы переходите непосредственно в конкретный пункт назначения внутри приложения. Для добавления глубокой ссылки щелкните на значок + на панели Argument в секции Deep Link. В диалоговом окнеAdd deep link (Добавить глубокую ссылку) введите URI.

На этом всё! Пишите код с удовольствием!

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

Источник