🚀 Simple albums and music track list app.
🛠 Simple implementation for MVI architecture pattern and Clean Architecture.
🛠 Unit tests included.
🛠 SOLID principles.
🛠 Standard Coding Style.
- Foundation - Components for core system capabilities, Kotlin extensions and support for multidex and unit testing.
- Test - An Android testing framework for unit and runtime UI tests.
- Architecture - A collection of libraries that help you design robust, testable, and
maintainable apps. Start with classes for managing your UI component lifecycle and handling data
persistence.
- View Binding - To more easily write code that interacts with views.
- Lifecycles - Create a UI that automatically responds to lifecycle events.
- Navigation - Handle everything needed for in-app navigation.
- ViewModel - Store UI-related data that isn't destroyed on app rotations. Easily schedule asynchronous tasks for optimal execution.
- Repository - A Module that handle data operations, You can consider repositories to be mediators between different data sources.
- Retrofit - A simple library that is used for network transaction.
- Hilt: For dependency injection
- Kotlin Coroutines For managing background threads with simplified code and reducing needs for callbacks.
- Kotlin Flows - A stream of data that can be computed asynchronously.
- Glide - For image loading.
MVI vs MVVM
- A consistent state during the lifecycle of Views.
- As it is unidirectional, Data flow can be tracked and predicted easily.
- It ensures thread safety as the state objects are immutable.
- Easy to debug, As we know the state of the object when the error occurred.
- It's more decoupled as each component fulfills its own responsibility.
- Testing the app also will be easier as we can map the business logic for each state.
- Read more
Hilt vs Dagger2 vs Koin
- Hilt is built on top of the Dagger, and it comes with some advantages like simplify Dagger code and create a standard set of components and scopes to ease setup.
- As this project is simple, Hilt is the best one. For more complex projects I will go with Dagger2 to avoid some limitation of hilt.
- Hilt does not need factories for ViewModel, koin need.
- Hilt generate the code in the compile time, while koin in runtime.
Coroutines vs RxJava
- Coroutines come with many advantages over RxJava, beside that it is Kotlin-friendly design pattern, it is:
- Lightweight: You can run many coroutines on a single thread due to support for suspension.
- Fewer memory leaks: Use structured concurrency to run operations within a scope.
- Built-in cancellation support.
- Many Jetpack libraries include extensions that provide full coroutines support.
While the project scale up, Some points should be considered:
- Analytics and tracking system should be implemented to provide insight on app usage and user engagement.
- Pagination should be handled in all lists from backend and client side. I already handled it in search screen only.
- More Unit & UI testing functions need to be added.
- ShutterStock image list - MVVM Sample.
- Recorder - Another MVVM Sample.
- Prayer Now - One of the projects I developed has 15+ Million downloads.
- Mn Ahyaha - Side project I developed from scratch.