Voyager

https://voyager.adriel.cafe/
Admin
Voyager is a multiplatform navigation library for Jetpack Compose, enabling scalable Single-Activity...
Tokens:19,789
Snippets:98
Trust Score:6.8
Update:1 year ago
Show doc for...
Tokens:
Raw
### Add Maven Central Repository

Source: https://voyager.adriel.cafe/setup

Configures the project to use Maven Central as a repository for fetching dependencies. This is a common prerequisite for many Gradle projects.

```gradle
repositories {
    mavenCentral()
}
```

--------------------------------

### Using SlideTransition with Navigator - Kotlin

Source: https://voyager.adriel.cafe/transitions-api

This snippet demonstrates how to set up a Navigator with a SlideTransition. It requires importing the `voyager-transitions` library. The `Navigator` is initialized with a starting screen, and the `SlideTransition` is used as the content for the navigator.

```kotlin
setContent {
    Navigator(HomeScreen) { navigator ->
        SlideTransition(navigator)
    }
}

```

--------------------------------

### Add Voyager Dependencies to build.gradle

Source: https://voyager.adriel.cafe/setup

Specifies the Voyager library dependencies required for the project. This includes core navigation, screen management, and platform-specific integrations. The version catalog helps manage dependency versions efficiently.

```gradle
dependencies {
    val voyagerVersion = "1.1.0-beta02"

    // Multiplatform

    // Navigator
    implementation("cafe.adriel.voyager:voyager-navigator:$voyagerVersion")

    // Screen Model
    implementation("cafe.adriel.voyager:voyager-screenmodel:$voyagerVersion")

    // BottomSheetNavigator
    implementation("cafe.adriel.voyager:voyager-bottom-sheet-navigator:$voyagerVersion")

    // TabNavigator
    implementation("cafe.adriel.voyager:voyager-tab-navigator:$voyagerVersion")

    // Transitions
    implementation("cafe.adriel.voyager:voyager-transitions:$voyagerVersion")

    // Koin integration
    implementation("cafe.adriel.voyager:voyager-koin:$voyagerVersion")

    // Android

    // Hilt integration
    implementation("cafe.adriel.voyager:voyager-hilt:$voyagerVersion")

    // LiveData integration
    implementation("cafe.adriel.voyager:voyager-livedata:$voyagerVersion")

    // Desktop + Android

    // Kodein integration
    implementation("cafe.adriel.voyager:voyager-kodein:$voyagerVersion")

    // RxJava integration
    implementation("cafe.adriel.voyager:voyager-rxjava:$voyagerVersion")
}
```

--------------------------------

### Voyager Navigation Setup in Jetpack Compose (Kotlin)

Source: https://voyager.adriel.cafe/index

This snippet demonstrates the basic setup for Voyager navigation within a Jetpack Compose application. It defines a `HomeScreenModel`, a `HomeScreen` composable, and a `SingleActivity` to host the `Navigator` with the initial screen. This is the foundational structure for using Voyager in an Android app.

```kotlin
class HomeScreenModel : ScreenModel {
    // ...
}

class HomeScreen : Screen {

    @Composable
    override fun Content() {
        val screenModel = rememberScreenModel { HomeScreenModel() }
        // ...
    }
}

class SingleActivity : ComponentActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        setContent {
            Navigator(HomeScreen())
        }
    }
}
```

--------------------------------

### Define Voyager Versions in build.gradle Version Catalog

Source: https://voyager.adriel.cafe/setup

Manages Voyager dependency versions using Gradle's version catalog. This approach centralizes version management, making it easier to update dependencies across the project.

```gradle
[versions]
voyager = "1.1.0-beta02"

[libraries]
voyager-navigator = { module = "cafe.adriel.voyager:voyager-navigator", version.ref = "voyager" }
voyager-screenModel = { module = "cafe.adriel.voyager:voyager-screenmodel", version.ref = "voyager" }
voyager-bottomSheetNavigator = { module = "cafe.adriel.voyager:voyager-bottom-sheet-navigator", version.ref = "voyager" }
voyager-tabNavigator = { module = "cafe.adriel.voyager:voyager-tab-navigator", version.ref = "voyager" }
voyager-transitions = { module = "cafe.adriel.voyager:voyager-transitions", version.ref = "voyager" }
voyager-koin = { module = "cafe.adriel.voyager:voyager-koin", version.ref = "voyager" }
voyager-hilt = { module = "cafe.adriel.voyager:voyager-hilt", version.ref = "voyager" }
voyager-kodein = { module = "cafe.adriel.voyager:voyager-kodein", version.ref = "voyager" }
voyager-rxjava = { module = "cafe.adriel.voyager:voyager-rxjava", version.ref = "voyager" }
```

--------------------------------

### Manage Screen Lifecycle with Callbacks in Kotlin

Source: https://context7.com/context7/voyager_adriel_cafe/llms.txt

Executes code when screens appear or are disposed using `LifecycleEffectOnce`. This is useful for one-time setup like starting polling or tracking screen views upon entry, and for cleanup like stopping polling or saving state upon exit.

```kotlin
import cafe.adriel.voyager.core.lifecycle.LifecycleEffectOnce
import cafe.adriel.voyager.core.screen.Screen
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.runtime.Composable

// Dummy ScreenModel for compilation
class PostListScreenModel {
    fun startPolling() {}
    fun trackScreenView() {}
    fun stopPolling() {}
    fun saveState() {}
}

class PostListScreen : Screen {
    @Composable
    override fun Content() {
        val screenModel = rememberScreenModel { PostListScreenModel() }

        LifecycleEffectOnce {
            // Called once when screen first appears
            screenModel.startPolling()
            screenModel.trackScreenView()

            onDispose {
                // Called when screen is removed from stack
                screenModel.stopPolling()
                screenModel.saveState()
            }
        }

        // UI content
        LazyColumn {
            // ...
        }
    }
}

// Dummy rememberScreenModel for compilation
@Composable
fun <T> rememberScreenModel(model: () -> T): T {
    return model()
}
```

