Nav3 Recipes: Practical navigation use-cases for Jetpack Navigation 3
Official Nav3 recipe set providing modular, reusable navigation patterns — a practical reference for migrating to or integrating Jetpack Navigation 3
GitHub android/nav3-recipes Updated 2025-12-07 Branch main Stars 986 Forks 89
Android Jetpack Navigation 3 Jetpack Compose Hilt Koin Samples Apache-2.0

💡 Deep Analysis

3
How does the project ensure navigation state persistence and recovery across configuration changes and process death, and what implementation details should you watch for when migrating to production?

Core Analysis

Problem Core: How to reliably restore the navigation stack and UI state after configuration changes and process death? The repository demonstrates using a saveable back stack pattern, but production migration requires careful handling of serialization and version stability.

Technical Analysis

  • Saveable back stack: Uses Nav3 persistence to rehydrate the back stack on system restore.
  • SavedStateHandle: Persist critical UI state in ViewModels so it can be restored after recreation.
  • Synthetic stacks & init order: Rebuild synthetic stacks in the original push order to preserve history semantics.
  • Data serializability: Anything saved to the back stack or SavedStateHandle must be serializable via Bundle/Parcel or a custom serializer.

Practical Recommendations

  1. Lock dependency versions: Recipes may target alpha/snapshot; use stable versions in production or assess migration cost.
  2. Audit serialization boundaries: Don’t put large objects, Context, or callbacks into saved state — persist IDs/references and reload on restore.
  3. Add restore tests: Create integration tests for process death and configuration changes to validate restored UI and navigation.
  4. Document push strategy: Mark which entries are synthetic and use the same reconstruction strategy to avoid duplicate pushes.

Important Notice: Non-serializable data and API churn are the main causes of restore failures. Thorough checks and tests are required before production adoption.

Summary: The repo’s saveable back stack recipe is a solid blueprint. For production, emphasize serialization, version locking, and comprehensive restore testing to ensure robustness.

89.0%
How does the repository parse deep links from an Intent and rebuild a synthetic back stack to ensure consistent Up/Back behavior?

Core Analysis

Problem Core: When a deep link opens a deep destination, users expect sensible Up/Back navigation. The repository’s advanced example solves this by rebuilding a synthetic navigation stack.

Technical Analysis

  • Parsing flow: Parse the deep link URL from the Intent and map it to a navigation key or destination identifier.
  • Entry generation: Convert the target into a sequence of logical entries (e.g., Home -> List -> Detail) and push them into the nav stack in order to recreate history.
  • Persistence & recovery: Combine the synthetic stack creation with a saveable back stack so the reconstructed stack survives configuration changes and process death.
  • Edge cases: Avoid duplicate pushes, handle singleTop semantics for singleton destinations, and ensure ViewModel scopes align with the synthetic entries’ lifecycles.

Practical Recommendations

  1. Reproduce the recipe: Run the deep link recipe in isolation to validate entry order and Up behavior.
  2. Centralize mapping rules: Define URL -> navigation key -> entry sequence mapping in a routing layer.
  3. Add idempotency checks: Prevent repeated processing of the same deep link or use navigation singleTop behavior.

Important Notice: When copying examples to production, review ViewModel scopes and push timing — incorrect timing can cause duplicated navigation or inconsistent UI/state.

Summary: The repo provides an end-to-end example for Intent -> synthetic back stack reconstruction. It’s a practical reference but must be adapted carefully to your app’s lifecycle and scope model.

88.0%
How does the repository safely pass navigation arguments and return results across different ViewModel construction approaches (`viewModel()`, `hiltViewModel()`, `koinViewModel()`)?

Core Analysis

Problem Core: How to reliably inject navigation arguments into ViewModels and return results across different construction methods, without introducing lifecycle or scope bugs?

Technical Analysis

  • Argument passing: Declare navigation parameters explicitly on the entry/navigation key and read them in the ViewModel via SavedStateHandle or entry properties.
  • DI & scope alignment:
  • viewModel(): Scoped to the NavBackStackEntry by default.
  • hiltViewModel(): Ensure Hilt components/scopes are aligned with the nav entry to avoid unintended instance reuse.
  • koinViewModel(): Configure a Koin scope per nav entry/module similarly.
  • Result return patterns:
  • Event-based: One-off results via SharedFlow or callbacks — good for transient interactions.
  • State-based: Store results in a CompositionLocal or SavedStateHandle so they survive recreation and can be consumed later.

Practical Recommendations

  1. Persist parameters in SavedStateHandle to avoid missing args when scopes differ.
  2. Unify scoping strategy across modules/DI providers to guarantee correct ViewModel lifecycles.
  3. Choose idempotent result delivery: event-based for one-time events, state-based for results that need to survive restoration.

Important Notice: Misaligned scopes are a common pitfall that lead to missing parameters, reused ViewModels, or memory leaks.

Summary: The repo offers concrete examples for the three ViewModel construction methods and two result patterns. When integrating, prioritize scope alignment and SavedStateHandle usage to reduce errors.

88.0%

✨ Highlights

  • Official AOSP-backed Nav3 recipes covering key navigation use-cases and patterns
  • Modular examples that are easy to learn, reuse, and integrate into projects
  • Some recipes track Nav3 snapshot/alpha releases and may break as the API evolves
  • Very limited contributor and commit activity; long-term maintenance and community support are uncertain

🔧 Engineering

  • Official recipe collection covering common Nav3 navigation scenarios and implementations
  • Examples include deep links, scene/layout patterns, animations, and multiple back-stack use-cases
  • Provides integration examples with Hilt, Koin, ViewModel and Jetpack Compose

⚠️ Risks

  • No releases and minimal commit/contributor activity — risk of limited maintenance and desynchronization
  • Some recipes depend on Nav3 snapshots/alpha; API changes can break samples and require frequent updates

👥 For who?

  • Android developers, especially teams migrating to or adopting Jetpack Navigation 3
  • Architects and sample consumers seeking patterns, integration approaches, and practical best practices