Unidirectional Data Flow in Android

In a bidirectional design, a text field updates a variable, the variable updates a label, the label's listener updates another variable... and nobody can say which value is "correct" when they disagree. Unidirectional data flow (UDF) removes that ambiguity with one rule: state flows down, events flow up.

The rule

• State is owned by a single source of truth and flows down to consumers, which can only read it.
• Events (user actions, system callbacks) flow up to the owner, which decides how state changes.
• The owner produces a new immutable state, which flows down again.

UDF end to end

// Data layer owns the truth
class PostRepository @Inject constructor(private val dao: PostDao, private val api: PostApi) {
    fun observePost(id: String): Flow<Post> = dao.observe(id).map { it.toDomain() }
    suspend fun setLiked(id: String, liked: Boolean) {
        dao.setLiked(id, liked)               // optimistic local update
        runCatching { api.setLiked(id, liked) }.onFailure { dao.setLiked(id, !liked); throw it }
    }
}

// ViewModel turns data into UI state and handles events
class PostViewModel(private val repo: PostRepository, postId: String) : ViewModel() {
    private val id = postId
    val uiState = repo.observePost(id)
        .map { PostUiState(title = it.title, liked = it.liked, likeCount = it.likeCount) }
        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), PostUiState())

    fun onLikeClick() = viewModelScope.launch {
        runCatching { repo.setLiked(id, !uiState.value.liked) }
    }
}

// UI renders state and emits events; it never flips `liked` itself
@Composable
fun LikeButton(liked: Boolean, count: Int, onClick: () -> Unit) {
    TextButton(onClick = onClick) {
        Icon(if (liked) Icons.Filled.Favorite else Icons.Outlined.FavoriteBorder, contentDescription = null)
        Text(" $count")
    }
}

Even the optimistic update goes through the database, so every screen showing this post agrees.

Benefits

• Consistency: one owner per piece of data means no conflicting copies.
• Predictability: state changes happen in known places, so bugs are easier to trace.
• Testability: feed events in, assert state out.
• Survives configuration changes, because state lives in ViewModels and repositories rather than Views.

Common UDF violations

UDF at different scales

Frequently asked questions

Conclusion

UDF is a simple discipline: one owner per piece of state, state down as immutable values, events up as function calls. Apply it at component, screen and app level and your Android code becomes predictable, consistent and testable.

Next step: scale the codebase physically with Multi-Module Architecture in Android.