Mastering Data Sharing Between Screens with Jetpack Compose: 5 Key Techniques

Mastering Data Sharing Between Screens with Jetpack Compose: 5 Key Techniques


Jetpack Compose is a modern toolkit for building Android user interfaces using Kotlin. One of the common problems when building an app is sharing data between different screens. There are many ways to do this, each with its advantages and disadvantages. In this article, we will go through the five main ways to share data between screens in Jetpack Compose and provide examples for each method.

In Series of Navigation In Compose :

Navigation Arguments

Navigation arguments involve passing data as a parameter while navigating from one screen to another. The parameter can be retrieved in the destination screen using NavBackStackEntry.arguments. Navigation arguments are easy to use and are automatically saved in the SavedStateHandle, which means they survive process death. However, they are not suitable for sharing complex objects, and there is a risk of mistyping the argument's key.


// Set up a simple example of sharing data using navigation arguments
NavHost(navController = navController, startDestination = "screen1") {
    composable("screen1") {
        Button(onClick = { navController.navigate("screen2/hello") }) {
            Text("Click me")
    composable("screen2/{param}") { backStackEntry ->
        val param = backStackEntry.arguments?.getString("param")
        Text(text = "Received parameter: $param")

Shared View Model

A shared view model can be accessed from multiple composables and allows data to be shared between them. To create a shared view model, it should be defined in a scope that is higher than that of the composables that need to access it. The view model can then be retrieved in the composables using viewModel(). Shared view models have the advantage of being able to share complex objects, but they do not survive process death by default.


// Define a shared view model
class SharedViewModel : ViewModel() {
    val data = mutableStateOf("Initial value")

// Retrieve the shared view model in the composables
val viewModel: SharedViewModel = viewModel()

// Update the shared data = "New value"

Stateful Dependency

A stateful dependency is composable that holds state and can be used by other composables. A stateful dependency can be created using remember { }, and its state can be updated using callback functions. Stateful dependencies are useful for sharing data between screens that are not directly connected through navigation.


// Define a stateful dependency
val counter = remember { mutableStateOf(0) }

// Use the stateful dependency in a composable
Button(onClick = { counter.value++ }) {
    Text(text = "${counter.value}")

Composition Local

Composition Local is a way to pass data down the composables tree without explicitly declaring it as a parameter. Composition Local can be created using Local { }, and its value can be retrieved using currentLocal.value. Composition Local is useful for sharing data that is needed by many composables in the tree.


// Define a composition local
private val LocalTheme = staticCompositionLocalOf { Theme.Light }

// Retrieve the composition local in the composables
val theme = LocalTheme.current

// Update the composition local
CompositionLocalProvider(LocalTheme provides Theme.Dark) {
    // Composables in this block will use the dark theme

Persistent Storage

Persistent storage can be achieved using SharedPreferences, Room, or other similar libraries. Persistent storage is useful for sharing data between screens that are not necessarily connected through navigation, and for sharing data between sessions. However, persistent storage requires more setup than the other methods and is not suitable for sharing large amounts of data.


// Save data to SharedPreferences
val prefs = context.getSharedPreferences("my_prefs", Context.MODE_PRIVATE)
val editor = prefs.edit()
editor.putString("my_key", "my_value")

// Retrieve data from SharedPreferences
val value = prefs.getString("my_key", "default_value")


In Conclusion, there are five main ways to share data between screens in Jetpack Compose: navigation arguments, shared view models, stateful dependencies, Composition Local, and persistent storage. Each method has its advantages and disadvantages, and the choice of method depends on the specific use case.