[offline] add default pixelRatio for TilesetDescriptorOptions (#640)

maios · web-flow · commit d8c8673c8fba · 2024-08-07T15:51:30.000+03:00
* [offline] add default pixelRatio for TilesetDescriptorOptions
* Automatically set MapboxMapsOptions.tileStore
diff --git a/android/src/main/kotlin/com/mapbox/maps/mapbox_maps/Extentions.kt b/android/src/main/kotlin/com/mapbox/maps/mapbox_maps/Extentions.kt
@@ -611,12 +611,12 @@ fun com.mapbox.maps.StylePackLoadProgress.toFLTStylePackLoadProgress(): StylePac
   )
 }
 
-fun TilesetDescriptorOptions.toTilesetDescriptorOptions(): com.mapbox.maps.TilesetDescriptorOptions {
+fun TilesetDescriptorOptions.toTilesetDescriptorOptions(context: Context): com.mapbox.maps.TilesetDescriptorOptions {
   val builder = com.mapbox.maps.TilesetDescriptorOptions.Builder()
     .styleURI(styleURI)
     .minZoom(minZoom.toByte())
     .maxZoom(maxZoom.toByte())
-  pixelRatio?.let { builder.pixelRatio(it.toFloat()) }
+    .pixelRatio(pixelRatio?.toFloat() ?: context.resources.displayMetrics.density)
   tilesets?.let { builder.tilesets(it) }
   stylePackOptions?.let { builder.stylePackOptions(it.toStylePackLoadOptions()) }
   extraOptions?.let { builder.extraOptions(it.toValue()) }
diff --git a/android/src/main/kotlin/com/mapbox/maps/mapbox_maps/offline/OfflineMapInstanceManager.kt b/android/src/main/kotlin/com/mapbox/maps/mapbox_maps/offline/OfflineMapInstanceManager.kt
@@ -2,6 +2,7 @@ package com.mapbox.maps.mapbox_maps.offline
 
 import android.content.Context
 import com.mapbox.common.TileStore
+import com.mapbox.maps.MapboxMapsOptions
 import com.mapbox.maps.mapbox_maps.ProxyBinaryMessenger
 import com.mapbox.maps.mapbox_maps.pigeons.*
 import io.flutter.plugin.common.BinaryMessenger
@@ -27,6 +28,7 @@ class OfflineMapInstanceManager(
   override fun setupTileStore(channelSuffix: String, filePath: String?) {
     val proxy = ProxyBinaryMessenger(messenger, channelSuffix)
     val tileStore = filePath?.let { TileStore.create(it) } ?: TileStore.create()
+    MapboxMapsOptions.tileStore = tileStore
     val tileStoreController = TileStoreController(context, messenger, tileStore)
     _TileStore.setUp(proxy, tileStoreController)
     proxies["tilestore/$channelSuffix"] = proxy
@@ -35,5 +37,6 @@ class OfflineMapInstanceManager(
   override fun tearDownTileStore(channelSuffix: String) {
     val proxy = proxies["tilestore/$channelSuffix"] ?: return
     _TileStore.setUp(proxy, null)
+    MapboxMapsOptions.tileStore = null
   }
 }
diff --git a/android/src/main/kotlin/com/mapbox/maps/mapbox_maps/offline/TileStoreController.kt b/android/src/main/kotlin/com/mapbox/maps/mapbox_maps/offline/TileStoreController.kt
@@ -38,7 +38,7 @@ class TileStoreController(
     callback: (Result<TileRegion>) -> Unit
   ) {
     tileStore.loadTileRegion(
-      id, offlineManager.tileRegionLoadOptions(loadOptions),
+      id, offlineManager.tileRegionLoadOptions(loadOptions, context),
       { progress ->
         mainHandler.post {
           tileRegionLoadProgressHandlers[id]?.success(progress.toFLTTileRegionLoadProgress().toList())
@@ -75,7 +75,7 @@ class TileStoreController(
   ) {
     tileStore.estimateTileRegion(
       id,
-      offlineManager.tileRegionLoadOptions(loadOptions),
+      offlineManager.tileRegionLoadOptions(loadOptions, context),
       estimateOptions?.toTileRegionEstimateOptions() ?: com.mapbox.common.TileRegionEstimateOptions(null),
       { progress ->
         mainHandler.post {
@@ -116,7 +116,7 @@ class TileStoreController(
   }
 
   override fun tileRegionContainsDescriptor(id: String, options: List<TilesetDescriptorOptions>, callback: (Result<Boolean>) -> Unit) {
-    val descriptors = options.map { offlineManager.createTilesetDescriptor(it.toTilesetDescriptorOptions()) }
+    val descriptors = options.map { offlineManager.createTilesetDescriptor(it.toTilesetDescriptorOptions(context)) }
     tileStore.tileRegionContainsDescriptors(id, descriptors) { expected ->
       mainHandler.post {
         callback(expected.toResult { it })
@@ -152,7 +152,7 @@ class TileStoreController(
   }
 }
 
-private fun OfflineManager.tileRegionLoadOptions(fltValue: TileRegionLoadOptions): com.mapbox.common.TileRegionLoadOptions {
+private fun OfflineManager.tileRegionLoadOptions(fltValue: TileRegionLoadOptions, context: Context): com.mapbox.common.TileRegionLoadOptions {
   val builder = com.mapbox.common.TileRegionLoadOptions.Builder()
     .geometry(fltValue.geometry?.toGeometry())
     .metadata(fltValue.metadata?.toValue())
@@ -165,7 +165,7 @@ private fun OfflineManager.tileRegionLoadOptions(fltValue: TileRegionLoadOptions
   fltValue.descriptorsOptions?.let { options ->
     val descriptors: List<TilesetDescriptorOptions> = options.filterNotNull()
     builder.descriptors(
-      descriptors.map { createTilesetDescriptor(it.toTilesetDescriptorOptions()) }
+      descriptors.map { createTilesetDescriptor(it.toTilesetDescriptorOptions(context)) }
     )
   }
 
diff --git a/example/ios/Podfile.lock b/example/ios/Podfile.lock
@@ -48,7 +48,7 @@ EXTERNAL SOURCES:
 
 SPEC CHECKSUMS:
   Flutter: e0871f40cf51350855a761d2e70bf5af5b9b5de7
-  integration_test: ce0a3ffa1de96d1a89ca0ac26fca7ea18a749ef4
+  integration_test: 13825b8a9334a850581300559b8839134b124670
   mapbox_maps_flutter: 4ad19682f43ffed50be9c1eb2364107e21725f1f
   MapboxCommon: 595dd030df6b2c88e73dd53cef95acc3f31cfa7e
   MapboxCoreMaps: f33e09b177988af18168b8717f5d79937c85908f
diff --git a/example/lib/offline_map.dart b/example/lib/offline_map.dart
@@ -32,20 +32,14 @@ class OfflineMapWidgetState extends State<OfflineMapWidget> {
   final StreamController<double> _tileRegionLoadProgress =
       StreamController.broadcast();
 
-  _onMapCreated(MapboxMap mapboxMap) async {
-    this.mapboxMap = mapboxMap;
-    await _downloadStylePack();
-    await _downloadTileRegion();
-  }
-
   _downloadStylePack() async {
     final offlineManager = await OfflineManager.create();
     final stylePackLoadOptions = StylePackLoadOptions(
         glyphsRasterizationMode:
             GlyphsRasterizationMode.IDEOGRAPHS_RASTERIZED_LOCALLY,
         metadata: {"tag": "test"},
         acceptExpired: false);
-    offlineManager.loadStylePack(MapboxStyles.OUTDOORS, stylePackLoadOptions,
+    offlineManager.loadStylePack(MapboxStyles.SATELLITE_STREETS, stylePackLoadOptions,
         (progress) {
       final percentage =
           progress.completedResourceCount / progress.requiredResourceCount;
@@ -59,13 +53,15 @@ class OfflineMapWidgetState extends State<OfflineMapWidget> {
   }
 
   _downloadTileRegion() async {
-    final tmpDir = await getTemporaryDirectory();
-    final tileStore = await TileStore.createAt(await tmpDir.uri);
+    final path = await getTemporaryDirectory();
+    final tileStore = await TileStore.createAt(path.uri);
     final tileRegionLoadOptions = TileRegionLoadOptions(
-        geometry: Point(coordinates: Position(-80.1263, 25.7845)).toJson(),
+        geometry: City.helsinki.toJson(),
         descriptorsOptions: [
+          // If you are using a raster tileset you may need to set a different pixelRatio.
+          // The default is UIScreen.main.scale on iOS and displayMetrics's density on Android.
           TilesetDescriptorOptions(
-              styleURI: MapboxStyles.OUTDOORS, minZoom: 0, maxZoom: 16)
+              styleURI: MapboxStyles.SATELLITE_STREETS, minZoom: 0, maxZoom: 16)
         ],
         acceptExpired: true,
         networkRestriction: NetworkRestriction.NONE);
@@ -85,18 +81,40 @@ class OfflineMapWidgetState extends State<OfflineMapWidget> {
 
   @override
   Widget build(BuildContext context) {
-    final mapWidget = MapWidget(
-      key: ValueKey("mapWidget"),
-      styleUri: MapboxStyles.OUTDOORS,
-      cameraOptions: CameraOptions(center: City.helsinki, zoom: 2.0),
-      onMapCreated: _onMapCreated,
-    );
+    String downloadButtonText = "Download Map";
+    final mapIsDownloaded = Future
+        .wait([_tileRegionLoadProgress.sink.done, _stylePackProgress.sink.done])
+        .whenComplete(() async {
+          await OfflineSwitch.shared.setMapboxStackConnected(false);
+        });
 
     return new Column(
       mainAxisSize: MainAxisSize.min,
       children: [
         Expanded(
-          child: mapWidget,
+          child: FutureBuilder(future: mapIsDownloaded, builder: (context, snapshot) {
+            if (snapshot.hasData) {
+              return MapWidget(
+                key: ValueKey("mapWidget"),
+                styleUri: MapboxStyles.SATELLITE_STREETS,
+                cameraOptions: CameraOptions(center: City.helsinki, zoom: 12.0),
+              );
+            } else {
+              return TextButton(
+                style: ButtonStyle(
+                  foregroundColor: MaterialStateProperty.all<Color>(Colors.blue),
+                ),
+                onPressed: () async {
+                  setState(() {
+                    downloadButtonText = "Downloading";
+                  });
+                  await _downloadStylePack();
+                  await _downloadTileRegion();
+                },
+                child: Text(downloadButtonText),
+              );
+            }
+          }),
         ),
         SizedBox(
             height: 100,
diff --git a/ios/Classes/Extensions.swift b/ios/Classes/Extensions.swift
@@ -917,25 +917,15 @@ extension MapboxCoreMaps.StylePackLoadProgress {
 
 extension MapboxCoreMaps.TilesetDescriptorOptions {
 
-    convenience init(fltValue: TilesetDescriptorOptions) {
-        if let pixelRatio = fltValue.pixelRatio {
-            self.init(
-                styleURI: fltValue.styleURI,
-                minZoom: UInt8(fltValue.minZoom),
-                maxZoom: UInt8(fltValue.maxZoom),
-                pixelRatio: Float(pixelRatio),
-                tilesets: fltValue.tilesets?.compacted(),
-                stylePack: fltValue.stylePackOptions.flatMap(MapboxCoreMaps.StylePackLoadOptions.init(fltValue:)),
-                extraOptions: fltValue.extraOptions)
-        } else {
-            self.init(
-                styleURI: fltValue.styleURI,
-                minZoom: UInt8(fltValue.minZoom),
-                maxZoom: UInt8(fltValue.maxZoom),
-                tilesets: fltValue.tilesets?.compacted(),
-                stylePack: fltValue.stylePackOptions.flatMap(MapboxCoreMaps.StylePackLoadOptions.init(fltValue:)),
-                extraOptions: fltValue.extraOptions)
-        }
+    convenience init?(fltValue: TilesetDescriptorOptions) {
+        guard let styleURI = StyleURI(rawValue: fltValue.styleURI) else { return nil }
+        self.init(
+            styleURI: styleURI,
+            zoomRange: UInt8(fltValue.minZoom)...UInt8(fltValue.maxZoom),
+            pixelRatio: fltValue.pixelRatio.map(Float.init),
+            tilesets: fltValue.tilesets?.compacted(),
+            stylePackOptions: fltValue.stylePackOptions.flatMap(MapboxCoreMaps.StylePackLoadOptions.init(fltValue:)),
+            extraOptions: fltValue.extraOptions)
     }
 }
 
@@ -995,6 +985,20 @@ extension MapboxCommon.TileRegionEstimateProgress {
             erroredResourceCount: Int64(erroredResourceCount))
     }
 }
+
+extension MapboxCommon.NetworkRestriction {
+
+    init(fltValue: NetworkRestriction) {
+        switch fltValue {
+        case .nONE:
+            self = .none
+        case .dISALLOWEXPENSIVE:
+            self = .disallowExpensive
+        case .dISALLOWALL:
+            self = .disallowAll
+        }
+    }
+}
 // MARK: Result
 extension Result where Failure == any Error {
     init(code: String, catchingFlutter body: () throws -> Success) {
diff --git a/ios/Classes/Offline/OfflineMapInstanceManager.swift b/ios/Classes/Offline/OfflineMapInstanceManager.swift
@@ -1,4 +1,5 @@
 import Flutter
+import MapboxMaps
 
 final class OfflineMapInstanceManager: _OfflineMapInstanceManager, _TileStoreInstanceManager {
     enum `Error`: Swift.Error {
@@ -25,20 +26,24 @@ final class OfflineMapInstanceManager: _OfflineMapInstanceManager, _TileStoreIns
     }
 
     func setupTileStore(channelSuffix: String, filePath: String?) throws {
-        let tileStoreController: TileStoreController
         let proxy = ProxyBinaryMessenger(with: binaryMessenger, channelSuffix: channelSuffix)
+        let tileStore: TileStore
         if let filePath {
-            tileStoreController = TileStoreController(proxy: proxy, tileStore: .shared(for: URL(fileURLWithPath: filePath)))
+            tileStore = .shared(for: URL(fileURLWithPath: filePath))
         } else {
-            tileStoreController = TileStoreController(proxy: proxy, tileStore: .default)
+            tileStore = .default
         }
 
+        MapboxMapsOptions.tileStore = tileStore
+        let tileStoreController = TileStoreController(proxy: proxy, tileStore: tileStore)
+
         _TileStoreSetup.setUp(binaryMessenger: proxy, api: tileStoreController)
         proxies["tilestore/\(channelSuffix)"] = proxy
     }
 
     func tearDownTileStore(channelSuffix: String) throws {
         guard let proxy = proxies.removeValue(forKey: "tilestore/\(channelSuffix)") else { return }
         _TileStoreSetup.setUp(binaryMessenger: proxy, api: nil)
+        MapboxMapsOptions.tileStore = nil
     }
 }
diff --git a/ios/Classes/Offline/TileStoreController.swift b/ios/Classes/Offline/TileStoreController.swift
@@ -75,7 +75,7 @@ final class TileStoreController: _TileStore {
 
     func tileRegionContainsDescriptor(id: String, options: [TilesetDescriptorOptions], completion: @escaping (Result<Bool, Swift.Error>) -> Void) {
         let descriptors = options
-            .map(MapboxCoreMaps.TilesetDescriptorOptions.init(fltValue:))
+            .compactMap(MapboxCoreMaps.TilesetDescriptorOptions.init(fltValue:))
             .map(offlineManager.createTilesetDescriptor(for:))
 
         tileStore.tileRegionContainsDescriptors(forId: id, descriptors: descriptors, completion: executeOnMainThread(completion))
@@ -110,11 +110,11 @@ extension OfflineManager {
             geometry: convertDictionaryToGeometry(dict: fltValue.geometry),
             descriptors: fltValue.descriptorsOptions?.compactMap { descriptorOptions in
                 guard let descriptorOptions else { return nil }
-                return createTilesetDescriptor(for: MapboxCoreMaps.TilesetDescriptorOptions(fltValue: descriptorOptions))
+                return MapboxCoreMaps.TilesetDescriptorOptions(fltValue: descriptorOptions).map(createTilesetDescriptor(for:))
             },
             metadata: fltValue.metadata,
             acceptExpired: fltValue.acceptExpired,
-            networkRestriction: MapboxCommon.NetworkRestriction(other: fltValue.networkRestriction) ?? .none,
+            networkRestriction: MapboxCommon.NetworkRestriction(fltValue: fltValue.networkRestriction),
             averageBytesPerSecond: fltValue.averageBytesPerSecond.map(Int.init),
             extraOptions: fltValue.extraOptions
         )

Original file line number	Diff line number	Diff line change
`@@ -611,12 +611,12 @@ fun com.mapbox.maps.StylePackLoadProgress.toFLTStylePackLoadProgress(): StylePac`
`611`	`611`	`)`
`612`	`612`	`}`
`613`	`613`
`614`		`-fun TilesetDescriptorOptions.toTilesetDescriptorOptions(): com.mapbox.maps.TilesetDescriptorOptions {`
	`614`	`+fun TilesetDescriptorOptions.toTilesetDescriptorOptions(context: Context): com.mapbox.maps.TilesetDescriptorOptions {`
`615`	`615`	`val builder = com.mapbox.maps.TilesetDescriptorOptions.Builder()`
`616`	`616`	`.styleURI(styleURI)`
`617`	`617`	`.minZoom(minZoom.toByte())`
`618`	`618`	`.maxZoom(maxZoom.toByte())`
`619`		`- pixelRatio?.let { builder.pixelRatio(it.toFloat()) }`
	`619`	`+ .pixelRatio(pixelRatio?.toFloat() ?: context.resources.displayMetrics.density)`
`620`	`620`	`tilesets?.let { builder.tilesets(it) }`
`621`	`621`	`stylePackOptions?.let { builder.stylePackOptions(it.toStylePackLoadOptions()) }`
`622`	`622`	`extraOptions?.let { builder.extraOptions(it.toValue()) }`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`	`1`	`import Flutter`
	`2`	`+import MapboxMaps`
`2`	`3`
`3`	`4`	`final class OfflineMapInstanceManager: _OfflineMapInstanceManager, _TileStoreInstanceManager {`
`4`	`5`	enum `Error`: Swift.Error {
`@@ -25,20 +26,24 @@ final class OfflineMapInstanceManager: _OfflineMapInstanceManager, _TileStoreIns`
`25`	`26`	`}`
`26`	`27`
`27`	`28`	`func setupTileStore(channelSuffix: String, filePath: String?) throws {`
`28`		`- let tileStoreController: TileStoreController`
`29`	`29`	`let proxy = ProxyBinaryMessenger(with: binaryMessenger, channelSuffix: channelSuffix)`
	`30`	`+ let tileStore: TileStore`
`30`	`31`	`if let filePath {`
`31`		`- tileStoreController = TileStoreController(proxy: proxy, tileStore: .shared(for: URL(fileURLWithPath: filePath)))`
	`32`	`+ tileStore = .shared(for: URL(fileURLWithPath: filePath))`
`32`	`33`	`} else {`
`33`		`- tileStoreController = TileStoreController(proxy: proxy, tileStore: .default)`
	`34`	`+ tileStore = .default`
`34`	`35`	`}`
`35`	`36`
	`37`	`+ MapboxMapsOptions.tileStore = tileStore`
	`38`	`+ let tileStoreController = TileStoreController(proxy: proxy, tileStore: tileStore)`
	`39`	`+`
`36`	`40`	`_TileStoreSetup.setUp(binaryMessenger: proxy, api: tileStoreController)`
`37`	`41`	`proxies["tilestore/\(channelSuffix)"] = proxy`
`38`	`42`	`}`
`39`	`43`
`40`	`44`	`func tearDownTileStore(channelSuffix: String) throws {`
`41`	`45`	`guard let proxy = proxies.removeValue(forKey: "tilestore/\(channelSuffix)") else { return }`
`42`	`46`	`_TileStoreSetup.setUp(binaryMessenger: proxy, api: nil)`
	`47`	`+ MapboxMapsOptions.tileStore = nil`
`43`	`48`	`}`
`44`	`49`	`}`