@sargsyansevak/expo-mapbox-navigation 1.0.0

package/ios/ExpoMapboxNavigationView.swift

@@ -0,0 +1,509 @@
+import ExpoModulesCore
+import MapboxNavigationCore
+import MapboxMaps
+import MapboxNavigationUIKit
+import MapboxDirections
+import Combine
+
+
+class ExpoMapboxNavigationView: ExpoView {
+    private let onRouteProgressChanged = EventDispatcher()
+    private let onCancelNavigation = EventDispatcher()
+    private let onWaypointArrival = EventDispatcher()
+    private let onFinalDestinationArrival = EventDispatcher()
+    private let onRouteChanged = EventDispatcher()
+    private let onUserOffRoute = EventDispatcher()
+    private let onRoutesLoaded = EventDispatcher()
+    private let onRouteFailedToLoad = EventDispatcher()
+
+    let controller = ExpoMapboxNavigationViewController()
+
+    required init(appContext: AppContext? = nil) {
+        super.init(appContext: appContext)
+        clipsToBounds = true
+        addSubview(controller.view)
+
+        controller.onRouteProgressChanged = onRouteProgressChanged
+        controller.onCancelNavigation = onCancelNavigation
+        controller.onWaypointArrival = onWaypointArrival
+        controller.onFinalDestinationArrival = onFinalDestinationArrival
+        controller.onRouteChanged = onRouteChanged
+        controller.onUserOffRoute = onUserOffRoute
+        controller.onRoutesLoaded = onRoutesLoaded
+        controller.onRouteFailedToLoad = onRouteFailedToLoad
+    }
+
+    override func layoutSubviews() {
+        controller.view.frame = bounds
+    }
+}
+
+
+class ExpoMapboxNavigationViewController: UIViewController {
+    static let navigationProvider: MapboxNavigationProvider = MapboxNavigationProvider(coreConfig: CoreConfig(routingConfig: RoutingConfig(fasterRouteDetectionConfig: Optional<FasterRouteDetectionConfig>.none),locationSource: .live ))
+    var mapboxNavigation: MapboxNavigation? = nil
+    var routingProvider: RoutingProvider? = nil
+    var navigation: NavigationController? = nil
+    var tripSession: SessionController? = nil
+    var navigationViewController: NavigationViewController? = nil
+    
+    var currentCoordinates: Array<CLLocationCoordinate2D>? = nil
+    var initialLocation: CLLocationCoordinate2D? = nil
+    var initialLocationZoom: Double? = nil
+    var currentWaypointIndices: Array<Int>? = nil
+    var currentLocale: Locale = Locale.current
+    var currentRouteProfile: String? = nil
+    var currentRouteExcludeList: Array<String>? = nil
+    var currentMapStyle: String? = nil
+    var currentCustomRasterSourceUrl: String? = nil
+    var currentPlaceCustomRasterLayerAbove: String? = nil
+    var currentDisableAlternativeRoutes: Bool? = nil
+    var currentFollowingZoom: Double? = nil
+    var isUsingRouteMatchingApi: Bool = false
+    var vehicleMaxHeight: Double? = nil
+    var vehicleMaxWidth: Double? = nil
+
+    var onRouteProgressChanged: EventDispatcher? = nil
+    var onCancelNavigation: EventDispatcher? = nil
+    var onWaypointArrival: EventDispatcher? = nil
+    var onFinalDestinationArrival: EventDispatcher? = nil
+    var onRouteChanged: EventDispatcher? = nil
+    var onUserOffRoute: EventDispatcher? = nil
+    var onRoutesLoaded: EventDispatcher? = nil
+    var onRouteFailedToLoad: EventDispatcher? = nil
+
+    var calculateRoutesTask: Task<Void, Error>? = nil
+    private var routeProgressCancellable: AnyCancellable? = nil
+    private var waypointArrivalCancellable: AnyCancellable? = nil
+    private var reroutingCancellable: AnyCancellable? = nil
+    private var sessionCancellable: AnyCancellable? = nil
+
+    init() {
+        super.init(nibName: nil, bundle: nil)
+        mapboxNavigation = ExpoMapboxNavigationViewController.navigationProvider.mapboxNavigation
+        routingProvider = mapboxNavigation!.routingProvider()
+        navigation = mapboxNavigation!.navigation()
+        tripSession = mapboxNavigation!.tripSession()
+
+        routeProgressCancellable = navigation!.routeProgress.sink { progressState in
+            if(progressState != nil){
+
+
+                // For some reason the maneuver arrows sometimes (not consistently) show up the same color as the route line making them invisible.
+                // This is a hack to always ensure the arrows are visible.
+                try? self.navigationViewController?.navigationMapView?.mapView.mapboxMap.setLayerProperty(
+                    for: "com.mapbox.navigation.arrow.next",
+                    property: "line-color",
+                    value: "#FFFFFF" 
+                )
+                try? self.navigationViewController?.navigationMapView?.mapView.mapboxMap.setLayerProperty(
+                    for: "com.mapbox.navigation.arrow.next.stroke",
+                    property: "line-color",
+                    value: "#FFFFFF" 
+                )
+                try? self.navigationViewController?.navigationMapView?.mapView.mapboxMap.setLayerProperty(
+                    for: "com.mapbox.navigation.arrow.next.symbol",
+                    property: "icon-color",
+                    value: "#FFFFFF" 
+                )
+                try? self.navigationViewController?.navigationMapView?.mapView.mapboxMap.setLayerProperty(
+                    for: "com.mapbox.navigation.arrow.next.symbol.casing",
+                    property: "icon-color",
+                    value: "#FFFFFF" 
+                )
+                
+               self.onRouteProgressChanged?([
+                    "distanceRemaining": progressState!.routeProgress.distanceRemaining,
+                    "distanceTraveled": progressState!.routeProgress.distanceTraveled,
+                    "durationRemaining": progressState!.routeProgress.durationRemaining,
+                    "fractionTraveled": progressState!.routeProgress.fractionTraveled,
+                ])
+            }
+        }
+
+        waypointArrivalCancellable = navigation!.waypointsArrival.sink { arrivalStatus in
+            let event = arrivalStatus.event
+            if event is WaypointArrivalStatus.Events.ToFinalDestination {
+                self.onFinalDestinationArrival?()
+            } else if event is WaypointArrivalStatus.Events.ToWaypoint {
+                self.onWaypointArrival?()
+            }
+        }
+
+        reroutingCancellable = navigation!.rerouting.sink { rerouteStatus in
+            self.onRouteChanged?()            
+        }
+
+        sessionCancellable = tripSession!.session.sink { session in 
+            let state = session.state
+            switch state {
+                case .activeGuidance(let activeGuidanceState):
+                    switch(activeGuidanceState){
+                        case .offRoute:
+                            self.onUserOffRoute?()
+                        default: break
+                    }
+                default: break
+            }
+        }
+
+    }
+
+    deinit {
+        routeProgressCancellable?.cancel()
+        waypointArrivalCancellable?.cancel()
+        reroutingCancellable?.cancel()
+        sessionCancellable?.cancel()
+    }
+
+    override func viewDidDisappear(_ animated: Bool) {
+        super.viewDidDisappear(animated)
+        Task { @MainActor in tripSession?.setToIdle() } // Stops navigation
+    }
+
+    required init?(coder aDecoder: NSCoder) {
+        super.init(coder: aDecoder)
+        fatalError("This controller should not be loaded through a story board")
+    }
+
+    func addCustomRasterLayer() {
+        let navigationMapView = navigationViewController?.navigationMapView
+        let sourceId = "raster-source"
+        let layerId = "raster-layer"
+
+        if(currentCustomRasterSourceUrl == nil){
+            if let mapView = navigationMapView?.mapView.mapboxMap {
+                if mapView.layerExists(withId: layerId) {
+                    try? mapView.removeLayer(withId: layerId)
+                }
+                if mapView.sourceExists(withId: sourceId) {
+                    try? mapView.removeSource(withId: sourceId)
+                }
+            }
+            return
+        }
+
+        let sourceUrl = currentCustomRasterSourceUrl! 
+
+        var rasterSource = RasterSource(id: sourceId)
+
+        rasterSource.tiles = [sourceUrl]
+        rasterSource.tileSize = 256
+
+        let rasterLayer = RasterLayer(id: layerId, source: sourceId)
+
+
+        if let mapView = navigationMapView?.mapView.mapboxMap {
+            if mapView.layerExists(withId: layerId) {
+                try? mapView.removeLayer(withId: layerId)
+            }
+            if mapView.sourceExists(withId: sourceId) {
+                try? mapView.removeSource(withId: sourceId)
+            }
+
+            try? mapView.addSource(rasterSource)
+            try? mapView.addLayer(rasterLayer, layerPosition: .above(currentPlaceCustomRasterLayerAbove ?? "water"))    
+        }
+    }
+
+
+    func setCoordinates(coordinates: Array<CLLocationCoordinate2D>) {
+        currentCoordinates = coordinates
+        update()
+    }
+
+    func setVehicleMaxHeight(maxHeight: Double?) {
+        vehicleMaxHeight = maxHeight
+        update()
+    }
+
+    func setVehicleMaxWidth(maxWidth: Double?) {
+        vehicleMaxWidth = maxWidth
+        update()
+    }
+
+    func setLocale(locale: String?) {
+        if(locale != nil){
+            currentLocale = Locale(identifier: locale!)
+        } else {
+            currentLocale = Locale.current
+        }
+        update()
+    }
+
+    func setIsUsingRouteMatchingApi(useRouteMatchingApi: Bool?){
+        isUsingRouteMatchingApi = useRouteMatchingApi ?? false
+        update()
+    }
+
+    func setWaypointIndices(waypointIndices: Array<Int>?){
+        currentWaypointIndices = waypointIndices
+        update()
+    }
+
+    func setRouteProfile(profile: String?){
+        currentRouteProfile = profile
+        update()
+    }
+
+    func setRouteExcludeList(excludeList: Array<String>?){
+        currentRouteExcludeList = excludeList
+        update()
+    }
+
+    func setMapStyle(style: String?){
+        currentMapStyle = style
+        update()
+    }
+
+    func setCustomRasterSourceUrl(url: String?){
+        currentCustomRasterSourceUrl = url
+        update()
+    }
+
+    func setPlaceCustomRasterLayerAbove(layerId: String?){
+        currentPlaceCustomRasterLayerAbove = layerId
+        update()
+    }
+
+    func setDisableAlternativeRoutes(disableAlternativeRoutes: Bool?){
+        currentDisableAlternativeRoutes = disableAlternativeRoutes
+        update()
+    }
+
+    func recenterMap(){
+        let navigationMapView = navigationViewController?.navigationMapView
+        navigationMapView?.navigationCamera.update(cameraState: .following)
+    }
+
+    func setIsMuted(isMuted: Bool?){
+        if(isMuted != nil){
+            ExpoMapboxNavigationViewController.navigationProvider.routeVoiceController.speechSynthesizer.muted = isMuted!
+        }
+    }
+
+    func setInitialLocation(location: CLLocationCoordinate2D, zoom: Double?){
+        initialLocation = location
+        initialLocationZoom = zoom
+        let navigationMapView = navigationViewController?.navigationMapView
+        if(initialLocation != nil && navigationMapView != nil){
+            navigationMapView!.mapView.mapboxMap.setCamera(to: CameraOptions(center: initialLocation!, zoom: initialLocationZoom ?? 15))
+        }
+    }
+
+    func setFollowingZoom(followingZoom: Double?){
+        let navigationMapView = navigationViewController?.navigationMapView
+        currentFollowingZoom = followingZoom
+        if(navigationMapView != nil && followingZoom != nil){
+            let newDataSource = MobileViewportDataSource(navigationMapView!.mapView)
+            newDataSource.options.followingCameraOptions.zoomRange = followingZoom!...followingZoom!
+            navigationMapView?.navigationCamera.viewportDataSource = newDataSource
+        }
+    }
+
+    func update(){
+        calculateRoutesTask?.cancel()
+
+        if(currentCoordinates != nil){
+            let waypoints = currentCoordinates!.enumerated().map {
+                let index = $0
+                let coordinate = $1
+                var waypoint = Waypoint(coordinate: coordinate) 
+                waypoint.separatesLegs = currentWaypointIndices == nil ? true : currentWaypointIndices!.contains(index)
+                return waypoint
+            }
+
+            if(isUsingRouteMatchingApi){
+                calculateMapMatchingRoutes(waypoints: waypoints)
+            } else {
+                calculateRoutes(waypoints: waypoints)
+            }
+        }
+    }
+
+    func calculateRoutes(waypoints: Array<Waypoint>){
+        let routeOptions = NavigationRouteOptions(
+            waypoints: waypoints, 
+            profileIdentifier: currentRouteProfile != nil ? ProfileIdentifier(rawValue: currentRouteProfile!) : nil,
+            queryItems: [
+                URLQueryItem(name: "exclude", value: currentRouteExcludeList?.joined(separator: ",")),
+                URLQueryItem(name: "max_height", value: String(format: "%.1f", vehicleMaxHeight ?? 0.0)),
+                URLQueryItem(name: "max_width", value: String(format: "%.1f", vehicleMaxWidth ?? 0.0))
+            ],
+            locale: currentLocale, 
+            distanceUnit: currentLocale.usesMetricSystem ? LengthFormatter.Unit.meter : LengthFormatter.Unit.mile
+        )
+
+        calculateRoutesTask = Task {
+            switch await self.routingProvider!.calculateRoutes(options: routeOptions).result {
+            case .failure(let error):
+                onRouteFailedToLoad?([
+                    "errorMessage": error.localizedDescription
+                ])
+                print(error.localizedDescription)
+            case .success(let navigationRoutes):
+                onRoutesCalculated(navigationRoutes: navigationRoutes)
+            }
+        }
+    }
+
+    func calculateMapMatchingRoutes(waypoints: Array<Waypoint>){
+        let matchOptions = NavigationMatchOptions(
+            waypoints: waypoints, 
+            profileIdentifier: currentRouteProfile != nil ? ProfileIdentifier(rawValue: currentRouteProfile!) : nil,
+            queryItems: [URLQueryItem(name: "exclude", value: currentRouteExcludeList?.joined(separator: ","))],
+            distanceUnit: currentLocale.usesMetricSystem ? LengthFormatter.Unit.meter : LengthFormatter.Unit.mile
+        )
+        matchOptions.locale = currentLocale
+
+
+        calculateRoutesTask = Task {
+            switch await self.routingProvider!.calculateRoutes(options: matchOptions).result {
+            case .failure(let error):
+                onRouteFailedToLoad?([
+                    "errorMessage": error.localizedDescription
+                ])
+                print(error.localizedDescription)
+            case .success(let navigationRoutes):
+                onRoutesCalculated(navigationRoutes: navigationRoutes)
+            }
+        }
+    }
+
+    @objc func cancelButtonClicked(_ sender: AnyObject?) {
+        onCancelNavigation?()
+    }
+
+    func convertRoute(route: Route) -> Any {
+        return [
+            "distance": route.distance,
+            "expectedTravelTime": route.expectedTravelTime,
+            "legs": route.legs.map { leg in
+                return [
+                    "source": leg.source != nil ? [
+                        "latitude": leg.source!.coordinate.latitude,
+                        "longitude": leg.source!.coordinate.longitude
+                    ] : nil,
+                    "destination": leg.destination != nil ? [
+                        "latitude": leg.destination!.coordinate.latitude,
+                        "longitude": leg.destination!.coordinate.longitude
+                    ] : nil,
+                    "steps": leg.steps.map { step in
+                        return [
+                            "shape": step.shape != nil ? [
+                                "coordinates": step.shape!.coordinates.map { coordinate in
+                                    return [
+                                        "latitude": coordinate.latitude,
+                                        "longitude": coordinate.longitude,
+                                    ]
+                                }
+                            ] : nil
+                        ]
+                    }
+                ]
+            }
+        ]
+    }
+
+    func onRoutesCalculated(navigationRoutes: NavigationRoutes){
+        onRoutesLoaded?([
+            "routes": [
+                "mainRoute": convertRoute(route: navigationRoutes.mainRoute.route),
+                "alternativeRoutes": navigationRoutes.alternativeRoutes.map { convertRoute(route: $0.route) }
+            ]
+        ])
+
+        let topBanner = TopBannerViewController()
+        topBanner.instructionsBannerView.distanceFormatter.locale = currentLocale
+        let bottomBanner = BottomBannerViewController()
+        bottomBanner.distanceFormatter.locale = currentLocale
+        bottomBanner.dateFormatter.locale = currentLocale
+
+        let navigationOptions = NavigationOptions(
+            mapboxNavigation: self.mapboxNavigation!,
+            voiceController: ExpoMapboxNavigationViewController.navigationProvider.routeVoiceController,
+            eventsManager: ExpoMapboxNavigationViewController.navigationProvider.eventsManager(),
+            styles: [DayStyle()],
+            topBanner: topBanner,
+            bottomBanner: bottomBanner
+        )
+
+        let newNavigationControllerRequired = navigationViewController == nil
+
+        if(newNavigationControllerRequired){
+            navigationViewController = NavigationViewController(
+                navigationRoutes: navigationRoutes,
+                navigationOptions: navigationOptions
+            )
+        } else {
+            navigationViewController!.prepareViewLoading(
+                navigationRoutes: navigationRoutes,
+                navigationOptions: navigationOptions
+            )
+        }
+        
+        let navigationViewController = navigationViewController!
+
+        navigationViewController.showsContinuousAlternatives = currentDisableAlternativeRoutes != true
+        navigationViewController.usesNightStyleWhileInTunnel = false
+        navigationViewController.automaticallyAdjustsStyleForTimeOfDay = false
+
+        let navigationMapView = navigationViewController.navigationMapView
+        navigationMapView!.puckType = .puck2D(.navigationDefault)
+
+        if(initialLocation != nil && newNavigationControllerRequired){
+            navigationMapView!.mapView.mapboxMap.setCamera(to: CameraOptions(center: initialLocation!, zoom: initialLocationZoom ?? 15))
+        }
+
+        let style = currentMapStyle != nil ? StyleURI(rawValue: currentMapStyle!) : StyleURI.streets
+        navigationMapView!.mapView.mapboxMap.loadStyle(style!, completion: { _ in
+            navigationMapView!.localizeLabels(locale: self.currentLocale)
+            do{
+                try navigationMapView!.mapView.mapboxMap.localizeLabels(into: self.currentLocale)
+            } catch {}
+            self.addCustomRasterLayer()
+        })
+        
+
+        let cancelButton = navigationViewController.navigationView.bottomBannerContainerView.findViews(subclassOf: CancelButton.self)[0]
+        cancelButton.addTarget(self, action: #selector(cancelButtonClicked), for: .touchUpInside)
+
+        navigationViewController.delegate = self
+        addChild(navigationViewController)
+        view.addSubview(navigationViewController.view)
+        navigationViewController.view.translatesAutoresizingMaskIntoConstraints = false
+        NSLayoutConstraint.activate([
+            navigationViewController.view.leadingAnchor.constraint(equalTo: view.leadingAnchor, constant: 0),
+            navigationViewController.view.trailingAnchor.constraint(equalTo: view.trailingAnchor, constant: 0),
+            navigationViewController.view.topAnchor.constraint(equalTo: view.topAnchor, constant: 0),
+            navigationViewController.view.bottomAnchor.constraint(equalTo: view.bottomAnchor, constant: 0),
+        ])
+        didMove(toParent: self)
+        mapboxNavigation!.tripSession().startActiveGuidance(with: navigationRoutes, startLegIndex: 0)
+    }
+}
+extension ExpoMapboxNavigationViewController: NavigationViewControllerDelegate {
+    func navigationViewController(_ navigationViewController: NavigationViewController, didRerouteAlong route: Route) {
+        onRoutesLoaded?([
+            "routes": [
+                "mainRoute": convertRoute(route: route),
+                "alternativeRoutes": []
+            ]
+        ])
+    }
+
+    func navigationViewControllerDidDismiss(
+        _ navigationViewController: NavigationViewController,
+        byCanceling canceled: Bool
+    ) { }
+}
+
+extension UIView {
+    func findViews<T: UIView>(subclassOf: T.Type) -> [T] {
+        return recursiveSubviews.compactMap { $0 as? T }
+    }
+
+    var recursiveSubviews: [UIView] {
+        return subviews + subviews.flatMap { $0.recursiveSubviews }
+    }
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@sargsyansevak/expo-mapbox-navigation",
+  "version": "1.0.0",
+  "description": "Expo module for Mapbox's Navigation SDK",
+  "readmeFilename": "README.md",
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
+  "scripts": {
+    "build": "expo-module build",
+    "clean": "expo-module clean",
+    "lint": "expo-module lint",
+    "test": "expo-module test",
+    "prepare": "expo-module prepare",
+    "prepublishOnly": "expo-module prepublishOnly",
+    "expo-module": "expo-module",
+    "open:ios": "xed example/ios",
+    "open:android": "open -a \"Android Studio\" example/android"
+  },
+  "keywords": [
+    "react-native",
+    "expo",
+    "mapbox",
+    "navigation",
+    "expo-mapbox-navigation",
+    "ExpoMapboxNavigation"
+  ],
+  "repository": "https://github.com/SargsyanSevak/expo-mapbox-navigation",
+  "bugs": {
+    "url": "https://github.com/SargsyanSevak/expo-mapbox-navigation/issues"
+  },
+  "author": "sargsyansevak <thesevaksargsyan@gmail.com> (https://github.com/SargsyanSevak",
+  "license": "MIT",
+  "homepage": "https://github.com/SargsyanSevak/expo-mapbox-navigation#readme",
+  "dependencies": {},
+  "devDependencies": {
+    "@types/react": "^18.0.25",
+    "expo-module-scripts": "^3.5.2",
+    "expo-modules-core": "~2.5.0",
+    "@expo/config-plugins": "~8.0.10"
+  },
+  "peerDependencies": {
+    "expo": "*",
+    "react": "*",
+    "react-native": "*",
+    "@rnmapbox/maps": "*"
+  }
+}

package/plugin/config.js

@@ -0,0 +1,127 @@
+const {
+  withDangerousMod,
+  withAndroidColors,
+  withAndroidColorsNight,
+  AndroidConfig,
+} = require("@expo/config-plugins");
+const fs = require("fs/promises");
+const path = require("path");
+
+/**
+ * This plugin adds a post-install step to the Podfile that addresses linking issues between pods and xcframeworks.
+ * In this case, the navigation library is added as an xcframework, and the maps library is added as a pod
+ *
+ * See https://github.com/CocoaPods/CocoaPods/issues/11079#issuecomment-984670700
+ */
+
+const applyPodfilePostInstallModifications = (src, mapboxMapsVersion) => {
+  return (
+    `ENV['ExpoNavigationMapboxMapsVersion'] = '${mapboxMapsVersion}'\n` +
+    src.replace(
+      "post_install do |installer|",
+      `post_install do |installer|
+      installer.pods_project.targets.each do |target|
+          if (target.name.include? 'MapboxMaps' or target.name.include? 'Turf')
+            target.build_configurations.each do |config|
+              config.build_settings['BUILD_LIBRARY_FOR_DISTRIBUTION'] = 'YES'
+            end
+          end
+        end`
+    )
+  );
+};
+
+const withIosPostInstallStep = (config, mapboxMapsVersion) =>
+  withDangerousMod(config, [
+    "ios",
+    async (exportedConfig) => {
+      const file = path.join(
+        exportedConfig.modRequest.platformProjectRoot,
+        "Podfile"
+      );
+
+      const contents = await fs.readFile(file, "utf8");
+      await fs.writeFile(
+        file,
+        applyPodfilePostInstallModifications(contents, mapboxMapsVersion),
+        "utf-8"
+      );
+
+      return exportedConfig;
+    },
+  ]);
+
+const withIosTokenInfoPlist = (config, accessToken) => {
+  if (!config.ios) {
+    config.ios = {};
+  }
+  if (!config.ios.infoPlist) {
+    config.ios.infoPlist = {};
+  }
+
+  config.ios.infoPlist["MBXAccessToken"] = accessToken;
+
+  return config;
+};
+
+const withIosConfig = (config, { accessToken, mapboxMapsVersion }) => {
+  const configWithPostInstallStep = withIosPostInstallStep(
+    config,
+    mapboxMapsVersion
+  );
+  const configWithAccessToken = withIosTokenInfoPlist(
+    configWithPostInstallStep,
+    accessToken
+  );
+  return configWithAccessToken;
+};
+
+const withAndroidConfig = (config, { androidColorOverrides }) => {
+  const configWithAndroidColors = withAndroidColors(config, (config) => {
+    let currentModResults = config.modResults;
+
+    for (const [name, value] of Object.entries(androidColorOverrides ?? {})) {
+      AndroidConfig.Colors.assignColorValue(currentModResults, { name, value });
+    }
+
+    config.modResults = currentModResults;
+
+    return config;
+  });
+
+  const configWithAndroidColorsNight = withAndroidColorsNight(
+    configWithAndroidColors,
+    (config) => {
+      let currentModResults = config.modResults;
+
+      for (const [name, value] of Object.entries(androidColorOverrides ?? {})) {
+        AndroidConfig.Colors.assignColorValue(currentModResults, {
+          name,
+          value,
+        });
+      }
+
+      config.modResults = currentModResults;
+
+      return config;
+    }
+  );
+
+  return configWithAndroidColorsNight;
+};
+
+const withConfig = (
+  config,
+  { accessToken, mapboxMapsVersion, androidColorOverrides }
+) => {
+  const configWithIos = withIosConfig(config, {
+    accessToken,
+    mapboxMapsVersion,
+  });
+  const configWithAndroid = withAndroidConfig(configWithIos, {
+    androidColorOverrides,
+  });
+  return configWithAndroid;
+};
+
+module.exports = withConfig;