A word reminder android app!
Architecture that is meticulously planned is paramount for an application's scalability, and all architectural designs share a universal aim - to handle the complexity of your application. This might not be a concern for smaller-scale apps, but it can be incredibly advantageous when working on apps with an extended development timeline and a bigger team.
Robert C. Martin introduced the concept of Clean Architecture in 2012 via the Clean Code Blog, and it abides by the SOLID principle.
This app uses MVI (Model View Intent) architecture design.
The commons layer is responsible for common properties. It contains the implementations of the resources files, themes and components declared in the common layer.
- testing: This is responsible for common testing rules.
- ui: Has common UI components across the app.
- theme: Defines themes, colors, fonts and resource files.
- util: Mainly for storing global constants.
The data layer is responsible for selecting the proper data source for the domain layer. It contains the implementations of the repositories declared in the domain layer.
This is the core layer of the application. The domain layer is independent of any other layers thus ] domain business logic can be independent from other layers.This means that changes in other layers will have no effect on domain layer eg. screen UI (presentation layer) or changing database (data layer) will not result in any code change withing domain layer.
The features layer contains components involved in showing information to the user. The main part of this layer are the views(activity, compose) and ViewModels.
The framework layer is responsible for core functionalities, such as model for network responses, extensions, and base classes.
The plugins layer is responsible for dependency management. It control and manage all dependencies in one place with Kotlin using the Gradle Version Catalog.
This project uses many of the popular libraries, plugins and tools of the android ecosystem.
- Material Design 3 - Build Jetpack Compose UIs with ready to use Material Design Components.
- Foundation - Write Jetpack Compose applications with ready to use building blocks and extend foundation to build your own design system pieces.
- UI - Fundamental components of compose UI needed to interact with the device, including layout, drawing, and input.
- Lifecycle-ViewModel - Perform actions in response to a change in the lifecycle status of another component, such as activities and fragments.
- HiltViewModel - Hilt provides a standard way to incorporate Dagger dependency injection into an Android application.
- Lottie - Lottie is a mobile library for Android and iOS that parses Adobe After Effects animations exported as json with Bodymovin and renders them natively on mobile!
- SwipeRefresh - A library which provides a layout which provides the swipe-to-refresh UX pattern, similar to Android's SwipeRefreshLayout.
- Systemuicontroller - System UI Controller provides easy-to-use utilities for updating the System UI bar colors within Jetpack Compose.
- Navigation - A library which provides Compose Material support for Jetpack Navigation Compose. This features composable bottom sheet destinations.
- DataStore - Jetpack DataStore is a data storage solution that allows you to store key-value pairs or typed objects with protocol buffers.
- Android KTX - Provide concise, idiomatic Kotlin to Jetpack and Android platform APIs.
- AndroidX - Major improvement to the original Android Support Library, which is no longer maintained.
- Lifecycle - Perform actions in response to a change in the lifecycle status of another component, such as activities and fragments.
- ViewModel - Designed to store and manage UI-related data in a lifecycle conscious way. The ViewModel class allows data to survive configuration changes such as screen rotations.
- Room - Provides an abstraction layer over SQLite used for offline data caching.
- SplashScreen - Android 12 adds the SplashScreen API, which enables a new app launch animation for all apps when running on a device with Android 12 or higher.
- Dagger Hilt - Dependency Injection library.
- Retrofit - Type-safe http client and supports coroutines out of the box.
- OkHttp-Logging-Interceptor - Logs HTTP request and response data.
- Coroutines - Library Support for coroutines.
- Flow - Flows are built on top of coroutines and can provide multiple values. A flow is conceptually a stream of data that can be computed asynchronously.
- Timber - A logger with a small, extensible API which provides utility on top of Android's normal Log class.
- JUnit4 - JUnit is a simple framework to write repeatable tests.
- Mockk - A modern Mockk library for UnitTest.
- Coroutine-Test - Provides testing utilities for effectively testing coroutines.
- Check-Dependency-Versions - Check dependency updates.
- GradleVersionCatalog - Gradle's support for declaring and using dependencies.
- Gradle Kotlin DSL - makes it easy to manage dependency all module that we have
- Kapt - Kapt compiler plugin
- Ktlint - A ktlint gradle plugin. Provides a convenient wrapper plugin over the ktlint project.
- Kftmt - ktfmt is a program that pretty-prints (formats) Kotlin code, based on google-java-format.
- Spotless - It’s pretty useful in automating fixes for pretty simple (and common) formatting mistakes as in spaces, newlines, removing unnecessary imports, etc.