🇺🇸English

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).

Weekly Installs

176

Repository

new-silvermoon/…t-skills

GitHub Stars

565

First Seen

Jan 27, 2026

Security Audits

Gen Agent Trust HubPassSocketPassSnykPass

Installed on

opencode160

codex159

gemini-cli134

github-copilot130

kimi-cli126

amp125