Redux for Android Development: Simplify Your App’s State Management

Photo by Ross Sneddon on Unsplash

Redux is a state management library that is commonly used in web applications, but it can also be used in Android applications to manage the application’s state.

Redux has a lot of benefits over other app architectures. If you want to check why we should use redux, you can read from here.

Here I am going to show, how we can use it in android development.

1. Dependencies: Add the following dependencies to your build.gradle file:

dependencies {
    implementation 'com.google.dagger:dagger:2.37'
    kapt 'com.google.dagger:dagger-compiler:2.37'
    implementation 'com.squareup.retrofit2:retrofit:2.9.0'
    implementation 'com.squareup.retrofit2:converter-gson:2.9.0'
}

2. State: Define the state of your app as a data class.

data class AppState(
    val isLoading: Boolean = false,
    val error: String? = null,
    val data: List<Post> = emptyList()
)

3. Actions: Define the actions that can be performed on the app state as a sealed class.

sealed class AppAction {
    object FetchPosts : AppAction()
    data class PostsFetched(val result: Result<List<Post>>) : AppAction()
}

4. Reducer: Define the reducer function that takes in the current state and an action, and returns the new state.

fun appReducer(state: AppState, action: AppAction): AppState {
    return when (action) {
        is AppAction.FetchPosts -> {
            state.copy(isLoading = true, error = null)
        }
        is AppAction.PostsFetched -> {
            when (action.result) {
                is Result.Success -> {
                    state.copy(isLoading = false, data = action.result.data)
                }
                is Result.Error -> {
                    state.copy(isLoading = false, error = action.result.message)
                }
            }
        }
    }
}

5. Store: Define the store that holds the app state and dispatches actions to the reducer.

class AppStore @Inject constructor(private val apiService: ApiService) {

    private val state = mutableStateOf(AppState())

    fun getState(): State<AppState> {
        return state
    }

    fun dispatch(action: AppAction) {
        when (action) {
            is AppAction.FetchPosts -> {
                state.value = appReducer(state.value, action)
                viewModelScope.launch {
                    val result = apiService.getPosts()
                    state.value = appReducer(state.value, AppAction.PostsFetched(result))
                }
            }
            else -> state.value = appReducer(state.value, action)
        }
    }
}

Note that the ApiService class makes the network call to fetch the posts.

6. View: Create a Composable that displays the app state and dispatches actions to the store.

@Composable
fun PostsScreen(store: AppStore) {
    val state by store.getState().collectAsState()
    val scaffoldState = rememberScaffoldState()

    Scaffold(
        scaffoldState = scaffoldState,
        topBar = {
            TopAppBar(title = { Text("Posts") })
        },
        content = {
            if (state.isLoading) {
                CircularProgressIndicator(modifier = Modifier.align(Alignment.Center))
            } else {
                if (state.error != null) {
                    Text(
                        text = state.error,
                        style = MaterialTheme.typography.h6,
                        modifier = Modifier.padding(16.dp)
                    )
                } else {
                    LazyColumn(modifier = Modifier.fillMaxSize()) {
                        items(state.data) { post ->
                            PostItem(post = post)
                        }
                    }
                }
            }
        },
        floatingActionButton = {
            FloatingActionButton(
                onClick = { store.dispatch(AppAction.FetchPosts) },
                content = {
                    Icon(Icons.Filled.Refresh, contentDescription = "Refresh")
                }
            )
        }
    )
}

This is a very basic example, to just showcase, how we can integrate REDUX in android app development. There are a few libraries as well that you can check to make your app production-ready like Redux Kotlin, komposable-architecture etc. Also you can check my GitHub page to know more about how you can implement and improve redux implementation.

That’s it for now, hope you found this article helpful and informative.