add button states to task viewModels and add onclick listener handlers

Author: andreia-ferreira

app/src/main/java/org/groundplatform/android/ui/datacollection/DataCollectionViewModel.kt

@@ -205,7 +205,13 @@ internal constructor(
 
     viewModel?.let { created ->
       val taskData = if (shouldLoadFromDraft) getValueFromDraft(state.job, task) else null
-      created.initialize(state.job, task, taskData)
+      created.initialize(
+        job = state.job,
+        task = task,
+        taskData = taskData,
+        isFirstPosition = { isFirstPosition(task.id) },
+        isLastPosition = { isLastPositionWithValue(task, it) },
+      )
       updateDataAndInvalidateTasks(task, taskData)
       taskViewModels.value[task.id] = created
     }

app/src/main/java/org/groundplatform/android/ui/datacollection/tasks/AbstractMapTaskViewModel.kt

@@ -22,7 +22,7 @@ import org.groundplatform.android.model.map.CameraPosition
 import org.groundplatform.android.ui.common.BaseMapViewModel
 
 /** Defines the state of an inflated Map [Task] and controls its UI. */
-open class AbstractMapTaskViewModel internal constructor() : AbstractTaskViewModel() {
+abstract class AbstractMapTaskViewModel internal constructor() : AbstractTaskViewModel() {
 
   /** Allows control for triggering the location lock programmatically. */
   private val _enableLocationLockFlow = MutableStateFlow(LocationLockEnabledState.UNKNOWN)

app/src/main/java/org/groundplatform/android/ui/datacollection/tasks/AbstractTaskFragment.kt

@@ -240,14 +240,15 @@ abstract class AbstractTaskFragment<T : AbstractTaskViewModel> : AbstractFragmen
         Column(modifier = Modifier.fillMaxWidth()) {
           HeaderCard()
           Spacer(Modifier.height(12.dp))
-          ActionButtonsRow()
+          Footer()
         }
       } else {
-        ActionButtonsRow()
+        Footer()
       }
     }
   }
 
+  @Suppress("UnusedPrivateMember") // andreia: revert this later
   @Composable
   private fun ActionButtonsRow() {
     Row(
@@ -258,6 +259,33 @@ abstract class AbstractTaskFragment<T : AbstractTaskViewModel> : AbstractFragmen
     }
   }
 
+  @Composable
+  private fun Footer() {
+    val taskActionButtonsStates by viewModel.taskActionButtonStates.collectAsStateWithLifecycle()
+    Row(modifier = Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.SpaceBetween) {
+      taskActionButtonsStates.forEach { state ->
+        if (state.isVisible) { // andreia:review
+          org.groundplatform.android.ui.datacollection.components.refactor.TaskButton(
+            state = state,
+            onClick = { handleButtonClick(state.action) },
+          )
+        }
+      }
+    }
+  }
+
+  private fun handleButtonClick(action: ButtonAction) {
+    when (action) {
+      // Navigation actions
+      ButtonAction.PREVIOUS -> moveToPrevious()
+      ButtonAction.NEXT,
+      ButtonAction.DONE -> handleNext()
+      ButtonAction.SKIP -> onSkip()
+      // Task-specific actions - delegate to ViewModel
+      else -> viewModel.onButtonClick(action)
+    }
+  }
+
   // This function can allow any task to show a Header card on top of the Button row.
   open fun shouldShowHeader() = false
 

app/src/main/java/org/groundplatform/android/ui/datacollection/tasks/AbstractTaskViewModel.kt

@@ -23,21 +23,36 @@ import org.groundplatform.android.R
 import org.groundplatform.android.model.job.Job
 import org.groundplatform.android.model.submission.SkippedTaskData
 import org.groundplatform.android.model.submission.TaskData
+import org.groundplatform.android.model.submission.isNotNullOrEmpty
 import org.groundplatform.android.model.submission.isNullOrEmpty
 import org.groundplatform.android.model.task.Task
 import org.groundplatform.android.ui.common.AbstractViewModel
+import org.groundplatform.android.ui.datacollection.components.ButtonAction
+import org.groundplatform.android.ui.datacollection.components.refactor.ButtonActionState
 
 /** Defines the state of an inflated [Task] and controls its UI. */