--------------------------------

### Providing uniqueScreenKey for Screens - Kotlin

Source: https://voyager.adriel.cafe/transitions-api

This example shows how to prevent 'Screen was used multiple times' crashes by providing a `uniqueScreenKey` for your `Screen` implementations. By overriding the `key` property with `uniqueScreenKey`, each screen instance gets a distinct identifier.

```kotlin
class ScreenFoo : Screen {

    override val key: ScreenKey = uniqueScreenKey

    @Composable
    override fun Content() {
        ...
    }
}

```

--------------------------------

### Create Reusable SlideTransition and FadeTransition Classes

Source: https://voyager.adriel.cafe/transitions-api

These examples show how to create reusable transition classes, `SlideTransition` and `FadeTransition`, by implementing the `ScreenTransition` interface. `FadeTransition` uses `fadeIn` and `fadeOut` with specified durations and delays, while `SlideTransition` provides similar slide animations as the `ExampleSlideScreen`.

```kotlin
class FadeTransition : ScreenTransition {

    override fun enter(lastEvent: StackEvent): EnterTransition {
        return fadeIn(tween(500, delayMillis = 500))
    }

    override fun exit(lastEvent: StackEvent): ExitTransition {
        return fadeOut(tween(500))
    }
}

class SlideTransition : ScreenTransition {

    override fun enter(lastEvent: StackEvent): EnterTransition {
        return slideIn {
            val x = if (lastEvent == StackEvent.Pop) -size.width else size.width
            IntOffset(x = x, y = 0)
        }
    }

    override fun exit(lastEvent: StackEvent): ExitTransition {
        return slideOut {
            val x = if (lastEvent == StackEvent.Pop) size.width else -size.width
            IntOffset(x = x, y = 0)
        }
    }
}
```

--------------------------------

### Java Serializable Screens and Parameters

Source: https://voyager.adriel.cafe/state-restoration

Demonstrates how to make screens and their parameters Java Serializable for state restoration. This includes valid and invalid examples for both data classes and properties, emphasizing the need for all components to be serializable.

```kotlin
// ✔️ DO
data class Post(/*...*/) : Serializable

data class ValidScreen(
    val userId: UUID, // Built-in serializable types
    val post: Post // Your own serializable types
) : Screen {
    // ...
}

// 🚫 DON'T
class Post(/*...*/)

data class InvalidScreen(
    val context: Context, // Built-in non-serializable types
    val post: Post, // Your own non-serializable types
    val parcelable: SomeParcelable // Android Parcelable is not Java Serializable by default
) : Screen {
    // ...
}

```

```kotlin
// ✔️ DO
class ValidScreen : Screen {

    // Serializable properties
    val tag = "ValidScreen"

    // Lazily initialized serializable types
    val randomId by lazy { UUID.randomUUID() }
}

// 🚫 DON'T
class InvalidScreen : Screen {

    // Non-serializable properties
    val postService = PostService()
}

```

--------------------------------

### Define Per-Screen Transitions with ScreenTransition Interface

Source: https://voyager.adriel.cafe/transitions-api

This example demonstrates how to implement the `ScreenTransition` interface to define custom enter and exit transitions for a specific screen. It uses `slideIn` and `slideOut` based on the `StackEvent` to control the animation direction. The `key` and `Content` are standard `Screen` implementations.

```kotlin
class ExampleSlideScreen : Screen, ScreenTransition {
    override val key: ScreenKey
        get() = uniqueScreenKey

    @Composable
    override fun Content() {
        ...
    }

    override fun enter(lastEvent: StackEvent): EnterTransition {
        return slideIn {
            val x = if (lastEvent == StackEvent.Pop) -size.width else size.width
            IntOffset(x = x, y = 0)
        }
    }

    override fun exit(lastEvent: StackEvent): ExitTransition {
        return slideOut {
            val x = if (lastEvent == StackEvent.Pop) size.width else -size.width
            IntOffset(x = x, y = 0)
        }
    }
}
```

--------------------------------

### Android ViewModel Integration with Voyager (Kotlin)

Source: https://context7.com/context7/voyager_adriel_cafe/llms.txt

Illustrates integrating Android ViewModels with the Voyager navigation library using `LocalViewModelStoreOwner`. This allows the use of ViewModels without direct dependencies on Activity or Fragment. The example shows a `PostListViewModel` managing a list of posts and a `PostListScreen` that consumes these posts, along with a `PostDetailsScreen` demonstrating ViewModel creation with a custom factory for passing arguments.

```kotlin
class PostListViewModel : ViewModel() {
    private val _posts = MutableStateFlow<List<Post>>(emptyList())
    val posts: StateFlow<List<Post>> = _posts.asStateFlow()

    init {
        loadPosts()
    }

    private fun loadPosts() {
        viewModelScope.launch {
            _posts.value = repository.getPosts()
        }
    }

    override fun onCleared() {
        super.onCleared()
        println("ViewModel cleared")
    }
}

class PostListScreen : Screen {
    @Composable
    override fun Content() {
        val viewModel = viewModel<PostListViewModel>()
        val posts by viewModel.posts.collectAsState()

        LazyColumn {
            items(posts) {
 post ->
                Text(post.title)
            }
        }
    }
}

// With ViewModelFactory
class PostDetailsViewModel(
    private val postId: Long
) : ViewModel() {
    // Implementation
}

class PostDetailsViewModelFactory(
    private val postId: Long
) : ViewModelProvider.Factory {
    override fun <T : ViewModel> create(modelClass: Class<T>): T {
        if (modelClass.isAssignableFrom(PostDetailsViewModel::class.java)) {
            @Suppress("UNCHECKED_CAST")
            return PostDetailsViewModel(postId) as T
        }
        throw IllegalArgumentException("Unknown ViewModel class")
    }
}

data class PostDetailsScreen(val postId: Long) : Screen {
    @Composable
    override fun Content() {
        val viewModel = viewModel<PostDetailsViewModel>(
            factory = PostDetailsViewModelFactory(postId)
        )
        // Use viewModel
    }
}
```

