vk-2926-tilestore-config: added tile storage configuration for Predic…

…tiveCaching setup. Removed TileStoreConfiguration RawRepresentable adoption, fixed NavigationViewController.mapTileStore setup.

Sources/MapboxCoreNavigation/PassiveLocationDataSource.swift

@@ -22,7 +22,7 @@ open class PassiveLocationDataSource: NSObject {
     public required init(directions: Directions = Directions.shared, systemLocationManager: NavigationLocationManager? = nil, tileStoreLocation: TileStoreConfiguration.Location = .default) {
         self.directions = directions
         Navigator.credentials = directions.credentials
-        Navigator.tilesURL = tileStoreLocation.rawValue
+        Navigator.tilesURL = tileStoreLocation.tileStoreURL
 
         self.systemLocationManager = systemLocationManager ?? NavigationLocationManager()
 

Sources/MapboxCoreNavigation/PredictiveCacheManager.swift

@@ -8,14 +8,39 @@ import MapboxNavigationNative
  */
 public class PredictiveCacheManager {
     public typealias MapOptions = (tileStore: TileStore, styleSourcePaths: [String])
+    public typealias TileStoreMapOptions = (tileStoreConfiguration: TileStoreConfiguration, styleSourcePaths: [String])
 
     private(set) var controllers: [PredictiveCacheController] = []
 
     /**
      Initializes a predictive cache.
+     
+     Recommended constructor. This action will initialize tile storage for navigation tiles.
+    
+     - parameter predictiveCacheOptions: A configuration specifying various caching parameters, such as the radii of current and destination locations.
+     - parameter tileStoreMapOptions: Information about tile storages locations, as well as tilesets names for caching. If no Map tile store location is provided - predictive caching is disabled for map tiles.
+     */
+    public convenience init(predictiveCacheOptions: PredictiveCacheOptions, tileStoreMapOptions: TileStoreMapOptions) {
+        Navigator.tilesURL = tileStoreMapOptions.tileStoreConfiguration.navigatorLocation.tileStoreURL
+
+        var mapOptions: MapOptions?
+        if let tileStore = tileStoreMapOptions.tileStoreConfiguration.mapLocation?.tileStore {
+            mapOptions = MapOptions(tileStore,
+                                    tileStoreMapOptions.styleSourcePaths)
+        }
+
+        self.init(predictiveCacheOptions: predictiveCacheOptions, mapOptions: mapOptions)
+    }
+
+    /**
+     Initializes a predictive cache.
+     
+     This action will initialize tile storage for navigation tiles.
+     It is recommended to use `init(predictiveCacheOptions:, tileStoreMapOptions:)` instead to control navigator storage location.
     
      - parameter predictiveCacheOptions: A configuration specifying various caching parameters, such as the radii of current and destination locations.
      - parameter mapOptions: Information about `MapView` tiles such as the location and tilesets to cache. If this argument is set to `nil`, predictive caching is disabled for map tiles.
+     - seealso: `PredictiveCacheManager.init(predictiveCacheOptions:, tileStoreMapOptions)`
      */
     public init(predictiveCacheOptions: PredictiveCacheOptions, mapOptions: MapOptions?) {
         Navigator.credentials = predictiveCacheOptions.credentials
@@ -43,13 +68,13 @@ public class PredictiveCacheManager {
                                                  version: String = "",
                                                  dataset: String = "mapbox",
                                                  maxConcurrentRequests: UInt32 = 2) -> PredictiveCacheController? {
-        let cacheOptions = PredictiveCacheControllerOptions(version: version,
-                                                            dataset: dataset,
-                                                            dataDomain: .maps,
-                                                            concurrency: maxConcurrentRequests,
-                                                            maxAverageDownloadBytesPerSecond: 0)
         let predictiveLocationTrackerOptions = PredictiveLocationTrackerOptions(options)
         if let tileStore = tileStore {
+            let cacheOptions = PredictiveCacheControllerOptions(version: version,
+                                                                dataset: dataset,
+                                                                dataDomain: .maps,
+                                                                concurrency: maxConcurrentRequests,
+                                                                maxAverageDownloadBytesPerSecond: 0)
             return Navigator.shared.navigator.createPredictiveCacheController(for: tileStore,
                                                                               cacheOptions: cacheOptions,
                                                                               locationTrackerOptions: predictiveLocationTrackerOptions)

Sources/MapboxCoreNavigation/RouteController.swift

@@ -160,7 +160,7 @@ open class RouteController: NSObject {
     required public init(along route: Route, routeIndex: Int, options: RouteOptions, directions: Directions = Directions.shared, dataSource source: RouterDataSource, tileStoreLocation: TileStoreConfiguration.Location = .default) {
         self.directions = directions
         Navigator.credentials = directions.credentials
-        Navigator.tilesURL = tileStoreLocation.rawValue
+        Navigator.tilesURL = tileStoreLocation.tileStoreURL
         self._routeProgress = RouteProgress(route: route, routeIndex: routeIndex, options: options)
         self.dataSource = source
         self.refreshesRoute = options.profileIdentifier == .automobileAvoidingTraffic && options.refreshingEnabled

Sources/MapboxCoreNavigation/TileStoreConfiguration.swift

@@ -12,7 +12,7 @@ public struct TileStoreConfiguration {
     /**
      Describes filesystem location for tile storage folder
      */
-    public enum Location: RawRepresentable {
+    public enum Location{
         /**
          Encapsulated default location.
          
@@ -24,16 +24,12 @@ public struct TileStoreConfiguration {
          */
         case custom(URL)
 
-        public init?(rawValue: URL?) {
-            self = rawValue.map { .custom($0) } ?? .default
-        }
-
         /**
          Corresponding URL path
          
          `default` location is interpreted as `nil`.
          */
-        public var rawValue: URL? {
+        public var tileStoreURL: URL? {
             switch self {
             case .default:
                 return nil

Sources/MapboxNavigation/NavigationMapView.swift

@@ -267,16 +267,25 @@ open class NavigationMapView: UIView {
      If `NavigationMapView` was not configured to maintain a tile storage - this function does nothing.
      
      - parameter options: options, controlling caching parameters like area radius and concurrent downloading threads.
+     - parameter tileStoreConfiguration: configuration for tile storage parameters. If `nil` - default settings will be used.
      */
-    public func enablePredictiveCaching(options predictiveCacheOptions: PredictiveCacheOptions) {
-        guard let tileStore = mapTileStore else {
-            return
-        }
-        let mapOptions = PredictiveCacheManager.MapOptions(tileStore,
-                                                           mapView.styleSourceDatasets(["raster", "vector"]))
+    public func enablePredictiveCaching(options predictiveCacheOptions: PredictiveCacheOptions, tileStoreConfiguration: TileStoreConfiguration?) {
+        let styleSourcePaths = mapView.styleSourceDatasets(["raster", "vector"])
 
-        predictiveCacheManager = PredictiveCacheManager(predictiveCacheOptions: predictiveCacheOptions,
-                                                        mapOptions: mapOptions)
+        if let tileStoreConfiguration = tileStoreConfiguration {
+            let tileStoreMapOptions = PredictiveCacheManager.TileStoreMapOptions(tileStoreConfiguration,
+                                                                                 styleSourcePaths)
+
+
+            predictiveCacheManager = PredictiveCacheManager(predictiveCacheOptions: predictiveCacheOptions,
+                                                            tileStoreMapOptions: tileStoreMapOptions)
+        } else if let tileStore = mapTileStore {
+            let mapOptions = PredictiveCacheManager.MapOptions(tileStore,
+                                                               styleSourcePaths)
+
+            predictiveCacheManager = PredictiveCacheManager(predictiveCacheOptions: predictiveCacheOptions,
+                                                            mapOptions: mapOptions)
+        }
     }
 
     // MARK: - Overridden methods

Sources/MapboxNavigation/NavigationViewController.swift

@@ -318,8 +318,8 @@ open class NavigationViewController: UIViewController, NavigationStatusPresenter
      - parameter navigationOptions: The navigation options to use for the navigation session.
      */
     required public init(for route: Route, routeIndex: Int, routeOptions: RouteOptions, navigationOptions: NavigationOptions? = nil) {
-        if let mapTileStoreLocation = navigationOptions?.tileStoreConfiguration.mapLocation {
-            mapTileStore = mapTileStoreLocation
+        if let options = navigationOptions {
+            mapTileStore = options.tileStoreConfiguration.mapLocation
         }
 
         super.init(nibName: nil, bundle: nil)
@@ -347,7 +347,8 @@ open class NavigationViewController: UIViewController, NavigationStatusPresenter
 
         subviewInits.append { [weak self] in
             if let predictiveCacheOptions = navigationOptions?.predictiveCacheOptions {
-                self?.navigationMapView?.enablePredictiveCaching(options: predictiveCacheOptions)
+                self?.navigationMapView?.enablePredictiveCaching(options: predictiveCacheOptions,
+                                                                 tileStoreConfiguration: navigationOptions?.tileStoreConfiguration)
             }
         }
     }