Viewport

The viewport represents the ways to position camera.

The viewport may be set to the map as initial viewport:

 Map(initialViewport: .styleDefault)

or as binding:

struct UserLocationMap: View {
  @State var viewport: Viewport = .followPuck(zoom: 16, bearing: .heading)
  var body: some View {
    Map(viewport: $viewport)
  }
}

Viewport change can be animated via the withViewportAnimation(_:body:completion:).

  struct AnimatedMap: View {
      @State var viewport: Viewport = .styleDefault
      var body: some View {
          Map(viewport: $viewport)
              .overlay {
                  Button("Locate the user") {
                      withViewportAnimation {
                          viewport = .followPuck(zoom: 16, bearing: .heading, pitch: 60)
                      }
                  }
              }
      }
  }

Configuraton options for ViewportManager.

ViewportStatus contains 3 cases that express what the ViewportManager is doing at any given time.

The state(_:) and transition(_:toState:) cases have associated values that are reference types, so equality and hash are implemented in terms of the identities of those objects.

ViewportStatusObserver must be implemented by objects that wish to register themselves using addStatusObserver(_:) so that they can observe status changes.

Constants that describe why status changed.

ViewportState is a protocol that ViewportManager depends on as it orchestrates transitions to and from different states.

A ViewportState is a reference type and must not be shared among multiple ViewportManager instances simultaneously.

The observeDataSource(with:) method allows ViewportTransitions to consume a stream of camera updates from a target state while executing a transition. startUpdatingCamera() and stopUpdatingCamera() are invoked to tell the state that it should assume or relinquish control of the map’s camera. These are typically used by ViewportManager itself after a successful transition into a state and when exiting a state, respectively.

MapboxMaps provides implementations of ViewportState that can be created and configured via methods on ViewportManager. Applications may also define their own implementations to handle advanced use cases not covered by the provided implementations.

States should generally pre-warm their data sources as soon as they are created to minimize delays when they become current. For this reason, only states that are currently (or soon-to-be) needed should be kept alive so that unneeded resources (e.g. location services) can be released.

A ViewportState implementation that tracks the location puck (to show a puck, use puckType)

Use makeFollowPuckViewportState(options:) to create instances of this class.

Configuration options for FollowPuckViewportState.

Each of the CameraOptions-related properties is optional, so that the state can be configured to only modify certain aspects of the camera if desired. This can be used, to achieve effects like allowing zoom gestures to work simultaneously with FollowPuckViewportState.

Expresses the different ways that FollowPuckViewportState can obtain values to use when setting CameraOptions.

A ViewportState implementation that shows an overview of the geometry specified by its geometry.

Use makeOverviewViewportState(options:) to create instances of this class.

Configuration options for OverviewViewportState.

ViewportTransition is a protocol that ViewportManager depends on as it orchestrates transitions to and from different ViewportStates.

MapboxMaps provides implementations of ViewportTransition that can be created and configured via methods on ViewportManager. Applications may also define their own implementations to handle advanced use cases not covered by the provided implementations.

A default ViewportTransition implementation.

Use makeDefaultViewportTransition(options:) to create instances of this class.

Configuration options for DefaultViewportTransition.

A ViewportTransition implementation that transitions immediately without any animation.

Use makeImmediateViewportTransition() to create instances of this class.