-open class AbstractTaskViewModel internal constructor() : AbstractViewModel() {
+abstract class AbstractTaskViewModel internal constructor() : AbstractViewModel() {
 
   /** Current value. */
   private val _taskDataFlow: MutableStateFlow<TaskData?> = MutableStateFlow(null)
   val taskTaskData: StateFlow<TaskData?> = _taskDataFlow.asStateFlow()
 
+  abstract val taskActionButtonStates: StateFlow<List<ButtonActionState>>
+
   lateinit var task: Task
+  private lateinit var isFirstPosition: () -> Boolean
+  private lateinit var isLastPositionWithValue: (TaskData?) -> Boolean
 
-  open fun initialize(job: Job, task: Task, taskData: TaskData?) {
+  open fun initialize(
+    job: Job,
+    task: Task,
+    taskData: TaskData?,
+    isFirstPosition: () -> Boolean,
+    isLastPosition: (TaskData?) -> Boolean,
+  ) {
     this.task = task
+    this.isFirstPosition = isFirstPosition
+    this.isLastPositionWithValue = isLastPosition
     setValue(taskData)
   }
 
@@ -74,4 +89,50 @@ open class AbstractTaskViewModel internal constructor() : AbstractViewModel() {
   fun isTaskOptional(): Boolean = !task.isRequired
 
   fun hasNoData(): Boolean = taskTaskData.value.isNullOrEmpty()
+
+  fun getPreviousButtonState(): ButtonActionState =
+    ButtonActionState(
+      action = ButtonAction.PREVIOUS,
+      isEnabled = !isFirstPosition(),
+      isVisible = true,
+    )
+
+  fun getNextButtonState(taskData: TaskData?, hideIfEmpty: Boolean = false): ButtonActionState {
+    val isVisible = if (hideIfEmpty) taskData.isNotNullOrEmpty() else true
+    return if (isLastPositionWithValue(taskData)) {
+      ButtonActionState(
+        action = ButtonAction.DONE,
+        isEnabled = taskData.isNotNullOrEmpty(),
+        isVisible = isVisible,
+      )
+    } else {
+      ButtonActionState(
+        action = ButtonAction.NEXT,
+        isEnabled = taskData.isNotNullOrEmpty(),
+        isVisible = isVisible,
+      )
+    }
+  }
+
+  fun getSkipButtonState(taskData: TaskData?): ButtonActionState =
+    ButtonActionState(
+      action = ButtonAction.SKIP,
+      isEnabled = isTaskOptional(),
+      isVisible = isTaskOptional() && taskData.isNullOrEmpty(),
+    )
+
+  fun getUndoButtonState(taskData: TaskData?): ButtonActionState =
+    ButtonActionState(
+      action = ButtonAction.UNDO,
+      isEnabled = taskData.isNotNullOrEmpty(),
+      isVisible = taskData.isNotNullOrEmpty(),
+    )
+
+  open fun onButtonClick(action: ButtonAction) {
+    if (action == ButtonAction.UNDO) {
+      clearResponse()
+    } else {
+      // Subclasses handle other actions
+    }
+  }
 }

app/src/main/java/org/groundplatform/android/ui/datacollection/tasks/date/DateTaskViewModel.kt

@@ -15,12 +15,23 @@
  */
 package org.groundplatform.android.ui.datacollection.tasks.date
 
+import androidx.lifecycle.viewModelScope
 import java.util.Date
 import javax.inject.Inject
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.stateIn
 import org.groundplatform.android.model.submission.DateTimeTaskData.Companion.fromMillis
+import org.groundplatform.android.ui.datacollection.components.refactor.ButtonActionState
 import org.groundplatform.android.ui.datacollection.tasks.AbstractTaskViewModel
 
 class DateTaskViewModel @Inject constructor() : AbstractTaskViewModel() {
+  override val taskActionButtonStates: StateFlow<List<ButtonActionState>> by lazy {
+    taskTaskData
+      .map { listOf(getPreviousButtonState(), getSkipButtonState(it), getNextButtonState(it)) }
+      .stateIn(viewModelScope, SharingStarted.Lazily, emptyList())
+  }
 
   fun updateResponse(date: Date) {
     setValue(fromMillis(date.time))

app/src/main/java/org/groundplatform/android/ui/datacollection/tasks/instruction/InstructionTaskViewModel.kt

@@ -15,8 +15,20 @@
  */
 package org.groundplatform.android.ui.datacollection.tasks.instruction
 
+import androidx.lifecycle.viewModelScope
 import javax.inject.Inject
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.stateIn
+import org.groundplatform.android.ui.datacollection.components.refactor.ButtonActionState
 import org.groundplatform.android.ui.datacollection.tasks.AbstractTaskViewModel
 
 @Suppress("EmptyClassBlock")
-class InstructionTaskViewModel @Inject constructor() : AbstractTaskViewModel() {}
+class InstructionTaskViewModel @Inject constructor() : AbstractTaskViewModel() {
+  override val taskActionButtonStates: StateFlow<List<ButtonActionState>> by lazy {
+    taskTaskData
+      .map { listOf(getPreviousButtonState(), getNextButtonState(it)) }
+      .stateIn(viewModelScope, SharingStarted.Lazily, emptyList())
+  }
+}

app/src/main/java/org/groundplatform/android/ui/datacollection/tasks/location/CaptureLocationTaskViewModel.kt

@@ -16,15 +16,26 @@
 package org.groundplatform.android.ui.datacollection.tasks.location
 
 import android.location.Location
+import androidx.lifecycle.viewModelScope
 import javax.inject.Inject
+import kotlin.lazy
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.flow.update
 import org.groundplatform.android.common.Constants.ACCURACY_THRESHOLD_IN_M
 import org.groundplatform.android.model.geometry.Point
 import org.groundplatform.android.model.submission.CaptureLocationTaskData
+import org.groundplatform.android.model.submission.TaskData
+import org.groundplatform.android.model.submission.isNullOrEmpty
+import org.groundplatform.android.ui.datacollection.components.ButtonAction
+import org.groundplatform.android.ui.datacollection.components.refactor.ButtonActionState
 import org.groundplatform.android.ui.datacollection.tasks.AbstractMapTaskViewModel
 import org.groundplatform.android.ui.datacollection.tasks.LocationLockEnabledState
 import org.groundplatform.android.ui.map.gms.getAccuracyOrNull
@@ -42,6 +53,20 @@ class CaptureLocationTaskViewModel @Inject constructor() : AbstractMapTaskViewMo
       location != null && accuracy <= ACCURACY_THRESHOLD_IN_M
     }
 
+  override val taskActionButtonStates: StateFlow<List<ButtonActionState>> by lazy {
+    combine(isCaptureEnabled, taskTaskData) { captureEnabled, taskData ->
+        listOf(
+          getPreviousButtonState(),
+          getSkipButtonState(taskData),
+          getUndoButtonState(taskData),
+          getCaptureLocationButtonState(captureEnabled, taskData),
+          getNextButtonState(taskData, hideIfEmpty = true),
+        )
+      }
+      .distinctUntilChanged()
+      .stateIn(viewModelScope, SharingStarted.Lazily, emptyList())
+  }
+
   fun updateLocation(location: Location) {
     _lastLocation.update { location }
   }
@@ -64,4 +89,22 @@ class CaptureLocationTaskViewModel @Inject constructor() : AbstractMapTaskViewMo
       )
     }
   }
+
+  private fun getCaptureLocationButtonState(
+    captureEnabled: Boolean,
+    taskData: TaskData?,
+  ): ButtonActionState =
+    ButtonActionState(
+      action = ButtonAction.CAPTURE_LOCATION,
+      isEnabled = captureEnabled,
+      isVisible = taskData.isNullOrEmpty(),
+    )
+
+  override fun onButtonClick(action: ButtonAction) {
+    if (action == ButtonAction.CAPTURE_LOCATION) {
+      updateResponse()
+    } else {
+      super.onButtonClick(action)
+    }
+  }
 }

