Android Modern Architecture & Modularization

Instructions

When designing or refactoring an Android application, adhere to the Guide to App Architecture and Clean Architecture principles.

1. High-Level Layers

Structure the application into three primary layers. Dependencies must strictly flow inwards (or downwards) to the core logic.

• UI Layer (Presentation):
  • Responsibility: Displaying data and handling user interactions.
  • Components: Activities, Fragments, Composables, ViewModels.
  • Dependencies: Depends on the Domain Layer (or Data Layer if simple). Never depends on the Data Layer implementation details directly.
• Domain Layer (Business Logic) [Optional but Recommended]:
  • Responsibility: Encapsulating complex business rules and reuse.
  • Components: Use Cases (e.g.,

    GetLatestNewsUseCase

    ), Domain Models (pure Kotlin data classes).
  • Pure Kotlin: Must NOT contain any Android framework dependencies (no

    android.*

    imports).
  • Dependencies: Depends on Repository Interfaces.
• Data Layer:
  • Responsibility: Managing application data (fetching, caching, saving).
  • Components: Repositories (implementations), Data Sources (Retrofit APIs, Room DAOs).
  • Dependencies: Depends only on external sources and libraries.

2. Dependency Injection with Hilt

Use Hilt for all dependency injection.

• @HiltAndroidApp: Annotate the

  Application

  class.
• @AndroidEntryPoint: Annotate Activities and Fragments.
• @HiltViewModel: Annotate ViewModels; use standard

  constructor

  injection.
• Modules:
  • Use

    @Module

    and

    @InstallIn(SingletonComponent::class)

    for app-wide singletons (e.g., Network, Database).
  • Use

    @Binds

    in an abstract class to bind interface implementations (cleaner than

    @Provides

    ).

3. Modularization Strategy

For production apps, use a multi-module strategy to improve build times and separation of concerns.

• :app: The main entry point, connects features.
• :core:model: Shared domain models (Pure Kotlin).
• :core:data: Repositories, Data Sources, Database, Network.
• :core:domain: Use Cases and Repository Interfaces.
• :core:ui: Shared Composables, Theme, Resources.
• :feature:[name]: Standalone feature modules containing their own UI and ViewModels. Depends on

  :core:domain

  and

  :core:ui

  .

4. Checklist for implementation

• Ensure

  Domain

  layer has no Android dependencies.
• Repositories should default to main-safe suspend functions (use

  Dispatchers.IO

  internally if needed).
• ViewModels should interact with the UI layer via

  StateFlow

  (see

  android-viewmodel

  skill).