Shared KMP module - Revision history

Uwe: /* 1. Gradle Configuration */

2026-06-06T15:21:32Z

1. Gradle Configuration

← Older revision		Revision as of 17:21, 6 June 2026
Line 35:		Line 35:
	implementation(project(":shared"))		implementation(project(":shared"))
	}		}
	~~</source>~~

	=== 2. Dependency Injection ===		=== 2. Dependency Injection ===
	The Android app utilizes <code>kotlin-inject</code> to build the final dependency graph. The <code>AppComponent</code> inside the <code>app</code> module		The Android app utilizes <code>kotlin-inject</code> to build the final dependency graph. The <code>AppComponent</code> inside the <code>app</code> module

Uwe: /* 2. Dependency Injection */

2026-06-06T15:21:23Z

2. Dependency Injection

← Older revision		Revision as of 17:21, 6 June 2026
Line 41:		Line 41:
	inherits from the <code>SharedModule</code> interface defined in the KMP code.		inherits from the <code>SharedModule</code> interface defined in the KMP code.

	~~<source>~~
	@Component		@Component
	@ApplicationScope		@ApplicationScope

Uwe: /* 2. Dependency Injection */

2026-06-06T15:21:11Z

2. Dependency Injection

← Older revision		Revision as of 17:21, 6 June 2026
Line 41:		Line 41:
	inherits from the <code>SharedModule</code> interface defined in the KMP code.		inherits from the <code>SharedModule</code> interface defined in the KMP code.

	<source ~~lang="kotlin"~~>		<source>
	@Component		@Component
	@ApplicationScope		@ApplicationScope
	abstract class AppComponent(		abstract class AppComponent(
	@get:Provides val context: Context		@get:Provides val context: Context
	) : SharedModule { ... }		) : SharedModule { ... }

Uwe: /* 2. Dependency Injection */

2026-06-06T15:20:51Z

2. Dependency Injection

← Older revision		Revision as of 17:20, 6 June 2026
Line 40:		Line 40:
	The Android app utilizes <code>kotlin-inject</code> to build the final dependency graph. The <code>AppComponent</code> inside the <code>app</code> module		The Android app utilizes <code>kotlin-inject</code> to build the final dependency graph. The <code>AppComponent</code> inside the <code>app</code> module
	inherits from the <code>SharedModule</code> interface defined in the KMP code.		inherits from the <code>SharedModule</code> interface defined in the KMP code.

	<source lang="kotlin">		<source lang="kotlin">
	@Component		@Component
Line 46:		Line 47:
	@get:Provides val context: Context		@get:Provides val context: Context
	) : SharedModule { ... }		) : SharedModule { ... }
	~~</source>~~

	=== 3. Initialization ===		=== 3. Initialization ===

Uwe: /* 3. Initialization */

2026-06-06T15:20:35Z

3. Initialization

← Older revision		Revision as of 17:20, 6 June 2026
Line 58:		Line 58:
	}		}
	}		}
	~~</source>~~
	Android ViewModels then inject and observe the <code>StateFlow</code> properties from the shared repositories directly.		Android ViewModels then inject and observe the <code>StateFlow</code> properties from the shared repositories directly.

Uwe: /* 2. Swift Dependency Injection Bridge */

2026-06-06T15:20:27Z

2. Swift Dependency Injection Bridge

← Older revision		Revision as of 17:20, 6 June 2026
Line 88:		Line 88:
	}		}
	}		}
	~~</source>~~

	=== 3. Flow Collection in Swift ===		=== 3. Flow Collection in Swift ===

Uwe: /* 3. Flow Collection in Swift */

2026-06-06T15:20:19Z

3. Flow Collection in Swift

← Older revision		Revision as of 17:20, 6 June 2026
Line 102:		Line 102:
	)		)
	}		}
	~~</source>~~
	This ensures the SwiftUI interface remains fully reactive to background network syncs and database changes occurring within the KMP layer.		This ensures the SwiftUI interface remains fully reactive to background network syncs and database changes occurring within the KMP layer.

Uwe: /* 2. Swift Dependency Injection Bridge */

2026-06-06T15:20:04Z

2. Swift Dependency Injection Bridge

← Older revision		Revision as of 17:20, 6 June 2026
Line 89:		Line 89:
	}		}
	</source>		</source>

	=== 3. Flow Collection in Swift ===		=== 3. Flow Collection in Swift ===
	Kotlin's <code>StateFlow</code> is not automatically bridged to Swift's <code>AsyncSequence</code> or <code>@Published</code> properties. To consume the		Kotlin's <code>StateFlow</code> is not automatically bridged to Swift's <code>AsyncSequence</code> or <code>@Published</code> properties. To consume the

Uwe: Created page with "= Aquarium Control Shared Module (KMP) = The '''Shared KMP Module''' is the core of the mobile Aquarium Control application, implemented using [https://kotlinlang.org/docs/multiplatform.html Kotlin (KMP)]. It encapsulates the entire data layer, business logic, and network communication, allowing that the code to be written once and shared natively across both the Android and iOS applications. == Architecture == The shared module follows a clean architecture approach, se..."

2026-06-06T15:19:38Z

Created page with "= Aquarium Control Shared Module (KMP) = The '''Shared KMP Module''' is the core of the mobile Aquarium Control application, implemented using [https://kotlinlang.org/docs/multiplatform.html Kotlin (KMP)]. It encapsulates the entire data layer, business logic, and network communication, allowing that the code to be written once and shared natively across both the Android and iOS applications. == Architecture == The shared module follows a clean architecture approach, se..."

New page

