Forms: Iterable collection of states (#263)

Author: kaushikrw

toolkit/featureforms/src/main/java/com/arcgismaps/toolkit/featureforms/FeatureForm.kt

@@ -14,7 +14,6 @@ import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.width
 import androidx.compose.foundation.lazy.LazyColumn
-import androidx.compose.foundation.lazy.items
 import androidx.compose.foundation.lazy.rememberLazyListState
 import androidx.compose.material3.CircularProgressIndicator
 import androidx.compose.material3.Divider
@@ -39,15 +38,15 @@ import com.arcgismaps.mapping.featureforms.ComboBoxFormInput
 import com.arcgismaps.mapping.featureforms.DateTimePickerFormInput
 import com.arcgismaps.mapping.featureforms.FeatureForm
 import com.arcgismaps.mapping.featureforms.FieldFormElement
-import com.arcgismaps.mapping.featureforms.FormElement
 import com.arcgismaps.mapping.featureforms.GroupFormElement
 import com.arcgismaps.mapping.featureforms.RadioButtonsFormInput
 import com.arcgismaps.mapping.featureforms.SwitchFormInput
 import com.arcgismaps.mapping.featureforms.TextAreaFormInput
 import com.arcgismaps.mapping.featureforms.TextBoxFormInput
 import com.arcgismaps.toolkit.featureforms.components.base.BaseFieldState
-import com.arcgismaps.toolkit.featureforms.components.base.BaseGroupState
-import com.arcgismaps.toolkit.featureforms.components.base.FormElementState
+import com.arcgismaps.toolkit.featureforms.components.base.MutableStateCollection
+import com.arcgismaps.toolkit.featureforms.components.base.FormStateCollection
+import com.arcgismaps.toolkit.featureforms.components.base.getState
 import com.arcgismaps.toolkit.featureforms.components.base.rememberBaseGroupState
 import com.arcgismaps.toolkit.featureforms.components.codedvalue.rememberCodedValueFieldState
 import com.arcgismaps.toolkit.featureforms.components.codedvalue.rememberRadioButtonFieldState
@@ -59,7 +58,6 @@ import com.arcgismaps.toolkit.featureforms.components.text.rememberFormTextField
 import com.arcgismaps.toolkit.featureforms.utils.FeatureFormDialog
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.delay
-import java.util.Objects
 
 /**
  * A composable Form toolkit component that enables users to edit field values of features in a
@@ -135,20 +133,10 @@ internal fun FeatureFormContent(
 ) {
     val context = LocalContext.current
     val scope = rememberCoroutineScope()
-    val fieldStateMap = rememberFieldStates(
-        form = form,
-        elements = form.elements,
-        context = context,
-        scope = scope
-    )
-    val groupStateMap = rememberGroupStates(
-        form = form,
-        context = context,
-        scope = scope
-    )
+    val states = rememberStates(form = form, context = context, scope = scope)
     FeatureFormBody(
         form = form,
-        states = fieldStateMap + groupStateMap,
+        states = states,
         modifier = modifier
     )
     FeatureFormDialog()
@@ -157,7 +145,7 @@ internal fun FeatureFormContent(
 @Composable
 private fun FeatureFormBody(
     form: FeatureForm,
-    states: Map<Int, FormElementState>,
+    states: FormStateCollection,
     modifier: Modifier = Modifier
 ) {
     val lazyListState = rememberLazyListState()
@@ -178,28 +166,19 @@ private fun FeatureFormBody(
             modifier = Modifier.fillMaxSize(),
             state = lazyListState
         ) {
-            items(form.elements) { formElement ->
-                when (formElement) {
-                    is FieldFormElement -> {
-                        val state = states[formElement.id] as? BaseFieldState<*>
-                        if (state != null) {
-                            FieldElement(state = state)
+            states.forEach { entry ->
+                item {
+                    when (entry.formElement) {
+                        is FieldFormElement -> {
+                            FieldElement(state = entry.getState<BaseFieldState<*>>())
                         }
-                    }
 
-                    is GroupFormElement -> {
-                        val state = states[formElement.id] as? BaseGroupState
-                        if (state != null) {
+                        is GroupFormElement -> {
                             GroupElement(
-                                state,
+                                state = entry.getState(),
                                 modifier = Modifier
                                     .fillMaxWidth()
-                                    .padding(
-                                        start = 15.dp,
-                                        end = 15.dp,
-                                        top = 10.dp,
-                                        bottom = 10.dp
-                                    )
+                                    .padding(horizontal = 15.dp, vertical = 10.dp)
                             )
                         }
                     }
@@ -209,136 +188,142 @@ private fun FeatureFormBody(
     }
 }
 
+/**
+ * Creates and remembers state objects for all the supported element types that are part of the
+ * provided FeatureForm. These state objects are returned as part of a [FormStateCollection].
+ *
+ * @param form the [FeatureForm] to create the states for.
+ * @param context a [Context].
+ * @param scope a [CoroutineScope] to run collectors and calculations on.
+ *
+ * @return returns the [FormStateCollection] created.
+ */
 @Composable
-internal fun rememberGroupStates(
+internal fun rememberStates(
     form: FeatureForm,
     context: Context,
-    scope: CoroutineScope,
-): Map<Int, BaseGroupState> {
-    return form.elements.filterIsInstance<GroupFormElement>().associateBy(
-        { groupElement ->
-            groupElement.id
-        },
-        { groupElement ->
-            val fieldStates = rememberFieldStates(
-                form = form,
-                elements = groupElement.formElements,
-                context = context,
-                scope = scope
-            )
-            rememberBaseGroupState(groupElement = groupElement, fieldStates = fieldStates)
+    scope: CoroutineScope
+): FormStateCollection {
+    val states = MutableStateCollection()
+    form.elements.forEach { element ->
+        when (element) {
+            is FieldFormElement -> {
+                val state = rememberFieldState(element, form, context, scope)
+                if (state != null) {
+                    states.add(element, state)
+                }
+            }
+
+            is GroupFormElement -> {
+                val fieldStateCollection = MutableStateCollection()
+                element.formElements.forEach {
+                    if (it is FieldFormElement) {
+                        val state = rememberFieldState(
+                            element = it,
+                            form = form,
+                            context = context,
+                            scope = scope
+                        )
+                        if (state != null) {
+                            fieldStateCollection.add(it, state)
+                        }
+                    }
+                }
+                val groupState = rememberBaseGroupState(
+                    groupElement = element,
+                    fieldStates = fieldStateCollection
+                )
+                states.add(element, groupState)
+            }
         }
-    )
+    }
+    return states
 }
 
+/**
+ * Creates and remembers a [BaseFieldState] for the provided [element].
+ *
+ * @param element the [FieldFormElement] to create the state for.
+ * @param form the [FeatureForm] the [element] is part of.
+ * @param context a [Context].
+ * @param scope a [CoroutineScope] to run collectors and calculations on.
+ *
+ * @return returns the [BaseFieldState] created.
+ */
 @Composable
-internal fun rememberFieldStates(
+internal fun rememberFieldState(
+    element: FieldFormElement,
     form: FeatureForm,
-    elements: List<FormElement>,
     context: Context,
     scope: CoroutineScope
-): Map<Int, BaseFieldState<*>> {
-    val stateMap = mutableMapOf<Int, BaseFieldState<*>>()
-    elements.forEach { element ->
-        if (element is FieldFormElement) {
-            val state = when (element.input) {
-                is TextBoxFormInput, is TextAreaFormInput -> {
-                    val minLength = if (element.input is TextBoxFormInput) {
-                        (element.input as TextBoxFormInput).minLength.toInt()
-                    } else {
-                        (element.input as TextAreaFormInput).minLength.toInt()
-                    }
-                    val maxLength = if (element.input is TextBoxFormInput) {
-                        (element.input as TextBoxFormInput).maxLength.toInt()
-                    } else {
-                        (element.input as TextAreaFormInput).maxLength.toInt()
-                    }
-                    rememberFormTextFieldState(
-                        field = element,
-                        minLength = minLength,
-                        maxLength = maxLength,
-                        form = form,
-                        context = context,
-                        scope = scope
-                    )
-                }
+): BaseFieldState<out Any?>? {
+    return when (element.input) {
+        is TextBoxFormInput, is TextAreaFormInput -> {
+            val minLength = if (element.input is TextBoxFormInput) {
+                (element.input as TextBoxFormInput).minLength.toInt()
+            } else {
+                (element.input as TextAreaFormInput).minLength.toInt()
+            }
+            val maxLength = if (element.input is TextBoxFormInput) {
+                (element.input as TextBoxFormInput).maxLength.toInt()
+            } else {
+                (element.input as TextAreaFormInput).maxLength.toInt()
+            }
+            rememberFormTextFieldState(
+                field = element,
+                minLength = minLength,
+                maxLength = maxLength,
+                form = form,
+                context = context,
+                scope = scope
+            )
+        }
 
-                is DateTimePickerFormInput -> {
-                    val input = element.input as DateTimePickerFormInput
-                    rememberDateTimeFieldState(
-                        field = element,
-                        minEpochMillis = input.min,
-                        maxEpochMillis = input.max,
-                        shouldShowTime = input.includeTime,
-                        form = form,
-                        scope = scope
-                    )
-                }
+        is DateTimePickerFormInput -> {
+            val input = element.input as DateTimePickerFormInput
+            rememberDateTimeFieldState(
+                field = element,
+                minEpochMillis = input.min,
+                maxEpochMillis = input.max,
+                shouldShowTime = input.includeTime,
+                form = form,
+                scope = scope
+            )
+        }
 
-                is ComboBoxFormInput -> {
-                    rememberCodedValueFieldState(
-                        field = element,
-                        form = form,
-                        scope = scope
-                    )
-                }
+        is ComboBoxFormInput -> {
+            rememberCodedValueFieldState(
+                field = element,
+                form = form,
+                scope = scope
+            )
+        }
 
-                is SwitchFormInput -> {
-                    val input = element.input as SwitchFormInput
-                    val initialValue = element.formattedValue
-                    val fallback = initialValue.isEmpty()
-                        || (element.value.value != input.onValue.code && element.value.value != input.offValue.code)
-                    rememberSwitchFieldState(
-                        field = element,
-                        form = form,
-                        fallback = fallback,
-                        scope = scope,
-                        noValueString = context.getString(R.string.no_value)
-                    )
-                }
+        is SwitchFormInput -> {
+            rememberSwitchFieldState(
+                field = element,
+                form = form,
+                scope = scope,
+                noValueString = context.getString(R.string.no_value)
+            )
+        }
 
-                is RadioButtonsFormInput -> {
-                    rememberRadioButtonFieldState(
-                        field = element,
-                        form = form,
-                        scope = scope
-                    )
-                }
+        is RadioButtonsFormInput -> {
+            rememberRadioButtonFieldState(
+                field = element,
+                form = form,
+                scope = scope
+            )
+        }
 
-                else -> {
-                    null
-                }
-            }
-            if (state != null) {
-                stateMap[element.id] = state
-            }
+        else -> {
+            null
         }
     }
-    return stateMap
 }
 
 @Preview(showBackground = true, backgroundColor = 0xFFFFFF)
 @Composable
 private fun InitializingExpressionsPreview() {
     InitializingExpressions { false }
 }
-
-/**
- * Unique id for each form element.
- */
-internal val FieldFormElement.id: Int
-    get() {
-        return Objects.hash(fieldName, label, description, hint)
-    }
-
-/**
- * Unique id for each form element.
- */
-internal val GroupFormElement.id: Int
-    get() {
-        return Objects.hash(
-            formElements.forEach { if (it is FieldFormElement) it.id },
-            label,
-            description
-        )
-    }

toolkit/featureforms/src/main/java/com/arcgismaps/toolkit/featureforms/components/base/BaseGroupState.kt

@@ -30,7 +30,7 @@ internal class BaseGroupState(
     description: String,
     isVisible: StateFlow<Boolean>,
     expanded: Boolean,
-    val fieldStates: Map<Int, BaseFieldState<*>>
+    val fieldStates: FormStateCollection
 ) : FormElementState(
     label = label,
     description = description,
@@ -46,7 +46,7 @@ internal class BaseGroupState(
     companion object {
         fun Saver(
             groupElement: GroupFormElement,
-            fieldStates: Map<Int, BaseFieldState<*>>
+            fieldStates: FormStateCollection
         ): Saver<BaseGroupState, Boolean> = Saver(
             save = {
                 it.expanded.value
@@ -67,7 +67,7 @@ internal class BaseGroupState(
 @Composable
 internal fun rememberBaseGroupState(
     groupElement: GroupFormElement,
-    fieldStates: Map<Int, BaseFieldState<*>>
+    fieldStates: FormStateCollection
 ): BaseGroupState = rememberSaveable(
     saver = BaseGroupState.Saver(groupElement, fieldStates)
 ) {