Move endpoints to HTTPS and make design little adaptive

Author: AlexEreh

app/src/main/java/com/nekodev/hackathonapp/di/NetworkModule.kt

@@ -5,8 +5,6 @@ import com.nekodev.hackathonapp.network.api.DroneApi
 import com.nekodev.hackathonapp.network.api.OrderApi
 import com.nekodev.hackathonapp.network.datasource.NetworkDataSource
 import com.nekodev.hackathonapp.network.datasource.OrdersDataSource
-import kotlinx.coroutines.time.withTimeout
-import kotlinx.coroutines.withTimeout
 import kotlinx.serialization.ExperimentalSerializationApi
 import kotlinx.serialization.json.Json
 import kotlinx.serialization.json.JsonNamingStrategy
@@ -27,10 +25,10 @@ val networkModule = module {
         }
     }
     single(named("droneEndpoint")) {
-        Endpoint("http://91.107.125.237:8001/")
+        Endpoint("https://dronepost.m41den.com/api/")
     }
     single(named("orderEndpoint")) {
-        Endpoint("http://91.107.125.237:8002/api/v1/")
+        Endpoint("https://dronepost.m41den.com/market/api/v1/")
     }
     single<Json> {
         Json {

app/src/main/java/com/nekodev/hackathonapp/navigation/root/DefaultRootComponent.kt

@@ -4,27 +4,19 @@ import com.arkivanov.decompose.ComponentContext
 import com.arkivanov.decompose.router.stack.ChildStack
 import com.arkivanov.decompose.router.stack.StackNavigation
 import com.arkivanov.decompose.router.stack.childStack
-import com.arkivanov.decompose.router.stack.push
 import com.arkivanov.decompose.router.stack.replaceAll
-import com.arkivanov.decompose.router.stack.replaceCurrent
 import com.arkivanov.essenty.lifecycle.doOnCreate
-import com.arkivanov.essenty.lifecycle.doOnResume
-import com.nekodev.hackathonapp.data.OrderRepository
-import com.nekodev.hackathonapp.model.OrderState
-import com.nekodev.hackathonapp.navigation.root.RootComponent.Child.*
+import com.nekodev.hackathonapp.navigation.root.RootComponent.Child.DetailsScreenChild
+import com.nekodev.hackathonapp.navigation.root.RootComponent.Child.MainScreenChild
+import com.nekodev.hackathonapp.navigation.root.RootComponent.Child.SplashScreenChild
 import com.nekodev.hackathonapp.screens.details.RealDetailsScreenComponent
 import com.nekodev.hackathonapp.screens.main.RealMainScreenComponent
 import com.nekodev.hackathonapp.screens.splash.RealSplashScreenComponent
 import com.nekodev.hackathonapp.util.BaseComponent
 import com.nekodev.hackathonapp.util.toStateFlow
-import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.delay
-import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
-import kotlinx.coroutines.withContext
-import org.koin.core.component.inject
 
 class DefaultRootComponent(
     componentContext: ComponentContext
@@ -42,16 +34,11 @@ class DefaultRootComponent(
 
     override val stack: StateFlow<ChildStack<*, RootComponent.Child>> = _stack
 
-    private val _states: MutableStateFlow<List<OrderState>> = MutableStateFlow(emptyList())
-
-    private val repo: OrderRepository by inject()
-
     private fun child(config: RootConfig, componentContext: ComponentContext): RootComponent.Child {
         return when(config){
             is RootConfig.MainScreen -> MainScreenChild(
                 RealMainScreenComponent(
                     componentContext = componentContext,
-                    _states = _states,
                     navigateToDetails = {
                         mainScope.launch {
                             navigation.replaceAll(RootConfig.MainScreen, RootConfig.DetailsScreen(it))
@@ -69,48 +56,8 @@ class DefaultRootComponent(
                 RealDetailsScreenComponent(
                     componentContext = componentContext,
                     orderId = config.orderId,
-                    updateOrders = { state ->
-                        _states.update {
-                            if (
-                                it.indexOfFirst { state ->
-                                    when (state) {
-                                        is OrderState.OnlyOrder -> {
-                                            state.orderId == config.orderId
-                                        }
-
-                                        is OrderState.OrderAndState -> {
-                                            state.orderId == config.orderId
-                                        }
-                                    }
-                                } == -1
-                            ) {
-                                val newList: MutableList<OrderState> = it.toMutableList()
-                                newList += state
-                                return@update newList
-                            } else {
-                                val newList = it.toMutableList()
-                                val lol = newList.indexOfFirst {
-                                    when (state) {
-                                        is OrderState.OnlyOrder -> {
-                                            state.orderId == config.orderId
-                                        }
-
-                                        is OrderState.OrderAndState -> {
-                                            state.orderId == config.orderId
-                                        }
-                                    }
-                                }
-                                if (lol == -1) return@update newList
-                                newList.removeAt(lol)
-                                newList += state
-                                return@update newList
-                            }
-                        }
-                    },
                     navigateToMain = {
                         mainScope.launch {
-                            val result = withContext(Dispatchers.IO){ repo.getAllStates() }
-                            _states.value = result
                             navigation.replaceAll(RootConfig.MainScreen)
                         }
                     }
@@ -122,21 +69,8 @@ class DefaultRootComponent(
     init {
         lifecycle.doOnCreate {
             mainScope.launch {
-                val result = withContext(Dispatchers.IO){ repo.getAllStates() }
-                _states.value = result
                 delay(1_000L)
-                navigation.replaceCurrent(RootConfig.MainScreen)
-            }
-        }
-        lifecycle.doOnResume(isOneTime = false) {
-            mainScope.launch {
-                if (
-                    stack.value.active.configuration is RootConfig.MainScreen ||
-                    stack.value.active.configuration is RootConfig.DetailsScreen
-                    ) {
-                    val result = withContext(Dispatchers.IO){ repo.getAllStates() }
-                    _states.value = result
-                }
+                navigation.replaceAll(RootConfig.MainScreen)
             }
         }
     }