--------------------------------

### Initialize Navigator with Multiple Screens (Kotlin)

Source: https://context7.com/context7/voyager_adriel_cafe/llms.txt

Demonstrates how to initialize the Voyager Navigator with multiple screens to handle deep links. It parses a postId from the intent data to navigate to a specific post details screen or defaults to the home screen for a normal start. This approach preserves the back stack, allowing navigation between screens like PostDetails -> PostList -> Home.

```kotlin
class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // Parse deep link
        val postId = intent.data?.getQueryParameter("postId")?.toLongOrNull()

        setContent {
            if (postId != null) {
                // Deep link: HomeScreen -> PostListScreen -> PostDetailsScreen
                Navigator(
                    HomeScreen,
                    PostListScreen(),
                    PostDetailsScreen(postId)
                ) { // The composable to render
                    CurrentScreen()
                }
            } else {
                // Normal start
                Navigator(HomeScreen) { // The composable to render
                    CurrentScreen()
                }
            }
        }
    }
}

// User can press back to navigate: PostDetails -> PostList -> Home
```

--------------------------------

### AssistedInject ScreenModel with Hilt Factory

Source: https://voyager.adriel.cafe/screenmodel/hilt-integration

Illustrates using @AssistedInject for ScreenModels that require constructor parameters in Voyager. It involves defining a ScreenModelFactory and using it to create instances. The example shows how to provide parameters like postId when retrieving the ScreenModel.

```kotlin
class PostDetailsScreenModel @AssistedInject constructor(
    @Assisted val postId: Long
) : ScreenModel {

    @AssistedFactory
    interface Factory : ScreenModelFactory {
        fun create(postId: Long): PostDetailsScreenModel
    }
}
```

```kotlin
data class PostDetailsScreen(val postId: Long): AndroidScreen() {

    @Composable
    override fun Content() {
        val screenModel = getScreenModel<PostDetailsScreenModel, PostDetailsScreenModel.Factory> { factory ->
            factory.create(postId)
        }
        // ...
    }
}
```

--------------------------------

### Basic TabNavigator Setup with Scaffold in Kotlin

Source: https://voyager.adriel.cafe/navigation/tab-navigation

Demonstrates how to integrate `TabNavigator` with Jetpack Compose's `Scaffold` to build a tabbed interface. It sets up the `TabNavigator` with an initial tab and configures `Scaffold`'s `bottomBar` to display navigation items for each tab. Uses `CurrentTab()` for displaying the active tab's content.

```kotlin
setContent {
    TabNavigator(HomeTab) {
        Scaffold(
            content = { 
                CurrentTab() 
            },
            bottomBar = {
                BottomNavigation {
                    TabNavigationItem(HomeTab)
                    TabNavigationItem(FavoritesTab)
                    TabNavigationItem(ProfileTab)
                }
            }
        )
    }
}
```

--------------------------------

### Nested Tab Navigation with Voyager

Source: https://context7.com/context7/voyager_adriel_cafe/llms.txt

Demonstrates how to use TabNavigator with nested Navigators to create a tabbed interface. Each tab manages its own independent navigation stack, allowing for complex patterns like YouTube's tab structure. This example shows navigation within a tab and switching between tabs.

```kotlin
object HomeTab : Tab {
    override val options: TabOptions
        @Composable
        get() = remember {
            TabOptions(0u, "Home", rememberVectorPainter(Icons.Default.Home))
        }

    @Composable
    override fun Content() {
        // Each tab has its own independent navigation stack
        Navigator(PostListScreen())
    }
}

class PostListScreen : Screen {
    @Composable
    override fun Content() {
        // Access the Navigator for this tab
        val navigator = LocalNavigator.currentOrThrow
        // Access TabNavigator for switching tabs
        val tabNavigator = LocalTabNavigator.current

        Column {
            LazyColumn {
                items(posts) { post ->
                    Card(onClick = {
                        // Navigate within this tab's stack
                        navigator.push(PostDetailsScreen(post.id))
                    }) {
                        Text(post.title)
                    }
                }
            }

            Button(onClick = {
                // Switch to another tab
                tabNavigator.current = ProfileTab
            }) {
                Text("Go to Profile Tab")
            }
        }
    }
}

class PostDetailsScreen(val postId: Long) : Screen {
    @Composable
    override fun Content() {
        val navigator = LocalNavigator.currentOrThrow

        Column {
            Text("Post Details: $postId")
            Button(onClick = { navigator.pop() }) {
                Text("Back to List")
            }
        }
    }
}
```

--------------------------------

### TabNavigator Bottom Navigation with Kotlin

Source: https://context7.com/context7/voyager_adriel_cafe/llms.txt

Implements tab-based navigation using TabNavigator and BottomNavigation in Kotlin. This setup allows for specialized navigation within tabs, with automatic state preservation for each tab's content. Dependencies include Voyager and Jetpack Compose Material Design components.

