voyager kotlin

• Nested navigation
• Multi-module navigation
• Android ViewModel
• ViewModel KMP
• State restoration
• Transitions
• Migration to 1.0.0
• Community Projects

Navigation ¶

To use the Navigator you should first import cafe.adriel.voyager:voyager-navigator (see Setup ).

Screen ¶

On Voyager, screens are just classes with a composable function as the entrypoint. To create one, you should implement the Screen interface and override the Content() composable function.

You can use data class (if you need to send params), class (if no param is required).

Navigator ¶

Navigator is a composable function deeply integrated with Compose internals. It’ll manage the lifecyle , back press , state restoration and even nested navigation for you.

To start using it, just set the initial Screen .

Use the LocalNavigator to navigate to other screens. Take a look at the Stack API for the available operations.

If part of your UI is shared between screens, like the TopAppBar or BottomNavigation , you can easily reuse them with Voyager.

{% hint style=”warning” %} You should use CurrentScreen() instead of navigator.lastItem.Content() , because it will save the Screen’s subtree for you (see SaveableStateHolder ). {% endhint %}

Sample ¶

Source code here .

Free Version

Get in Touch

Voyager: The Navigation Library for Kotlin Multiplatform and Compose Multiplatform

Learn how Voyager handles navigation in a cross-platform app

Introduction

Voyager is a new navigation library built specifically for Compose multiplatform, which is designed to make navigation in Compose-based apps simpler and more intuitive.

It offers a composable API that allows developers to create screens with minimal effort, and provides an easy-to-use navigation stack that supports push, pop, replace , and other common navigation operations.

With Voyager, developers can build complex, multi-screen apps with ease, and can take advantage of Compose’s powerful tooling and state management capabilities to create responsive and performant UIs.

Open source template

Before continuing, we made an open source template for Kotlin multiplatform and Compose Multiplatform. Navigation with Voyager is setup. But that’s not all : UI, DI, offline cache, multiplatform localization and resources. All of this is setup.

Open source template with voyager

This is a version of AppKickstarter with very limited features but yet useful setup.

Back to our guide.

Why it’s important for Compose multiplatform applications

Voyager offers a unified approach to navigation in a multiplatform Compose project.

By using Voyager in the shared module of the app, there’s no need to duplicate the navigation implementation for each platform, reducing the development effort and improving the code maintainability.

Additionally, Voyager offers seamless integration with Compose’s lifecycle and state management, making it a powerful and efficient solution for multiplatform navigation in Jetpack Compose.

Basic setup of Voyager

In your MainActivity (or any other activity that uses Jetpack Compose), use the Navigator composable to set up your app’s navigation:

Use the push method of the Navigator instance to navigate to a new screen. Here is an example of how you can navigate from the HomeScreen to the DetailScreen:

This code sets up the Navigator with the HomeScreen as the initial screen. The push method is used to navigate to the DetailScreen when the user taps the “View details” button. The LocalNavigator is used to get a reference to the current navigator instance.

Screen models, state management, coroutine and Koin integration

State management is a crucial part of any mobile app. Voyager’s StateScreenModel is a helpful tool for managing screen state and updating the UI based on changes to that state. The StateScreenModel class extends the ScreenModel interface and provides a mutable MutableState property that can be used to hold and update the current state of the screen.

To use the StateScreenModel in a Voyager screen, you can define a sealed class that represents the possible states for your screen. For example:

Then, define a StateScreenModel that takes the initial state as a parameter:

One of the benefits of using Voyager’s StateScreenModel is the reduction in code required for state management.

Since StateScreenModel integrates a mutable state, there’s no need to manually define a public StateFlow for the state and a private mutableStateFlow for the same state. This saves developers from writing a lot of template code and reduces the likelihood of errors.

Coroutines integration

As you can see in this code, Voyager integrates seamlessly with coroutines.

It makes it easy to manage asynchronous operations within screen models.

Screen models in Voyager come with a coroutineScope property that allows you to launch coroutines and ensure they are properly cancelled when the screen model is disposed.

