Add Napier logger library

build.gradle.kts

@@ -6,4 +6,5 @@ plugins {
     alias(libs.plugins.composeMultiplatform) apply false
     alias(libs.plugins.composeCompiler) apply false
     alias(libs.plugins.kotlinMultiplatform) apply false
+    alias(libs.plugins.kotlin.serialization) apply false
 }

composeApp/build.gradle.kts

@@ -6,6 +6,7 @@ plugins {
     alias(libs.plugins.androidApplication)
     alias(libs.plugins.composeMultiplatform)
     alias(libs.plugins.composeCompiler)
+    alias(libs.plugins.kotlin.serialization)
 }
 
 kotlin {
@@ -34,6 +35,7 @@ kotlin {
             implementation(libs.koin.androidx.compose)
             implementation(libs.koin.compose)
             implementation(libs.koin.compose.viewmodel)
+            implementation(libs.ktor.client.okhttp)
         }
         commonMain.dependencies {
             implementation(libs.compose.runtime)
@@ -45,19 +47,19 @@ kotlin {
             implementation(libs.androidx.lifecycle.viewmodelCompose)
             implementation(libs.androidx.lifecycle.runtimeCompose)
 
-            implementation(project.dependencies.platform(libs.koin.bom))
-            implementation(libs.koin.core)
-            implementation(libs.koin.compose)
-            implementation(libs.koin.compose.viewmodel)
-
             implementation(libs.compose.material.icons.extended)
             implementation(libs.androidx.navigation.compose)
 
-//            implementation(libs.compose.material3.adaptiveNavigation3)
+            implementation(project.dependencies.platform(libs.koin.bom))
-//            implementation(libs.androidx.lifecycle.viewmodelNavigation3)
+            implementation(libs.bundles.ktor)
+
+            implementation(libs.koin.core)
+            implementation(libs.koin.compose.viewmodel)
+
+            implementation(libs.logger.napier)
         }
         iosMain.dependencies {
-
+            implementation(libs.ktor.client.darwin)
         }
         commonTest.dependencies {
             implementation(libs.kotlin.test)

composeApp/src/androidMain/AndroidManifest.xml

@@ -1,7 +1,10 @@
 <?xml version="1.0" encoding="utf-8"?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android">
-
+    <uses-permission android:name="android.permission.INTERNET" />
+    <!-- Allow access http: android:usesCleartextTraffic="true" -->
     <application
+        android:name=".MyApplication"
+        android:usesCleartextTraffic="true"
         android:allowBackup="true"
         android:icon="@mipmap/ic_launcher"
         android:label="@string/app_name"

composeApp/src/androidMain/kotlin/com/digitoolsolutions/app/torquevaultkmp/AppStorage.android.kt

@@ -0,0 +1,33 @@
+package com.digitoolsolutions.app.torquevaultkmp
+
+import android.content.Context
+import com.digitoolsolutions.app.torquevaultkmp.data.storage.AppStorage
+import kotlin.reflect.KClass
+import androidx.core.content.edit
+
+class AppStoragePlatform(context: Context) : AppStorage {
+    private val prefs = context.getSharedPreferences("app_prefs", Context.MODE_PRIVATE)
+
+    override fun <T : Any> save(key: String, value: T) {
+        when (value) {
+            is String -> prefs.edit { putString(key, value) }
+            is Int -> prefs.edit { putInt(key, value) }
+            is Boolean -> prefs.edit { putBoolean(key, value) }
+            else -> throw IllegalArgumentException("Unsupported type")
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    override fun <T : Any> load(key: String, type: KClass<T>): T? {
+        return when (type) {
+            String::class -> prefs.getString(key, null) as T?
+            Int::class -> prefs.getInt(key, -1) as T?
+            Boolean::class -> prefs.getBoolean(key, false) as T?
+            else -> throw IllegalArgumentException("Unsupported type")
+        }
+    }
+
+    override fun remove(key: String) {
+        prefs.edit { remove(key) }
+    }
+}

composeApp/src/androidMain/kotlin/com/digitoolsolutions/app/torquevaultkmp/MainActivity.kt

@@ -6,12 +6,13 @@ import androidx.activity.compose.setContent
 import androidx.activity.enableEdgeToEdge
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.tooling.preview.Preview
+import com.digitoolsolutions.app.torquevaultkmp.di.initKoin
+import org.koin.android.ext.koin.androidContext
 
 class MainActivity : ComponentActivity() {
     override fun onCreate(savedInstanceState: Bundle?) {
         enableEdgeToEdge()
         super.onCreate(savedInstanceState)
-
         setContent {
             App()
         }

composeApp/src/androidMain/kotlin/com/digitoolsolutions/app/torquevaultkmp/MyApplication.kt

@@ -0,0 +1,17 @@
+package com.digitoolsolutions.app.torquevaultkmp
+
+import android.app.Application
+import com.digitoolsolutions.app.torquevaultkmp.di.initKoin
+import io.github.aakira.napier.DebugAntilog
+import io.github.aakira.napier.Napier
+import org.koin.android.ext.koin.androidContext
+class MyApplication : Application() {
+    override fun onCreate() {
+        super.onCreate()
+        // Add logger lib
+        Napier.base(DebugAntilog()) // NoOpAntilog() for release
+        initKoin {
+            androidContext(this@MyApplication)
+        }
+    }
+}

composeApp/src/androidMain/kotlin/com/digitoolsolutions/app/torquevaultkmp/NetworkEngine.android.kt

@@ -0,0 +1,75 @@
+package com.digitoolsolutions.app.torquevaultkmp
+
+import com.digitoolsolutions.app.torquevaultkmp.data.network.api.AuthApi
+import com.digitoolsolutions.app.torquevaultkmp.data.storage.ReferKeys
+import com.digitoolsolutions.app.torquevaultkmp.data.storage.TokenManager
+import com.digitoolsolutions.app.torquevaultkmp.utils.ForceLogoutException
+import io.github.aakira.napier.Napier
+import io.ktor.client.HttpClient
+import io.ktor.client.engine.okhttp.OkHttp
+import io.ktor.client.plugins.DefaultRequest
+import io.ktor.client.plugins.HttpSend
+import io.ktor.client.plugins.HttpTimeout
+import io.ktor.client.plugins.contentnegotiation.ContentNegotiation
+import io.ktor.client.plugins.logging.DEFAULT
+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.plugins.plugin
+import io.ktor.client.request.header
+import io.ktor.http.HttpStatusCode
+import io.ktor.serialization.kotlinx.json.json
+import kotlinx.serialization.json.Json
+
+actual fun createPlatformHttpClient(
+    tokenManager: TokenManager,
+    authApi: AuthApi?
+): HttpClient {
+    val client = HttpClient(OkHttp) {
+        install(ContentNegotiation) {
+            json(Json {
+                ignoreUnknownKeys = true
+                isLenient = true
+            })
+        }
+        install(DefaultRequest) {
+            tokenManager.getAccessToken()?.let {
+                header("Authorization", "Bearer $it")
+            }
+        }
+        install(HttpTimeout) { requestTimeoutMillis = 30_000 }
+        install(Logging) {
+            logger = object : Logger {
+                override fun log(message: String) {
+                    Napier.v(message, tag = "HTTP")
+                }
+            }
+            level = LogLevel.ALL // set LogLevel.NONE for release
+        }
+    }
+
+    if (authApi != null) {
+        client.plugin(HttpSend).intercept { request ->
+            // Skip interceptor for refresh token request to avoid recursion
+            if (request.url.pathSegments.contains(ReferKeys.REFRESH_TOKEN)) {
+                return@intercept execute(request)
+            }
+
+            val originalCall = execute(request)
+            if (originalCall.response.status == HttpStatusCode.Unauthorized) {
+                Napier.d(">>>>> [NetworkEngine.ios.kt] Access token expired, auto request refresh token...")
+                val newToken = authApi.refreshToken()
+                if (newToken != null) {
+                    request.headers["Authorization"] = "Bearer $newToken"
+                    execute(request)
+                } else {
+                    tokenManager.clearTokens()
+                    throw ForceLogoutException()
+                }
+            } else {
+                originalCall
+            }
+        }
+    }
+    return client
+}

composeApp/src/androidMain/kotlin/com/digitoolsolutions/app/torquevaultkmp/di/PlatformModules.kt

@@ -0,0 +1,10 @@
+package com.digitoolsolutions.app.torquevaultkmp.di
+
+import com.digitoolsolutions.app.torquevaultkmp.AppStoragePlatform
+import com.digitoolsolutions.app.torquevaultkmp.data.storage.AppStorage
+import org.koin.android.ext.koin.androidContext
+import org.koin.dsl.module
+
+actual val platformModule = module {
+    single<AppStorage> { AppStoragePlatform(androidContext()) }
+}

composeApp/src/commonMain/kotlin/com/digitoolsolutions/app/torquevaultkmp/App.kt

@@ -1,18 +1,25 @@
 package com.digitoolsolutions.app.torquevaultkmp
 
+import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.tooling.preview.Preview
 import com.digitoolsolutions.android.torquevault.ui.theme.TorqueVaultTheme
 import com.digitoolsolutions.app.torquevaultkmp.screens.MainScreen
+import org.koin.compose.viewmodel.koinViewModel
 
 @Composable
 @Preview
 fun App() {
-    TorqueVaultTheme {
+    val viewModel = koinViewModel<AppViewModel>()
+    val savedTheme = viewModel.isDarkTheme.value
+    val isDarkTheme = savedTheme ?: isSystemInDarkTheme()
+    val isLoggedIn = viewModel.isLoggedIn()
+
+    TorqueVaultTheme(darkTheme = isDarkTheme) {
         MainScreen(
-            isLoggedIn = false,
+            isDarkTheme = isDarkTheme,
-            isDarkTheme = true,
+            onThemeToggle = { viewModel.toggleTheme(it) },
-            onThemeToggle = {}
+            isLoggedIn = isLoggedIn
         )
     }
 }

composeApp/src/commonMain/kotlin/com/digitoolsolutions/app/torquevaultkmp/AppViewModel.kt

@@ -0,0 +1,27 @@
+package com.digitoolsolutions.app.torquevaultkmp
+
+import androidx.compose.runtime.State
+import androidx.compose.runtime.mutableStateOf
+import androidx.lifecycle.ViewModel
+import com.digitoolsolutions.app.torquevaultkmp.data.storage.AppStorage
+import com.digitoolsolutions.app.torquevaultkmp.data.storage.ReferKeys
+import com.digitoolsolutions.app.torquevaultkmp.data.storage.TokenManager
+import com.digitoolsolutions.app.torquevaultkmp.data.storage.load
+
+class AppViewModel(
+    private val tokenManager: TokenManager,
+    private val storage: AppStorage
+) : ViewModel() {
+
+    private val _isDarkTheme = mutableStateOf<Boolean?>(storage.load(ReferKeys.THEME))
+    val isDarkTheme: State<Boolean?> = _isDarkTheme
+
+    fun isLoggedIn(): Boolean {
+        return tokenManager.getRefreshToken() != null
+    }
+
+    fun toggleTheme(isDark: Boolean) {
+        _isDarkTheme.value = isDark
+        storage.save(ReferKeys.THEME, isDark)
+    }
+}

composeApp/src/commonMain/kotlin/com/digitoolsolutions/app/torquevaultkmp/NetworkEngine.kt

@@ -0,0 +1,7 @@
+package com.digitoolsolutions.app.torquevaultkmp
+
+import com.digitoolsolutions.app.torquevaultkmp.data.network.api.AuthApi
+import com.digitoolsolutions.app.torquevaultkmp.data.storage.TokenManager
+import io.ktor.client.HttpClient
+
+expect fun createPlatformHttpClient(tokenManager: TokenManager, authApi: AuthApi?): HttpClient

composeApp/src/commonMain/kotlin/com/digitoolsolutions/app/torquevaultkmp/components/AppBar.kt

@@ -2,11 +2,6 @@ package com.digitoolsolutions.app.torquevaultkmp.components
 
 import androidx.compose.foundation.layout.RowScope
 import androidx.compose.foundation.layout.WindowInsets
-import androidx.compose.foundation.layout.WindowInsetsSides
-import androidx.compose.foundation.layout.displayCutout
-import androidx.compose.foundation.layout.navigationBars
-import androidx.compose.foundation.layout.only
-import androidx.compose.foundation.layout.union
 import androidx.compose.material3.ExperimentalMaterial3Api
 import androidx.compose.material3.Icon
 import androidx.compose.material3.IconButton
@@ -30,7 +25,6 @@ import torquevaultkmp.composeapp.generated.resources.baseline_menu_24
 import torquevaultkmp.composeapp.generated.resources.menu_item_accessibility
 import torquevaultkmp.composeapp.generated.resources.navigation_item_accessibility
 
-
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
 fun AppBar(

composeApp/src/commonMain/kotlin/com/digitoolsolutions/app/torquevaultkmp/data/network/NetworkModule.kt

@@ -0,0 +1,25 @@
+package com.digitoolsolutions.app.torquevaultkmp.data.network
+
+import com.digitoolsolutions.app.torquevaultkmp.utils.ApiException
+import io.ktor.client.HttpClient
+import io.ktor.client.plugins.HttpResponseValidator
+import io.ktor.client.plugins.HttpTimeout
+import io.ktor.client.plugins.contentnegotiation.ContentNegotiation
+import io.ktor.serialization.kotlinx.json.json
+import kotlinx.serialization.json.Json
+
+object NetworkModule {
+    val client = HttpClient {
+        install(ContentNegotiation) {
+            json(Json { ignoreUnknownKeys = true })
+        }
+        install(HttpTimeout) { requestTimeoutMillis = 30_000 }
+//        install(HttpResponseValidator) {
+//            validateResponse { response ->
+//                if (response.status.value >= 400) {
+//                    throw ApiException(response.status, response.bodyAsText())
+//                }
+//            }
+//        }
+    }
+}

composeApp/src/commonMain/kotlin/com/digitoolsolutions/app/torquevaultkmp/data/network/api/AuthApi.kt

@@ -0,0 +1,50 @@
+package com.digitoolsolutions.app.torquevaultkmp.data.network.api
+
+import com.digitoolsolutions.app.torquevaultkmp.data.network.dto.LoginRequestDto
+import com.digitoolsolutions.app.torquevaultkmp.data.network.dto.LoginResponseDto
+import com.digitoolsolutions.app.torquevaultkmp.data.network.dto.RefreshRequestDto
+import com.digitoolsolutions.app.torquevaultkmp.data.network.dto.RefreshResponseDto
+import com.digitoolsolutions.app.torquevaultkmp.data.storage.TokenManager
+import io.ktor.client.HttpClient
+import io.ktor.client.call.body
+import io.ktor.client.request.post
+import io.ktor.client.request.setBody
+import io.ktor.http.ContentType
+import io.ktor.http.contentType
+
+
+class AuthApi(
+    private val client: HttpClient,
+    private val baseUrl: String,
+    private val tokenManager: TokenManager
+) {
+    suspend fun login(username: String, password: String): Boolean {
+        return try {
+            println(">>>>> Check LOGIN Api")
+            val res: LoginResponseDto = client.post("$baseUrl${Endpoints.AUTH_TOKEN}") {
+                contentType(ContentType.Application.Json)
+                setBody(LoginRequestDto(username, password))
+            }.body()
+            println(res)
+            tokenManager.saveTokens(res.access, res.refresh)
+            true
+        } catch (e: Exception) {
+            println(">>>>> [AuthApi] Exception: $e")
+            false
+        }
+    }
+    suspend fun refreshToken(): String? {
+        val refreshToken = tokenManager.getRefreshToken() ?: return null
+        return try {
+            val res: RefreshResponseDto = client.post("$baseUrl${Endpoints.AUTH_REFRESH}") {
+                contentType(ContentType.Application.Json)
+                setBody(RefreshRequestDto(refreshToken))
+            }.body()
+            tokenManager.saveTokens(res.access, refreshToken)
+            res.access
+        } catch (e: Exception) {
+            tokenManager.clearTokens()
+            null // refresh token invalid
+        }
+    }
+}

composeApp/src/commonMain/kotlin/com/digitoolsolutions/app/torquevaultkmp/data/network/api/Endpoints.kt

@@ -0,0 +1,8 @@
+package com.digitoolsolutions.app.torquevaultkmp.data.network.api
+
+object Endpoints {
+    const val AUTH_TOKEN = "/token/"
+    const val AUTH_REFRESH = "/token/refresh/"
+    const val WORK_ORDERS = "/work-orders/able-v2/"
+    const val CONFIRM = "/confirm"
+}

composeApp/src/commonMain/kotlin/com/digitoolsolutions/app/torquevaultkmp/data/network/api/WorkOrderApi.kt

@@ -0,0 +1,27 @@
+package com.digitoolsolutions.app.torquevaultkmp.data.network.api
+
+import com.digitoolsolutions.app.torquevaultkmp.data.network.dto.ConfirmRequestDto
+import com.digitoolsolutions.app.torquevaultkmp.data.network.dto.WorkOrderDto
+import io.ktor.client.HttpClient
+import io.ktor.client.call.body
+import io.ktor.client.request.get
+import io.ktor.client.request.parameter
+import io.ktor.client.request.post
+import io.ktor.client.request.setBody
+
+class WorkOrderApi(
+    private val client: HttpClient,
+    private val baseUrl: String
+) {
+    suspend fun fetchAbleWorkOrders(page: Int): List<WorkOrderDto> {
+        return client.get("$baseUrl${Endpoints.WORK_ORDERS}") {
+            parameter("page", page)
+        }.body()
+    }
+
+    suspend fun confirm(mac: String, type: Int) {
+        client.post("$baseUrl${Endpoints.CONFIRM}") {
+            setBody(ConfirmRequestDto(mac, type))
+        }
+    }
+}

composeApp/src/commonMain/kotlin/com/digitoolsolutions/app/torquevaultkmp/data/network/dto/AuthDto.kt

@@ -0,0 +1,12 @@
+package com.digitoolsolutions.app.torquevaultkmp.data.network.dto
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class LoginRequestDto(val username: String, val password: String)
+@Serializable
+data class RefreshRequestDto(val refresh: String)
+@Serializable
+data class LoginResponseDto(val access: String, val refresh: String)
+@Serializable
+data class RefreshResponseDto(val access: String)

composeApp/src/commonMain/kotlin/com/digitoolsolutions/app/torquevaultkmp/data/network/dto/WorkOrderDto.kt

@@ -0,0 +1,34 @@
+package com.digitoolsolutions.app.torquevaultkmp.data.network.dto
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.json.JsonElement
+
+@Serializable
+data class WorkOrderDto(
+    @SerialName("wo_id") val id: String,
+    val status: String,
+    val car: String? = null,
+    val make: String?,
+    @SerialName("license_plate") val licensePlate: String,
+    val services: Map<String, ServiceDto>?,
+    @SerialName("meas_result") val measResult: Map<String, JsonElement>?,
+    @SerialName("meas_history") val measHistory: Map<String, JsonElement>?,
+    @SerialName("finished_at") val finishedAt: String?,
+    @SerialName("created_at") val createdAt: String,
+    @SerialName("updated_at") val updatedAt: String? = null,
+)
+@Serializable
+data class ServiceDto(
+    val nut: Int?,
+    val status: Int,
+    val wheels: List<String>?,
+    val wrench: String?,
+    @SerialName("torque_required") val torqueRequired: Double
+)
+
+@Serializable
+data class ConfirmRequestDto(
+    @SerialName("wrench_mac_addr") val mac: String,
+    val type: Int
+)

composeApp/src/commonMain/kotlin/com/digitoolsolutions/app/torquevaultkmp/data/network/mapper/AuthMapper.kt

@@ -0,0 +1,24 @@
+package com.digitoolsolutions.app.torquevaultkmp.data.network.mapper
+
+import com.digitoolsolutions.app.torquevaultkmp.data.network.dto.LoginRequestDto
+import com.digitoolsolutions.app.torquevaultkmp.data.network.dto.LoginResponseDto
+import com.digitoolsolutions.app.torquevaultkmp.data.network.dto.RefreshRequestDto
+import com.digitoolsolutions.app.torquevaultkmp.data.network.dto.RefreshResponseDto
+import com.digitoolsolutions.app.torquevaultkmp.domain.model.LoginRequest
+import com.digitoolsolutions.app.torquevaultkmp.domain.model.LoginResponse
+import com.digitoolsolutions.app.torquevaultkmp.domain.model.RefreshRequest
+import com.digitoolsolutions.app.torquevaultkmp.domain.model.RefreshResponse
+
+fun LoginRequestDto.toDomain(): LoginRequest {
+    return LoginRequest(username,password)
+}
+
+fun LoginResponseDto.toDomain(): LoginResponse {
+    return LoginResponse(access, refresh)
+}
+fun RefreshRequestDto.toDomain(): RefreshRequest {
+    return RefreshRequest(refresh)
+}
+fun RefreshResponseDto.toDomain(): RefreshResponse {
+    return RefreshResponse(access)
+}

composeApp/src/commonMain/kotlin/com/digitoolsolutions/app/torquevaultkmp/data/network/mapper/WorkOrderMapper.kt

@@ -0,0 +1,35 @@
+package com.digitoolsolutions.app.torquevaultkmp.data.network.mapper
+
+import com.digitoolsolutions.app.torquevaultkmp.data.network.dto.WorkOrderDto
+import com.digitoolsolutions.app.torquevaultkmp.domain.model.Service
+import com.digitoolsolutions.app.torquevaultkmp.domain.model.WorkOrder
+import kotlinx.serialization.json.doubleOrNull
+import kotlinx.serialization.json.jsonPrimitive
+
+fun WorkOrderDto.toDomain(): WorkOrder {
+    return WorkOrder(
+        id = id,
+        status = status,
+        car = car,
+        make = make,
+        licensePlate = licensePlate,
+        services = services?.mapValues { (_, dto) ->
+            Service(
+                nut = dto.nut,
+                status = dto.status,
+                wheels = dto.wheels,
+                wrench = dto.wrench,
+                torqueRequired = dto.torqueRequired
+            )
+        },
+        measResult = measResult?.mapValues { (_, value) ->
+            value.jsonPrimitive.doubleOrNull ?: Double.NaN
+        },
+        measHistory = measHistory?.mapValues { (_, value) ->
+            value.jsonPrimitive.doubleOrNull ?: Double.NaN
+        },
+        finishedAt = finishedAt,
+        createdAt = createdAt,
+        updatedAt = updatedAt
+    )
+}

composeApp/src/commonMain/kotlin/com/digitoolsolutions/app/torquevaultkmp/data/repository/WorkOrderRepository.kt

@@ -0,0 +1,8 @@
+package com.digitoolsolutions.app.torquevaultkmp.data.repository
+
+import com.digitoolsolutions.app.torquevaultkmp.domain.model.WorkOrder
+
+interface WorkOrderRepository {
+    suspend fun fetchAbleWorkOrders(page: Int): List<WorkOrder>
+    suspend fun confirm(mac: String, type: Int)
+}

composeApp/src/commonMain/kotlin/com/digitoolsolutions/app/torquevaultkmp/data/repository/WorkOrderRepositoryImpl.kt

@@ -0,0 +1,15 @@
+package com.digitoolsolutions.app.torquevaultkmp.data.repository
+
+import com.digitoolsolutions.app.torquevaultkmp.data.network.api.WorkOrderApi
+import com.digitoolsolutions.app.torquevaultkmp.data.network.mapper.toDomain
+import com.digitoolsolutions.app.torquevaultkmp.domain.model.WorkOrder
+class WorkOrderRepositoryImpl(private val api: WorkOrderApi) : WorkOrderRepository {
+    override suspend fun fetchAbleWorkOrders(page: Int): List<WorkOrder> {
+        val dto = api.fetchAbleWorkOrders(page)
+        return dto.map { it.toDomain() }
+    }
+
+    override suspend fun confirm(mac: String, type: Int) {
+        api.confirm(mac, type)
+    }
+}

composeApp/src/commonMain/kotlin/com/digitoolsolutions/app/torquevaultkmp/data/storage/AppStorage.kt

@@ -0,0 +1,13 @@
+package com.digitoolsolutions.app.torquevaultkmp.data.storage
+
+import kotlin.reflect.KClass
+
+interface AppStorage {
+    fun <T : Any> save(key: String, value: T)
+    fun <T : Any> load(key: String, type: KClass<T>): T?
+    fun remove(key: String)
+}
+
+inline fun <reified T : Any> AppStorage.load(key: String): T? {
+    return load(key, T::class)
+}

composeApp/src/commonMain/kotlin/com/digitoolsolutions/app/torquevaultkmp/data/storage/ReferKeys.kt

@@ -0,0 +1,7 @@
+package com.digitoolsolutions.app.torquevaultkmp.data.storage
+
+object ReferKeys {
+    const val ACCESS_TOKEN = "access_token"
+    const val REFRESH_TOKEN = "refresh_token"
+    const val THEME = "theme"
+}

composeApp/src/commonMain/kotlin/com/digitoolsolutions/app/torquevaultkmp/data/storage/TokenManager.kt

@@ -0,0 +1,29 @@
+package com.digitoolsolutions.app.torquevaultkmp.data.storage
+
+class TokenManager(private val storage: AppStorage) {
+    private var accessToken: String? = null
+    private var refreshToken: String? = null
+
+    fun getAccessToken(): String? {
+        if (accessToken == null) accessToken = storage.load(ReferKeys.ACCESS_TOKEN)
+        return accessToken
+    }
+    fun getRefreshToken(): String? {
+        if (refreshToken == null) refreshToken = storage.load(ReferKeys.REFRESH_TOKEN)
+        return refreshToken
+    }
+
+    fun saveTokens(access: String, refresh: String) {
+        accessToken = access
+        refreshToken = refresh
+        storage.save(ReferKeys.ACCESS_TOKEN, access)
+        storage.save(ReferKeys.REFRESH_TOKEN, refresh)
+    }
+
+    fun clearTokens() {
+        accessToken = null
+        refreshToken = null
+        storage.remove(ReferKeys.ACCESS_TOKEN)
+        storage.remove(ReferKeys.REFRESH_TOKEN)
+    }
+}

composeApp/src/commonMain/kotlin/com/digitoolsolutions/app/torquevaultkmp/di/Koin.kt

@@ -1,4 +1,16 @@
 package com.digitoolsolutions.app.torquevaultkmp.di
 
-class Koin {
+import org.koin.core.context.startKoin
+import org.koin.dsl.KoinAppDeclaration
+
+fun initKoin(config: KoinAppDeclaration? = null) {
+     startKoin {
+        config?.invoke(this)
+        modules(
+            appModule,
+            networkModule,
+            viewModelModule,
+            platformModule
+        )
+    }
 }

composeApp/src/commonMain/kotlin/com/digitoolsolutions/app/torquevaultkmp/di/Modules.kt

@@ -1,5 +1,46 @@
 package com.digitoolsolutions.app.torquevaultkmp.di
 
+import com.digitoolsolutions.app.torquevaultkmp.AppViewModel
+import com.digitoolsolutions.app.torquevaultkmp.createPlatformHttpClient
+import com.digitoolsolutions.app.torquevaultkmp.data.network.api.AuthApi
+import com.digitoolsolutions.app.torquevaultkmp.data.network.api.WorkOrderApi
+import com.digitoolsolutions.app.torquevaultkmp.data.repository.WorkOrderRepository
+import com.digitoolsolutions.app.torquevaultkmp.data.repository.WorkOrderRepositoryImpl
+import com.digitoolsolutions.app.torquevaultkmp.data.storage.TokenManager
+import com.digitoolsolutions.app.torquevaultkmp.domain.usecase.FetchWorkOrdersUseCase
+import com.digitoolsolutions.app.torquevaultkmp.screens.auth.AuthViewModel
+import com.digitoolsolutions.app.torquevaultkmp.screens.home.HomeViewModel
+import org.koin.core.module.Module
+import org.koin.core.module.dsl.factoryOf
+import org.koin.core.qualifier.named
 import org.koin.dsl.module
 
-val homeModule = module {  }
+expect val platformModule: Module
+
+val appModule = module {
+    // TokenManager use AppStorage
+    single { TokenManager(get()) }
+}
+
+val networkModule = module {
+    single { "http://digitoolsolutions.synology.me:3000/api/v1" } // base URL
+
+    // Auth client (no interceptor to avoid circular dependency and recursion)
+    single(named("authClient")) { createPlatformHttpClient(get(), null) }
+
+    // AuthApi uses the auth client
+    single<AuthApi> { AuthApi(get(named("authClient")), get(), get()) }
+
+    // Main client uses AuthApi for its interceptor
+    single { createPlatformHttpClient(get(), get()) }
+
+    single<WorkOrderApi> { WorkOrderApi(get(), get()) }
+    single<WorkOrderRepository> { WorkOrderRepositoryImpl(get()) }
+    factory { FetchWorkOrdersUseCase(get()) }
+}
+
+val viewModelModule = module {
+    factoryOf(::HomeViewModel)
+    factoryOf(::AuthViewModel)
+    factoryOf(::AppViewModel)
+}

composeApp/src/commonMain/kotlin/com/digitoolsolutions/app/torquevaultkmp/domain/model/Auth.kt

@@ -0,0 +1,6 @@
+package com.digitoolsolutions.app.torquevaultkmp.domain.model
+
+data class LoginRequest(val username: String, val password: String)
+data class RefreshRequest(val refresh: String)
+data class LoginResponse(val access: String, val refresh: String)
+data class RefreshResponse(val access: String)

composeApp/src/commonMain/kotlin/com/digitoolsolutions/app/torquevaultkmp/domain/model/WorkOrder.kt

@@ -0,0 +1,44 @@
+package com.digitoolsolutions.app.torquevaultkmp.domain.model
+val wheelsCode = mapOf(
+    "DF" to 0b0001,
+    "PF" to 0b0010,
+    "DR" to 0b0100,
+    "PR" to 0b1000,
+    "DRO" to 0b00010000,
+    "PRO" to 0b100000
+)
+
+fun WorkOrder.computeWheelsNuts(): Int {
+    var wNut = 0
+    var nutCount = 0
+    val wheelSer = services?.get("0")
+
+    wheelSer?.wheels?.forEach { wheelStr ->
+        if (wheelStr.isNotBlank()) {
+            wNut = wNut or (wheelsCode[wheelStr] ?: 0)
+            nutCount++
+        }
+    }
+    return (wNut shl 8) or nutCount
+}
+
+data class WorkOrder(
+    val id: String,
+    val status: String,
+    val car: String?,
+    val make: String?,
+    val licensePlate: String,
+    val services: Map<String, Service>?,
+    val measResult: Map<String, Double>?,
+    val measHistory: Map<String, Double>?,
+    val finishedAt: String?,
+    val createdAt: String,
+    val updatedAt: String?
+)
+data class Service(
+    val nut: Int?,
+    val status: Int,
+    val wheels: List<String>?,
+    val wrench: String?,
+    val torqueRequired: Double
+)

composeApp/src/commonMain/kotlin/com/digitoolsolutions/app/torquevaultkmp/domain/usecase/FetchWorkOrdersUseCase.kt

@@ -0,0 +1,10 @@
+package com.digitoolsolutions.app.torquevaultkmp.domain.usecase
+
+import com.digitoolsolutions.app.torquevaultkmp.data.repository.WorkOrderRepository
+import com.digitoolsolutions.app.torquevaultkmp.domain.model.WorkOrder
+
+class FetchWorkOrdersUseCase(private val repository: WorkOrderRepository) {
+    suspend operator fun invoke(page: Int): List<WorkOrder> {
+        return repository.fetchAbleWorkOrders(page)
+    }
+}

composeApp/src/commonMain/kotlin/com/digitoolsolutions/app/torquevaultkmp/screens/MainScreen.kt

@@ -28,9 +28,9 @@ import org.jetbrains.compose.resources.painterResource
 import org.koin.compose.viewmodel.koinViewModel
 @Composable
 fun MainScreen(
-    isLoggedIn: Boolean,
     isDarkTheme: Boolean,
     onThemeToggle: (Boolean) -> Unit,
+    isLoggedIn: Boolean,
 ) {
     val destinations = listOf(
         HomeDestination,
@@ -77,7 +77,7 @@ fun MainScreen(
     ) { innerPadding ->
         NavHost(
             navController = navController,
-            startDestination = HomeDestination.route,
+            startDestination = if (isLoggedIn) HomeDestination.route else AuthDestination.route,
             modifier = Modifier.padding(innerPadding).fillMaxSize()
         ) {
             composable(AuthDestination.route) { LoginScreen(navController) }

composeApp/src/commonMain/kotlin/com/digitoolsolutions/app/torquevaultkmp/screens/auth/AuthViewModel.kt

@@ -0,0 +1,43 @@
+package com.digitoolsolutions.app.torquevaultkmp.screens.auth
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import com.digitoolsolutions.app.torquevaultkmp.data.network.api.AuthApi
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.launch
+
+sealed class LoginUiState {
+    object Idle : LoginUiState()
+    object Loading : LoginUiState()
+    object Success : LoginUiState()
+    data class Error(val message: String) : LoginUiState()
+}
+
+class AuthViewModel(
+    private val authApi: AuthApi
+) : ViewModel() {
+
+    private val _loginState = MutableStateFlow<LoginUiState>(LoginUiState.Idle)
+    val loginState = _loginState.asStateFlow()
+
+    fun login(username: String, password: String) {
+        viewModelScope.launch {
+            _loginState.value = LoginUiState.Loading
+            try {
+                val success = authApi.login(username, password)
+                if (success) {
+                    _loginState.value = LoginUiState.Success
+                } else {
+                    _loginState.value = LoginUiState.Error("Login failed: Invalid credentials")
+                }
+            } catch (e: Exception) {
+                _loginState.value = LoginUiState.Error("Error: ${e.message}")
+            }
+        }
+    }
+
+    fun resetState() {
+        _loginState.value = LoginUiState.Idle
+    }
+}

composeApp/src/commonMain/kotlin/com/digitoolsolutions/app/torquevaultkmp/screens/auth/LoginScreen.kt

@@ -54,6 +54,7 @@ import com.digitoolsolutions.app.torquevaultkmp.screens.home.HomeDestination
 import kotlinx.coroutines.launch
 import org.jetbrains.compose.resources.painterResource
 import org.jetbrains.compose.resources.stringResource
+import org.koin.compose.viewmodel.koinViewModel
 import torquevaultkmp.composeapp.generated.resources.Res
 import torquevaultkmp.composeapp.generated.resources.btn_login
 import torquevaultkmp.composeapp.generated.resources.dts_text
@@ -64,17 +65,17 @@ import torquevaultkmp.composeapp.generated.resources.server_url_placeholder
 
 @Composable
 fun LoginScreen(
-    navController: NavController,
+    navController: NavController
-//    viewModel: AuthViewModel = hiltViewModel()
 ) {
-//    val loginState by viewModel.loginState.collectAsState()
+    val viewModel = koinViewModel<AuthViewModel>()
+    val loginState by viewModel.loginState.collectAsState()
 
     LoginScreenContent(
-//        viewModel = viewModel,
+        viewModel = viewModel,
-//        loginState = loginState,
+        loginState = loginState,
         onLogin = { serverUrl, username, password ->
 //            viewModel.updateServerUrl(serverUrl)
-//            viewModel.login(username, password)
+            viewModel.login(username, password)
         },
         onLoginSuccess = {
             navController.navigate(HomeDestination.route)
@@ -85,8 +86,8 @@ fun LoginScreen(
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
 fun LoginScreenContent(
-//    viewModel: AuthViewModel,
+    viewModel: AuthViewModel,
-//    loginState: LoginUiState,
+    loginState: LoginUiState,
     onLogin: (String, String, String) -> Unit,
     onLoginSuccess: () -> Unit
 ) {
@@ -99,14 +100,14 @@ fun LoginScreenContent(
     val snackbarHostState = remember { SnackbarHostState() }
     val scope = rememberCoroutineScope()
 
-//    LaunchedEffect(loginState) {
+    LaunchedEffect(loginState) {
-//        if (loginState is LoginUiState.Error) {
+        if (loginState is LoginUiState.Error) {
-//            snackbarHostState.showSnackbar(loginState.message)
+            snackbarHostState.showSnackbar(loginState.message)
-//        }
+        }
-//        if (loginState is LoginUiState.Success) {
+        if (loginState is LoginUiState.Success) {
-//            onLoginSuccess()
+            onLoginSuccess()
-//        }
+        }
-//    }
+    }
     Scaffold(
         modifier = Modifier.imePadding(),
         snackbarHost = { SnackbarHost(snackbarHostState) })
@@ -203,18 +204,18 @@ fun LoginScreenContent(
                     else
                         onLogin(serverUrl.trim(), username.trim(), password.trim())
                 },
-//                enabled = loginState !is LoginUiState.Loading
+                enabled = loginState !is LoginUiState.Loading
                 ) {
                 Text(stringResource(Res.string.btn_login))
-//                if (loginState is LoginUiState.Loading) {
+                if (loginState is LoginUiState.Loading) {
-//                    Spacer(modifier = Modifier.width(16.dp))
+                    Spacer(modifier = Modifier.width(16.dp))
-//                    CircularProgressIndicator(
+                    CircularProgressIndicator(
-//                        modifier = Modifier.size(20.dp),
+                        modifier = Modifier.size(20.dp),
-//                        color = Color.Blue,
+                        color = Color.Blue,
-//                        strokeWidth = 2.dp
+                        strokeWidth = 2.dp
-//                    )
+                    )
-//
+
-//                }
+                }
             }
         }
     }
@@ -224,8 +225,8 @@ fun LoginScreenContent(
 @Composable
 private fun LoginScreenPreview() {
     LoginScreenContent(
-//        viewModel = viewModel(),
+        viewModel = viewModel(),
-//        loginState = LoginUiState.Idle,
+        loginState = LoginUiState.Idle,
         onLogin = { _, _, _ -> },
         onLoginSuccess = {}
     )

composeApp/src/commonMain/kotlin/com/digitoolsolutions/app/torquevaultkmp/screens/home/HomeScreen.kt

@@ -27,6 +27,7 @@ import androidx.compose.material3.SwipeToDismissBoxValue
 import androidx.compose.material3.Text
 import androidx.compose.material3.rememberSwipeToDismissBoxState
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
@@ -41,9 +42,14 @@ import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
 import androidx.navigation.NavController
 import com.digitoolsolutions.app.torquevaultkmp.components.AppBar
+import com.digitoolsolutions.app.torquevaultkmp.screens.auth.AuthDestination
 import com.digitoolsolutions.app.torquevaultkmp.screens.home.views.HomeEmpty
 import com.digitoolsolutions.app.torquevaultkmp.screens.home.views.HomeItem
+import com.digitoolsolutions.app.torquevaultkmp.utils.ForceLogoutException
+import kotlinx.coroutines.flow.collectLatest
+import kotlinx.coroutines.launch
 import org.jetbrains.compose.resources.stringResource
+import org.koin.compose.viewmodel.koinViewModel
 import torquevaultkmp.composeapp.generated.resources.Res
 import torquevaultkmp.composeapp.generated.resources.home_title
 //import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
@@ -65,31 +71,49 @@ fun HomeScreen(
 ) {
     val snackbarHostState = remember { SnackbarHostState() }
 //    val connectedDevice by bleScannerViewModel.connectedDevices.collectAsState(initial = emptyList())
+    val viewModel = koinViewModel<HomeViewModel>()
+    val workOrders by viewModel.workOrders.collectAsState()
 
-        Scaffold (
+    LaunchedEffect(Unit) {
+        viewModel.loadWorkOrders()
+    }
+
+    LaunchedEffect(viewModel) {
+        viewModel.error.collectLatest { error ->
+            if (error is ForceLogoutException) {
+                navController.navigate(AuthDestination.route) {
+                    popUpTo(0) { inclusive = true }
+                }
+            } else {
+                snackbarHostState.showSnackbar(error.message ?: "Unknown error")
+            }
+        }
+    }
+
+    Scaffold(
         modifier = Modifier.imePadding(),
         topBar = {
             AppBar(
-                title = {Text(stringResource(Res.string.home_title))},
+                title = { Text(stringResource(Res.string.home_title)) },
             )
         },
         snackbarHost = { SnackbarHost(snackbarHostState) })
     { padding ->
-        Column (
+        Column(
             modifier = Modifier
                 .fillMaxSize()
                 .imePadding()
                 .padding(padding)
                 .padding(horizontal = 16.dp, vertical = 12.dp),
         ) {
-//            if(connectedDevice.isEmpty())
+            if (workOrders.isEmpty())
-//                HomeEmpty()
+                HomeEmpty()
-//            else
+            else
-//                LazyColumn {
+                LazyColumn {
-//                    items(connectedDevice) { device ->
+                    items(workOrders) { workOrder ->
-//                        HomeItem(device)
+                        HomeItem(workOrder)
-//                    }
+                    }
-//                }
+                }
         }
     }
 }

composeApp/src/commonMain/kotlin/com/digitoolsolutions/app/torquevaultkmp/screens/home/HomeViewModel.kt

@@ -0,0 +1,33 @@
+package com.digitoolsolutions.app.torquevaultkmp.screens.home
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import com.digitoolsolutions.app.torquevaultkmp.domain.model.WorkOrder
+import com.digitoolsolutions.app.torquevaultkmp.domain.usecase.FetchWorkOrdersUseCase
+import com.digitoolsolutions.app.torquevaultkmp.utils.ForceLogoutException
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asSharedFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.launch
+
+class HomeViewModel(
+    private val fetchWorkOrdersUseCase: FetchWorkOrdersUseCase
+): ViewModel() {
+    private val _workOrders = MutableStateFlow<List<WorkOrder>>(emptyList())
+    val workOrders = _workOrders.asStateFlow()
+
+    private val _error = MutableSharedFlow<Throwable>()
+    val error = _error.asSharedFlow()
+
+    fun loadWorkOrders() {
+        viewModelScope.launch {
+            try {
+                val result = fetchWorkOrdersUseCase(page = 1)
+                _workOrders.value = result
+            } catch (e: Exception) {
+                _error.emit(e)
+            }
+        }
+    }
+}

composeApp/src/commonMain/kotlin/com/digitoolsolutions/app/torquevaultkmp/utils/ApiException.kt

@@ -0,0 +1,11 @@
+package com.digitoolsolutions.app.torquevaultkmp.utils
+
+import io.ktor.http.HttpStatusCode
+
+class ApiException(val status: HttpStatusCode, val body: String) : Exception(
+    "API error ${status.value}: $body"
+)
+
+class RetryWithNewTokenException : Exception(">>>>> Access token expired, retry with new token")
+class ForceLogoutException : Exception(">>>>> Refresh token expired, force logout")
+

composeApp/src/commonMain/kotlin/com/digitoolsolutions/app/torquevaultkmp/utils/NoOpAntilog.kt

@@ -0,0 +1,9 @@
+package com.digitoolsolutions.app.torquevaultkmp.utils
+
+import io.github.aakira.napier.Antilog
+import io.github.aakira.napier.LogLevel
+
+class NoOpAntilog : Antilog() {
+    override fun isEnable(priority: LogLevel, tag: String?): Boolean = false
+    override fun performLog(priority: LogLevel, tag: String?, throwable: Throwable?, message: String?) {}
+}

composeApp/src/iosMain/kotlin/com/digitoolsolutions/app/torquevaultkmp/AppStorage.ios.kt

@@ -0,0 +1,31 @@
+package com.digitoolsolutions.app.torquevaultkmp
+
+import com.digitoolsolutions.app.torquevaultkmp.data.storage.AppStorage
+import platform.Foundation.NSUserDefaults
+import kotlin.reflect.KClass
+
+class AppStoragePlatform : AppStorage {
+    private val defaults = NSUserDefaults.standardUserDefaults()
+
+    override fun <T : Any> save(key: String, value: T) {
+        when (value) {
+            is String -> defaults.setObject(value, forKey = key)
+            is Int -> defaults.setInteger(value.toLong(), forKey = key)
+            is Boolean -> defaults.setBool(value, forKey = key)
+            else -> throw IllegalArgumentException("Unsupported type")
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    override fun <T : Any> load(key: String, type: KClass<T>): T? {
+        return when (type) {
+            String::class -> defaults.stringForKey(key) as T?
+            Int::class -> defaults.integerForKey(key).toInt() as T?
+            Boolean::class -> defaults.boolForKey(key) as T?
+            else -> throw IllegalArgumentException("Unsupported type")
+        }
+    }
+    override fun remove(key: String) {
+        defaults.removeObjectForKey(key)
+    }
+}

composeApp/src/iosMain/kotlin/com/digitoolsolutions/app/torquevaultkmp/MainViewController.kt

@@ -1,5 +1,14 @@
 package com.digitoolsolutions.app.torquevaultkmp
 
 import androidx.compose.ui.window.ComposeUIViewController
+import com.digitoolsolutions.app.torquevaultkmp.di.initKoin
+import io.github.aakira.napier.DebugAntilog
+import io.github.aakira.napier.Napier
 
-fun MainViewController() = ComposeUIViewController { App() }
+fun MainViewController() = ComposeUIViewController(
+    configure = {
+        // Add logger lib
+        Napier.base(DebugAntilog()) // NoOpAntilog() for release
+        initKoin()
+    }
+) { App() }

composeApp/src/iosMain/kotlin/com/digitoolsolutions/app/torquevaultkmp/NetworkEngine.ios.kt

@@ -0,0 +1,76 @@
+package com.digitoolsolutions.app.torquevaultkmp
+
+import com.digitoolsolutions.app.torquevaultkmp.data.network.api.AuthApi
+import com.digitoolsolutions.app.torquevaultkmp.data.storage.ReferKeys
+import com.digitoolsolutions.app.torquevaultkmp.data.storage.TokenManager
+import com.digitoolsolutions.app.torquevaultkmp.utils.ForceLogoutException
+import io.github.aakira.napier.Napier
+import io.ktor.client.HttpClient
+import io.ktor.client.engine.darwin.Darwin
+import io.ktor.client.plugins.DefaultRequest
+import io.ktor.client.plugins.HttpSend
+import io.ktor.client.plugins.HttpTimeout
+import io.ktor.client.plugins.contentnegotiation.ContentNegotiation
+import io.ktor.client.plugins.logging.DEFAULT
+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.plugins.plugin
+import io.ktor.client.request.header
+import io.ktor.http.HttpStatusCode
+import io.ktor.serialization.kotlinx.json.json
+import kotlinx.serialization.json.Json
+
+actual fun createPlatformHttpClient(
+    tokenManager: TokenManager,
+    authApi: AuthApi?
+): HttpClient {
+    val client = HttpClient(Darwin) {
+        install(ContentNegotiation) {
+            json(Json {
+                ignoreUnknownKeys = true
+                isLenient = true
+            })
+        }
+        install(DefaultRequest) {
+            tokenManager.getAccessToken()?.let {
+                header("Authorization", "Bearer $it")
+            }
+        }
+        install(HttpTimeout) { requestTimeoutMillis = 30_000 }
+        install(Logging) {
+            logger = object : Logger {
+                override fun log(message: String) {
+                    Napier.v(message, tag = "HTTP")
+                }
+            }
+            level = LogLevel.ALL // set LogLevel.NONE for release
+        }
+    }
+
+    if (authApi != null) {
+        client.plugin(HttpSend).intercept { request ->
+            // Skip interceptor for refresh token request to avoid recursion
+            if (request.url.pathSegments.contains(ReferKeys.REFRESH_TOKEN)) {
+                return@intercept execute(request)
+            }
+
+            val originalCall = execute(request)
+            if (originalCall.response.status == HttpStatusCode.Unauthorized) {
+                println(">>>>> [NetworkEngine.ios.kt] Access token expired, auto request refresh token...")
+                val newToken = authApi.refreshToken()
+                if (newToken != null) {
+                    request.headers["Authorization"] = "Bearer $newToken"
+                    execute(request)
+                } else {
+                    tokenManager.clearTokens()
+                    throw ForceLogoutException()
+                }
+            } else {
+                originalCall
+            }
+        }
+    }
+
+    return client
+}

composeApp/src/iosMain/kotlin/com/digitoolsolutions/app/torquevaultkmp/di/PlatformModules.kt

@@ -0,0 +1,9 @@
+package com.digitoolsolutions.app.torquevaultkmp.di
+
+import com.digitoolsolutions.app.torquevaultkmp.AppStoragePlatform
+import com.digitoolsolutions.app.torquevaultkmp.data.storage.AppStorage
+import org.koin.dsl.module
+
+actual val platformModule = module {
+    single<AppStorage> { AppStoragePlatform() }
+}

gradle/libs.versions.toml

@@ -14,11 +14,10 @@ junit = "4.13.2"
 kotlin = "2.3.21"
 material3 = "1.10.0-alpha05"
 koin-bom = "4.2.1"
+ktor = "3.4.3"
 material-icons-extended = "1.7.3"
 navigation-compose = "2.9.2"
-compose-multiplatform-adaptive = "1.3.0-alpha07"
+logger = "2.7.1"
-compose-multiplatform-lifecycle = "2.10.0"
-
 
 [libraries]
 kotlin-test = { module = "org.jetbrains.kotlin:kotlin-test", version.ref = "kotlin" }
@@ -50,9 +49,13 @@ koin-compose = { module = "io.insert-koin:koin-compose" }
 koin-compose-viewmodel = { module = "io.insert-koin:koin-compose-viewmodel" }
 koin-ktor = { module = "io.insert-koin:koin-ktor" }
 koin-test = { module = "io.insert-koin:koin-test" }
-
+ktor-client-content-negotiation = { module = "io.ktor:ktor-client-content-negotiation", version.ref = "ktor" }
-#compose-material3-adaptiveNavigation3 = { module = "org.jetbrains.compose.material3.adaptive:adaptive-navigation3", version.ref = "compose-multiplatform-adaptive" }
+ktor-client-core = { module = "io.ktor:ktor-client-core", version.ref = "ktor" }
-#androidx-lifecycle-viewmodelNavigation3 = { module = "org.jetbrains.androidx.lifecycle:lifecycle-viewmodel-navigation3", version.ref = "compose-multiplatform-lifecycle" }
+ktor-client-darwin = { module = "io.ktor:ktor-client-darwin", version.ref = "ktor" }
+ktor-client-okhttp = { module = "io.ktor:ktor-client-okhttp", version.ref = "ktor" }
+ktor-serialization-kotlinx-json = { module = "io.ktor:ktor-serialization-kotlinx-json", version.ref = "ktor" }
+ktor-client-logging = { module = "io.ktor:ktor-client-logging", version.ref = "ktor" }
+logger-napier = { module = "io.github.aakira:napier", version.ref = "logger" }
 
 [plugins]
 androidApplication = { id = "com.android.application", version.ref = "agp" }
@@ -60,3 +63,13 @@ androidLibrary = { id = "com.android.library", version.ref = "agp" }
 composeMultiplatform = { id = "org.jetbrains.compose", version.ref = "composeMultiplatform" }
 composeCompiler = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" }
 kotlinMultiplatform = { id = "org.jetbrains.kotlin.multiplatform", version.ref = "kotlin" }
+kotlin-serialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin"}
+
+[bundles]
+ktor = [
+    "ktor-client-core",
+    "ktor-client-content-negotiation",
+#    "ktor-client-auth",
+    "ktor-client-logging",
+    "ktor-serialization-kotlinx-json"
+]

iosApp/iosApp/Info.plist

@@ -4,5 +4,19 @@
 <dict>
 	<key>CADisableMinimumFrameDurationOnPhone</key>
 	<true/>
+    <!-- Allow access http   -->
+    <key>NSAppTransportSecurity</key>
+    <dict>
+        <key>NSExceptionDomains</key>
+        <dict>
+            <key>digitoolsolutions.synology.me</key>
+            <dict>
+                <key>NSIncludesSubdomains</key>
+                <true/>
+                <key>NSTemporaryExceptionAllowsInsecureHTTPLoads</key>
+                <true/>
+            </dict>
+        </dict>
+    </dict>
 </dict>
 </plist>