```kotlin
object HomeTab : Tab {
    override val options: TabOptions
        @Composable
        get() {
            val title = "Home"
            val icon = rememberVectorPainter(Icons.Default.Home)

            return remember {
                TabOptions(
                    index = 0u,
                    title = title,
                    icon = icon
                )
            }
        }

    @Composable
    override fun Content() {
        Column {
            Text("Home Tab Content")
        }
    }
}

object FavoritesTab : Tab {
    override val options: TabOptions
        @Composable
        get() = remember {
            TabOptions(
                index = 1u,
                title = "Favorites",
                icon = rememberVectorPainter(Icons.Default.Favorite)
            )
        }

    @Composable
    override fun Content() {
        Text("Favorites Tab Content")
    }
}

object ProfileTab : Tab {
    override val options: TabOptions
        @Composable
        get() = remember {
            TabOptions(
                index = 2u,
                title = "Profile",
                icon = rememberVectorPainter(Icons.Default.Person)
            )
        }

    @Composable
    override fun Content() {
        Text("Profile Tab Content")
    }
}

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            TabNavigator(HomeTab) { tabNavigator ->
                Scaffold(
                    content = { paddingValues ->
                        Box(modifier = Modifier.padding(paddingValues)) {
                            CurrentTab()
                        }
                    },
                    bottomBar = {
                        BottomNavigation {
                            TabNavigationItem(HomeTab)
                            TabNavigationItem(FavoritesTab)
                            TabNavigationItem(ProfileTab)
                        }
                    }
                )
            }
        }
    }
}

@Composable
private fun RowScope.TabNavigationItem(tab: Tab) {
    val tabNavigator = LocalTabNavigator.current

    BottomNavigationItem(
        selected = tabNavigator.current == tab,
        onClick = { tabNavigator.current = tab },
        icon = { Icon(painter = tab.options.icon!!, contentDescription = tab.options.title) },
        label = { Text(tab.options.title) }
    )
}
```

--------------------------------

### Multiplatform Serializable Types

Source: https://voyager.adriel.cafe/state-restoration

Explains how to handle state restoration in multiplatform projects by defining common serializable types. It shows an example using expect/actual declarations for `JavaSerializable`.

```kotlin
// commonMain - module core
expect interface JavaSerializable

data class Post(/*...*/) : JavaSerializable

// androidMain - module core
actual typealias JavaSerializable = java.io.Serializable

// non AndroidMain (ios, web, etc) - module core
actual interface JavaSerializable

// android ui module or compose multiplatform module
data class ValidScreen(
    val post: Post
) : Screen

```

--------------------------------

### Hilt ViewModel Setup (Kotlin)

Source: https://voyager.adriel.cafe/android-viewmodel/hilt-integration

This snippet demonstrates how to annotate a ViewModel class with `@HiltViewModel` and `@Inject` for Hilt integration. Ensure you have imported the `voyager-hilt` dependency.

```kotlin
import androidx.hilt.navigation.compose.hiltViewModel
import androidx.lifecycle.ViewModel
import dagger.hilt.android.lifecycle.HiltViewModel
import javax.inject.Inject

@HiltViewModel
class HomeViewModel @Inject constructor() : ViewModel() {
    // ... ViewModel logic here
}
```

--------------------------------

### Enforcing Parcelable Screens with an Interface

Source: https://voyager.adriel.cafe/state-restoration

Shows how to create a custom `ParcelableScreen` interface to enforce that all screens are Parcelable at compile time. Includes examples of valid and invalid implementations.

```kotlin
interface ParcelableScreen : Screen, Parcelable

// Compile
@Parcelize
data class Post(/*...*/) : Parcelable

@Parcelize
data class ValidScreen(
    val post: Post
) : ParcelableScreen {
    // ...
}

// Not compile
data class Post(/*...*/)

@Parcelize
data class ValidScreen(
    val post: Post
) : ParcelableScreen {
    // ...
}

```

--------------------------------

### Navigate Between Tabs and Nested Screens in Kotlin

Source: https://voyager.adriel.cafe/navigation/tab-navigation

This example demonstrates how to use `LocalNavigator.currentOrThrow` to push new screens onto the current tab's navigation stack and `LocalTabNavigator.current` to switch between different tabs. It shows buttons for navigating to post details and switching to the profile tab.

```kotlin
class PostListScreen : Screen {

    @Composable
    private fun GoToPostDetailsScreenButton(post: Post) {
        val navigator = LocalNavigator.currentOrThrow

        Button(
            onClick = { navigator.push(PostDetailsScreen(post.id)) }
        )
    }

    @Composable
    private fun GoToProfileTabButton() {
        val tabNavigator = LocalTabNavigator.current

        Button(
            onClick = { tabNavigator.current = ProfileTab }
        )
    }
}
```

--------------------------------

### Applying Built-in Transitions in Voyager (Kotlin)

Source: https://context7.com/context7/voyager_adriel_cafe/llms.txt

Shows how to implement SlideTransition, FadeTransition, and ScaleTransition for navigation within a Voyager application. It also includes an example of fixing memory leaks with transitions by setting disposeScreenAfterTransitionEnd to true.

```kotlin
class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            // Slide transition
            Navigator(HomeScreen) { navigator ->
                SlideTransition(navigator)
            }

            // Fade transition
            Navigator(HomeScreen) { navigator ->
                FadeTransition(navigator)
            }

            // Scale transition
            Navigator(HomeScreen) { navigator ->
                ScaleTransition(navigator)
            }
        }
    }
}

// Fix memory leak with transitions (recommended)
Navigator(
    screen = HomeScreen,
    disposeBehavior = NavigatorDisposeBehavior(disposeSteps = false)
) { navigator ->
    SlideTransition(
        navigator = navigator,
        disposeScreenAfterTransitionEnd = true
    )
}

```

--------------------------------

### Android Parcelable Screens

Source: https://voyager.adriel.cafe/state-restoration

