Навигация с помощью Compose

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

Настраивать

Для поддержки Compose используйте следующую зависимость в файле build.gradle вашего модуля приложения:

dependencies {
    def nav_version = "2.8.4"

    implementation "androidx.navigation:navigation-compose:$nav_version"
}

dependencies {
    val nav_version = "2.8.4"

    implementation("androidx.navigation:navigation-compose:$nav_version")
}

Начать

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

Создайте NavController

Информацию о том, как создать NavController в Compose, см. в разделе «Создание» статьи «Создание контроллера навигации» .

Создать NavHost

Информацию о том, как создать NavHost в Compose, см. в разделе «Создание» статьи «Создание навигационного графа» .

Перейдите к составному элементу

Информацию о переходе к Composable см. в разделе «Навигация к месту назначения» документации по архитектуре.

Навигация с аргументами

Информацию о передаче аргументов между составными пунктами назначения см. в разделе «Создание» статьи «Создание навигационного графа» .

Получение сложных данных при навигации

Настоятельно рекомендуется не передавать сложные объекты данных при навигации, а вместо этого передавать минимально необходимую информацию, например уникальный идентификатор или другую форму идентификатора, в качестве аргументов при выполнении действий навигации:

// Pass only the user ID when navigating to a new destination as argument
navController.navigate(Profile(id = "user1234"))

Сложные объекты должны храниться как данные в одном источнике достоверности, например на уровне данных. Как только вы приземлитесь в пункте назначения после навигации, вы сможете загрузить необходимую информацию из единого источника истины, используя переданный идентификатор. Чтобы получить аргументы в вашей ViewModel , отвечающие за доступ к уровню данных, используйте SavedStateHandle ViewModel :

class UserViewModel(
    savedStateHandle: SavedStateHandle,
    private val userInfoRepository: UserInfoRepository
) : ViewModel() {

    private val profile = savedStateHandle.toRoute<Profile>()

    // Fetch the relevant user information from the data layer,
    // ie. userInfoRepository, based on the passed userId argument
    private val userInfo: Flow<UserInfo> = userInfoRepository.getUserInfo(profile.id)

// …

}

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

Более подробное объяснение того, почему следует избегать передачи сложных данных в качестве аргументов, а также список поддерживаемых типов аргументов см. в разделе Передача данных между пунктами назначения .

Глубокие ссылки

Navigation Compose поддерживает глубокие ссылки, которые также можно определить как часть функции composable() . Его параметр deepLinks принимает список объектов NavDeepLink , которые можно быстро создать с помощью метода navDeepLink() :

@Serializable data class Profile(val id: String)
val uri = "https://www.example.com"

composable<Profile>(
  deepLinks = listOf(
    navDeepLink<Profile>(basePath = "$uri/profile")
  )
) { backStackEntry ->
  ProfileScreen(id = backStackEntry.toRoute<Profile>().id)
}

Эти глубокие ссылки позволяют связать определенный URL-адрес, действие или тип MIME с составным объектом. По умолчанию эти глубокие ссылки не доступны внешним приложениям. Чтобы сделать эти глубокие ссылки доступными извне, необходимо добавить соответствующие элементы <intent-filter> в файл manifest.xml . Чтобы включить глубокую ссылку в предыдущем примере, вам следует добавить следующее внутрь элемента <activity> манифеста:

<activity …>
  <intent-filter>
    ...
    <data android:scheme="https" android:host="www.example.com" />
  </intent-filter>
</activity>

Автоматическая навигация по глубоким ссылкам на этот компонуемый объект, когда глубокая ссылка активируется другим приложением.

Эти же глубокие ссылки также можно использовать для создания PendingIntent с соответствующей глубокой ссылкой из составного объекта:

val id = "exampleId"
val context = LocalContext.current
val deepLinkIntent = Intent(
    Intent.ACTION_VIEW,
    "https://www.example.com/profile/$id".toUri(),
    context,
    MyActivity::class.java
)

val deepLinkPendingIntent: PendingIntent? = TaskStackBuilder.create(context).run {
    addNextIntentWithParentStack(deepLinkIntent)
    getPendingIntent(0, PendingIntent.FLAG_UPDATE_CURRENT)
}

Затем вы можете использовать этот deepLinkPendingIntent , как и любой другой PendingIntent , чтобы открыть свое приложение в месте назначения глубокой ссылки.

Вложенная навигация

Информацию о том, как создавать вложенные графики навигации, см. в разделе Вложенные графики .

