mcpField
A
android-architecture

android-architecture

github.com/new-silvermoonDevelopment992676 installsUpdated 13w ago
Repository

About android-architecture

A guide to modern architecture and modularization for developers designing or refactoring Android apps. It covers UI, Domain, and Data layers, Hilt dependency injection, and multi-module organization.

Key features

  1. 01UI, Domain, and Data layers
  2. 02Inward dependency rules
  3. 03Dependency injection with Hilt
  4. 04Modules for core and feature code
  5. 05Connect ViewModels and UI with StateFlow

Use cases

  1. 01Plan an Android app's layered structure
  2. 02Separate business logic from Android frameworks
  3. 03Split production apps into feature modules
  4. 04Manage object dependencies with Hilt

Install

Copy the command and run it in a terminal.

$npx skills add https://github.com/new-silvermoon/awesome-android-agent-skills --skill android-architecture

After installing, type/android-architecturein Claude Code to confirm it loaded.

Details

From the project README

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

Comments

Markdown supported