Moved api and dao into state (refactoring)

app/src/main/java/org/sirekanyan/outline/MainActivity.kt

@@ -7,12 +7,9 @@ import androidx.activity.compose.setContent
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Surface
-import androidx.compose.runtime.remember
 import androidx.compose.ui.Modifier
 import androidx.core.view.WindowCompat
 import kotlinx.coroutines.launch
-import org.sirekanyan.outline.api.OutlineApi
-import org.sirekanyan.outline.db.rememberApiUrlDao
 import org.sirekanyan.outline.ui.AddServerContent
 import org.sirekanyan.outline.ui.DeleteKeyContent
 import org.sirekanyan.outline.ui.DeleteServerContent
@@ -24,22 +21,20 @@ class MainActivity : ComponentActivity() {
         super.onCreate(savedInstanceState)
         WindowCompat.setDecorFitsSystemWindows(window, false)
         setContent {
-            val api = remember { OutlineApi() }
-            val dao = rememberApiUrlDao()
-            val state = rememberMainState(api)
+            val state = rememberMainState()
             OutlineTheme {
                 Surface(Modifier.fillMaxSize(), color = MaterialTheme.colorScheme.background) {
                     BackHandler(state.drawer.isOpen) {
                         state.closeDrawer()
                     }
-                    MainContent(api, dao, state)
+                    MainContent(state)
                     state.dialog?.let { dialog ->
                         BackHandler(state.dialog != null) {
                             state.dialog = null
                         }
                         when (dialog) {
-                            is AddServerDialog -> Surface { AddServerContent(dao, state) }
-                            is EditKeyDialog -> Surface { EditKeyContent(api, state, dialog) }
+                            is AddServerDialog -> Surface { AddServerContent(state) }
+                            is EditKeyDialog -> Surface { EditKeyContent(state, dialog) }
                             is DeleteKeyDialog -> {
                                 val (apiUrl, key) = dialog
                                 DeleteKeyContent(
@@ -48,7 +43,7 @@ class MainActivity : ComponentActivity() {
                                     onConfirm = {
                                         state.scope.launch {
                                             state.deletingKey = key
-                                            api.deleteAccessKey(apiUrl, key.accessKey.id)
+                                            state.api.deleteAccessKey(apiUrl, key.accessKey.id)
                                             state.refreshCurrentKeys(showLoading = false)
                                         }.invokeOnCompletion {
                                             state.deletingKey = null
@@ -63,7 +58,7 @@ class MainActivity : ComponentActivity() {
                                     onDismiss = { state.dialog = null },
                                     onConfirm = {
                                         state.scope.launch {
-                                            dao.deleteUrl(apiUrl.id)
+                                            state.dao.deleteUrl(apiUrl.id)
                                         }
                                         state.page = HelloPage
                                         state.openDrawer()

app/src/main/java/org/sirekanyan/outline/MainContent.kt

@@ -26,8 +26,6 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
 import kotlinx.coroutines.launch
-import org.sirekanyan.outline.api.OutlineApi
-import org.sirekanyan.outline.db.ApiUrlDao
 import org.sirekanyan.outline.ext.plus
 import org.sirekanyan.outline.feature.keys.KeysContent
 import org.sirekanyan.outline.feature.keys.KeysErrorContent
@@ -39,8 +37,8 @@ import org.sirekanyan.outline.ui.DrawerContent
 import org.sirekanyan.outline.ui.KeyBottomSheet
 
 @Composable
-fun MainContent(api: OutlineApi, dao: ApiUrlDao, state: MainState) {
-    ModalNavigationDrawer({ DrawerContent(dao, state) }, drawerState = state.drawer) {
+fun MainContent(state: MainState) {
+    ModalNavigationDrawer({ DrawerContent(state) }, drawerState = state.drawer) {
         val insets = WindowInsets.systemBars.asPaddingValues() + PaddingValues(top = 64.dp)
         when (val page = state.page) {
             is HelloPage -> {
@@ -102,7 +100,7 @@ fun MainContent(api: OutlineApi, dao: ApiUrlDao, state: MainState) {
                 state.selectedPage?.let { page ->
                     state.scope.launch {
                         state.isFabLoading = true
-                        api.createAccessKey(page.apiUrl)
+                        state.api.createAccessKey(page.apiUrl)
                         state.refreshCurrentKeys(showLoading = false)
                     }.invokeOnCompletion {
                         state.isFabLoading = false

app/src/main/java/org/sirekanyan/outline/MainState.kt

@@ -18,7 +18,9 @@ import kotlinx.coroutines.launch
 import kotlinx.coroutines.plus
 import org.sirekanyan.outline.api.OutlineApi
 import org.sirekanyan.outline.api.model.Key
+import org.sirekanyan.outline.db.ApiUrlDao
 import org.sirekanyan.outline.db.model.ApiUrl
+import org.sirekanyan.outline.db.rememberApiUrlDao
 import org.sirekanyan.outline.ext.logError
 import org.sirekanyan.outline.feature.keys.KeysErrorState
 import org.sirekanyan.outline.feature.keys.KeysLoadingState
@@ -29,7 +31,7 @@ import java.net.ConnectException
 import java.net.UnknownHostException
 
 @Composable
-fun rememberMainState(api: OutlineApi): MainState {
+fun rememberMainState(): MainState {
     val context = LocalContext.current
     val scope = rememberCoroutineScope {
         CoroutineExceptionHandler { _, throwable ->
@@ -49,10 +51,12 @@ fun rememberMainState(api: OutlineApi): MainState {
         }
     }
     val supervisor = remember { SupervisorJob() }
-    return remember { MainState(scope + supervisor, api) }
+    val api = remember { OutlineApi() }
+    val dao = rememberApiUrlDao()
+    return remember { MainState(scope + supervisor, api, dao) }
 }
 
-class MainState(val scope: CoroutineScope, private val api: OutlineApi) {
+class MainState(val scope: CoroutineScope, val api: OutlineApi, val dao: ApiUrlDao) {
 
     val servers = ServerRepository(api)
     val drawer = DrawerState(DrawerValue.Closed)

app/src/main/java/org/sirekanyan/outline/ui/AddServerContent.kt

@@ -27,12 +27,11 @@ import kotlinx.coroutines.launch
 import org.sirekanyan.outline.MainState
 import org.sirekanyan.outline.NotSupportedContent
 import org.sirekanyan.outline.SelectedPage
-import org.sirekanyan.outline.db.ApiUrlDao
 import org.sirekanyan.outline.db.model.ApiUrl
 import javax.net.ssl.SSLException
 
 @Composable
-fun AddServerContent(dao: ApiUrlDao, state: MainState) {
+fun AddServerContent(state: MainState) {
     var draft by remember { mutableStateOf("") }
     var insecure by remember { mutableStateOf(false) }
     var error by remember(draft) { mutableStateOf("") }
@@ -47,7 +46,7 @@ fun AddServerContent(dao: ApiUrlDao, state: MainState) {
             isLoading = true
             val apiUrl = ApiUrl(draft, insecure)
             state.servers.fetchServer(apiUrl)
-            dao.insertUrl(apiUrl)
+            state.dao.insertUrl(apiUrl)
             state.dialog = null
             state.page = SelectedPage(apiUrl)
             state.closeDrawer(animated = false)

app/src/main/java/org/sirekanyan/outline/ui/DrawerContent.kt

@@ -36,22 +36,21 @@ import org.sirekanyan.outline.BuildConfig
 import org.sirekanyan.outline.MainState
 import org.sirekanyan.outline.R
 import org.sirekanyan.outline.SelectedPage
-import org.sirekanyan.outline.db.ApiUrlDao
 import org.sirekanyan.outline.isPlayFlavor
 import org.sirekanyan.outline.text.formatTraffic
 import org.sirekanyan.outline.ui.icons.IconOpenInNew
 import org.sirekanyan.outline.ui.icons.IconPlayStore
 
 @Composable
-fun DrawerContent(dao: ApiUrlDao, state: MainState) {
+fun DrawerContent(state: MainState) {
     val insets = WindowInsets.systemBars.asPaddingValues()
     ModalDrawerSheet(windowInsets = WindowInsets(0.dp)) {
-        DrawerSheetContent(dao, state, insets)
+        DrawerSheetContent(state, insets)
     }
 }
 
 @Composable
-private fun DrawerSheetContent(dao: ApiUrlDao, state: MainState, insets: PaddingValues) {
+private fun DrawerSheetContent(state: MainState, insets: PaddingValues) {
     Column(
         modifier = Modifier
             .fillMaxHeight()
@@ -64,7 +63,7 @@ private fun DrawerSheetContent(dao: ApiUrlDao, state: MainState, insets: Padding
             modifier = Modifier.padding(horizontal = 28.dp, vertical = 16.dp),
             style = MaterialTheme.typography.titleSmall,
         )
-        val apiUrls by remember { dao.observeUrls() }.collectAsState(listOf())
+        val apiUrls by remember { state.dao.observeUrls() }.collectAsState(listOf())
         apiUrls.forEach { apiUrl ->
             val isSelected = state.selectedPage?.apiUrl?.id == apiUrl.id
             val server by produceState(state.servers.getCachedServer(apiUrl), state.drawer.isOpen) {

app/src/main/java/org/sirekanyan/outline/ui/EditKeyContent.kt

@@ -20,10 +20,9 @@ import androidx.compose.ui.unit.dp
 import kotlinx.coroutines.launch
 import org.sirekanyan.outline.EditKeyDialog
 import org.sirekanyan.outline.MainState
-import org.sirekanyan.outline.api.OutlineApi
 
 @Composable
-fun EditKeyContent(api: OutlineApi, state: MainState, dialog: EditKeyDialog) {
+fun EditKeyContent(state: MainState, dialog: EditKeyDialog) {
     val accessKey = dialog.key.accessKey
     var draft by remember {
         mutableStateOf(TextFieldValue(accessKey.nameOrDefault, TextRange(Int.MAX_VALUE)))
@@ -39,7 +38,7 @@ fun EditKeyContent(api: OutlineApi, state: MainState, dialog: EditKeyDialog) {
                     val isSuccess = try {
                         isLoading = true
                         val newName = draft.text.ifBlank { accessKey.defaultName }
-                        api.renameAccessKey(dialog.apiUrl, accessKey.id, newName)
+                        state.api.renameAccessKey(dialog.apiUrl, accessKey.id, newName)
                         state.dialog = null
                         true
                     } catch (exception: Exception) {