Merge branch 'develop' into MKMPT-7-SPM

app/shared/build.gradle.kts

@@ -70,6 +70,7 @@ private val modules: List<DelegatingProjectDependency> = listOf(
     projects.common.coroutinesKtx,
     projects.common.domain,
     projects.features.launches.di,
+    projects.features.launches.presentation,
 )
 
 kotlin {

common/compose-ktx/build.gradle.kts

@@ -8,7 +8,13 @@ group = "com.mindera.compose.extensions"
 version = "1.0.0"
 
 kotlin {
-    jvm()
+    androidTarget()
+    jvm("desktop")
+    iOS {
+        iosX64()
+        iosArm64()
+        iosSimulatorArm64()
+    }
 
     sourceSets {
         val commonMain by getting {

common/viewmodel/build.gradle.kts

@@ -10,12 +10,17 @@ version = "1.0.0"
 kotlin {
     androidTarget()
     jvm("desktop")
+    iOS {
+        iosX64()
+        iosArm64()
+        iosSimulatorArm64()
+    }
 
     sourceSets {
         val commonMain by getting {
             dependencies {
-                api(libs.precompose.viewmodel)
                 implementation(compose.runtime)
+                implementation(libs.lifecycle.viewmodel)
             }
         }
     }

common/viewmodel/src/commonMain/kotlin/com/mindera/BundleOfArguments.kt

@@ -1,5 +1,7 @@
 package com.mindera
 
+import kotlin.jvm.JvmSuppressWildcards
+
 typealias BundleOfArguments = Map<@JvmSuppressWildcards Any, @JvmSuppressWildcards Any?>
 fun BundleOfArguments.getString(key: Any) = this[key]?.toString().orEmpty()
 fun BundleOfArguments.getInt(key: Any) = getString(key).toInt()

common/viewmodel/src/commonMain/kotlin/com/mindera/lifecycle/ViewModel.kt

@@ -1,14 +1,14 @@
 package com.mindera.lifecycle
 
+import androidx.lifecycle.viewModelScope
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.CoroutineStart
 import kotlinx.coroutines.async
 import kotlinx.coroutines.launch
-import moe.tlaster.precompose.viewmodel.viewModelScope
 import kotlin.coroutines.CoroutineContext
 import kotlin.coroutines.EmptyCoroutineContext
 
-open class ViewModel: moe.tlaster.precompose.viewmodel.ViewModel()
+open class ViewModel: androidx.lifecycle.ViewModel()
 
 fun ViewModel.launch(
     context: CoroutineContext = EmptyCoroutineContext,

common/viewmodel/src/commonMain/kotlin/com/mindera/viewmodel/Extensions.kt

@@ -24,16 +24,16 @@ fun <VM : ViewModel> create(
     vararg args: Pair<Any, Any?>,
 ): VM = create(klass, mapOf(pairs = args))
 
-@Composable
-fun <VM : ViewModel> viewModel(
-    klass: KClass<VM>,
-    bundle: BundleOfArguments? = null,
-    keys: List<Any?> = emptyList(),
-): VM = moe.tlaster.precompose.viewmodel.viewModel(klass, keys) { create(klass, bundle) }
-
-@Composable
-fun <VM : ViewModel> viewModel(
-    klass: KClass<VM>,
-    vararg args: Pair<Any, Any?>,
-    keys: List<Any?> = emptyList(),
-): VM = viewModel(klass, mapOf(pairs = args), keys)
+//@Composable
+//fun <VM : ViewModel> viewModel(
+//    klass: KClass<VM>,
+//    bundle: BundleOfArguments? = null,
+//    keys: List<Any?> = emptyList(),
+//): VM = moe.tlaster.precompose.viewmodel.viewModel(klass, keys) { create(klass, bundle) }
+//
+//@Composable
+//fun <VM : ViewModel> viewModel(
+//    klass: KClass<VM>,
+//    vararg args: Pair<Any, Any?>,
+//    keys: List<Any?> = emptyList(),
+//): VM = viewModel(klass, mapOf(pairs = args), keys)

features/launches/composables/build.gradle.kts

@@ -10,6 +10,11 @@ version = "1.0.0"
 kotlin {
     androidTarget()
     jvm("desktop")
+    iOS {
+        iosX64()
+        iosArm64()
+        iosSimulatorArm64()
+    }
 
     sourceSets {
         val commonMain by getting {

features/launches/composables/src/commonMain/kotlin/com/mindera/kmpexample/composables/CurrencyExchangeScreen.kt

@@ -12,33 +12,34 @@ import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.unit.dp
 import com.mindera.compose.collections.ImmutableList
 import com.mindera.kmpexample.launches.domain.model.CurrencyExchangeResponseItem
-import java.util.Locale
 
 @Composable
 fun CurrencyExchangeScreen(
     modifier: Modifier = Modifier,
-    launches: ImmutableList<CurrencyExchangeResponseItem>,
+    currencies: ImmutableList<CurrencyExchangeResponseItem>,
 ) {
     val lazyListState = rememberLazyListState()
 
-    if (launches.isNotEmpty()) {
+    if (currencies.isNotEmpty()) {
         LazyColumn(
             modifier = modifier.fillMaxWidth(),
             state = lazyListState,
         ) {
-            itemsIndexed(items = launches[0].rates, key = { index, _ -> index }) { index, launch ->
-
-                if (index != 0) {
-                    Divider(thickness = 2.dp)
+            currencies.forEach {
+                itemsIndexed(items = it.rates, key = { index, _ -> index }) { index, launch ->
+                    if (index != 0) {
+                        Divider(thickness = 2.dp)
+                    }
+                    Text(it.no)
+                    Text(launch.id)
+                    Text(launch.currency.replaceFirstChar {
+                        if (it.isLowerCase()) it.titlecase() else it.toString()
+                    })
+                    Text(launch.code, color = Color.Blue)
+                    Text(launch.currencyRate.toString(), color = Color.Gray)
                 }
-                Text(launch.id)
-                Text(launch.currency.replaceFirstChar {
-                    if (it.isLowerCase()) it.titlecase(Locale.getDefault()) else it.toString()
-                })
-                Text(launch.code, color = Color.Blue)
-                Text(launch.currencyRate.toString(), color = Color.Gray)
             }
         }
-    }
 
+    }
 }

features/launches/data/remote/mindera/rest/ktor/src/commonMain/kotlin/com/mindera/datasource/remote/KtorCurrencyExchangeRemoteSource.kt

@@ -13,10 +13,9 @@ class KtorCurrencyExchangeRemoteSource constructor(
     private val client: HttpClient,
 ) : CurrencyExchangeRemoteSource {
 
+
     override suspend fun getCurrencyExchange(): List<DomainCurrencyExchangeResponseItem> =
-        getCurrencyExchange("A").zip(getCurrencyExchange("B")) { listA, listB ->
-            DomainCurrencyExchangeResponseItem(listA.rates + listB.rates)
-        }
+        getCurrencyExchange("A/last/10/")
 
     private suspend fun getCurrencyExchange(table: String): List<DomainCurrencyExchangeResponseItem> =
         client.get("$baseUrl/$table")

features/launches/data/remote/mindera/rest/ktor/src/commonMain/kotlin/com/mindera/datasource/remote/converters/Api.kt

@@ -5,6 +5,9 @@ import com.mindera.uuid
 
 internal fun CurrencyExchangeResponseItem.toDomain() =
     com.mindera.kmpexample.launches.domain.model.CurrencyExchangeResponseItem(
+        table = table,
+        no = no,
+        effectiveDate = effectiveDate,
         rates = rates.map { it.toDomain() },
     )
 

features/launches/data/remote/mindera/rest/schema/src/commonMain/kotlin/com.mindera.rest/CurrencyExchangeResponse.kt

@@ -19,6 +19,15 @@ data class RatesItem(
 @Serializable
 data class CurrencyExchangeResponseItem(
 
+	@SerialName("table")
+	val table: String,
+
+	@SerialName("no")
+	val no: String,
+
+	@SerialName("effectiveDate")
+	val effectiveDate: String,
+
 	@SerialName("rates")
 	val rates: List<RatesItem>,
 )

features/launches/di/build.gradle.kts

@@ -27,15 +27,15 @@ kotlin {
                 implementation(libs.koin.core)
                 implementation(libs.ktor.core)
                 implementation(libs.ktor.content.negotiation)
-
+                implementation(projects.features.launches.presentation)
             }
         }
 
         val androidMain by getting {
             dependsOn(commonMain)
             dependencies {
                 implementation(libs.ktor.okhttp)
-                implementation(projects.features.launches.presentation)
+
             }
         }
 

features/launches/di/src/iosMain/kotlin/com.mindera.di/DIHelper.kt

@@ -1,10 +1,11 @@
 package com.mindera.di
 
 import com.mindera.kmpexample.launches.domain.usecase.GetCurrencyExchangeUseCase
-import com.mindera.kmpexample.launches.usecase.GetCurrencyExchangeUseCaseV1
+import com.mindera.kmpexample.launches.viewmodel.CurrencyExchangeViewModel
 import org.koin.core.component.KoinComponent
 import org.koin.core.component.inject
 
-class DIHelper: KoinComponent {
+object DIHelper: KoinComponent {
     val getGetCurrencyExchangeUseCase: GetCurrencyExchangeUseCase by inject()
+    val viewModel: CurrencyExchangeViewModel by inject()
 }

features/launches/domain/src/commonMain/kotlin/com/mindera/kmpexample/launches/domain/model/CurrencyExchangeResponse.kt

@@ -13,5 +13,11 @@ data class RatesItem(
 
 data class CurrencyExchangeResponseItem(
 
+	val table: String,
+
+	val no: String,
+
+	val effectiveDate: String,
+
 	val rates: List<RatesItem>,
 )

features/launches/presentation/build.gradle.kts

@@ -1,21 +1,26 @@
 plugins {
     alias(libs.plugins.kotlin.multiplatform)
     alias(libs.plugins.compose.multiplatform)
+    alias(libs.plugins.android.library)
 }
 
 group = "com.mindera.kmpexample.features.launches.presentation"
 version = "1.0.0"
 
 kotlin {
-    jvm()
+    androidTarget()
+    jvm("desktop")
+    iOS {
+        iosX64()
+        iosArm64()
+        iosSimulatorArm64()
+    }
+
 
     sourceSets {
         val commonMain by getting {
             dependencies {
-                implementation(compose.foundation)
-                implementation(compose.runtime)
-                implementation(compose.ui)
-                implementation(compose.material3)
+
                 implementation(projects.common.domain)
                 implementation(projects.common.coroutinesKtx)
                 implementation(projects.common.composeKtx)
@@ -36,9 +41,36 @@ kotlin {
                 implementation(libs.ktor.serialization)
                 implementation(libs.kotlinx.serialization)
                 implementation(libs.ktor.logging)
-                implementation(libs.ktor.okhttp)
                 implementation(libs.koin.core)
+
+            }
+        }
+
+        val androidMain by getting {
+            dependsOn(commonMain)
+            dependencies {
+                implementation(compose.foundation)
+                implementation(compose.runtime)
+                implementation(compose.ui)
+                implementation(compose.material3)
+                implementation(libs.lifecycle.viewmodel.ktx)
+            }
+        }
+
+        if (iOSEnabled) {
+            val iosX64Main by getting
+            val iosArm64Main by getting
+            val iosSimulatorArm64Main by getting
+            val iosMain by creating {
+                dependsOn(commonMain)
+                iosX64Main.dependsOn(this)
+                iosArm64Main.dependsOn(this)
+                iosSimulatorArm64Main.dependsOn(this)
+                dependencies {
+                    implementation(libs.lifecycle.viewmodel)
+                }
             }
         }
     }
+
 }

features/launches/presentation/src/commonMain/kotlin/com/mindera/kmpexample/launches/CurrencyExchangeScene.kt → features/launches/presentation/src/androidMain/kotlin/com/mindera/kmpexample/launches/CurrencyExchangeScene.kt

@@ -23,15 +23,15 @@ fun CurrencyExchangeScene(onBack: (() -> Unit)) {
     BackHandler(onBack = onBack)
 
     val viewModel = remember { KoinHelper().viewModel }
-    val state = viewModel.state.collectAsState()
+    val state = viewModel.mutableStateFlow.collectAsState()
 
     Column(modifier = Modifier.fillMaxSize()) {
         Text(
             text = "Currency Exchange",
             fontSize = 40.sp,
         )
         CurrencyExchangeScreen(
-            launches = state.value.launches
+            currencies = state.value.launches
         )
     }
 }

features/launches/presentation/src/commonMain/kotlin/com/mindera/kmpexample/launches/viewmodel/CurrencyExchangeViewModel.kt

@@ -8,26 +8,51 @@ import com.mindera.kmpexample.launches.domain.model.CurrencyExchangeResponseItem
 import com.mindera.kmpexample.launches.domain.usecase.GetCurrencyExchangeUseCase
 import com.mindera.lifecycle.ViewModel
 import com.mindera.lifecycle.launch
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
 
 class CurrencyExchangeViewModel constructor(
     private val getCurrencyExchange: GetCurrencyExchangeUseCase,
 ) : ViewModel() {
-    data class State(
+    data class CurrencyState(
         val loading: Boolean = true,
         val launches: ImmutableList<CurrencyExchangeResponseItem> = ImmutableList(),
         val error: Error? = null,
     )
 
-    var state = MutableStateFlow(value = State())
+    var mutableStateFlow = MutableStateFlow(value = CurrencyState())
         private set
 
+    val currencyStateFlow: StateFlow<CurrencyState>
+        get() = mutableStateFlow
+
+    fun onChange(provideNewState: ((CurrencyState) -> Unit)) {
+        currencyStateFlow.onEach {
+            provideNewState.invoke(it)
+        }.launchIn(CoroutineScope(Dispatchers.Main))
+    }
+
+// This example to access data in IOS
+//    class AppViewModel: ObservableObject {
+//        let coreModel : CurrencyExchangeViewModel = DIHelper().viewModel
+//
+//        func fetchData() {
+//            coreModel.onChange { newState in
+//                    print(newState.launches)
+//            }
+//        }
+//    }
+
     init {
         launch {
             getCurrencyExchange().on(
                 left = {
                     println(">>> Rates: $it")
-                    state.value = with(state.value) {
+                    mutableStateFlow.value = with(mutableStateFlow.value) {
                         copy(
                             loading = false,
                             launches = it.immutable(),
@@ -37,7 +62,7 @@ class CurrencyExchangeViewModel constructor(
                 },
                 right = {
                     println(">>> Rates error: $it")
-                    state.value = with(state.value) {
+                    mutableStateFlow.value = with(mutableStateFlow.value) {
                         copy(
                             loading = false,
                             launches = ImmutableList(emptyList()),

gradle.properties

@@ -33,3 +33,5 @@ kotlin.native.binary.memoryModel=experimental
 kotlin.native.binary.objcExportSuspendFunctionLaunchThreadRestriction=none
 kotlin.native.disableCompilerDaemon=true
 kotlin.native.ignoreDisabledTargets=true
+
+org.jetbrains.compose.experimental.uikit.enabled=true