Illustrates how to use Android Parcelable for state restoration in screens. Provides examples of valid and invalid implementations, highlighting the requirements for Parcelable types and the `Parcelize` annotation.

```kotlin
// ✔️ DO
@Parcelize
data class Post(/*...*/) : Parcelable

@Parcelize
data class ValidScreen(
    val post: Post // Your own parcelable types
) : Screen, Parcelable {
    // ...
}

// 🚫 DON'T
class Post(/*...*/)

@Parcelize
data class InvalidScreen(
    val context: Context, // Built-in non-parcelable types
    val post: Post, // Your own non-parcelable types
    val serializable: SomeSerializable // Java Serializable are not Android Parcelable by default
) : Screen, Parcelable {
    // ...
}

```

--------------------------------

### Apply Custom ScreenTransition instance directly to Navigator

Source: https://voyager.adriel.cafe/transitions-api

This example illustrates an alternative way to apply a custom screen transition to the `Navigator`. Instead of using the `ScreenTransition` composable, it directly wraps the `Navigator` content with a transition function (e.g., `SlideTransition(navigator)`), which is assumed to be a composable that handles the navigation transitions.

```kotlin
setContent {
    Navigator(HomeScreen) { navigator ->
        SlideTransition(navigator)
    }
}
```

--------------------------------

### Get ScreenModel Instance in Voyager Screen

Source: https://voyager.adriel.cafe/screenmodel/koin-integration

Retrieves a new instance of a declared `ScreenModel` within a Voyager `Screen`. This function assumes Koin has been set up and the `ScreenModel` is registered as a factory. Use `<YourScreenModelType>` to specify the type.

```kotlin
class HomeScreen : Screen {

    @Composable
    override fun Content() {
        val screenModel = getScreenModel<HomeScreenModel>()
        // ...
    }
}
```

--------------------------------

### Create ViewModel in Voyager Screen (Kotlin)

Source: https://voyager.adriel.cafe/android-viewmodel

Demonstrates how to obtain a ViewModel instance within a Voyager Screen's Composable content. It utilizes the `viewModel()` function, relying on Voyager's provided `LocalViewModelStoreOwner` and `LocalSavedStateRegistryOwner` for automatic setup.

```kotlin
class PostListScreen : Screen {

    @Composable
    override fun Content() {
        val viewModel = viewModel<PostListViewModel>()
        // ...
    }
}

```

--------------------------------

### Nested Navigator Example in Kotlin

Source: https://voyager.adriel.cafe/navigation/nested-navigation

Demonstrates the creation and interaction with nested navigators in Voyager. It shows how to access the navigator's level and parent navigator to understand the navigation hierarchy. This is useful for complex navigation flows where you need context about the current navigation depth.

```kotlin
setContent {
    Navigator(ScreenA) { navigator0 ->
        println(navigator.level)
        // 0
        println(navigator.parent == null)
        // true
        Navigator(ScreenB) { navigator1 ->
            println(navigator.level)
            // 1
            println(navigator.parent == navigator0)
            // true
            Navigator(ScreenC) { navigator2 ->
                println(navigator.level)
                // 2
                println(navigator.parent == navigator1)
                // true
            }
        }
    }
}
```

--------------------------------

### Custom Screen Disposal Logic with ScreenLifecycleOwner in Voyager

Source: https://voyager.adriel.cafe/lifecycle

Implement the `ScreenLifecycleProvider` interface to provide a custom `ScreenLifecycleOwner`. This owner's `onDispose` method is called when the associated `Screen` is removed from the navigation stack, enabling specific cleanup or logging actions. The example shows a `MyScreenLifecycleOwner` that prints a message upon disposal.

```kotlin
class MyScreenLifecycleOwner : ScreenLifecycleOwner {
    override fun onDispose(screen: Screen) {
        println("My ${screen.key} is being disposed")
    }
}

data object MyScreen : Screen, ScreenLifecycleProvider {
   @Composable
   fun Content() {
      ...
   }

   public override fun getLifecycleOwner(): ScreenLifecycleOwner = 
       ScreenLifecycleOwner()
}

```

--------------------------------

### Define and Navigate to Screens in Voyager

Source: https://context7.com/context7/voyager_adriel_cafe/llms.txt

Demonstrates how to define basic and parameterized screens implementing the Voyager Screen interface. Includes navigation logic using `LocalNavigator` and `navigator.push()` for parameterized screens, and `navigator.pop()` for returning. Assumes `PostDetailsScreenModel` and `posts` data are defined elsewhere.

```kotlin
class PostListScreen : Screen {
    @Composable
    override fun Content() {
        val navigator = LocalNavigator.currentOrThrow

        LazyColumn {
            items(posts) { post ->
                Card(
                    modifier = Modifier.clickable {
                        navigator.push(PostDetailsScreen(post.id))
                    }
                ) {
                    Text(post.title)
                }
            }
        }
    }
}

data class PostDetailsScreen(val postId: Long) : Screen {
    @Composable
    override fun Content() {
        val navigator = LocalNavigator.currentOrThrow
        val screenModel = rememberScreenModel { PostDetailsScreenModel(postId) }
        val post by screenModel.post.collectAsState()

        Column {
            Text(post.title, style = MaterialTheme.typography.h4)
            Text(post.content)
            Button(onClick = { navigator.pop() }) {
                Text("Back")
            }
        }
    }
}

// Initialize Navigator in Activity
class SingleActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            Navigator(HomeScreen)
        }
    }
}
```

--------------------------------

### Koin Dependency Injection with Voyager ScreenModels (Kotlin)

Source: https://context7.com/context7/voyager_adriel_cafe/llms.txt

