Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/adamdawi/architecture-patterns-in-android
Examples of architecture patterns in jetpack compose
https://github.com/adamdawi/architecture-patterns-in-android
android-architecture architectural-patterns architecture jetpack-compose mvc-architecture mvi-architecture mvp-architecture mvvm-architecture
Last synced: 5 days ago
JSON representation
Examples of architecture patterns in jetpack compose
- Host: GitHub
- URL: https://github.com/adamdawi/architecture-patterns-in-android
- Owner: AdamDawi
- Created: 2024-10-20T09:58:26.000Z (4 months ago)
- Default Branch: master
- Last Pushed: 2024-11-23T17:50:53.000Z (3 months ago)
- Last Synced: 2024-11-23T18:29:13.623Z (3 months ago)
- Topics: android-architecture, architectural-patterns, architecture, jetpack-compose, mvc-architecture, mvi-architecture, mvp-architecture, mvvm-architecture
- Language: Kotlin
- Homepage:
- Size: 118 KB
- Stars: 0
- Watchers: 1
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
README
# Android Architecture Patterns with Jetpack Compose
This repository demonstrates several mobile architecture patterns implemented in **Kotlin** using **Jetpack Compose**. The goal is to showcase architecture patterns, helping developers understand how to structure Android applications more effectively.
## Architectures Overview
- **MVVM (Model-View-ViewModel)**: Separates concerns into Model, View, and ViewModel layers.
- **MVI (Model-View-Intent)**: Implements a unidirectional data flow, where user intents are transformed into view states.
- **MVC (Model-View-Controller)**: Classic pattern where UI and data-access mechanism(Model) are tightly coupled. *(Not supported in jetpack compose)*
- **MVP (Model-View-Presenter)**: A more structured variant of MVC where presenter class manages one View at a time. *(Not supported in jetpack compose)*
## MVVM (Model-View-ViewModel)
### MVVM
- **Model:** This layer is responsible for the abstraction of the data sources. Model and ViewModel work together to get and save the data.
- **View:** The purpose of this layer is to inform the ViewModel about the user’s action. This layer observes the ViewModel and does not contain any kind of application logic.
- **ViewModel:** It exposes those data streams which are relevant to the View. Moreover, it servers as a link between the Model and the View.
### Features:
- Using ViewModel fuctions directly in view: ```viewModel.fetchData()```
- Multiple states in ViewModel describes the UI.
## MVI (Model-View-Intent)
### MVI
- **Model:** represents the state of the app.
- **View:** displays the state and sends user intents to the ViewModel.
- **Intent:** describes actions that the user can take, which result in state changes.
### Features:
- Using intent to specify user action making it easy to track user interactions in ViewModel with when statement:
```kotlin
when(event){
MainScreenIntent.FetchData -> { /* handle fetching */ }
MainScreenIntent.ObserveData -> { /* handle observing */ }
}
```
- Only one public function in ViewModel: ```viewModel.onEvent()```
- One state stored in ViewModel that fully describes the UI:
```kotlin
data class MainViewState(
val loading: Boolean = false,
val data: List = emptyList(),
val error: String? = null
)
```
## MVC (Model-View-Controller)
### MVC
- **Model:** This component stores the application data. It has no knowledge about the interface. The model is responsible for handling the domain logic(real-world business rules) and communication with the database and network layers.
- **View:** It is the UI(User Interface) layer that holds components that are visible on the screen. Moreover, it provides the visualization of the data stored in the Model and offers interaction to the user.
- **Controller:** This component establishes the relationship between the View and the Model. It contains the core application logic and gets informed of the user’s response and updates the Model as per the need.
### Features:
- Jetpack Compose is not well-suited for this pattern due to its declarative nature, which blurs the boundaries between view and logic.
- Does not automate data synchronization between UI and Model (doesn't use states):
```kotlin
private fun updateUI(weather: Weather) {
// Update UI elements with data
textViewTemperature.text = weather.temperature.toString()
textViewDescription.text = weather.description
}
```
## MVP (Model-View-Presenter)
### MVP
- **Model:** Layer for storing data. It is responsible for handling the domain logic(real-world business rules) and communication with the database and network layers.
- **View:** UI(User Interface) layer. It provides the visualization of the data and keep a track of the user’s action in order to notify the Presenter.
- **Presenter:** Fetch the data from the model and applies the UI logic to decide what to display. It manages the state of the View and takes actions according to the user’s input notification from the View.
### Features:
- Jetpack Compose is not well-suited for MVP because its declarative UI model inherently couples the UI state with the data layer, making the Presenter layer redundant.
- MVP views should be easy to replace with alternative implementations.
- MVP views should be reusable (can't be tightly coupled to the presenter) without its presenter
- To establish communication between View-Presenter and Presenter-Model, an interface is needed:
```kotlin
interface Contract {
interface View {
fun showProgress()
fun hideProgress()
fun setString(string: String?)
}
interface Model {
interface OnFinishedListener {
fun onFinished(string: String?)
}
fun getNextCourse(onFinishedListener: OnFinishedListener?)
}
interface Presenter {
fun onButtonClick()
fun onDestroy()
}
}
```
## Installation
1. Clone the repository:
```bash
git clone https://github.com/AdamDawi/Architecture-patterns-in-android
```
2. Open the project in Android Studio.
## Author
Adam Dawidziuk🧑💻