The getPerson function launches a coroutine using coroutineScope.launch . This allows you to perform asynchronous operations such as network requests, database queries, and other time-consuming tasks without blocking the UI thread.

Integration of dependency injection with Koin

You can then use this StateScreenModel in your screen and update the state as needed, which will automatically trigger a recomposition of the UI.

In your screen, you can then inject the screen model using the getScreenModel() function from the koin voyager library. Here is an example:

Voyager integrates well with the Koin dependency injection framework. It allows for easy management and injection of dependencies into screen models. To use Koin with Voyager, you will need to include the Koin dependency in your project and define your Koin modules.

To define a Koin module for a screen model, you can use the factory component and provide a lambda that returns an instance of the screen model. Here is an example:

Voyager comes with a built-in transition mechanism that allows you to create smooth transitions between screens.

To use the transition mechanism, you can pass a Transition instance to the Navigator composable.

The Transition instance defines how the transition should be animated.

For example, the following code shows how to use the SlideTransition to animate the transition between screens:

In this example, the SlideTransition is used to animate the transition between screens. The SlideTransition takes the navigator object as an argument, which is used to get the current screen and the previous screen. The SlideTransition then animates the transition between these screens by sliding the new screen in from the right.

There are several other built-in transitions available in Voyager, such as the FadeTransition and the ScaleTransition. You can also create your own custom transitions by implementing the Transition interface.

Why we love Voyager

At AppKickstarter , we love using Voyager because it is an efficient solution for implementing navigation in our Kotlin Multiplatform projects. Voyager solves the problem of duplicate navigation code in our Android and iOS projects by providing a shared navigation module.

Additionally, its integration with popular Kotlin tools such as Koin and Coroutines makes it easy to manage dependencies and asynchronous tasks.

Open Source template with Voyager

We offer a free and open source template for building multiplatform apps using Compose multiplatform and Voyager.

Our template includes everything you need to get started, from setting up Voyager to defining screens and injecting dependencies using Koin.

Upgrade Your Cross-Platform App Development with AppKickstarter

For those looking for additional features and dedicated support, we also offer a premium version called AppKickstarter.

With AppKickstarter, you’ll have access to features such as authentication with Firebase, data storage with Firebase and SqlDelight, onboarding screens, and payment integration with RevenueCat.

Our team is dedicated to providing you with the support you need to build the best possible cross-platform app.

If you’re interested in learning more about AppKickstarter and how it can help you take your project to the next level, please visit our website to learn more and purchase your license today.

Upgrade with AppKickstarter

We believe that AppKickstarter is the ultimate tool for building high-quality cross-platform apps, and we’re confident that you’ll love using it as much as we do.

Start Earning Money on Stores by Shipping Your App At Lightning Speed

AppKickstarter © 2024

[email protected]

Documentation

Business ideas

Morse Code App

Affiliates program

Free AppKickstarter version (save 1 day)

I'm passionate about making Kotlin and Compose Multiplatform resources widely accessible. That's why I've created a free template just for you. Claim yours now!

Get Free Template

Kotlin Multiplatform Development Help

Navigation and routing.

Navigation is a key part of UI applications that allows users to move between different application screens. Compose Multiplatform adopts the Jetpack Compose approach to navigation .

To use the navigation library, add the following dependency to your commonMain source set:

Sample project

To see the Compose Multiplatform navigation library in action, check out the nav_cupcake project , which was converted from the Navigate between screens with Compose Android codelab.

Just as with Jetpack Compose, to implement navigation, you should:

List routes that should be included in the navigation graph. Each route must be a unique string that defines a path.

Create a NavHostController instance as your main composable property to manage navigation.

Add a NavHost composable to your app:

Choose the starting destination from the list of routes you defined earlier.

Create a navigation graph, either directly, as part of creating a NavHost , or programmatically, using the NavController.createGraph() function.

