GithubCompose (Jetpack Compose + MVI + Clean Code + TDD Template)

GithubCompose is a showcase project embodying a modern approach to Android app development. It meticulously combines prominent Android tools and adheres to best development practices, featuring state-of-the-art technologies like Jetpack Compose, Kotlin Flow, and Koin dependency injection. This sample app highlights a robust Android architecture, emphasizing scalability, maintainability, and testability through the MVI (Model-View-Intent) pattern, making it a valuable reference for developers.

The sample app presents a modern Android application architecture, emphasizing scalability and maintainability through the implementation of MVI (Model-View-Intent).

Description

• UI

  • Compose declarative UI framework
  • Material design

• Tech/Tools

  • Kotlin 100% coverage
  • Coroutines and Flow for async operations
  • Koin for dependency injection
  • Jetpack
    • Compose
    • Navigation for navigation between composables
    • ViewModel that stores, exposes and manages UI state
  • Retrofit for networking
  • Coil for image loading

• Modern Architecture

  • Single activity architecture (with Navigation component) that defines navigation graphs
  • MVI
  • Android Architecture components (ViewModel, Navigation)
  • Android KTX - Jetpack Kotlin extensions

Light and Dark mode compatible

Dark Theme UI	Light Theme UI
dark-theme.mp4	light-theme.mp4

Architecture

The project's architecture follows a clear division of responsibilities between its View, Presentation, and Model components, thoughtfully implementing the Model-View-Intent (MVI) pattern in conjunction with the powerful features of Jetpack Compose.

Architecture layers:

• View - Composable screens that consume state, apply effects and delegate events.
• ViewModel - that manages and reduces the state of the corresponding screen. Additionally, it intercepts UI events and produces side-effects. The ViewModel lifecycle scope is tied to the corresponding screen composable.
• Model - Repository classes that retrieve data. In a clean architecture context, one should use use-cases that tap into repositories.

There are a three core components described:

• State - data class that holds the state content of the corresponding screen e.g. list of User, loading status etc. The state is exposed as a Compose runtime MutableState object from that perfectly matches the use-case of receiving continuous updates with initial value.

• Event - plain object that is sent through callbacks from the UI to the presentation layer. Events should reflect UI events caused by the user. Event updates are exposed as a MutableSharedFlow type which is similar to StateFlow and that behaves as in the absence of a subscriber, any posted event will be immediately dropped.

• Effect - plain object that signals one-time side-effect actions that should impact the UI e.g. triggering a navigation action, showing a Toast, SnackBar etc. Effects are exposed as ChannelFlow which behave as in each event is delivered to a single subscriber. An attempt to post an event without subscribers will suspend as soon as the channel buffer becomes full, waiting for a subscriber to appear.

Every screen/flow defines its own contract class that states all corresponding core components described above: state content, events and effects.

Connect with Us

For more updates and contributions, connect with us on .

Give a Star!

If you like this repository, please give it a star ⭐.