AgentSkillsCN

android-architecture

精通使用 Clean Architecture 与 Koin 构建并维护现代 Android 应用架构的专家指导。当被问及项目结构、模块搭建，或依赖注入时，可参考此指导。

SKILL.md
--- frontmatter
name: android-architecture
description: Expert guidance on setting up and maintaining a modern Android application architecture using Clean Architecture and Koin. Use this when asked about project structure, module setup, or dependency injection.

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 Koin

Use Koin for all dependency injection.

  • •startKoin {}: Initialize Koin in the Application class using startKoin { modules(...) }.
  • •module {}: Define dependency modules using Koin DSL.
  • •single {}: Provide app-wide singletons (e.g., Network, Database).
  • •factory {}: Provide new instances each time.
  • •viewModel {}: Provide ViewModel instances.
  • •bind: Bind interface to implementation (e.g., single { OfflineFirstNewsRepository() } bind NewsRepository::class).

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