maps-kt-compose/src/commonMain/kotlin/center/sciprog/maps/compose/MapTileProvider.kt

@@ -13,7 +13,7 @@ public data class TileId(
 
 public data class MapTile(
     val id: TileId,
-    val image: ImageBitmap?,
+    val image: ImageBitmap,
 )
 
 public interface MapTileProvider {

maps-kt-compose/src/jvmMain/kotlin/center/sciprog/maps/compose/MapViewJvm.kt

@@ -195,12 +195,13 @@ public actual fun MapView(
             for (j in verticalIndices) {
                 for (i in horizontalIndices) {
                     val id = TileId(zoom, i, j)
+                    try {
                         //start all
                         val deferred = loadTileAsync(id)
                         //wait asynchronously for it to finish
                         launch {
-                        try {
                             mapTiles += deferred.await()
+                        }
                     } catch (ex: Exception) {
                         if (ex !is CancellationException) {
                             //displaying the error is maps responsibility
@@ -208,7 +209,7 @@ public actual fun MapView(
                         }
                     }
                 }
-                }
+
             }
         }
     }
@@ -232,6 +233,7 @@ public actual fun MapView(
                     feature.size,
                     center = feature.center.toOffset()
                 )
+
                 is MapRectangleFeature -> drawRect(
                     feature.color,
                     topLeft = feature.center.toOffset() - Offset(
@@ -240,6 +242,7 @@ public actual fun MapView(
                     ),
                     size = feature.size.toSize()
                 )
+
                 is MapLineFeature -> drawLine(feature.color, feature.a.toOffset(), feature.b.toOffset())
                 is MapArcFeature -> {
                     val topLeft = feature.oval.topLeft.toOffset()
@@ -252,6 +255,7 @@ public actual fun MapView(
                     drawPath(path, color = feature.color, style = Stroke())
 
                 }
+
                 is MapBitmapImageFeature -> drawImage(feature.image, feature.position.toOffset())
                 is MapVectorImageFeature -> {
                     val offset = feature.position.toOffset()
@@ -262,6 +266,7 @@ public actual fun MapView(
                         }
                     }
                 }
+
                 is MapTextFeature -> drawIntoCanvas { canvas ->
                     val offset = feature.position.toOffset()
                     canvas.nativeCanvas.drawString(
@@ -272,17 +277,20 @@ public actual fun MapView(
                         feature.color.toPaint()
                     )
                 }
+
                 is MapDrawFeature -> {
                     val offset = feature.position.toOffset()
                     translate(offset.x, offset.y) {
                         feature.drawFeature(this)
                     }
                 }
+
                 is MapFeatureGroup -> {
                     feature.children.values.forEach {
                         drawFeature(zoom, it)
                     }
                 }
+
                 is MapPointsFeature -> {
                     val points = feature.points.map { it.toOffset() }
                     drawPoints(
@@ -292,6 +300,7 @@ public actual fun MapView(
                         pointMode = feature.pointMode
                     )
                 }
+
                 else -> {
                     logger.error { "Unrecognized feature type: ${feature::class}" }
                 }
@@ -313,14 +322,12 @@ public actual fun MapView(
                     (canvasSize.width / 2 + (mapTileProvider.toCoordinate(id.i).dp - centerCoordinates.x.dp) * tileScale.toFloat()).roundToPx(),
                     (canvasSize.height / 2 + (mapTileProvider.toCoordinate(id.j).dp - centerCoordinates.y.dp) * tileScale.toFloat()).roundToPx()
                 )
-                image?.let {
                 drawImage(
-                        image = it,
+                    image = image,
                     dstOffset = offset,
                     dstSize = tileSize
                 )
             }
-            }
             features.values.filter { zoom in it.zoomRange }.forEach { feature ->
                 drawFeature(zoom, feature)
             }

maps-kt-compose/src/jvmMain/kotlin/center/sciprog/maps/compose/OpenStreetMapTileProvider.kt

@@ -2,11 +2,10 @@ package center.sciprog.maps.compose
 
 import androidx.compose.ui.graphics.ImageBitmap
 import androidx.compose.ui.graphics.toComposeImageBitmap
-import io.ktor.client.*
-import io.ktor.client.network.sockets.*
-import io.ktor.client.request.*
-import io.ktor.client.statement.*
-import io.ktor.utils.io.*
+import io.ktor.client.HttpClient
+import io.ktor.client.request.get
+import io.ktor.client.statement.readBytes
+import io.ktor.utils.io.CancellationException
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Deferred
 import kotlinx.coroutines.Dispatchers
@@ -25,11 +24,11 @@ import kotlin.io.path.*
 public class OpenStreetMapTileProvider(
     private val client: HttpClient,
     private val cacheDirectory: Path,
-    parallelism: Int = 1,
+    parallelism: Int = 4,
     cacheCapacity: Int = 200,
 ) : MapTileProvider {
     private val semaphore = Semaphore(parallelism)
-    private val cache = LruCache<TileId, Deferred<ImageBitmap?>>(cacheCapacity)
+    private val cache = LruCache<TileId, Deferred<ImageBitmap>>(cacheCapacity)
 
     private fun TileId.osmUrl() = URL("https://tile.openstreetmap.org/${zoom}/${i}/${j}.png")
 
@@ -38,7 +37,7 @@ public class OpenStreetMapTileProvider(
     /**
      * Download and cache the tile image
      */
-    private fun CoroutineScope.downloadImageAsync(id: TileId): Deferred<ImageBitmap?> = async(Dispatchers.IO) {
+    private fun CoroutineScope.downloadImageAsync(id: TileId): Deferred<ImageBitmap> = async(Dispatchers.IO) {
 
         id.cacheFilePath()?.let { path ->
             if (path.exists()) {
@@ -53,7 +52,6 @@ public class OpenStreetMapTileProvider(
 
         //semaphore works only for actual download
         semaphore.withPermit {
-            try {
             val url = id.osmUrl()
             val byteArray = client.get(url).readBytes()
             logger.debug { "Finished downloading map tile with id $id from $url" }
@@ -65,10 +63,6 @@ public class OpenStreetMapTileProvider(
             }
 
             Image.makeFromEncoded(byteArray).toComposeImageBitmap()
-            } catch (e: ConnectTimeoutException) {
-                logger.error(e) { e.localizedMessage }
-                null
-            }
         }
     }
 
@@ -83,7 +77,7 @@ public class OpenStreetMapTileProvider(
 
         //collect the result asynchronously
         return async {
-            val image = try {
+            val image: ImageBitmap = try {
                 imageDeferred.await()
             } catch (ex: Exception) {
                 cache.remove(tileId)