Интеграция с нижней панелью навигации

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

Чтобы использовать компоненты BottomNavigation и BottomNavigationItem , добавьте зависимость androidx.compose.material в свое приложение Android.

dependencies {
    implementation "androidx.compose.material:material:1.7.5"
}

android {
    buildFeatures {
        compose true
    }

    composeOptions {
        kotlinCompilerExtensionVersion = "1.5.15"
    }

    kotlinOptions {
        jvmTarget = "1.8"
    }
}

dependencies {
    implementation("androidx.compose.material:material:1.7.5")
}

android {
    buildFeatures {
        compose = true
    }

    composeOptions {
        kotlinCompilerExtensionVersion = "1.5.15"
    }

    kotlinOptions {
        jvmTarget = "1.8"
    }
}

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

data class TopLevelRoute<T : Any>(val name: String, val route: T, val icon: ImageVector)

Затем поместите эти маршруты в список, который может использоваться BottomNavigationItem :

val topLevelRoutes = listOf(
   TopLevelRoute("Profile", Profile, Icons.Profile),
   TopLevelRoute("Friends", Friends, Icons.Friends)
)

В компонуемом элементе BottomNavigation получите текущий NavBackStackEntry с помощью функции currentBackStackEntryAsState() . Эта запись дает вам доступ к текущему NavDestination . Затем выбранное состояние каждого BottomNavigationItem можно определить путем сравнения маршрута элемента с маршрутом текущего пункта назначения и его родительских пунктов назначения для обработки случаев, когда вы используете вложенную навигацию с использованием иерархии NavDestination .

Маршрут элемента также используется для подключения лямбды onClick к вызову navigate , чтобы нажатие на элемент переходило к этому элементу. При использовании флагов saveState и restoreState состояние и задний стек этого элемента правильно сохраняются и восстанавливаются при переключении между элементами нижней навигации.

val navController = rememberNavController()
Scaffold(
  bottomBar = {
    BottomNavigation {
      val navBackStackEntry by navController.currentBackStackEntryAsState()
      val currentDestination = navBackStackEntry?.destination
      topLevelRoutes.forEach { topLevelRoute ->
        BottomNavigationItem(
          icon = { Icon(topLevelRoute.icon, contentDescription = topLevelRoute.name) },
          label = { Text(topLevelRoute.name) },
          selected = currentDestination?.hierarchy?.any { it.hasRoute(topLevelRoute.route::class) } == true,
          onClick = {
            navController.navigate(topLevelRoute.route) {
              // Pop up to the start destination of the graph to
              // avoid building up a large stack of destinations
              // on the back stack as users select items
              popUpTo(navController.graph.findStartDestination().id) {
                saveState = true
              }
              // Avoid multiple copies of the same destination when
              // reselecting the same item
              launchSingleTop = true
              // Restore state when reselecting a previously selected item
              restoreState = true
            }
          }
        )
      }
    }
  }
) { innerPadding ->
  NavHost(navController, startDestination = Profile, Modifier.padding(innerPadding)) {
    composable<Profile> { ProfileScreen(...) }
    composable<Friends> { FriendsScreen(...) }
  }
}

Здесь вы воспользуетесь методом NavController.currentBackStackEntryAsState() чтобы поднять состояние navController из функции NavHost и поделиться им с компонентом BottomNavigation . Это означает, что BottomNavigation автоматически получает самое актуальное состояние.

Совместимость

Если вы хотите использовать компонент «Навигация» с Compose, у вас есть два варианта:

• Определите граф навигации с помощью компонента «Навигация» для фрагментов.
• Определите граф навигации с помощью NavHost в Compose, используя пункты назначения Compose. Это возможно только в том случае, если все экраны навигационного графа являются составными.

Поэтому для смешанных приложений Compose и Views рекомендуется использовать компонент навигации на основе фрагментов. Затем фрагменты будут содержать экраны на основе просмотра, экраны создания и экраны, использующие как представления, так и создание. Как только содержимое каждого фрагмента окажется в Compose, следующим шагом будет объединение всех этих экранов вместе с помощью Navigation Compose и удаление всех фрагментов.

Переход от создания с помощью навигации по фрагментам

Чтобы изменить пункты назначения внутри кода Compose, вы предоставляете события, которые могут быть переданы и запущены любым компонуемым объектом в иерархии:

