Added separate rename state (refactoring)

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

@@ -35,8 +35,8 @@ class MainActivity : ComponentActivity() {
                         }
                         when (dialog) {
                             is AddServerDialog -> Surface { AddServerContent(router) }
-                            is RenameServerDialog -> Surface { RenameServerContent(state, router, dialog.server) }
-                            is RenameKeyDialog -> Surface { RenameKeyContent(state, dialog.key) }
+                            is RenameServerDialog -> Surface { RenameServerContent(router, dialog.server) }
+                            is RenameKeyDialog -> Surface { RenameKeyContent(router, dialog.key) }
                             is DeleteKeyDialog -> {
                                 val (key) = dialog
                                 DeleteKeyContent(

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

@@ -18,61 +18,83 @@ import androidx.compose.ui.focus.focusRequester
 import androidx.compose.ui.text.TextRange
 import androidx.compose.ui.text.input.TextFieldValue
 import androidx.compose.ui.unit.dp
+import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.launch
-import org.sirekanyan.outline.MainState
+import org.sirekanyan.outline.Router
 import org.sirekanyan.outline.ext.rememberStateScope
 
 interface RenameDelegate {
     suspend fun onRename(newName: String)
 }
 
+@Composable
+fun rememberRenameState(router: Router, delegate: RenameDelegate): RenameState {
+    val scope = rememberStateScope()
+    return remember { RenameState(scope, router, delegate) }
+}
+
+class RenameState(
+    scope: CoroutineScope,
+    private val router: Router,
+    private val renameDelegate: RenameDelegate,
+) : CoroutineScope by scope {
+
+    var error by mutableStateOf("")
+    var isLoading by mutableStateOf(false)
+
+    fun onSaveClicked(newName: String) {
+        launch {
+            try {
+                isLoading = true
+                renameDelegate.onRename(newName)
+                router.dialog = null
+            } catch (exception: Exception) {
+                exception.printStackTrace()
+                error = "Check name or try again"
+            } finally {
+                isLoading = false
+            }
+        }
+    }
+
+}
+
 @Composable
 fun RenameContent(
-    state: MainState,
+    state: RenameState,
+    router: Router,
     dialogTitle: String,
     initialName: String,
     defaultName: String,
-    renameDelegate: RenameDelegate,
 ) {
-    val scope = rememberStateScope()
     var draft by rememberSaveable(stateSaver = TextFieldValue.Saver) {
         mutableStateOf(TextFieldValue(initialName, TextRange(Int.MAX_VALUE)))
     }
-    var error by remember(draft) { mutableStateOf("") }
-    var isLoading by remember { mutableStateOf(false) }
     Column {
         DialogToolbar(
             title = dialogTitle,
-            onCloseClick = { state.dialog = null },
+            onCloseClick = { router.dialog = null },
             action = "Save" to {
-                scope.launch {
-                    try {
-                        isLoading = true
-                        val newName = draft.text.ifBlank { defaultName }
-                        renameDelegate.onRename(newName)
-                        state.dialog = null
-                    } catch (exception: Exception) {
-                        exception.printStackTrace()
-                        error = "Check name or try again"
-                    } finally {
-                        isLoading = false
-                    }
-                }
+                val newName = draft.text.ifBlank { defaultName }
+                state.onSaveClicked(newName)
             },
-            isLoading = isLoading,
+            isLoading = state.isLoading,
         )
         val focusRequester = remember { FocusRequester() }
         OutlinedTextField(
             value = draft,
-            onValueChange = { draft = it.copy(text = it.text.trim('\n')) },
+            onValueChange = {
+                draft = it.copy(text = it.text.trim('\n'))
+                state.error = ""
+            },
             modifier = Modifier
                 .fillMaxWidth()
                 .padding(horizontal = 16.dp, vertical = 24.dp)
                 .focusRequester(focusRequester),
             label = { Text("Name") },
             placeholder = { Text(defaultName) },
-            isError = error.isNotEmpty(),
-            supportingText = { Text(error) },
+            isError = state.error.isNotEmpty(),
+            supportingText = { Text(state.error) },
             maxLines = 4,
         )
         LaunchedEffect(Unit) {

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

@@ -3,7 +3,7 @@ package org.sirekanyan.outline.ui
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.remember
 import androidx.compose.ui.platform.LocalContext
-import org.sirekanyan.outline.MainState
+import org.sirekanyan.outline.Router
 import org.sirekanyan.outline.api.model.Key
 import org.sirekanyan.outline.app
 import org.sirekanyan.outline.repository.KeyRepository
@@ -12,7 +12,7 @@ import org.sirekanyan.outline.repository.KeyRepository
 private fun rememberRenameKeyDelegate(key: Key): RenameDelegate {
     val context = LocalContext.current
     val keys = remember { context.app().keyRepository }
-    return remember { RenameKeyDelegate(keys, key) }
+    return remember(key) { RenameKeyDelegate(keys, key) }
 }
 
 private class RenameKeyDelegate(
@@ -30,7 +30,8 @@ private class RenameKeyDelegate(
 }
 
 @Composable
-fun RenameKeyContent(state: MainState, key: Key) {
+fun RenameKeyContent(router: Router, key: Key) {
     val delegate = rememberRenameKeyDelegate(key)
-    RenameContent(state, "Edit key", key.name, key.defaultName, delegate)
+    val state = rememberRenameState(router, delegate)
+    RenameContent(state, router, "Edit key", key.name, key.defaultName)
 }

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

@@ -3,7 +3,6 @@ package org.sirekanyan.outline.ui
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.remember
 import androidx.compose.ui.platform.LocalContext
-import org.sirekanyan.outline.MainState
 import org.sirekanyan.outline.Router
 import org.sirekanyan.outline.SelectedPage
 import org.sirekanyan.outline.api.model.Server
@@ -14,7 +13,7 @@ import org.sirekanyan.outline.repository.ServerRepository
 private fun rememberRenameServerDelegate(router: Router, server: Server): RenameDelegate {
     val context = LocalContext.current
     val servers = remember { context.app().serverRepository }
-    return remember { RenameServerDelegate(router, servers, server) }
+    return remember(server) { RenameServerDelegate(router, servers, server) }
 }
 
 private class RenameServerDelegate(
@@ -29,7 +28,8 @@ private class RenameServerDelegate(
 }
 
 @Composable
-fun RenameServerContent(state: MainState, router: Router, server: Server) {
+fun RenameServerContent(router: Router, server: Server) {
     val delegate = rememberRenameServerDelegate(router, server)
-    RenameContent(state, "Edit server", server.name, server.getHost(), delegate)
+    val state = rememberRenameState(router, delegate)
+    RenameContent(state, router, "Edit server", server.name, server.getHost())
 }