Use LocationTracker to schedule location recording

geo/src/main/java/org/odk/collect/geo/geopoly/GeoPolyFragment.kt

@@ -39,10 +39,6 @@ import org.odk.collect.maps.layers.OfflineMapLayersPickerBottomSheetDialogFragme
 import org.odk.collect.maps.layers.ReferenceLayerRepository
 import org.odk.collect.settings.SettingsProvider
 import org.odk.collect.webpage.WebPageService
-import java.util.concurrent.Executors
-import java.util.concurrent.ScheduledExecutorService
-import java.util.concurrent.ScheduledFuture
-import java.util.concurrent.TimeUnit
 import javax.inject.Inject
 
 class GeoPolyFragment @JvmOverloads constructor(
@@ -73,9 +69,6 @@ class GeoPolyFragment @JvmOverloads constructor(
     lateinit var webPageService: WebPageService
 
     private var previousState: Bundle? = null
-    private val executorServiceScheduler: ScheduledExecutorService =
-        Executors.newSingleThreadScheduledExecutor()
-    private var schedulerHandler: ScheduledFuture<*>? = null
 
     private var map: MapFragment? = null
     private var featureId = -1 // will be a positive featureId once map is ready
@@ -105,7 +98,7 @@ class GeoPolyFragment @JvmOverloads constructor(
     private val viewModel: GeoPolyViewModel by viewModels {
         viewModelFactory {
             addInitializer(GeoPolyViewModel::class) {
-                GeoPolyViewModel(outputMode, inputPolygon)
+                GeoPolyViewModel(outputMode, inputPolygon, locationTracker)
             }
         }
     }
@@ -188,28 +181,13 @@ class GeoPolyFragment @JvmOverloads constructor(
         state.putInt(ACCURACY_THRESHOLD_INDEX_KEY, accuracyThresholdIndex)
     }
 
-    override fun onDestroy() {
-        schedulerHandler?.let {
-            if (!it.isCancelled) {
-                it.cancel(true)
-            }
-        }
-
-        locationTracker.stop()
-        super.onDestroy()
-    }
-
     fun initMap(newMapFragment: MapFragment?, binding: GeopolyLayoutBinding) {
         map = newMapFragment
 
         binding.clear.setOnClickListener { showClearDialog() }
         binding.pause.setOnClickListener {
+            viewModel.stopRecording()
             inputActive = false
-            try {
-                schedulerHandler?.cancel(true)
-            } catch (_: Exception) {
-                // Do nothing
-            }
             updateUi()
         }
 
@@ -336,28 +314,10 @@ class GeoPolyFragment @JvmOverloads constructor(
     override fun startInput() {
         inputActive = true
         if (recordingEnabled && recordingAutomatic) {
-            locationTracker.start(retainMockAccuracy)
-
-            recordPoint(map!!.getGpsLocation())
-            schedulerHandler = executorServiceScheduler.scheduleAtFixedRate(
-                {
-                    requireActivity().runOnUiThread {
-                        val currentLocation = locationTracker.getCurrentLocation()
-                        if (currentLocation != null) {
-                            val currentMapPoint = MapPoint(
-                                currentLocation.latitude,
-                                currentLocation.longitude,
-                                currentLocation.altitude,
-                                currentLocation.accuracy.toDouble()
-                            )
-
-                            recordPoint(currentMapPoint)
-                        }
-                    }
-                },
-                INTERVAL_OPTIONS[intervalIndex].toLong(),
-                INTERVAL_OPTIONS[intervalIndex].toLong(),
-                TimeUnit.SECONDS
+            viewModel.startRecording(
+                retainMockAccuracy,
+                ACCURACY_THRESHOLD_OPTIONS[accuracyThresholdIndex],
+                INTERVAL_OPTIONS[intervalIndex].toLong() * 1000
             )
         }
         updateUi()

geo/src/main/java/org/odk/collect/geo/geopoly/GeoPolyViewModel.kt

@@ -1,13 +1,19 @@
 package org.odk.collect.geo.geopoly
 
 import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.launch
 import org.odk.collect.geo.geopoly.GeoPolyFragment.OutputMode
+import org.odk.collect.location.tracker.LocationTracker
 import org.odk.collect.maps.MapPoint
-import kotlin.collections.plus
 
-class GeoPolyViewModel(outputMode: OutputMode, points: List<MapPoint>) :
+class GeoPolyViewModel(
+    outputMode: OutputMode,
+    points: List<MapPoint>,
+    private val locationTracker: LocationTracker
+) :
     ViewModel() {
 
     private val _points = MutableStateFlow(
@@ -22,6 +28,29 @@ class GeoPolyViewModel(outputMode: OutputMode, points: List<MapPoint>) :
         }
     )
     val points: StateFlow<List<MapPoint>> = _points
+    private var accuracyThreshold: Int = 0
+
+    init {
+        viewModelScope.launch {
+            locationTracker.getLocation().collect {
+                if (it != null) {
+                    accuracyThreshold.let { threshold ->
+                        if (threshold == 0 || it.accuracy <= threshold) {
+                            add(
+                                MapPoint(
+                                    it.latitude,
+                                    it.longitude,
+                                    it.altitude,
+                                    it.accuracy.toDouble()
+                                )
+                            )
+                        }
+                    }
+
+                }
+            }
+        }
+    }
 
     fun add(point: MapPoint) {
         val points = _points.value
@@ -37,4 +66,17 @@ class GeoPolyViewModel(outputMode: OutputMode, points: List<MapPoint>) :
     fun update(points: List<MapPoint>) {
         _points.value = points
     }
+
+    fun startRecording(retainMockAccuracy: Boolean, accuracyThreshold: Int, interval: Long) {
+        this.accuracyThreshold = accuracyThreshold
+        locationTracker.start(retainMockAccuracy, interval)
+    }
+
+    fun stopRecording() {
+        locationTracker.stop()
+    }
+
+    override fun onCleared() {
+        locationTracker.stop()
+    }
 }

geo/src/test/java/org/odk/collect/geo/geopoly/GeoPolyFragmentTest.kt

@@ -22,6 +22,8 @@ import org.junit.Rule
 import org.junit.Test
 import org.junit.runner.RunWith
 import org.mockito.Mockito
+import org.mockito.kotlin.any
+import org.mockito.kotlin.eq
 import org.mockito.kotlin.mock
 import org.mockito.kotlin.verify
 import org.odk.collect.androidshared.ui.FragmentFactoryBuilder
@@ -358,7 +360,7 @@ class GeoPolyFragmentTest {
         }
 
         startInput(R.id.automatic_mode)
-        verify(locationTracker).start(true)
+        verify(locationTracker).start(eq(true), any())
     }
 
     @Test
@@ -374,7 +376,7 @@ class GeoPolyFragmentTest {
         }
 
         startInput(R.id.automatic_mode)
-        verify(locationTracker).start(false)
+        verify(locationTracker).start(eq(false), any())
     }
 
     @Test

location/src/main/java/org/odk/collect/location/tracker/ForegroundServiceLocationTracker.kt

@@ -86,7 +86,7 @@ class LocationTrackerService : Service(), LocationClient.LocationClientListener
             val interval = intent.getLongExtra(EXTRA_UPDATE_INTERVAL, -1)
             locationClient.setUpdateIntervals(
                 interval,
-                interval / 2
+                interval
             )
         }
 

location/src/test/java/org/odk/collect/location/tracker/ForegroundServiceLocationTrackerTest.kt

@@ -78,7 +78,7 @@ class ForegroundServiceLocationTrackerTest : LocationTrackerTest() {
         locationTracker.start(updateInterval = 1000)
         runBackground()
 
-        assertThat(locationClient.getUpdateIntervals(), equalTo(Pair(1000L, 500L)))
+        assertThat(locationClient.getUpdateIntervals(), equalTo(Pair(1000L, 1000L)))
     }
 
     @Test
@@ -90,7 +90,7 @@ class ForegroundServiceLocationTrackerTest : LocationTrackerTest() {
         runBackground()
 
         assertThat(locationClient.getRetainMockAccuracy(), equalTo(true))
-        assertThat(locationClient.getUpdateIntervals(), equalTo(Pair(2000L, 1000L)))
+        assertThat(locationClient.getUpdateIntervals(), equalTo(Pair(2000L, 2000L)))
     }
 }