Suporte ao Koin Annotations -> Core Network

build-logic/src/main/java/Config.kt

@@ -9,7 +9,7 @@ object Config {
     const val compileSdkVersion = 36
     const val minSdkVersion = 28
     const val targetSdkVersion = 36
-    const val versionName = "1.2"
+    const val versionName = "1.3"
     const val versionCode = 1
     const val testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
 

composeApp/src/commonMain/kotlin/com.codandotv.streamplayerapp/di/AppModule.kt

@@ -8,10 +8,11 @@ import com.codandotv.streamplayerapp.feature_list_streams.list.di.ListStreamModu
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.IO
 import org.koin.dsl.module
+import org.koin.ksp.generated.module
 
 object AppModule {
     private val module = module {
         single(QualifierDispatcherIO) { Dispatchers.IO }
     }
-    val list  = module + NetworkModule.module + LocalStorageModule.module + SyncModule.module + ListStreamModule.module
+    val list  = module + NetworkModule().module + LocalStorageModule.module + SyncModule.module + ListStreamModule.module
 }

core-networking/build.gradle.kts

@@ -5,6 +5,7 @@ plugins {
     alias(libs.plugins.jetbrains.compose)
     alias(libs.plugins.compose.compiler)
     alias(libs.plugins.buildkonfig.plugin)
+    id("com.streamplayer.koin-annotations-setup")
 }
 
 buildkonfig {

core-networking/src/commonMain/kotlin/com/codandotv/streamplayerapp/core_networking/HttpClientBuilder.kt

@@ -0,0 +1,94 @@
+package com.codandotv.streamplayerapp.core_networking
+
+import com.codandotv.streamplayerapp.core_networking.di.Network.TIMEOUT
+import com.codandotv.streamplayerapp.core_networking.handleError.Failure
+import core.networking.BuildKonfig
+import io.ktor.client.HttpClient
+import io.ktor.client.plugins.ClientRequestException
+import io.ktor.client.plugins.HttpResponseValidator
+import io.ktor.client.plugins.HttpTimeout
+import io.ktor.client.plugins.auth.Auth
+import io.ktor.client.plugins.auth.providers.BearerTokens
+import io.ktor.client.plugins.auth.providers.bearer
+import io.ktor.client.plugins.contentnegotiation.ContentNegotiation
+import io.ktor.client.plugins.defaultRequest
+import io.ktor.client.plugins.logging.LogLevel
+import io.ktor.client.plugins.logging.Logger
+import io.ktor.client.plugins.logging.Logging
+import io.ktor.client.request.accept
+import io.ktor.http.ContentType
+import io.ktor.http.contentType
+import io.ktor.serialization.kotlinx.json.json
+import kotlinx.io.IOException
+import kotlinx.serialization.SerializationException
+import kotlinx.serialization.json.Json
+
+internal object HttpClientBuilder {
+    fun build(baseUrl: String) : HttpClient {
+        return HttpClient(engine = httpClientEnginePlatform()) {
+            expectSuccess = false
+
+            install(ContentNegotiation) {
+                json(Json {
+                    explicitNulls = false
+                    ignoreUnknownKeys = true
+                })
+            }
+
+            install(HttpTimeout) {
+                socketTimeoutMillis = TIMEOUT
+                requestTimeoutMillis = TIMEOUT
+                connectTimeoutMillis = TIMEOUT
+            }
+
+            defaultRequest {
+                url(baseUrl)
+                contentType(ContentType.Application.Json)
+                accept(ContentType.Application.Json)
+            }
+
+            install(Auth) {
+                bearer {
+                    loadTokens {
+                        BearerTokens(
+                            accessToken = BuildKonfig.API_BEARER_AUTH,
+                            refreshToken = ""
+                        )
+                    }
+                }
+            }
+
+            install(Logging) {
+                level = LogLevel.ALL
+                logger = object : Logger {
+                    override fun log(message: String) {
+                        //TODO: Migrar Logs para Utilizar Kermit
+                        println("HttpClient${message}")
+                    }
+                }
+            }
+
+            HttpResponseValidator {
+                handleResponseExceptionWithRequest { cause, _ ->
+                    throw when (cause) {
+                        is ClientRequestException -> {
+                            Failure.ServerError(codeStatus = cause.response.status.value)
+                        }
+
+                        is SerializationException -> {
+                            Failure.UnparsableResponseException(throwable = cause)
+                        }
+
+                        is IOException -> {
+                            Failure.NetworkError(throwable = cause)
+                        }
+
+                        else -> {
+                            Failure.UnknownError(throwable = cause)
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

core-networking/src/commonMain/kotlin/com/codandotv/streamplayerapp/core_networking/di/NetworkModule.kt

@@ -1,116 +1,28 @@
 package com.codandotv.streamplayerapp.core_networking.di
 
-import com.codandotv.streamplayerapp.core_networking.di.Network.TIMEOUT
-import com.codandotv.streamplayerapp.core_networking.handleError.Failure
-import com.codandotv.streamplayerapp.core_networking.httpClientEnginePlatform
+import com.codandotv.streamplayerapp.core_networking.HttpClientBuilder
 import core.networking.BuildKonfig
 import io.ktor.client.HttpClient
-import io.ktor.client.plugins.ClientRequestException
-import io.ktor.client.plugins.HttpResponseValidator
-import io.ktor.client.plugins.HttpTimeout
-import io.ktor.client.plugins.auth.Auth
-import io.ktor.client.plugins.auth.providers.BearerTokens
-import io.ktor.client.plugins.auth.providers.bearer
-import io.ktor.client.plugins.contentnegotiation.ContentNegotiation
-import io.ktor.client.plugins.defaultRequest
-import io.ktor.client.plugins.logging.LogLevel
-import io.ktor.client.plugins.logging.Logger
-import io.ktor.client.plugins.logging.Logging
-import io.ktor.client.request.accept
-import io.ktor.http.ContentType
-import io.ktor.http.contentType
-import io.ktor.serialization.kotlinx.json.json
-import kotlinx.io.IOException
-import kotlinx.serialization.SerializationException
-import kotlinx.serialization.json.Json
-import org.koin.dsl.module
-
-object NetworkModule {
-    val module = module {
-        single(QualifierHost) { BuildKonfig.HOST }
-        single(QualifierProfile) { BuildKonfig.PROFILE }
-
-        single {
-            provideKtorHttpClient(
-                baseUrl = get(QualifierHost),
-            )
-        }
-
-        single(QualifierProfileHttpClient) {
-            provideKtorHttpClient(
-                baseUrl = get(QualifierProfile),
-            )
-        }
+import org.koin.core.annotation.Module
+import org.koin.core.annotation.Qualifier
+import org.koin.core.annotation.Single
+
+@Module
+class NetworkModule {
+
+    @Single
+    fun provideHttpClient() : HttpClient {
+        return HttpClientBuilder.build(
+            baseUrl = BuildKonfig.HOST,
+        )
     }
 
-    private fun provideKtorHttpClient(
-        baseUrl: String,
-    ): HttpClient {
-        return HttpClient(engine = httpClientEnginePlatform()) {
-            expectSuccess = false
-
-            install(ContentNegotiation) {
-                json(Json {
-                    explicitNulls = false
-                    ignoreUnknownKeys = true
-                })
-            }
-
-            install(HttpTimeout) {
-                socketTimeoutMillis = TIMEOUT
-                requestTimeoutMillis = TIMEOUT
-                connectTimeoutMillis = TIMEOUT
-            }
-
-            defaultRequest {
-                url(baseUrl)
-                contentType(ContentType.Application.Json)
-                accept(ContentType.Application.Json)
-            }
-
-            install(Auth) {
-                bearer {
-                    loadTokens {
-                        BearerTokens(
-                            accessToken = BuildKonfig.API_BEARER_AUTH,
-                            refreshToken = ""
-                        )
-                    }
-                }
-            }
-
-            install(Logging) {
-                level = LogLevel.ALL
-                logger = object : Logger {
-                    override fun log(message: String) {
-                        //TODO: Migrar Logs para Utilizar Kermit
-                        println("HttpClient${message}")
-                    }
-                }
-            }
-
-            HttpResponseValidator {
-                handleResponseExceptionWithRequest { cause, _ ->
-                    throw when (cause) {
-                        is ClientRequestException -> {
-                            Failure.ServerError(codeStatus = cause.response.status.value)
-                        }
-
-                        is SerializationException -> {
-                            Failure.UnparsableResponseException(throwable = cause)
-                        }
-
-                        is IOException -> {
-                            Failure.NetworkError(throwable = cause)
-                        }
-
-                        else -> {
-                            Failure.UnknownError(throwable = cause)
-                        }
-                    }
-                }
-            }
-        }
+    @Single
+    @Qualifier(QualifierProfileHttpClient::class)
+    fun provideProfileHttpClient(): HttpClient {
+        return HttpClientBuilder.build(
+            baseUrl = BuildKonfig.PROFILE,
+        )
     }
 }
 

core-networking/src/commonMain/kotlin/com/codandotv/streamplayerapp/core_networking/di/QualifierNetworking.kt

@@ -3,28 +3,8 @@ package com.codandotv.streamplayerapp.core_networking.di
 import org.koin.core.qualifier.Qualifier
 import org.koin.core.qualifier.QualifierValue
 
-object QualifierHost : Qualifier {
-    override val value: QualifierValue
-        get() = "QualifierHost"
-}
-
-object QualifierProfile : Qualifier {
-    override val value: QualifierValue
-        get() = "QualifierProfile"
-}
-
 object QualifierProfileHttpClient : Qualifier {
     override val value: QualifierValue
         get() = "QualifierProfileRetrofit"
 }
 
-object QualifierLoggerInterceptor : Qualifier {
-    override val value: QualifierValue
-        get() = "QualifierLoggerInterceptor"
-}
-
-object QualifierAuthInterceptor : Qualifier {
-    override val value: QualifierValue
-        get() = "QualifierAuthInterceptor"
-}
-