Demonstrates Koin module definition, ScreenModel creation with injected dependencies, and initializing Koin in the Application class. It also shows how to access ScreenModels within Composables using koinScreenModel and navigator.getNavigatorScreenModel.

```kotlin
// Define Koin module
val homeModule = module {
    factory { PostRepository(get()) }
    factory { PostListScreenModel(get()) }
}

class PostListScreenModel(
    private val repository: PostRepository
) : ScreenModel {
    private val _posts = MutableStateFlow<List<Post>>(emptyList())
    val posts: StateFlow<List<Post>> = _posts.asStateFlow()

    init {
        loadPosts()
    }

    private fun loadPosts() {
        // Use injected repository
        _posts.value = repository.getPosts()
    }
}

// Initialize Koin in Application
class MyApp : Application() {
    override fun onCreate() {
        super.onCreate(savedInstanceState)

        startKoin {
            androidContext(this@MyApp)
            modules(homeModule)
        }
    }
}

// Use in Screen
class PostListScreen : Screen {
    @Composable
    override fun Content() {
        // koinScreenModel is the new name (replaces deprecated getScreenModel)
        val screenModel = koinScreenModel<PostListScreenModel>()
        val posts by screenModel.posts.collectAsState()

        LazyColumn {
            items(posts) {
                Text(post.title)
            }
        }
    }
}

// Navigator-scoped with Koin
class HomeScreen : Screen {
    @Composable
    override fun Content() {
        val navigator = LocalNavigator.currentOrThrow
        val screenModel = navigator.getNavigatorScreenModel<SharedCartScreenModel>()

        // Shared across all screens in this navigator
    }
}

```

--------------------------------

### Basic ScreenModel with State Management in Kotlin

Source: https://context7.com/context7/voyager_adriel_cafe/llms.txt

Demonstrates a basic ScreenModel for managing UI state like posts and loading status. It uses Kotlin's StateFlow for reactive updates and provides methods for loading and refreshing data. The `onDispose` method is included for resource cleanup.

```kotlin
class PostListScreenModel : ScreenModel {
    private val _posts = MutableStateFlow<List<Post>>(emptyList())
    val posts: StateFlow<List<Post>> = _posts.asStateFlow()

    private val _isLoading = MutableStateFlow(false)
    val isLoading: StateFlow<Boolean> = _isLoading.asStateFlow()

    init {
        loadPosts()
    }

    private fun loadPosts() {
        _isLoading.value = true
        // Simulate API call
        _posts.value = listOf(
            Post(1, "First Post", "Content 1"),
            Post(2, "Second Post", "Content 2")
        )
        _isLoading.value = false
    }

    fun refreshPosts() {
        loadPosts()
    }

    override fun onDispose() {
        // Clean up resources when screen is removed from stack
        println("PostListScreenModel disposed")
    }
}

class PostListScreen : Screen {
    @Composable
    override fun Content() {
        val screenModel = rememberScreenModel { PostListScreenModel() }
        val posts by screenModel.posts.collectAsState()
        val isLoading by screenModel.isLoading.collectAsState()

        Column {
            if (isLoading) {
                CircularProgressIndicator()
            }

            Button(onClick = { screenModel.refreshPosts() }) {
                Text("Refresh")
            }

            LazyColumn {
                items(posts) {
                    Text(it.title)
                }
            }
        }
    }
}

// Multiple ScreenModel instances with tags
class MultiModelScreen : Screen {
    @Composable
    override fun Content() {
        val primaryModel = rememberScreenModel { PostListScreenModel() }
        val secondaryModel = rememberScreenModel(tag = "SECONDARY") { PostListScreenModel() }

        // Both models are independent instances
    }
}
```

--------------------------------

### SnapshotStateStack Basic Operations (Kotlin)

Source: https://voyager.adriel.cafe/stack-api

Demonstrates basic operations of SnapshotStateStack, including initialization, adding, removing, and replacing elements. It shows how to observe the stack's state and use specific navigation methods.

```kotlin
val stack = mutableStateStackOf("🍇", "🍉", "🍌", "🍐", "🥝", "🍋")
// 🍇, 🍉, 🍌, 🍐, 🥝, 🍋

stack.lastItemOrNull
// 🍋

stack.push("🍍")
// 🍇, 🍉, 🍌, 🍐, 🥝, 🍋, 🍍

stack.pop()
// 🍇, 🍉, 🍌, 🍐, 🥝, 🍋

stack.popUntil { it == "🍐" }
// 🍇, 🍉, 🍌, 🍐

stack.replace("🍓")
// 🍇, 🍉, 🍌, 🍓

stack.replaceAll("🍒")
// 🍒
```

--------------------------------

### Stack API Navigation Operations with Kotlin

Source: https://context7.com/context7/voyager_adriel_cafe/llms.txt

Demonstrates state-aware navigation operations using the SnapshotStateStack in Kotlin. It covers pushing, popping, replacing, and managing the navigation stack, automatically triggering recomposition on content changes. This requires the Voyager navigation library.