Each back stack entry (each navigation route included in the graph) implements the LifecycleOwner interface. A switch between different screens of the app makes it change its state from RESUMED to STARTED and back. RESUMED is also described as "settled": navigation is considered finished when the new screen is prepared and active. See the Lifecycle page for details of the current implementation in Compose Multiplatform.

Limitations

Current limitations of navigation in Compose Multiplatform, compared to Jetpack Compose:

Deep links (handling or following them) are not supported.

The BackHandler function and predictive back gestures are not supported on any platform besides Android.

Third-party alternatives

If the Compose Multiplatform navigation components do not solve your problems, there are third-party alternatives that you can choose from:

#59 - Voyager with Adriel Café

The Developers' Bakery

A Podcast about Developer tools and libraries

• Apple Podcasts
• Pocket Casts
• Buy me a Coffee
• Custom Social Profile Link

Joining us today is Adriel Café , the creator and maintainer of Voyager . We’ll be delving into the depths of Navigation with Jetpack Compose, touching on topics such as tab navigation, nested navigation and deep-links. Also, Voyager let’s you build navigation experiences which are fully cross-platform thanks to its support for Android, iOS, Web and Desktop.

Adriel is also a former Web engineers and is going to tell us what he loves and hates between the two worlds.

Enjoy the show 👨‍🍳

• 00.13 Intro
• 00.59 Episode Start
• 01.32 Adriel’s Introduction
• 02.54 What is Voyager?
• 06.07 What’s the story behind Voyager?
• 12.22 How hard is navigation across platforms?
• 14.23 Bottom bar, tabs and other navigation patterns
• 16.38 Deeplinks
• 18.35 Nested Navigation
• 20.40 Multi-module Navigation
• 22.47 1.0.0 when?
• 23.58 The most requested feature
• 25.04 Who’s maintaining Voyager?
• 27.50 Which future for Voyager?
• 29.34 Android vs Web
• 33.26 Android engineers do it better
• 34.47 Web vs Mobile IDEs
• 36.45 Further reading
• 38.40 Where people can find you online?
• adrielcafe/voyager on GitHub
• Voyager Official Website
• adrielcafe/lyricist on GitHub
• programadorthi/kotlin-routing on GitHub
• Jetpack Compose internals - by Jorge Castillo
• @adrielcafe on GitHub
• @adrielcafe on Twitter
• Adriel Café on LinkedIn
• Adriel’s Website
• Podcast Website
• The Developers’ Bakery on Spotify
• The Developers’ Bakery on Apple Podcasts
• The Developers’ Bakery on Google Podcasts
• @thebakerydev on Twitter
• @cortinico on Twitter

You may also enjoy

#88 - charty with himanshu singh, 27 aug 2024.

Charts for Jetpack Compose with Charty and Himanshu Singh

#87 - Redpanda with Christina Lin

14 aug 2024.

Super fast data streaming platform with Christina Lin, Developer Advocate at Redpanda

#86 - Dagster with Sandy Ryza

31 jul 2024.

We venture in the world of Data Pipelines with Dagster and Sandy Ryza

#85 - Kotlin Multiplatform at Google I/O with Marcello Galhardo

10 jul 2024.

Amazing announcements about Kotlin Multiplatform at Google I/O 2024

• Releases 1.0.0-rc03
• MIT License

🛸Voyager is a pragmatic navigation library built for, and seamlessly integrated with, Jetpack Compose.

Related tags

Voyager : Compose on Warp Speed

Voyager is a pragmatic navigation library built for, and seamlessly integrated with, Jetpack Compose .

Turn on the Warp Drive and enjoy the trek 🖖

• Create scalable Single-Activity apps powered by a pragmatic API
• State-aware Stack API
• Tab navigation like Youtube app
• Nested navigation if you need to manage multiple stacks
• State restoration after Activity recreation
• Lifecycle callbacks
• Back press handling
• Deep linking support
• Compose for Desktop support (soon™)

Add the desired dependencies to your module's build.gradle:

Let's start by creating the screens: you should implement the Screen interface and override the Content() composable function. Screens can be data class (if you need to send params), class (if no param is required) or even object (useful for tabs).

