Re-enable parallel map layer loading

Signed-off-by: Kyle Corry <[email protected]>

Author: kylecorry31

app/src/main/java/com/kylecorry/trail_sense/shared/andromeda_temp/ParallelCoroutineRunner2.kt

@@ -0,0 +1,48 @@
+package com.kylecorry.trail_sense.shared.andromeda_temp
+
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.Semaphore
+import kotlinx.coroutines.sync.withPermit
+
+class ParallelCoroutineRunner2(maxParallel: Int = 8) {
+
+    private val semaphore = Semaphore(maxParallel)
+
+    suspend fun run(coroutines: List<suspend () -> Any>) = coroutineScope {
+        for (coroutine in coroutines) {
+            launch {
+                semaphore.withPermit { coroutine() }
+            }
+        }
+    }
+
+    suspend fun <R> run(items: List<R>, coroutine: suspend (R) -> Unit) {
+        run(items.map { { coroutine(it) } })
+    }
+
+    suspend fun <T> map(coroutines: List<suspend () -> T>): List<T> {
+        val items = mutableListOf<Pair<Int, T>>()
+        val lock = Any()
+
+        run(coroutines.mapIndexed { index, coroutine ->
+            {
+                val item = coroutine()
+                synchronized(lock) {
+                    items.add(index to item)
+                }
+            }
+        })
+
+        return items.sortedBy { it.first }.map { it.second }
+    }
+
+    suspend fun <T> mapFunctions(functions: List<() -> T>): List<T> {
+        return map(functions.map { { it() } })
+    }
+
+    suspend fun <R, T> map(items: List<R>, coroutine: suspend (R) -> T): List<T> {
+        return map(items.map { { coroutine(it) } })
+    }
+
+}

app/src/main/java/com/kylecorry/trail_sense/shared/map_layers/MapLayerBackgroundTask.kt

@@ -4,6 +4,7 @@ import com.kylecorry.andromeda.core.cache.AppServiceRegistry
 import com.kylecorry.luna.coroutines.CoroutineQueueRunner
 import com.kylecorry.luna.coroutines.ParallelCoroutineRunner
 import com.kylecorry.sol.science.geology.CoordinateBounds
+import com.kylecorry.trail_sense.shared.andromeda_temp.ParallelCoroutineRunner2
 import com.kylecorry.trail_sense.shared.andromeda_temp.grow
 import com.kylecorry.trail_sense.shared.device.DeviceSubsystem
 import com.kylecorry.trail_sense.shared.map_layers.tiles.TileMath
@@ -62,12 +63,8 @@ class MapLayerBackgroundTask {
             val taskCopy = synchronized(taskLock) {
                 tasks.toList()
             }
-            for (task in taskCopy) {
-                task(bounds, metersPerPixel)
-            }
-            // TODO: Parallel execution is not working properly - I think it's cancellation related
-//            val parallel = ParallelCoroutineRunner()
-//            parallel.run(taskCopy.map { { it(bounds, metersPerPixel) } })
+            val parallel = ParallelCoroutineRunner2()
+            parallel.run(taskCopy.map { { it(bounds, metersPerPixel) } })
         }
     ) {
 

app/src/main/java/com/kylecorry/trail_sense/shared/map_layers/MapLayerBackgroundTask2.kt

@@ -2,8 +2,10 @@ package com.kylecorry.trail_sense.shared.map_layers
 
 import com.kylecorry.andromeda.core.cache.AppServiceRegistry
 import com.kylecorry.luna.coroutines.CoroutineQueueRunner
+import com.kylecorry.luna.coroutines.ParallelCoroutineRunner
 import com.kylecorry.sol.math.geometry.Rectangle
 import com.kylecorry.sol.science.geology.CoordinateBounds
+import com.kylecorry.trail_sense.shared.andromeda_temp.ParallelCoroutineRunner2
 import com.kylecorry.trail_sense.shared.andromeda_temp.grow
 import com.kylecorry.trail_sense.shared.device.DeviceSubsystem
 import com.kylecorry.trail_sense.shared.map_layers.tiles.TileMath
@@ -64,12 +66,8 @@ class MapLayerBackgroundTask2 {
             val taskCopy = synchronized(taskLock) {
                 tasks.toList()
             }
-            for (task in taskCopy) {
-                task(viewBounds, bounds, projection)
-            }
-            // TODO: Parallel execution is not working properly - I think it's cancellation related
-//            val parallel = ParallelCoroutineRunner()
-//            parallel.run(taskCopy.map { { it(viewBounds, bounds, projection) } })
+            val parallel = ParallelCoroutineRunner2()
+            parallel.run(taskCopy.map { { it(viewBounds, bounds, projection) } })
         }
     ) {