```kotlin
class NavigationExampleScreen : Screen {
    @Composable
    override fun Content() {
        val navigator = LocalNavigator.currentOrThrow

        Column {
            // Push new screen (also works with: navigator += ScreenB or navigator push ScreenB)
            Button(onClick = { navigator.push(ScreenB()) }) {
                Text("Push Screen B")
            }

            // Pop current screen
            Button(onClick = { navigator.pop() }) {
                Text("Pop Current Screen")
            }

            // Replace current screen with new one
            Button(onClick = { navigator.replace(ScreenC()) }) {
                Text("Replace with Screen C")
            }

            // Pop until specific screen is found
            Button(onClick = {
                navigator.popUntil { screen -> screen is HomeScreen }
            }) {
                Text("Pop Until Home")
            }

            // Replace entire stack with single screen
            Button(onClick = { navigator.replaceAll(HomeScreen) }) {
                Text("Replace All with Home")
            }

            // Pop all screens except root
            Button(onClick = { navigator.popAll() }) {
                Text("Pop All")
            }

            Text("Stack size: ${navigator.size}")
            Text("Last event: ${navigator.lastEvent}")
        }
    }
}

// Using Stack outside Navigator as observable collection
@Composable
fun StackExample() {
    val stack = rememberStateStack("🍇", "🍉", "🍌", "🍐")

    Column {
        Text("Current items: ${stack.items.joinToString()}")
        Text("Last item: ${stack.lastItemOrNull}")

        Button(onClick = { stack.push("🍍") }) {
            Text("Add Pineapple")
        }
        Button(onClick = { stack.pop() }) {
            Text("Remove Last")
        }
    }
}
```

--------------------------------

### Initialize Voyager Navigator

Source: https://voyager.adriel.cafe/navigation

The `Navigator` is a composable function that manages the screen lifecycle, back presses, and state restoration. It is initialized within your Activity's `setContent` block, typically with an initial screen.

```kotlin
class SingleActivity : ComponentActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        setContent {
            Navigator(HomeScreen)
        }
    }
}
```

--------------------------------

### Instantiate ScreenModel with a Tag

Source: https://voyager.adriel.cafe/screenmodel

Illustrates how to create multiple distinct instances of the same ScreenModel within a single Screen by providing a unique tag to the rememberScreenModel function. This is useful for differentiating ScreenModels with the same type.

```kotlin
val screenModel = rememberScreenModel(tag = "CUSTOM_TAG") { HomeScreenModel() }

```

--------------------------------

### Collect State in Voyager Screen Composable

Source: https://voyager.adriel.cafe/screenmodel/coroutines-integration

Illustrates how to collect state from a Voyager `StateScreenModel` within a Jetpack Compose `Screen`. It uses `rememberScreenModel` to get the `ScreenModel` instance and `state.collectAsState()` to observe state changes. The UI then reacts to different states like `Loading` or `Result`.

```kotlin
class PostDetailsScreen : Screen {

    @Composable
    override fun Content() {
        val screenModel = rememberScreenModel<PostDetailsScreenModel>()
        val state by screenModel.state.collectAsState()

        when (state) {
            is State.Loading -> LoadingContent()
            is State.Result -> PostContent(state.post)
        }
    }
}
```

--------------------------------

### Multiplatform State Restoration with expect/actual in Kotlin

Source: https://context7.com/context7/voyager_adriel_cafe/llms.txt

Explains how to achieve multiplatform state restoration using expect/actual declarations for platform-specific serialization. This allows for adaptable serialization strategies across different targets like Android, iOS, and Web.

```kotlin
// commonMain
expect interface JavaSerializable

data class Post(
    val id: Long,
    val title: String
) : JavaSerializable

data class ValidScreen(
    val post: Post
) : Screen {
    @Composable
    override fun Content() {
        Text(post.title)
    }
}

// androidMain
actual typealias JavaSerializable = java.io.Serializable

// non-Android platforms (iOS, Web, etc)
actual interface JavaSerializable

// Dependency injection in composables (correct)
class ValidScreen : Screen {
    @Composable
    override fun Content() {
        val postService = get<PostService>() // Inject in composable
        // Use service
    }
}

// INVALID - non-serializable property
class InvalidScreen : Screen {
    val postService by inject<PostService>() // Will break state restoration

    @Composable
    override fun Content() {
        // Don't do this
    }
}
```

--------------------------------

### Consuming RxScreenModel State in Jetpack Compose

Source: https://voyager.adriel.cafe/screenmodel/rxjava-integration

Illustrates how to consume the state emitted by an RxScreenModel within a Jetpack Compose screen. It uses `rememberScreenModel` to get the ScreenModel instance and `subscribeAsState` to observe state changes, updating the UI based on the current state (Init, Loading, Result).

```kotlin
class PostDetailsScreen : Screen {

    @Composable
    override fun Content() {
        val screenModel = rememberScreenModel<PostDetailsScreenModel>()
        val state by screenModel.state.subscribeAsState(initial = State.Init)

        when (state) {
            is State.Loading -> LoadingContent()
            is State.Result -> PostContent(state.post)
        }
    }
}

```

--------------------------------

### Create and Use ScreenModule for Feature Screens

Source: https://voyager.adriel.cafe/navigation/multi-module-navigation

Demonstrates creating a `screenModule` within a feature module (e.g., `feature-posts`) to register its screens. This helps in keeping the `Application` class cleaner. The `Application` class can then simply call this module.

```kotlin
val featurePostsScreenModule = screenModule {
    register<SharedScreen.PostList> {
        ListScreen()
    }
    register<SharedScreen.PostDetails> {
        DetailsScreen(id = provider.id)
    }
}
```

```kotlin
override fun onCreate() {
    super.onCreate()

    ScreenRegistry {
        featurePostsScreenModule()
    }
}
```

--------------------------------

### Show BottomSheet using LocalBottomSheetNavigator

Source: https://voyager.adriel.cafe/navigation/bottomsheet-navigation

Illustrates how to access the `LocalBottomSheetNavigator` to programmatically show a front layer screen (`FrontScreen`) when a button is clicked. This is the standard way to interact with and present the bottom sheet from content within the back layer.

```kotlin
class BackScreen : Screen {

    @Composable
    override fun Content() {
        val bottomSheetNavigator = LocalBottomSheetNavigator.current

        Button(
            onClick = { 
                bottomSheetNavigator.show(FrontScreen())
            }
        ) {
            Text(text = "Show BottomSheet")
        }
    }
}
```

--------------------------------

