Offline map question about mapbox-maps-flutter HOT 7 OPEN

OfflineSwitch.shared.isMapboxStackConnected(false);

  Future<void> _downloadMap(Travel travel) async {
    await _initializeMapbox();
    LatLngBounds getBounds(Itinerary itinerary) {
      return LatLngBounds(
        northeast: Point(
            coordinates: Position(
              itinerary.destination!.bboxNe!.coordinates![1],
              itinerary.destination!.bboxNe!.coordinates![0],
            )),
        southwest: Point(
            coordinates: Position(
              itinerary.destination!.bboxSw!.coordinates![1],
              itinerary.destination!.bboxSw!.coordinates![0],
            )),
      );
    }

    final boundsProcessed = <LatLngBounds>[];

    for (final itinerary in travel.itineraries!) {
      final bounds = getBounds(itinerary);
      if (!boundsProcessed.contains(bounds)) {
        final minZoom = itinerary.destination!.minZoom!.toInt();
        final maxZoom = itinerary.destination!.maxZoom!.toInt();
        await _downloadItineraryMap(bounds, minZoom, maxZoom);
        boundsProcessed.add(bounds);
      }
    }
  }

  Future<void> _initializeMapbox() async {
    MapboxOptions.setAccessToken("key");
  }

  Future<void> _downloadStylePack() async {
    await _initializeMapbox();
    final offlineManager = await OfflineManager.create();
    final stylePackLoadOptions = StylePackLoadOptions(
        glyphsRasterizationMode: GlyphsRasterizationMode.IDEOGRAPHS_RASTERIZED_LOCALLY,
        metadata: {"tag": "test"},
        acceptExpired: false);

    await offlineManager.loadStylePack(
        'mapbox://styles/mapbox/streets-v11', stylePackLoadOptions, (progress) {
      final percentage =
          progress.completedResourceCount / progress.requiredResourceCount;
      if (!_stylePackProgress.isClosed) {
        _stylePackProgress.sink.add(percentage);
      }
    }).then((value) {
      _stylePackProgress.sink.add(1);
      _stylePackProgress.sink.close();
    }).catchError((error) {
      print('Error loading style pack: $error');
    });
  }

  Future<void> _downloadItineraryMap(
      LatLngBounds bounds,
      int minZoom,
      int maxZoom,
      ) async {
    var downloading = true;

    double centerLatitude =
        (bounds.southwest.coordinates[0]! + bounds.northeast.coordinates[0]!) / 2;
    double centerLongitude =
        (bounds.southwest.coordinates[1]! + bounds.northeast.coordinates[1]!) / 2;
    num southWestLatitude = bounds.southwest.coordinates[0]!;
    num southWestLongitude = bounds.southwest.coordinates[1]!;
    num northEastLatitude = bounds.northeast.coordinates[0]!;
    num northEastLongitude = bounds.northeast.coordinates[1]!;

    final bbox = BBox(
        southWestLongitude,
        southWestLatitude,
        northEastLongitude,
        northEastLatitude
    );

    final tmpDir = await getTemporaryDirectory();
    final tileStore = await TileStore.createAt(tmpDir.uri);
    if (tileStore != null) {
      print('TileStore created at ${tmpDir.uri}');
    } else {
      print('Failed to create TileStore');
    }

    final tileRegionLoadOptions = TileRegionLoadOptions(
        geometry: Point(
            coordinates: Position(centerLongitude, centerLatitude),
            bbox: bbox
        ).toJson(),
        descriptorsOptions: [
          TilesetDescriptorOptions(
            styleURI: 'mapbox://styles/mapbox/streets-v11',
            minZoom: minZoom,
            maxZoom: maxZoom,
          )
        ],
        acceptExpired: true,
        networkRestriction: NetworkRestriction.NONE);

    await tileStore.loadTileRegion(
        '$centerLatitude,$centerLongitude', tileRegionLoadOptions, (progress) {
      final percentage =
          progress.completedResourceCount / progress.requiredResourceCount;
      if (!_tileRegionLoadProgress.isClosed) {
        _tileRegionLoadProgress.sink.add(percentage);
      }
    }).then((value) {
      _tileRegionLoadProgress.sink.add(1);
    }).catchError((error) {
      print('Error loading tile region: $error');
    });
  }

      builder: (context, state) {
        _itinerary = state.selectedItinerary;
        _userLocation = state.userLocation;
        initLocation();
        MapboxOptions.setAccessToken("Key");
        return MapWidget(
          key: ValueKey("Key"),
          textureView: true,
          onMapCreated: (MapCreatedCallback) {
            _controller = MapCreatedCallback;
            _controller?.loadStyleURI('mapbox://styles/mapbox/streets-v11');
            _controller?.scaleBar.updateSettings(ScaleBarSettings(enabled: false));
            _controller?.location.updateSettings(LocationComponentSettings(
                enabled: true, locationPuck: LocationPuck(locationPuck2D: DefaultLocationPuck2D(),),),);
            _initMapComponents(_itinerary!);
          },
          onTapListener: (contextGesture) {
            _resetSelectedSymbol();
          },
        );
      },