Now, start the Navigator with the root screen.

Use the LocalNavigator to navigate to other screens. Take a look at the Stack API for the available operations.

Voyager is backed by a SnapshotStateStack :

• Implementation of Stack that can be observed and snapshot
• Internally uses a SnapshotStateList
• State-aware: content change triggers a recomposition

You will use it to navigate forward ( push , replace , replaceAll ) and backwards ( pop , popAll , popUntil ), but the SnapshotStateStack can also be used as a regular collection.

You can also create a SnapshotStateStack through rememberStateStack() , it will restore the values after Activity recreation .

State restoration

The Screen interface is Serializable . Every param of your screens will be saved and restored automatically. Because of that, it's important to known what can be passed as param: anything that can be stored inside a Bundle .

Not only the params, but the properties will also be restored, so the same rule applies.

If you want to inject dependencies through a DI framework, make sure it supports Compose, like Koin and Kodein .

Inside a Screen , you can call LifecycleEffect to listen for some events:

• onStarted : called when the screen enters the composition
• onDisposed : called when the screen is disposed

By default, Voyager will handle back presses but you can override its behavior. Use the onBackPressed to manually handle it: return true to pop the current screen, or false otherwise. To disable, just set to null .

You can initialize the Navigator with multiple screens, that way, the first visible screen will be the last one and will be possible to return ( pop() ) to the previous screens.

Transitions

It's simple to add transition between screens: when initializing the Navigator you can override the default content. You can use, for example, the built-in Crossfade animation.

Want to use a custom animation? No problem, just follow the same principle.

Tab navigation

Voyager provides a handy abstraction over the Navigator and Screen : the TabNavigator and Tab .

The Tab interface, like the Screen , has a Content() function, but also a title and an optional icon . Since tabs aren't usually reused, its OK to create them as object .

The TabNavigator unlike the Navigator :

• Don't handle back presses, because the tabs are siblings
• Don't exposes the Stack API , just a current property

You can use it with a Scaffold to easily create the UI for your tabs.

Use the LocalTabNavigator to get the current TabNavigator , and current to get and set the current tab.

Nested navigation

For more complex use cases, when each tab should have its own independent navigation, like the Youtube app , you can combine the TabNavigator with multiple Navigator s.

Let's go back to the previous example .

But now, the HomeTab will have it's own Navigator .

That way, we can use the LocalNavigator to navigate deeper into HomeTab , or the LocalTabNavigator to switch between tabs.

Going a little further, it's possible to have nested navigators. The Navigator has a level property (so you can check how deeper your are) and can have a parent navigator.

Another operation is the popUntilRoot() , it will recursively pop all screens starting from the leaf navigator until the root one.

• Logo by Icons8

How to multiple instance viewmodel for same compose fun

I have a list of items and a detail screen. Detail Screen is a compose function that takes a (post) parameter that I pass as an argument to the ViewModel. val viewModel = getStateViewModel<PostDetailViewModel>(parameters = { parametersOf(args) }) The problem is that it looks like the viewModel is cached, and all the time it opens the first post (argument) that was followed.

In jetpack navigation works correctly.

https://user-images.githubusercontent.com/27068529/129693071-ade8b0bc-1c0e-4bc0-a367-cceac22c4e53.mp4

[Hilt] [ViewModel] popUntil not working as expected?

Observed behavior:

• 3 destinations A, B, C - all AndroidScreen with Hilt ViewModels.
• Pushing A -> B -> C

When trying to use popUntil to A from C - the B screen and it's ViewModel are not being removed. If I try to push B again from A the ViewModel is the same instance holding latest state.

If I try to go A -> B -> pop -> A -> B everything is fine.

screen model doesn't survive the configuration changes

I try use Screen + ScreenModel + Hilt.

I create Screen like this:

And my ScreenModel:

But when i rotate my phone screen model recreated. Shouldn't the screen model survive the configuration changes? OR am I doing something wrong?

Beta13 hiltviewmodel crash when navigating back to same destination

