Use geojson source for paths

Signed-off-by: Kyle Corry <kylecorry31@gmail.com>

Author: kylecorry31

app/src/main/java/com/kylecorry/trail_sense/tools/map/ui/MapToolLayerManager.kt

@@ -39,7 +39,6 @@ import com.kylecorry.trail_sense.tools.beacons.map_layers.BeaconLayerManager
 import com.kylecorry.trail_sense.tools.navigation.infrastructure.Navigator
 import com.kylecorry.trail_sense.tools.navigation.map_layers.NavigationLayer
 import com.kylecorry.trail_sense.tools.navigation.map_layers.NavigationLayerManager
-import com.kylecorry.trail_sense.tools.paths.map_layers.LegacyPathLayer
 import com.kylecorry.trail_sense.tools.paths.map_layers.PathLayer
 import com.kylecorry.trail_sense.tools.paths.map_layers.PathLayerManager
 import com.kylecorry.trail_sense.tools.photo_maps.infrastructure.tiles.PhotoMapRegionLoader
@@ -167,7 +166,6 @@ class MapToolLayerManager {
         layerManager = MultiLayerManager(
             listOfNotNull(
                 if (prefs.map.pathLayer.isEnabled.get()) PathLayerManager(
-                    context,
                     pathLayer
                 ) else null,
                 if (prefs.map.myLocationLayer.isEnabled.get()) MyLocationLayerManager(

app/src/main/java/com/kylecorry/trail_sense/tools/navigation/ui/layers/NavigationCompassLayerManager.kt

@@ -97,7 +97,7 @@ class NavigationCompassLayerManager {
 
         layerManager = MultiLayerManager(
             listOfNotNull(
-                if (isPathLayerEnabled) PathLayerManager(context, pathLayer) else null,
+                if (isPathLayerEnabled) PathLayerManager(pathLayer) else null,
                 if (isMyLocationLayerEnabled) MyLocationLayerManager(
                     myLocationLayer,
                     Color.WHITE,

app/src/main/java/com/kylecorry/trail_sense/tools/paths/map_layers/PathGeoJsonSource.kt

@@ -1,22 +1,49 @@
 package com.kylecorry.trail_sense.tools.paths.map_layers
 
+import android.content.Context
+import com.kylecorry.andromeda.core.cache.AppServiceRegistry
 import com.kylecorry.andromeda.geojson.GeoJsonFeature
 import com.kylecorry.andromeda.geojson.GeoJsonFeatureCollection
 import com.kylecorry.andromeda.geojson.GeoJsonObject
 import com.kylecorry.sol.science.geology.CoordinateBounds
 import com.kylecorry.trail_sense.shared.extensions.lineString
 import com.kylecorry.trail_sense.shared.map_layers.ui.layers.geojson.sources.GeoJsonSource
-import com.kylecorry.trail_sense.tools.navigation.ui.IMappablePath
+import com.kylecorry.trail_sense.tools.paths.domain.Path
+import com.kylecorry.trail_sense.tools.paths.infrastructure.PathLoader
+import com.kylecorry.trail_sense.tools.paths.infrastructure.persistence.PathService
+import com.kylecorry.trail_sense.tools.paths.ui.asMappable
+import kotlinx.coroutines.flow.first
 
 class PathGeoJsonSource : GeoJsonSource {
 
-    var paths: List<IMappablePath> = emptyList()
+    private val context = AppServiceRegistry.get<Context>()
+    private val pathService = AppServiceRegistry.get<PathService>()
+    private val pathLoader = PathLoader(pathService)
+    private var paths = emptyList<Path>()
+    private var loaded = false
 
     override suspend fun load(
         bounds: CoordinateBounds,
         metersPerPixel: Float
     ): GeoJsonObject? {
-        return GeoJsonFeatureCollection(paths.map {
+        // If paths haven't been loaded yet, load them
+        if (paths.isEmpty()) {
+            paths = pathService.getPaths().first().filter { it.style.visible }
+        }
+
+        pathLoader.update(paths, bounds, bounds, !loaded)
+        loaded = true
+
+        val points = pathLoader.getPointsWithBacktrack(context)
+
+        val mappablePaths = points.mapNotNull {
+            val path =
+                paths.firstOrNull { p -> p.id == it.key } ?: return@mapNotNull null
+
+            it.value.asMappable(context, path)
+        }
+
+        return GeoJsonFeatureCollection(mappablePaths.map {
             GeoJsonFeature.lineString(
                 it.points.map { point -> point.coordinate },
                 it.id,
@@ -27,4 +54,9 @@ class PathGeoJsonSource : GeoJsonSource {
             )
         })
     }
+    
+    fun reload() {
+        loaded = false
+        paths = emptyList()
+    }
 }

app/src/main/java/com/kylecorry/trail_sense/tools/paths/map_layers/PathLayer.kt

@@ -14,8 +14,8 @@ class PathLayer : GeoJsonLayer<PathGeoJsonSource>(PathGeoJsonSource()) {
         renderer.configureLineStringRenderer(shouldRenderWithDrawLines = shouldRenderWithDrawLines)
     }
 
-    fun setPaths(paths: List<IMappablePath>) {
-        source.paths = paths
+    fun reload() {
+        source.reload()
         invalidate()
     }
 }

app/src/main/java/com/kylecorry/trail_sense/tools/paths/map_layers/PathLayerManager.kt

@@ -1,106 +1,50 @@
 package com.kylecorry.trail_sense.tools.paths.map_layers
 
-import android.content.Context
-import com.kylecorry.andromeda.core.coroutines.onDefault
+import com.kylecorry.andromeda.core.cache.AppServiceRegistry
 import com.kylecorry.luna.coroutines.CoroutineQueueRunner
-import com.kylecorry.sol.science.geology.CoordinateBounds
 import com.kylecorry.sol.units.Coordinate
-import com.kylecorry.trail_sense.tools.paths.domain.Path
-import com.kylecorry.trail_sense.tools.paths.domain.PathPoint
-import com.kylecorry.trail_sense.tools.paths.domain.hiking.HikingService
-import com.kylecorry.trail_sense.tools.paths.infrastructure.PathLoader
-import com.kylecorry.trail_sense.tools.paths.infrastructure.persistence.PathService
-import com.kylecorry.trail_sense.tools.paths.ui.IPathLayer
-import com.kylecorry.trail_sense.tools.paths.ui.asMappable
 import com.kylecorry.trail_sense.shared.map_layers.ui.layers.BaseLayerManager
+import com.kylecorry.trail_sense.tools.paths.infrastructure.persistence.PathService
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.cancel
 import kotlinx.coroutines.launch
 
 class PathLayerManager(
-    private val context: Context,
-    private val layer: PathLayer,
-    private val shouldCorrectElevations: Boolean = false
+    private val layer: PathLayer
 ) :
     BaseLayerManager() {
 
-    private val pathService = PathService.Companion.getInstance(context)
-    private val hikingService = HikingService()
-    private val pathLoader = PathLoader(pathService)
-    private var paths = emptyList<Path>()
+    private val pathService = AppServiceRegistry.get<PathService>()
     private val scope = CoroutineScope(Dispatchers.Default)
-    private val loadRunner = CoroutineQueueRunner(2, scope)
     private val listenerRunner = CoroutineQueueRunner(scope = scope)
-    private var loaded = false
     private var wasBacktrackOn = false
 
+
     override fun start() {
-        loaded = false
         scope.launch {
             listenerRunner.skipIfRunning {
                 pathService.getPaths().collect {
-                    paths = it.filter { path -> path.style.visible }
                     wasBacktrackOn = pathService.getBacktrackPathId() != null
-                    loaded = false
-                    loadRunner.replace {
-                        loadPaths(true)
-                    }
+                    // Paths changed, so we need to reload the paths
+                    layer.reload()
                 }
             }
         }
     }
 
     override fun stop() {
         listenerRunner.cancel()
-        loadRunner.cancel()
         scope.cancel()
     }
 
-    override fun onBoundsChanged(bounds: CoordinateBounds?) {
-        super.onBoundsChanged(bounds)
-        scope.launch {
-            loadRunner.enqueue {
-                loadPaths(false)
-            }
-        }
-    }
 
     override fun onLocationChanged(location: Coordinate, accuracy: Float?) {
         super.onLocationChanged(location, accuracy)
-        if (!wasBacktrackOn){
+        if (!wasBacktrackOn) {
             return
         }
-        scope.launch {
-            loadRunner.enqueue {
-                loadPaths(false)
-            }
-        }
-    }
-
-    private suspend fun loadPaths(reload: Boolean) = onDefault {
-        bounds?.let {
-            pathLoader.update(paths, it, it, reload || !loaded)
-            loaded = true
-        }
-
-        val points = pathLoader.getPointsWithBacktrack(context)
-        onPathsChanged(paths, points)
-    }
-
-    private fun onPathsChanged(paths: List<Path>, points: Map<Long, List<PathPoint>>) {
-        val mappablePaths = points.mapNotNull {
-            val path =
-                paths.firstOrNull { p -> p.id == it.key } ?: return@mapNotNull null
-
-            val correctedPoints = if (shouldCorrectElevations) {
-                hikingService.correctElevations(it.value.sortedBy { it.id }).reversed()
-            } else {
-                it.value
-            }
-
-            correctedPoints.asMappable(context, path)
-        }
-        layer.setPaths(mappablePaths)
+        // Location changed while backtrack is on, so we need to update the current location
+        layer.invalidate()
     }
 }

app/src/main/java/com/kylecorry/trail_sense/tools/photo_maps/ui/PhotoMapCalibrationFragment.kt

@@ -88,7 +88,7 @@ class PhotoMapCalibrationFragment : BoundFragment<FragmentPhotoMapCalibrationBin
         super.onResume()
         layerManager = MultiLayerManager(
             listOf(
-                PathLayerManager(requireContext(), pathLayer),
+                PathLayerManager(pathLayer),
                 MyLocationLayerManager(
                     myLocationLayer,
                     Resources.getPrimaryMarkerColor(requireContext()),

app/src/main/java/com/kylecorry/trail_sense/tools/photo_maps/ui/PhotoMapToolLayerManager.kt

@@ -147,7 +147,6 @@ class PhotoMapToolLayerManager {
         layerManager = MultiLayerManager(
             listOfNotNull(
                 if (prefs.photoMaps.pathLayer.isEnabled.get()) PathLayerManager(
-                    context,
                     pathLayer
                 ) else null,
                 if (prefs.photoMaps.myLocationLayer.isEnabled.get()) MyLocationLayerManager(