= Aquarium Control Shared Module (KMP) =
The '''Shared KMP Module''' is the core of the mobile Aquarium Control application, implemented using [https://kotlinlang.org/docs/multiplatform.html Kotlin (KMP)]. It encapsulates the entire data layer, business logic, and network communication, allowing that the code to be written once and shared
natively across both the Android and iOS applications.

== Architecture ==
The shared module follows a clean architecture approach, serving as the Data and Domain layer for the MVVM (Model-View-ViewModel) pattern used by the client
* '''Domain Layer''': Contains the core entities (e.g., <code>FeedProfile</code>, <code>HeatingSetVals</code>, <code>SummaryData</code>) and repository
interfaces. These define the strict contracts that the applications interact with.
* '''Data Layer''': Contains the concrete implementations of the repositories.
** '''Networking''': Utilizes [https://ktor.io/ Ktor] for all REST API communication with the aquarium controller hardware.
** '''Persistence''': Uses [https://developer.android.com/training/data-storage/room Room] (KMP compatible) for complex local relational data storage (such as history logs and controller profiles) and [https://developer.android.com/topic/libraries/architecture/datastore DataStore] for lightweight preferences (such as the default server profile ID).
* '''Reactive State''': Data is exposed to the presentation layers exclusively via Kotlin Coroutines and <code>StateFlow</code> / <code>SharedFlow</code>.
This ensures the UI is always reacting to a single source of truth.
* '''Dependency Injection''': Managed cross-platform using [https://github.com/evant/kotlin-inject kotlin-inject], providing compile-time safe dependency
graphs for both Android (<code>AppComponent</code>) and iOS (<code>IosComponent</code>).

== Functional Content ==
The module is organized into distinct feature domains:
* '''Summary''': Real-time polling of all sensors (temperature, pH, conductivity, tank levels) and actuator states.
* '''Controller Profile & Session''': Manages the connection details (IP, port, credentials) for multiple aquariums and tracks the currently active session.
* '''Schedule''': Global management of time-based rules for all actuators (Start/Stop times, limitations).
* '''TimeData (Telemetry)''': Paged and real-time visualization of sensor telemetry over time.
* '''Heating''': Management of switch-on/switch-off thresholds and historical heating statistics/runtime.
* '''Ventilation''': Management of surface ventilation thresholds and safety sanity checks.
* '''Feed''': Complex multi-phase profile creation (pausing skimmers/pumps) and schedule execution, alongside historical event logging.
* '''Balling (Dosing)''': Configuration of dosing pump volumes and historical logging of dosed fluids.
* '''Refill''': Manual control triggers (Start, Stop, Reset) and historical logging of ATO (Auto Top-Off) events.

== Android Integration ==
On Android, the shared module is consumed as a standard Gradle project dependency.
=== 1. Gradle Configuration ===
In the `app` module and feature modules, the shared module is included in the <code>build.gradle.kts</code>:
<source lang="kotlin">
dependencies {
implementation(project(":shared"))
}
</source>

=== 2. Dependency Injection ===
The Android app utilizes <code>kotlin-inject</code> to build the final dependency graph. The <code>AppComponent</code> inside the <code>app</code> module
inherits from the <code>SharedModule</code> interface defined in the KMP code.
<source lang="kotlin">
@Component
@ApplicationScope
abstract class AppComponent(
@get:Provides val context: Context
) : SharedModule { ... }
</source>

=== 3. Initialization ===
The graph is initialized once in the custom Android <code>Application</code> class:
<source lang="kotlin">
class AquariumControlApplication : Application() {
lateinit var appComponent: AppComponent
override fun onCreate() {
super.onCreate()
appComponent = AppComponent::class.create(this)
}
}
</source>
Android ViewModels then inject and observe the <code>StateFlow</code> properties from the shared repositories directly.

== iOS Integration ==
On iOS, the shared module is compiled into a native Apple Framework using the Kotlin Multiplatform Gradle plugin and embedded into the Xcode project.
=== 1. Xcode Build Phase ===
The Xcode project uses a "Run Script" build phase to automatically compile the Kotlin code into an iOS framework (e.g.,
<code>embedAndSignAppleFrameworkForXcode</code>) during the standard Xcode build process.
=== 2. Swift Dependency Injection Bridge ===
Because Swift cannot directly evaluate Kotlin's <code>@Inject</code> annotations, the shared module defines an <code>IosComponent</code> and a factory
function to instantiate the graph natively.
In Swift, a Singleton wrapper (<code>DependencyInjection.shared</code>) is created to hold this component and expose the repositories to the SwiftUI views:
<source lang="swift">
import SharedAquariumControl
class DependencyInjection {
static let shared = DependencyInjection()
private let iosComponent: IosComponent

// Repositories exposed to Swift
let summaryRepository: SummaryRepository
let heatingSetValsRepository: HeatingSetValsRepository
// ...

private init() {
self.iosComponent = IosComponentFactoryKt.createIosComponent()
self.summaryRepository = iosComponent.summaryRepository
self.heatingSetValsRepository = iosComponent.heatingSetValsRepository
// ...
}
}
</source>
=== 3. Flow Collection in Swift ===
Kotlin's <code>StateFlow</code> is not automatically bridged to Swift's <code>AsyncSequence</code> or <code>@Published</code> properties. To consume the
reactive streams, the iOS app uses a custom <code>FlowCollector</code> wrapper class.
Swift UI DataProviders initialize a <code>Task</code> to collect these flows and update their local <code>@Observable</code> properties:
<source lang="swift">
Task {
self.repository.heatingSetValsFlow.collect(
collector: FlowCollector<DataFetchResult<HeatingSetVals>> { [weak self] result in
self?.handleResult(result)
}
)
}
</source>
This ensures the SwiftUI interface remains fully reactive to background network syncs and database changes occurring within the KMP layer.