So the fix for the replace issue have now generated a worse issue.

it will crash whenever you navigate again to a destination.

So push(Screen) pop() push(Screen) will crash.

As said in https://github.com/adrielcafe/voyager/issues/17 the root issue is more about transitions and autodispose happening too early.

There's side effects too with ScreenModel that are disposed too early (even before the next screen is composed). This can corrupt what is displayed during transition and cause hard to diagnose side effects.

This is more a core issue for @adrielcafe than an hilt specific one. (The "fix" stills needs to be reverted) While we can disable autodispose at the navigator level we have no way to built custom transitions that would do a proper dispose after the end of the transition.

Wrap Navigator with AnimatedVisibility produce reset navigator to initial screen

Hi, many thanks for your library. I have tried it a bit and it's very powerful.

I have noticed when I wrap Navigator with AnimatedVisibility it is reset to the initial screen.

I created my own scaffold with slots, I need to use different navigators in each slot. In one slot in the scaffold root, I need to use AnimatedVisibility to produce hide/collapse animation, and in this slot I need to maintain some navigation. So after I create navigation in that AnimatedVisibility composable I have noticed that when it exit to the invisible state navigator also resets its state to the initial state.

Can you provide some ideas of how I can achieve some animation around box that contains navigator ?

Lifecycle onPause/onStop/onDestory are never called

While testing my app with Voyager I noticed some of my AndroidView states were never being saved. Investigating that lead me to my LifecycleObserver's never filling the bundle contained in my rememberSavable variable. I then logged the states that the lifecycle observer goes through and noticed that only onCreate/OnStart/OnResume are ever called, and never the last 3.

Here are the test composables I used

Hilt integration doesn't support Screen classes

I don't if that is intentional.Hilt integration only works with AndroidScreen . Also, docs seems incomplete... There is a sample project for that though.

1.0 RC01 side effect on tab navigation

