Domain Layer & Use Case Implementation

[AlexisTercero55]

Development iteration: Architectural Evolution & Domain Integrity

This iteration represents the transition of Rho Studio UI from a feature-modularized prototype to a structured Clean Architecture system. We have successfully decoupled business logic from the Android Framework, implemented a reactive unidirectional data flow (UDF), and established a strict hierarchical module boundary system.

Advanced Multi-Module Topology #28

We have moved away from a monolithic :app structure to a Feature-Layered Modularization strategy. This optimizes build parallelization and enforces strict dependency inversion.

• Feature Isolation: :features:auth and :features:home are now independent Android Libraries. They depend only on :core modules (:data,:domain,:ui), preventing circular dependencies and ensuring that changes in one feature cannot break another.
• Encapsulation of UI Models: The ServiceModule data class was migrated from :core:ui to :features:home:model. This adheres to the Interface Segregation Principle, ensuring that core modules remain generic and do not carry feature-specific payloads.

Domain Layer & Interactor Pattern #29

The implementation of the :core:domain module introduces a platform-agnostic layer that houses the application's "truth."

• BaseUseCase<P, R>: A standardized abstraction for business logic execution. It leverages Kotlin Coroutines to enforce suspend execution and provides a unified contract for error handling and execution state.
• Use Case Implementation:
  • LoginUseCase: Encapsulates the authentication transaction. It validates Credentials (Domain Entity) before interacting with the data layer, ensuring business rules are met before network/disk I/O.
  • LogoutUseCase: Orchestrates an atomic session teardown. It coordinates the clearing of tokens in SessionManager and triggers global state resets.
• Domain Entities: Entities like User and Credentials are now pure Kotlin data classes, preventing "leakage" of framework-specific logic (like Parcelable or Room annotations) into the business layer.

Reactive UI & Orchestration #30

The UI layer has been refined to use Jetpack Compose with a reactive state-push model, eliminating the manual synchronization bugs inherent in View-based systems.

• StateFlow & Lifecycle Awareness: All ViewModels now expose state via StateFlow. UI components consume this state using collectAsState(), ensuring that recompositions only occur when the specific backing data changes.
• Side-Effect Orchestration: In   MainActivity, we use LaunchedEffect keyed to isAuthenticated state. This transforms a state change into a one-time navigation event, preventing "multiple-navigation" bugs and ensuring that the NavHost is always in sync with the SessionManager.

Current State: Manual Dependency Management

While the architecture has been modularized, the project currently utilizes Manual Dependency Management.

• Service Locators & Singletons: Components like SessionManager are managed as singletons.
• Manual Instantiation: ViewModels currently instantiate their own dependencies (e.g., LogoutUseCase(SessionManager.getInstance())).
• Roadmap: This sets the stage for the next phase: migrating to a formal DI (Dagger) to further decouple the ViewModel from its implementation details.

Infrastructure & Verification

• CI/CD Pipeline: Implementation of .github/workflows/android.yml ensures that every commit is verified against a debug build and unit test suite.

• Static Analysis: All source files have been standardized with ASCII branding and metadata headers, and code style is enforced through automated linting to maintain high maintainability standards.

---

Rho.Studio® - Engineering Department - Contact alexis.tercero@rho.studio

[alexistercero-rho-dev]

CODE REVIEW & CI/CD

Ready for application test: install and run on Samsung Galaxy A34 5G.

sha256:cd054915e6969a9847276117c36bfa91c550dff15ae225b164c9df06d600144d

Rho.Studio® - Engineering Department - Contact alexis.tercero@rho.studio