💎 Android Showcase 2.0

A production-ready Android application demonstrating modern development practices and architectural patterns. This project showcases how to build scalable, maintainable, and testable Android applications using industry-standard tools and libraries.

Built with Clean Architecture principles, this app serves as a comprehensive example of modular design, advanced Gradle configuration, and robust CI/CD practices. Perfect for teams looking to establish solid architectural foundations for large-scale Android projects.

• 💎 Android Showcase 2.0
  • Application Scope
  • Tech-Stack
  • Architecture
    • Module Types and Dependencies
    • Feature Module Structure
      • Presentation Layer
      • Domain Layer
      • Data Layer
      • Common Module Components
    • Data Flow
  • Project Features
    • Development & Debugging
    • Custom Icons For Each Variant
    • Themed Icons
  • Gradle Config
    • Dependency Management
    • Convention Plugins
    • Type Safe Project Accessors
    • Unified Version Configuration
      • Java/JVM Version Configuration
    • Generated type-safe version catalogs accessors in build-logic module
    • Gradle Configuration Cache
  • Code Verification

Application Scope

A music discovery app built with Jetpack Compose that displays album information sourced from the Last.fm API. The application demonstrates real-world scenarios including network requests, local caching, navigation, and state management.

Features:

• Album List - Browse albums with search functionality
• Album Details - View detailed album information and track listings
• Favorites - Save preferred albums (WIP)
• Profile - User preferences and settings (WIP)

Tech-Stack

Built with modern Android development tools and libraries, prioritizing, project structure stability and production-readiness.

Core Technologies:

• Kotlin 2.2+ - Modern, expressive programming language
  • Coroutines - Asynchronous programming
  • Flow - Reactive data streams
  • KSP (Kotlin Symbol Processing) - Kotlin Symbol Processing
  • Serialization - JSON parsing

Android Jetpack:

• Compose - Declarative UI framework
• Navigation Compose - Type-safe navigation
• ViewModel - UI-related data management
• Room - Local database with SQLite
• Core Splashscreen - app Splashscreen

Networking & Images:

• Retrofit - HTTP client for API communication
• Coil - Image loading optimized for Compose

Dependency Injection:

• Koin - Lightweight dependency injection framework

Architecture:

• Clean Architecture - Separation of concerns with defined layers
• Single Activity Architecture - Modern navigation approach
• MVVM + MVI - Reactive presentation layer pattern providing common UI state.
• Modular Design - Feature-based modules for scalability

UI & Design:

• Material Design 3 - Latest design system
• Dynamic Theming - Wallpaper-based themes (Android 12+)
• Dark Theme - System-aware dark mode
• Lottie - Vector animations

Testing:

• JUnit 6 - Modern testing framework
• Mockk - Kotlin-first mocking library
• Kluent - Fluent assertion library
• Espresso - UI testing (WIP)

Code Quality:

• Konsist - Architecture and code structure convention tests
• Ktlint - Kotlin code formatting and issue detection
  • Ktlint Standard Rules - set of custom rules for Jetpack Compose
  • Nlopez Jetpack Compose Rules - set of custom rules for Jetpack Compose
  • Twitter's Jetpack Compose Rules - set of custom rules for Jetpack Compose
• Detekt - Static analysis and complexity checks
• Android Lint - Android-specific code analysis
• Spotless - Code formatting enforcement

Build & CI:

• Gradle Kotlin DSL - Type-safe build scripts
• Version Catalogs - Centralized dependency management
• Convention Plugins - Shared build logic
• Renovate - Automated dependency updates

GitHub Actions:

• Check - CI pipeline with build, lint, test, and code quality checks
• Auto Approve - Auto-approval for trusted bot and maintainer PRs
• Claude Code - AI-powered code assistance and review
• Claude Code Review - Automated PR reviews using Claude

Gradle Plugins:

• Android Application (com.android.application) - Android app module configuration
• Android Library (com.android.library) - Android library module configuration
• Kotlin Android (org.jetbrains.kotlin.android) - Kotlin compilation for Android
• Kotlin Serialization (org.jetbrains.kotlin.plugin.serialization) - JSON serialization support
• Kotlin Compose Compiler (org.jetbrains.kotlin.plugin.compose) - Compose compiler plugin
• KSP - Kotlin Symbol Processing
• Detekt - Static code analysis
• Spotless - Code formatting
• Test Logger - Enhanced test log output
• Easylauncher - Modify the launcher icon of each of your app-variants
• AboutLibraries - collects dependency details, including licenses and visualize these in the app

Architecture

The project implements Clean Architecture with a modular approach, treating each feature as an independent, reusable component similar to a microservice. This design enables maintainability and scalability for large development teams.

Benefits of Modular Architecture:

• Reusability - Shared code across multiple app variants
• Separation of Concerns - Clear module boundaries with explicit dependencies
• Parallel Development - Teams can work on features independently
• Faster Build Times - Incremental compilation and build caching
• Testability - Isolated testing of individual components

Module Types and Dependencies

Module Types:

• app - Main application module containing navigation setup, DI configuration, and app-level components
• feature-* - Feature modules (album, profile, favourite) containing feature-specific business logic
• feature-base - Shared foundation module providing common utilities and base classes
• library-* - Utility modules for testing and shared functionality

Feature Module Structure

Clean Architecture is implemented at the module level - each module contains its own set of Clean Architecture layers:

Notice that the app module and library_x modules structure differs a bit from the feature module structure.

Each feature module contains 3 layers with a distinct set of responsibilities and common module components.

Presentation Layer

This layer is closest to what the user sees on the screen.

The presentation layer mixes MVVM and MVI patterns:

• MVVM - Jetpack ViewModel is used to encapsulate a common UI state. It exposes the state via observable state holder (Kotlin Flow)
• MVI - action modifies the common UI state and emits a new state to a view via Kotlin Flow

The common state is a single source of truth for each view. This solution derives from Unidirectional Data Flow and Redux principles.

This approach facilitates the creation of consistent states. The state is collected via collectAsUiStateWithLifecycle method. Flows collection happens in a lifecycle-aware manner, so no resources are wasted.

Stated is annotated with [Immutable](https://developer.android.com/reference/kotlin/androidx/compo