The fix (https://github.com/adrielcafe/voyager/pull/55) have the side effect of now fully unloading the view models when navigating between tabs.

While the fix is normal and wanted, due to the current limitations of LazyList not proposing any proper way to delay the state restoration, this makes restoring scroll position insanely complex until they propose something.

It would be nice to have a way to opt out or a workaround for this use case.

Re: Wanted to show you project I made with your library

Hi @adrielcafe, I wanted to show you my sample app I made with Voyager: https://github.com/JohnBuhanan/MVI-Public

I studied a dozen github repos and felt like yours was closest to what I wanted.

Three things I thought you might find interesting:

• I wrapped your Navigator so that I can do routing from ViewModels.
• Each feature contains an api gradle module and an impl gradle module. The impl s can be commented out from settings.gradle and app.gradle to unload them from Android Studio indexing and gradle builds. This allows scaling for massively multi-module apps.
• I used reflection to get access to the "internal factories" of ScreenRegistry.

Biggest thing I am thinking about now is best way to "navigate for result".

Accessing Tab's navigator through TabNavigator

I've been using your library for a month or something, and I'm pretty satisfied of it. It's cool!

But there's a thing. I want my app to have the following behaviour: when user clicks on a tab in BottomNavigation and the tab isn't selected yet, the library just switches Tabs, but when the tab is already selected, I want my app to reset navigation state of the tab (i.e. pop navigator to root).

Did I miss something? Any help will be appreciated. Thanks in advance!

Screen Model test Exception

I can't use rememberScreenModel or ScreenModelStore.getOrPut in the test so that's why the error is thrown. Any idea how to work around this? @adrielcafe @terrakok @programadorthi @DevSrSouza

Tab transitions

Hello. It would be great if we could add transitions to TabNavigator content in the same manner as we do for normal screens:

Would that be possible to implement?

Add `tag` argument to `Screen.getScreenModel`

Hello. My use case involves creating multiple instances of the same ScreenModel via hilt's assissted injection, as demonstrated here: https://voyager.adriel.cafe/screenmodel/hilt-integration#assistedinject. The issue is that the current Screen.getScreenModel function does not allow us to specify a tag to differentiate screen models. This PR is designed to address that.

SavedStateHandle doesn't work

I save the screen state in the SavedStateHandle in the viewmodel, but after recreating the activity, the SavedStateHandle has null data. Version: 1.0.0-rc03

iOS / Full Multiplatform Support?

Getting official support for ios, and the other kotlin multiplatform targets would be great. It seems like people are forking the library to add this. It'd be great if the main project just did it.

Allow custom navigators to dispose, such as the TabNavigator

Make navigator.dispose public and implement it in the TabNavigator

navigator.dispose should be public to allow custom navigators to cleanup thier screens properly and remove any possible memory leaks. I use a custom navigator in my application and it was a leak mess until I added this to my fork.

Also added the current tab to saveableState, allowing for more custom implementations

Implement SavedStateHandle in a working manner

Closes #99 SavedStateHandle support didn't work since the outstate was always null or never got saved outside the screen lifecycle owner. I found a way to test SavedStateHandle to get it working how its meant to be used.

• Put the app in the background for a few seconds, at least until the activity hits the stop state
• Use the (old) android studio logcat's menu to use its unique terminate app button
• When starting up the app should try to return to its old state with SavedStateHandles and everything

Whats left to do for Android lifecycle integration(will happen in other PRs):

• Attach the lifecycle to the parent lifecycle, so if the activity hits onStop, the ScreenLifecycle will as well

Releases(1.0.0-rc03)

1.0.0-rc03(nov 24, 2022).

First of all, sorry for being so absent the last few months. I plan to return to working on Voyager in January, but I will gladly accept PRs anytime!

I want to thank @Syer10 for his great work on fixing bugs, we are closer to a stable 1.0 release because of you ❤️

• Check if the activity is changing configurations before clearing the navigator (#84) by @Syer10
• Handle Lifecycle.Event instead of managing the states themselves, include a onStart and onStop function to say when the screen is displayed (#87) by @Syer10
• Add support for HasDefaultViewModelProviderFactory by returning a SavedStateViewModelFactory (#88) by @Syer10
• Creates replaceAll(items: List<Item>) allowing a step to replace the navigation stack with another stack (#95) by @Alaksion
• Kotlin 1.7.10
• Jetpack Compose 1.3.1
• Compose Multiplatform 1.2.1

1.0.0-rc02(Apr 30, 2022)

• Added a disposeNestedNavigators param on TabNavigator to control the disposal behavior of nested navigators inside tabs (#58)
• AndroidScreenLifecycleOwner now provides a LocalLifecycleOwner and emits onPause/onStop/onDestroy states (#42)
• Downgraded jvmTarget to 1.8 for better compatibility

1.0.0-rc01(Apr 25, 2022)

• Moved Kodein integration from jvmMain to commonMain (#56)
• Fixed ScreenModel disposal on root screens (#24) by @programadorthi
• Jetpack Compose 1.1.1
• Compose Multiplatform 1.1.1

1.0.0-beta16(Feb 21, 2022)

• Fixed ScreenModel's dependency exception on tests (#45)
• Avoid reflection on ScreenRegistry.get() (#46)
• Updated Jetpack Compose to 1.1.0

1.0.0-beta15(Jan 30, 2022)

• Fixed broken builds caused by multiplatform (#34) by @DevSrSouza
• Migrate modules from jvmMain to commonMain (#40) by @DevSrSouza
• Migrate the buildscript from Groovy to Kotlin (#38) by @DevSrSouza
• Migrate voyager-rxjava to multiplatform (#36) by @terrakok
• Update Jetpack Compose to 1.1.0-rc03

1.0.0-beta14(Dec 20, 2021)

• Check the platform compatibility of each module
• Fixes for Hilt integration (#21, #22) by @programadorthi
• Fixes for BottomSheetNavigator (#28, #32) by @Tolriq
• Kotlin 1.6.10
• Jetpack Compose 1.1.0-rc01
• Compose Multiplatform 1.0.1-rc2

1.0.0-beta13(Oct 19, 2021)

• Fixed multiple Hilt issues (#15, #16, #17) by @programadorthi
• Updated dependencies (Compose 1.1.0-alpha06)

1.0.0-beta12(Oct 6, 2021)

• Added Hilt integration ( ScreenModel docs , ViewModel docs ) (#11) by @programadorthi #13
• Fixed crash with ScreenModel's coroutineScope (#14)
• Updated dependencies (Kotlin 1.5.31, Compose 1.1.0-alpha05 and more)

1.0.0-beta11(Sep 17, 2021)

• Added LiveData integration ( docs )
• Fixed crash when combined TabNavigator with BottomSheetNavigator (#12)

1.0.0-beta10(Sep 3, 2021)

• Added ScreenModel and integrations for Koin, Kodein, Coroutines, RxJava ( docs )
• Fixed BackHandler for nested navigation (#10)
• Updated dependencies

1.0.0-beta09(Aug 27, 2021)

• Added BottomSheetNavigator #8 ( docs )
• Fixed ViewModel lifecycle #7

1.0.0-beta08(Aug 25, 2021)

• Updated Compose to 1.1.0-alpha02 (now requires targetSdk 31)
• Replaced custom transition implementation with AnimatedContent
• Added support for SavedStateHandle (#7)

1.0.0-beta07(Aug 24, 2021)

• Added support for multi-module navigation ( docs )

1.0.0-beta06(Aug 23, 2021)

• Fixed ViewModel integration (#7)
• Added voyager-androidx module that provides AndroidScreen ( docs )
• Added Screen.uniqueScreenKey extension property to generate screen keys ( docs )
• Added hooks support ( docs )

1.0.0-beta05(Aug 9, 2021)

• Fixed state restoration when using transitions (#6)

1.0.0-beta04(Aug 8, 2021)

• Fixed state restoration after Acitivity recreation (#6)

1.0.0-beta03(Aug 7, 2021)

• Updated Kotlin to 1.5.21 and Compose to 1.0.1
• Added TabOptions and deprecated Tab.title and Tab.icon
• Replaced NavigatorCache with SaveableStateHolder (#4 and #5, special thanks to @Grouen and @andkulikov!)

1.0.0-beta02(Jul 30, 2021)

• Updated Compose to 1.0.0 :tada:
• Added transitions, initially with fade, scale and slide animations
• Added StackEvent and Stack.lastEvent
• Added Stack.lastItemOrNull and Navigator.lastItem
• Deprecated Stack.lastOrNull and Navigator.last

1.0.0-beta01(Jul 30, 2021)

Initial release 🎉

Adriel Café

Bottom-App-Bar-with-Bottom-Navigation-in-Jetpack-compose-Android - Bottom App Bar with Bottom Navigation in Jetpack compose

Bottom-App-Bar-with-Bottom-Navigation-in-Jetpack-compose-Android This is simple

New style for app design simple bottom navigation with side navigation drawer UI made in Jetpack Compose.😉😎

BottomNavWithSideDrawer New style for app design simple bottom navigtaion with side navigation drawer UI made in Jetpack Compose. ?? ?? (Navigation Co

Alligator is a modern Android navigation library that will help to organize your navigation code in clean and testable way.

Alligator Alligator is a modern Android navigation library that will help to organize your navigation code in clean and testable way. Features Any app

[ACTIVE] Simple Stack, a backstack library / navigation framework for simpler navigation and state management (for fragments, views, or whatevers).

Simple Stack Why do I want this? To make navigation to another screen as simple as backstack.goTo(SomeScreen()), and going back as simple as backstack

A small and simple, yet fully fledged and customizable navigation library for Jetpack Compose

Animated Tab Bar is an awesome navigation extension that you can use to add cool, animated and fully customizable tab navigation in your apps

Animated Tab Bar is an awesome navigation extension that you can use to add cool, animated and fully customizable tab navigation in your apps. The extension provides handy methods and properties to change the behaviour as well as the appearance of the navigation bar.

A small navigation library for Jetpack Compose with state saving, backstack and animations support.

DSC Moi University session on using Navigation components to simplify creating navigation flow in our apps to use best practices recommended by the Google Android Team

Navigation Components Navigate between destination using safe args How to use the navigation graph and editor How send data between destinations Demo

Navigation Component: THE BEST WAY to create navigation flows for your app

LIVE #017 - Navigation Component: A MELHOR FORMA de criar fluxos de navegação para o seu app! Código fonte do projeto criado na live #017, ensinando c

Navigation Drawer Bottom Navigation View

LIVE #019 - Toolbar, Navigation Drawer e BottomNavigationView com Navigation Com

A small navigation library for Android to ease the use of fragment transactions & handling backstack (also available for Jetpack Compose).

A small navigation library for Android to ease the use of fragment transactions & handling backstack (also available for Jetpack Compose).

A library that you can use for bottom navigation bar. Written with Jetpack Compose

FancyBottomNavigationBar A library that you can use for bottom navigation bar. W

Implementing bottom navigation in jetpack compose

Compose-Bottom-Navigation Implementing bottom navigation in jetpack compose Add the Navigation dependency Open the app's build file, found at app/buil

🎉 [Android Library] A light-weight library to easily make beautiful Navigation Bar with ton of 🎨 customization option.

Bubble Navigation ?? A light-weight library to easily make beautiful Navigation Bars with a ton of ?? customization options. Demos FloatingTopBarActiv

CustomNavigationDrawer - Custom Navigation Drawer with compose

An easy sample to explore navigation component and navigation drawer from Jetpac

Navigation for compose multiplatform

A simple, highly customizable compose navigation component for Android & Desktop platform.

介绍 一个简单并提供高度扩展功能的 Compose 导航组件，同时支持 Android 和 Desktop 平台。 常用功能 使用 下载 // Android implementation("io.github.succlz123:compose-screen-android:0.0.1") //

AndroidBriefActions - Android library for sending and observing non persistent actions such as showing a message; nice readable way to call navigation actions from ViewModel or Activity/Fragment.

implementation "com.vladmarkovic.briefactions:briefactions:$briefActionsVersion" Benefits Why use brief-actions library pattern: Prevent short-term ac

A simple navigation library for Android 🗺️

Enro ??️ A simple navigation library for Android "The novices’ eyes followed the wriggling path up from the well as it swept a great meandering arc ar

Dataframe 0.13 Help

Return cross-section from the DataFrame .

Filters DataFrame by matching key values with key columns and removes key columns.

When keyColumns are not specified, it takes first n columns in dfs order (looking inside ColumnGroup ), where n is a number of given keyValues .

Navigation Menu

Search code, repositories, users, issues, pull requests..., provide feedback.

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly.

To see all available qualifiers, see our documentation .

• Repositories

Eugene Plovotok

• https://vk.com/zsozinov
• https://discord.com/users/creepskiper

Block or report Plovotok

Prevent this user from interacting with your repositories and sending you notifications. Learn more about blocking users .

You must be logged in to block users.

Contact GitHub support about this user’s behavior. Learn more about reporting abuse .

Hi My name is Eugene

I'm an android-developer from moscow.

Graduated from the Moscow Aviation Institute with a degree in Certification of Aviation Equipment. Work experience: 1 year and 8 months

• 🌍  I'm based in Moscow
• 🖥️  See my portfolio at my repositories
• ✉️  You can contact me at [email protected]
• 🚀  I'm currently working on Maps application (still private repo, I'l make it public in couple of months)
• 🧠  I'm learning Jetpack Compose

Technologies

• Jetpack Compose,
• Navigation Component,
• Clean architecture,
• Hilt, Koin, Kodein,
• Accompanist,
• Retrofit, Ktor-client,
• Glide, Coil,
• Cloudpayments android,
• Mapbox maps,
• Kotlin Coroutines, Kotlin Flow
• MPAndroid Charts

My GitHub Stats

Top Repositories

Pinned Loading