@Composable
fun MyScreen(onNavigate: (Int) -> Unit) {
    Button(onClick = { onNavigate(R.id.nav_profile) } { /* ... */ }
}

В своем фрагменте вы создаете мост между Compose и компонентом навигации на основе фрагментов, находя NavController и переходя к месту назначения:

override fun onCreateView( /* ... */ ) {
    setContent {
        MyScreen(onNavigate = { dest -> findNavController().navigate(dest) })
    }
}

Альтернативно вы можете передать NavController вниз по иерархии Compose. Однако предоставление простых функций гораздо более пригодно для повторного использования и тестирования.

Тестирование

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

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

Уровень косвенности, обеспечиваемый composable лямбдой, позволяет вам отделить код навигации от самого составного объекта. Это работает в двух направлениях:

• Передавайте в компонуемый объект только проанализированные аргументы.
• Передавайте лямбды, которые должны запускаться компонуемым объектом для навигации, а не самим NavController .

Например, компонуемый ProfileScreen , который принимает userId в качестве входных данных и позволяет пользователям переходить на страницу профиля друга, может иметь подпись:

@Composable
fun ProfileScreen(
    userId: String,
    navigateToFriendProfile: (friendUserId: String) -> Unit
) {
 …
}

Таким образом, компонуемый ProfileScreen работает независимо от навигации, что позволяет тестировать его независимо. composable лямбда-выражение будет инкапсулировать минимальную логику, необходимую для устранения разрыва между API навигации и вашим компонуемым объектом:

@Serializable data class Profile(id: String)

composable<Profile> { backStackEntry ->
    val profile = backStackEntry.toRoute<Profile>()
    ProfileScreen(userId = profile.id) { friendUserId ->
        navController.navigate(route = Profile(id = friendUserId))
    }
}

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

Тестирование NavHost

Чтобы начать тестирование вашего NavHost , добавьте следующую зависимость тестирования навигации:

dependencies {
// ...
  androidTestImplementation "androidx.navigation:navigation-testing:$navigationVersion"
  // ...
}

Оберните NavHost вашего приложения в составной элемент, который принимает NavHostController в качестве параметра.

@Composable
fun AppNavHost(navController: NavHostController){
  NavHost(navController = navController){ ... }
}

Теперь вы можете протестировать AppNavHost и всю логику навигации, определенную внутри NavHost , передав экземпляр артефакта тестирования навигации TestNavHostController . Тест пользовательского интерфейса, проверяющий начальный пункт назначения вашего приложения и NavHost будет выглядеть следующим образом:

class NavigationTest {

    @get:Rule
    val composeTestRule = createComposeRule()
    lateinit var navController: TestNavHostController

    @Before
    fun setupAppNavHost() {
        composeTestRule.setContent {
            navController = TestNavHostController(LocalContext.current)
            navController.navigatorProvider.addNavigator(ComposeNavigator())
            AppNavHost(navController = navController)
        }
    }

    // Unit test
    @Test
    fun appNavHost_verifyStartDestination() {
        composeTestRule
            .onNodeWithContentDescription("Start Screen")
            .assertIsDisplayed()
    }
}

Тестирование действий навигации

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

Поскольку вы хотите протестировать реализацию конкретного приложения, предпочтительным является нажатие на пользовательский интерфейс. Чтобы узнать, как протестировать это вместе с отдельными составными функциями изолированно, обязательно ознакомьтесь с кодовой лабораторией «Тестирование в Jetpack Compose» .

Вы также можете использовать navController для проверки своих утверждений, сравнивая текущий маршрут с ожидаемым, используя currentBackStackEntry navController :

@Test
fun appNavHost_clickAllProfiles_navigateToProfiles() {
    composeTestRule.onNodeWithContentDescription("All Profiles")
        .performScrollTo()
        .performClick()

    assertTrue(navController.currentBackStackEntry?.destination?.hasRoute<Profile>() ?: false)
}

Дополнительные рекомендации по основам тестирования Compose см. в разделах Тестирование макета Compose и лаборатории тестирования Compose в Jetpack . Чтобы узнать больше о расширенном тестировании кода навигации, посетите руководство по тестированию навигации .

Узнать больше

Дополнительные сведения о навигации Jetpack см. в разделе Начало работы с компонентом навигации или воспользуйтесь лабораторной работой по написанию кода Jetpack Compose Navigation .

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

Чтобы узнать о более продвинутой реализации навигации Compose в модульном приложении, включая такие концепции, как вложенные графики и интеграция нижней панели навигации, ознакомьтесь с приложением Now in Android на GitHub.

Образцы