### Gradle Dependencies for Voyager (Kotlin)

Source: https://context7.com/context7/voyager_adriel_cafe/llms.txt

Provides the necessary Gradle dependencies to integrate the Voyager navigation library into an Android project. It includes the core navigation module and optional modules for features like ScreenModel support, bottom sheet navigation, tab navigation, transitions, and integrations with dependency injection frameworks (Koin, Kodein, Hilt) and reactive programming libraries (RxJava, LiveData). Version catalog usage is also demonstrated.

```kotlin
// build.gradle.kts
repositories {
    mavenCentral()
}

dependencies {
    val voyagerVersion = "1.1.0-beta02"

    // Core navigation (required)
    implementation("cafe.adriel.voyager:voyager-navigator:$voyagerVersion")

    // ScreenModel support
    implementation("cafe.adriel.voyager:voyager-screenmodel:$voyagerVersion")

    // BottomSheet navigation
    implementation("cafe.adriel.voyager:voyager-bottom-sheet-navigator:$voyagerVersion")

    // Tab navigation
    implementation("cafe.adriel.voyager:voyager-tab-navigator:$voyagerVersion")

    // Transitions
    implementation("cafe.adriel.voyager:voyager-transitions:$voyagerVersion")

    // Koin integration (multiplatform)
    implementation("cafe.adriel.voyager:voyager-koin:$voyagerVersion")

    // Kodein integration (Desktop + Android)
    implementation("cafe.adriel.voyager:voyager-kodein:$voyagerVersion")

    // Hilt integration (Android only)
    implementation("cafe.adriel.voyager:voyager-hilt:$voyagerVersion")

    // RxJava integration (Desktop + Android)
    implementation("cafe.adriel.voyager:voyager-rxjava:$voyagerVersion")

    // LiveData integration (Android only)
    implementation("cafe.adriel.voyager:voyager-livedata:$voyagerVersion")
}

// Using version catalog
// libs.versions.toml
[versions]
voyager = "1.1.0-beta02"

[libraries]
voyager-navigator = { module = "cafe.adriel.voyager:voyager-navigator", version.ref = "voyager" }
voyager-screenModel = { module = "cafe.adriel.voyager:voyager-screenmodel", version.ref = "voyager" }
voyager-bottomSheetNavigator = { module = "cafe.adriel.voyager:voyager-bottom-sheet-navigator", version.ref = "voyager" }
voyager-tabNavigator = { module = "cafe.adriel.voyager:voyager-tab-navigator", version.ref = "voyager" }
voyager-transitions = { module = "cafe.adriel.voyager:voyager-transitions", version.ref = "voyager" }
voyager-koin = { module = "cafe.adriel.voyager:voyager-koin", version.ref = "voyager" }
voyager-hilt = { module = "cafe.adriel.voyager:voyager-hilt", version.ref = "voyager" }
```

--------------------------------

### Instantiate ScreenModel in a Screen

Source: https://voyager.adriel.cafe/screenmodel

Shows how to create and remember an instance of a ScreenModel within a Jetpack Compose Screen using the rememberScreenModel factory lambda. This ensures the ScreenModel's lifecycle is tied to the Screen's.

```kotlin
class HomeScreen : Screen {

    @Composable
    override fun Content() {
        val screenModel = rememberScreenModel { HomeScreenModel() }
        // ...
    }
}

```

--------------------------------

### Provide ScreenDisposable for All Screens in Navigator in Voyager

Source: https://voyager.adriel.cafe/lifecycle

To apply a `ScreenDisposable` to all screens within a `Navigator`, register a `ScreenLifecycleOwner` for each `lastItem` in the `Navigator`'s composable. The example reuses `MyScreenLifecycleOwner` to ensure that disposal logic is consistently applied across all screens managed by the navigator. This is achieved by observing `navigator.lastItem` and registering the owner within the `ScreenLifecycleStore`.

```kotlin
class MyScreenLifecycleOwner : ScreenDisposable {
    override fun onDispose(screen: Screen) {
        println("My ${screen.key} is being disposed")
    }
}

@Composable
fun YourAppComposable() {
  Navigator(...) { navigator ->
     remember(navigator.lastItem) {
        ScreenLifecycleStore.get(navigator.lastItem) {
           MyScreenLifecycleOwner()
        }
     }
     CurrentScreen()
  }
}

```

--------------------------------

### Dependency Injection with Screens

Source: https://voyager.adriel.cafe/state-restoration

Shows how to inject dependencies into screens using DI frameworks like Koin or Kodein, ensuring that dependencies are injected within composable functions and avoiding non-serializable types as properties.

```kotlin
// ✔️ DO
class ValidScreen : Screen {

    @Composable
    override fun Content() {
        // Inject your dependencies inside composables
        val postService = get<PostService>()
    }
}

// 🚫 DON'T
class InvalidScreen : Screen {

    // Using DI to inject non-serializable types as properties
    val postService by inject<PostService>()
}

```

--------------------------------

### Define a Basic ScreenModel

Source: https://voyager.adriel.cafe/screenmodel

Demonstrates how to define a custom ScreenModel by extending the ScreenModel interface and optionally overriding the onDispose method. This class is designed to hold and manage UI-related data.

```kotlin
class HomeScreenModel : ScreenModel {

   // Optional
    override fun onDispose() {
        // ...
    }
}

```

--------------------------------

### Declare ScreenModel with Kodein

Source: https://voyager.adriel.cafe/screenmodel/kodein-integration

Declare your ScreenModels using Kodein's `bindProvider` within a DI.Module. This sets up the dependency injection for your ScreenModels.

```kotlin
val homeModule = DI.Module(name = "home") {
    bindProvider { HomeScreenModel() } 
}
```
Tokens:
Raw