Fix issue 3541, Can't complete polygon after getting an interception error popup

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

@@ -50,11 +50,13 @@ class PhotoTaskViewModel @Inject constructor(private val userMediaRepository: Us
 
   val showPermissionDeniedDialog = mutableStateOf(false)
 
-  val uri: Flow<Uri> = taskTaskData.map { taskData ->
-    if (taskData is PhotoTaskData && taskData.isNotNullOrEmpty()) {
-      userMediaRepository.getDownloadUrl(taskData.remoteFilename)
-    } else {
-      Uri.EMPTY
+  val uri: Flow<Uri> =
+    taskTaskData.map { taskData ->
+      if (taskData is PhotoTaskData && taskData.isNotNullOrEmpty()) {
+        userMediaRepository.getDownloadUrl(taskData.remoteFilename)
+      } else {
+        Uri.EMPTY
+      }
     }
   }
 

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

@@ -19,9 +19,9 @@ import android.view.LayoutInflater
 import android.widget.Toast
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
-import androidx.compose.runtime.setValue
 import androidx.compose.ui.viewinterop.AndroidView
 import androidx.core.os.bundleOf
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import androidx.lifecycle.lifecycleScope
 import dagger.hilt.android.AndroidEntryPoint
 import javax.inject.Inject
@@ -53,7 +53,8 @@ class DrawAreaTaskFragment @Inject constructor() : AbstractTaskFragment<DrawArea
 
   @Composable
   override fun TaskBody() {
-    var showSelfIntersectionDialog by viewModel.showSelfIntersectionDialog
+    val showSelfIntersectionDialog by
+      viewModel.showSelfIntersectionDialog.collectAsStateWithLifecycle()
 
     AndroidView(
       factory = { context ->
@@ -86,7 +87,8 @@ class DrawAreaTaskFragment @Inject constructor() : AbstractTaskFragment<DrawArea
         description = R.string.polygon_vertex_add_dialog_message,
         confirmButtonText = R.string.polygon_vertex_add_dialog_positive_button,
         dismissButtonText = null,
-        onConfirmClicked = { showSelfIntersectionDialog = false },
+        onConfirmClicked = { viewModel.dismissSelfIntersectionDialog() },
+        onDismiss = { viewModel.dismissSelfIntersectionDialog() },
       )
     }
   }

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

@@ -140,24 +140,28 @@ internal constructor(
   private val _isTooClose = MutableStateFlow(false)
   val isTooClose: StateFlow<Boolean> = _isTooClose.asStateFlow()
 
-  val showSelfIntersectionDialog = mutableStateOf(false)
+  private val _showSelfIntersectionDialog = MutableStateFlow(false)
+  val showSelfIntersectionDialog: StateFlow<Boolean> = _showSelfIntersectionDialog.asStateFlow()
 
-  var hasSelfIntersection: Boolean = false
-    private set
+  private val _hasSelfIntersection = MutableStateFlow(false)
+  val hasSelfIntersection: StateFlow<Boolean> = _hasSelfIntersection.asStateFlow()
 
   private lateinit var featureStyle: Feature.Style
   lateinit var measurementUnits: MeasurementUnits
 
   override val taskActionButtonStates: StateFlow<List<ButtonActionState>> by lazy {
-    combine(taskTaskData, merge(draftArea, draftUpdates)) { taskData, currentFeature ->
+    combine(taskTaskData, merge(draftArea, draftUpdates), hasSelfIntersection) {
+        taskData,
+        currentFeature,
+        intersected ->
         val isClosed = (currentFeature?.geometry as? LineString)?.isClosed() ?: false
         listOfNotNull(
           getPreviousButton(),
           getSkipButton(taskData),
           getUndoButton(taskData, true),
           getRedoButton(taskData),
           getAddPointButton(isClosed, isTooClose.value),
-          getCompleteButton(isClosed, isMarkedComplete.value, hasSelfIntersection),
+          getCompleteButton(isClosed, isMarkedComplete.value, intersected),
           getNextButton(taskData).takeIf { isMarkedComplete() },
         )
       }
@@ -202,8 +206,13 @@ internal constructor(
 
   @VisibleForTesting fun getLastVertex() = vertices.lastOrNull()
 
-  private fun onSelfIntersectionDetected() {
-    showSelfIntersectionDialog.value = true
+  private fun showSelfIntersectionDialog() {
+    _showSelfIntersectionDialog.value = true
+  }
+
+  fun dismissSelfIntersectionDialog() {
+    _showSelfIntersectionDialog.value = false
+    resetHasSelfIntersection()
   }
 
   /**
@@ -319,12 +328,12 @@ internal constructor(
   }
 
   private fun checkVertexIntersection(): Boolean {
-    hasSelfIntersection = isSelfIntersecting(vertices)
-    if (hasSelfIntersection) {
-      vertices = vertices.dropLast(1)
-      onSelfIntersectionDetected()
+    _hasSelfIntersection.value = isSelfIntersecting(vertices)
+    if (_hasSelfIntersection.value) {
+      updateVertices(vertices.dropLast(1))
+      showSelfIntersectionDialog()
     }
-    return hasSelfIntersection
+    return _hasSelfIntersection.value
   }
 
   private fun validatePolygonCompletion(): Boolean {
@@ -339,9 +348,9 @@ internal constructor(
         vertices
       }
 
-    hasSelfIntersection = isSelfIntersecting(ring)
-    if (hasSelfIntersection) {
-      onSelfIntersectionDetected()
+    _hasSelfIntersection.value = isSelfIntersecting(ring)
+    if (_hasSelfIntersection.value) {
+      showSelfIntersectionDialog()
       return false
     }
     return true
@@ -352,6 +361,10 @@ internal constructor(
     refreshMap()
   }
 
+  fun resetHasSelfIntersection() {
+    _hasSelfIntersection.value = false
+  }
+
   @VisibleForTesting
   fun completePolygon() {
     check(LineString(vertices).isClosed()) { "Polygon is not complete" }

app/src/test/java/org/groundplatform/android/ui/datacollection/tasks/polygon/DrawAreaTaskViewModelTest.kt

@@ -29,12 +29,17 @@ import kotlin.test.assertEquals
 import kotlin.test.assertFalse
 import kotlin.test.assertNotNull
 import kotlin.test.assertTrue
+import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.filterNotNull
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.merge
+import kotlinx.coroutines.test.UnconfinedTestDispatcher
 import kotlinx.coroutines.test.advanceUntilIdle
+import kotlinx.coroutines.test.resetMain
+import kotlinx.coroutines.test.runTest
+import kotlinx.coroutines.test.setMain
 import org.groundplatform.android.BaseHiltTest
 import org.groundplatform.android.data.local.LocalValueStore
 import org.groundplatform.android.model.job.Job
@@ -53,6 +58,7 @@ import org.groundplatform.domain.model.geometry.Coordinates
 import org.groundplatform.domain.model.geometry.LineString
 import org.groundplatform.domain.model.geometry.LinearRing
 import org.groundplatform.domain.model.geometry.Polygon
+import org.junit.After
 import org.junit.Assert.assertThrows
 import org.junit.Test
 import org.junit.runner.RunWith
@@ -72,6 +78,7 @@ class DrawAreaTaskViewModelTest : BaseHiltTest() {
 
   override fun setUp() {
     super.setUp()
+    Dispatchers.setMain(UnconfinedTestDispatcher())
     mergedFeatureFlow = merge(viewModel.draftArea.filterNotNull(), viewModel.draftUpdates)
 
     mergedFeatureLiveData = mergedFeatureFlow.asLiveData()
@@ -620,6 +627,95 @@ class DrawAreaTaskViewModelTest : BaseHiltTest() {
     assertThat(viewModel.isMarkedComplete()).isTrue()
   }
 
+  @Test
+  fun `checkVertexIntersection sets hasSelfIntersection and showSelfIntersectionDialog to true`() =
+    runWithTestDispatcher {
+      setupViewModel()
+
+      // Create a path: (0,0) -> (10,10) -> (0,10)
+      updateLastVertexAndAdd(COORDINATE_1)
+      updateLastVertexAndAdd(COORDINATE_2)
+      updateLastVertexAndAdd(COORDINATE_6)
+
+      // Move cursor to a point that crosses the first segment: (10,0)
+      updateLastVertex(COORDINATE_5)
+
+      // Trigger ADD_POINT which calls checkVertexIntersection
+      viewModel.onButtonClick(ButtonAction.ADD_POINT)
+      advanceUntilIdle()
+
+      assertThat(viewModel.hasSelfIntersection.value).isTrue()
+      assertThat(viewModel.showSelfIntersectionDialog.value).isTrue()
+      // offending vertex should be dropped
+      assertGeometry(4, isLineString = true)
+    }
+
+  @Test
+  fun `dismissSelfIntersectionDialog resets both flag and dialog visibility`() =
+    runWithTestDispatcher {
+      setupViewModel()
+
+      // Force an intersection state
+      updateLastVertexAndAdd(COORDINATE_1)
+      updateLastVertexAndAdd(COORDINATE_2)
+      updateLastVertexAndAdd(COORDINATE_6)
+      updateLastVertex(COORDINATE_5)
+      viewModel.onButtonClick(ButtonAction.ADD_POINT)
+      advanceUntilIdle()
+
+      viewModel.dismissSelfIntersectionDialog()
+      assertThat(viewModel.hasSelfIntersection.value).isFalse()
+      assertThat(viewModel.showSelfIntersectionDialog.value).isFalse()
+    }
+
+  @Test
+  fun `taskActionButtonStates re-enables COMPLETE button after intersection is dismissed`() =
+    runTest(UnconfinedTestDispatcher()) { // Use Unconfined to trigger emissions immediately
+      setupViewModel()
+
+      viewModel.taskActionButtonStates.test {
+        // 1. Initial State: Create a closed non-intersecting square
+        updateLastVertexAndAdd(COORDINATE_1)
+        updateLastVertexAndAdd(COORDINATE_2)
+        updateLastVertexAndAdd(COORDINATE_3)
+        // Set state to be near first vertex to enable COMPLETE
+        updateLastVertex(COORDINATE_1, isNearFirstVertex = true)
+
+        // 2. Trigger Intersection Logic
+        // Clear state (Simulated)
+        while (viewModel.getLastVertex() != null) {
+          viewModel.removeLastVertex()
+        }
+
+        updateLastVertexAndAdd(COORDINATE_1)
+        updateLastVertexAndAdd(COORDINATE_2)
+        updateLastVertexAndAdd(COORDINATE_6)
+        updateLastVertexAndAdd(COORDINATE_5)
+        updateLastVertex(COORDINATE_1, isNearFirstVertex = true)
+
+        // Trigger validation
+        viewModel.onButtonClick(ButtonAction.COMPLETE)
+
+        // 3. Assert: Button should eventually become disabled due to intersection
+        // We look for the emission where COMPLETE is disabled
+        expectMostRecentItem().let { latestStates ->
+          val completeAction = latestStates.find { it.action == ButtonAction.COMPLETE }
+          assertThat(completeAction?.isEnabled).isFalse()
+        }
+
+        // 4. Act: Dismiss and Verify
+        viewModel.dismissSelfIntersectionDialog()
+
+        // 5. Assert: Button is enabled again
+        expectMostRecentItem().let { latestStates ->
+          val completeAction = latestStates.find { it.action == ButtonAction.COMPLETE }
+          assertThat(completeAction?.isEnabled).isTrue()
+        }
+
+        cancelAndIgnoreRemainingEvents()
+      }
+    }
+
   private fun assertGeometry(
     expectedVerticesCount: Int,
     isLineString: Boolean = false,
@@ -679,6 +775,8 @@ class DrawAreaTaskViewModelTest : BaseHiltTest() {
     private val COORDINATE_2 = Coordinates(10.0, 10.0)
     private val COORDINATE_3 = Coordinates(20.0, 20.0)
     private val COORDINATE_4 = Coordinates(30.0, 30.0)
+    private val COORDINATE_5 = Coordinates(10.0, 0.0)
+    private val COORDINATE_6 = Coordinates(0.0, 10.0)
 
     private val TASK =
       Task(
@@ -690,4 +788,9 @@ class DrawAreaTaskViewModelTest : BaseHiltTest() {
       )
     private val JOB = Job("job", Style("#112233"))
   }
+
+  @After
+  fun tearDown() {
+    Dispatchers.resetMain()
+  }
 }