Architecture Overview

​

Architecture Principles

• Separation of Concerns: Clear separation between UI, domain, and data layers
• Unidirectional Data Flow: Data flows from repositories through interactors to ViewModels
• Reactive Programming: Heavy use of Kotlin Flows for reactive data streams
• Dependency Injection: kotlin-inject for compile-time safe dependency injection
• Modular Design: Feature-based modularization with shared core modules

​

Architecture Diagram

┌─────────────────────────────────────────────────────────────┐
│                        UI Layer                              │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐      │
│  │   Compose    │  │  ViewModels  │  │  Navigation  │      │
│  │   Screens    │◄─┤              │  │              │      │
│  └──────────────┘  └──────┬───────┘  └──────────────┘      │
└────────────────────────────┼──────────────────────────────────┘
                             │
                             ▼
┌─────────────────────────────────────────────────────────────┐
│                      Domain Layer                            │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐      │
│  │ Interactors  │  │  Observers   │  │   Entities   │      │
│  │  (UseCases)  │  │ (SubjectInt) │  │              │      │
│  └──────┬───────┘  └──────┬───────┘  └──────────────┘      │
└─────────┼──────────────────┼──────────────────────────────────┘
          │                  │
          ▼                  ▼
┌─────────────────────────────────────────────────────────────┐
│                       Data Layer                             │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐      │
│  │ Repositories │  │  Room DAOs   │  │  Remote API  │      │
│  │              │  │              │  │   (Ktor)     │      │
│  └──────────────┘  └──────────────┘  └──────────────┘      │
└─────────────────────────────────────────────────────────────┘

​

Layer Responsibilities

​

UI Layer

• Composable Screens: Declarative UI components
• ViewModels: State management and user action handling
• Navigation: Screen navigation and deep linking
• State: Immutable state classes using StateFlow

​

Domain Layer

• Interactors: Execute single use cases (write operations)
• Observers: Provide reactive streams of data (read operations)
• Domain Models: Business entities and models
• Mappers: Transform data between layers

​

Data Layer

• Repositories: Single source of truth for data
• DAOs: Room database access objects
• Remote Data Sources: API clients (Ktor)
• Local Storage: Room database, DataStore preferences
• Mappers: Convert between network/database and domain models

​

Technology Stack

​

Key Architectural Patterns

​

Reactive Data Flow

1. Repository observes database or remote data source
2. Observer (SubjectInteractor) exposes a Flow
3. ViewModel collects the Flow and transforms to UI state
4. Composable collects state and renders UI

@ApplicationScope
class HomepageRepository @Inject constructor(
    private val firestoreGraph: FirestoreGraph,
    private val homepageMapper: HomepageMapper
) {
    fun observeHomepageCollection() =
        firestoreGraph.homepageCollection.snapshots
            .flatMapLatest { it.toHomepage() }
}

​

Separation of Read and Write Operations

• Observers (SubjectInteractor): Read operations that return Flow<T>
• Interactors: Write operations that return Flow<InvokeStatus>
• ResultInteractors: Operations that return Result<T>

​

Kotlin Multiplatform

• base:domain - Core domain patterns
• data:* - All data modules
• domain - Business logic
• ui:common, ui:components, ui:theme - Shared UI components

​

Next Steps