app/src/main/java/org/groundplatform/android/ui/datacollection/tasks/multiplechoice/MultipleChoiceTaskViewModel.kt

@@ -15,9 +15,13 @@
  */
 package org.groundplatform.android.ui.datacollection.tasks.multiplechoice
 
+import androidx.lifecycle.viewModelScope
 import javax.inject.Inject
 import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.flow.update
 import org.groundplatform.android.R
 import org.groundplatform.android.common.Constants
@@ -28,18 +32,31 @@ import org.groundplatform.android.model.submission.TaskData
 import org.groundplatform.android.model.task.MultipleChoice.Cardinality.SELECT_MULTIPLE
 import org.groundplatform.android.model.task.Option
 import org.groundplatform.android.model.task.Task
+import org.groundplatform.android.ui.datacollection.components.refactor.ButtonActionState
 import org.groundplatform.android.ui.datacollection.tasks.AbstractTaskViewModel
 
 class MultipleChoiceTaskViewModel @Inject constructor() : AbstractTaskViewModel() {
 
+  override val taskActionButtonStates: StateFlow<List<ButtonActionState>> by lazy {
+    taskTaskData
+      .map { listOf(getPreviousButtonState(), getSkipButtonState(it), getNextButtonState(it)) }
+      .stateIn(viewModelScope, SharingStarted.Lazily, emptyList())
+  }
+
   private val _items: MutableStateFlow<List<MultipleChoiceItem>> = MutableStateFlow(emptyList())
   val items: StateFlow<List<MultipleChoiceItem>> = _items
 
   private val selectedIds: MutableSet<String> = mutableSetOf()
   private var otherText: String = ""
 
-  override fun initialize(job: Job, task: Task, taskData: TaskData?) {
-    super.initialize(job, task, taskData)
+  override fun initialize(
+    job: Job,
+    task: Task,
+    taskData: TaskData?,
+    isFirstPosition: () -> Boolean,
+    isLastPosition: (TaskData?) -> Boolean,
+  ) {
+    super.initialize(job, task, taskData, isFirstPosition, isLastPosition)
     loadPendingSelections()
     updateMultipleChoiceItems()
   }

app/src/main/java/org/groundplatform/android/ui/datacollection/tasks/number/NumberTaskViewModel.kt

@@ -17,15 +17,26 @@ package org.groundplatform.android.ui.datacollection.tasks.number
 
 import androidx.lifecycle.LiveData
 import androidx.lifecycle.asLiveData
+import androidx.lifecycle.viewModelScope
 import javax.inject.Inject
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.filterIsInstance
 import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.stateIn
 import org.groundplatform.android.model.submission.NumberTaskData
 import org.groundplatform.android.model.submission.TaskData
+import org.groundplatform.android.ui.datacollection.components.refactor.ButtonActionState
 import org.groundplatform.android.ui.datacollection.tasks.AbstractTaskViewModel
 
 class NumberTaskViewModel @Inject constructor() : AbstractTaskViewModel() {
 
+  override val taskActionButtonStates: StateFlow<List<ButtonActionState>> by lazy {
+    taskTaskData
+      .map { listOf(getPreviousButtonState(), getSkipButtonState(it), getNextButtonState(it)) }
+      .stateIn(viewModelScope, SharingStarted.Lazily, emptyList())
+  }
+
   /** Transcoded text to be displayed for the current [TaskData]. */
   val responseText: LiveData<String> =
     taskTaskData.filterIsInstance<NumberTaskData?>().map { it?.number ?: "" }.asLiveData()

app/src/main/java/org/groundplatform/android/ui/datacollection/tasks/photo/PhotoTaskViewModel.kt

@@ -22,20 +22,37 @@ import androidx.lifecycle.viewModelScope
 import java.io.IOException
 import javax.inject.Inject
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.filterIsInstance
 import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 import org.groundplatform.android.data.remote.firebase.FirebaseStorageManager
 import org.groundplatform.android.model.submission.PhotoTaskData
 import org.groundplatform.android.model.submission.isNotNullOrEmpty
 import org.groundplatform.android.repository.UserMediaRepository
+import org.groundplatform.android.ui.datacollection.components.refactor.ButtonActionState
 import org.groundplatform.android.ui.datacollection.tasks.AbstractTaskViewModel
 import timber.log.Timber
 
 class PhotoTaskViewModel @Inject constructor(private val userMediaRepository: UserMediaRepository) :
   AbstractTaskViewModel() {
 
+  override val taskActionButtonStates: StateFlow<List<ButtonActionState>> by lazy {
+    taskTaskData
+      .map {
+        listOf(
+          getPreviousButtonState(),
+          getUndoButtonState(it),
+          getSkipButtonState(it),
+          getNextButtonState(it),
+        )
+      }
+      .stateIn(viewModelScope, SharingStarted.Lazily, emptyList())
+  }
+
   /**
    * Task id waiting for a photo result. As only one photo result is returned at a time, we can
    * directly map it 1:1 with the task waiting for a photo result.