Display a map

Maps specify how geographic data is organized and how it should be communicated to your app users. Each instance of a map (AGSMap) represents an individual map you can display for your users. To display a map you must assign it to a map view (AGSMapView). In an MVC architecture, the map represents the model tier and the map view represents the view tier. The map and map view work together to visualize the geographic data on a screen.

Users can interact with the map and its layers using the map view's built-in navigation tools. You have many ways to enhance this experience by configuring the look and feel of the map and adding business logic to these user interactions.

Open a map

You can open a map by creating it from a web map or from a mobile map package.

Create the map object from a web map

Web maps can be accessed using either their URL or directly from a portal using their portal item ID. Both methods are described here along with the authentication process required to access the map if it or its data is not public.

Using a web map URL

You can construct the map object from one of the map’s URL strings as follows:

@property (nonatomic, strong) AGSMap *map;
self.map = [[AGSMap alloc] initWithURL:[NSURL URLWithString:@"https://....."]];

The map constructor supports these three URL formats:

  • The map viewer URL—For example, https://www.arcgis.com/home/webmap/viewer.html?webmap=69fdcd8e40734712aaec34194d4b988c. The URL is provided in the browser's address bar when a web map is created or viewed using the ArcGIS.com map viewer.
  • The item details URL—For example, https://www.arcgis.com/home/item.html?id=69fdcd8e40734712aaec34194d4b988c. This URL is found in the address bar when you're viewing the details page for an item presented in My Content in ArcGIS.com.
  • The item data URL—For example, https://www.arcgis.com/sharing/rest/content/items/69fdcd8e40734712aaec34194d4b988c/data?. This is the address of the JSON string that represents the information to display the map.

If the map is not public, the API’s authentication challenge handler automatically requests that the user provides his credentials.

Using a web map portal item

You can construct the map object using the map's portal item ID. You can find this 32 character ID within any of the three URLs described above. For example, here is a map that's identified by the item ID of 69fdcd8e40734712aaec34194d4b988c.

Web map details page

  1. Create the portal object by providing the URL string to the portal. In the example below, the public map is accessed from ArcGIS Online (www.arcgis.com).

    //construct the portal from the URL of the portal
    self.portal = [[AGSPortal alloc] initWithURL:[NSURL URLWithString:@"https://www.arcgis.com"] loginRequired:FALSE];

  2. Construct the portal item object by providing the portal and the item ID string for the map.

    //construct a portal item from the portal and item ID string
    self.portalItem = [[AGSPortalItem alloc] initWithPortal:self.portal itemID:@"e229d715f7ca4fa980308549fb288165"];

  3. Pass the portal item to the map constructor.

    //construct a map from the portal item
    self.map = [[AGSMap alloc] initWithItem:self.portalItem];

Upon completion of this code, neither the portal, portal item, nor the map are loaded. These objects will be loaded when you pass the map to the map view or if you load them explicitly. See the loadable pattern topic for more information. You can override any of the map's properties by setting their value before the map is loaded.


If the map or its layers are not public, you need to provide credentials to access them. In these cases you can either rely on the API’s authentication challenge handler to prompt the user for their credentials or you can provide your own login facility and pass the credentials to the portal's Credential property as described in the Access the ArcGIS platform topic.

Create a map object from a mobile map package

A mobile map package is a file object (.mmpk) created in ArcGIS Pro. It is a transport mechanism for maps, their layers, data, networks, and locators. A mobile map package can be sideloaded onto a device by email, or by platform-specific transfer mechanism such as AirDrop, or it can be downloaded from a portal to the device.


StreetMap Premium also provides ready-to-use and regularly updated mobile map packages that include a street map, locator, and network dataset for areas throughout the globe. For details, see Add StreetMap Premium data.

Each mobile map package can contain one or more maps that can be displayed in a map view. For more information, see creating mobile map packages.

  1. Obtain the file path to the mobile map package.

    // The mobile map package has been placed in the apps documents folder
    NSString *documentFolder = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES)[0];
    NSString *filepath = [documentFolder stringByAppendingString:@"/CaliforniaNevada.mmpk"];
    NSURL *fileURL = [[NSURL alloc]initWithString:filepath];

  2. Construct the mobile map package object using the file path.

    self.mobileMapPackage = [[AGSMobileMapPackage alloc] initWithFileURL:fileURL];

  3. The mobile map package must be loaded into the app before the maps themselves can be accessed. Once the mobile map package is loaded, any of its maps can be assigned to the map view to be displayed.

    __weak __typeof(self) weakSelf = self;
    [self.mobileMapPackage loadWithCompletion:^(NSError * _Nullable error) {
     if (error != nil) {
     else {
      weakSelf.map = weakSelf.mobileMapPackage.maps[0];

Upon completion of this code the map is not loaded. You can override any of the map's properties by setting their value before the map is loaded. See the loadable pattern topic for more information.

Display the map in a map view

To display a map, you assign it to a map view. Each map view can display a different visible area of the map, can be configured in different ways, and can be designed to respond differently to user gestures. Assign a map to a map view as follows:

self.mapView.map = self.map;

Assigning a map to a map view initiates the map’s load cycle. When that cycle completes, the map view initiates the load cycle on the map’s layers in order to draw them. For more information loading resources (load cycles), see Loadable pattern of asynchronous resources. You can monitor the loading of the individual layers using the map view's layerViewStateChangedHandler.

You can load the map into your app before assigning it to a map view. This is useful if you want to validate the content of the map or you want to access any content or properties in the map without displaying it. For example, this code loads the map explicitly and checks if the map contains bookmarks before it displays the map in the map view.

__weak __typeof(self) weakSelf = self;

[self.map loadWithCompletion:^(NSError * _Nullable error) {
 if (error != nil) {
 else {
  if (weakSelf.map.bookmarks.count > 0) {
   //display the bookmarks
  weakSelf.mapView.map = weakSelf.map;

Monitor layer loading

Assigning a map to a map view or explicitly loading a map triggers loading of the map's basemap and operational layers. Each time the state of a layer changes, the map view's layerViewStateChangedHandler is triggered. Examine the layer's view status to determine whether a layer is active, loading, not visible, out of scale, or whether an error has occurred with the layer's loading process.

[self.mapView setLayerViewStateChangedHandler:^(AGSLayer *layer, AGSLayerViewState *layerViewState) {
 switch (layerViewState.status) {
  case AGSLayerViewStatusActive:
   NSLog(@"Active - %@", layer.name);
  case AGSLayerViewStatusLoading:
   NSLog(@"Loading - %@", layer.name);
  case AGSLayerViewStatusNotVisible:
   NSLog(@"NotVisible - %@", layer.name);
  case AGSLayerViewStatusOutOfScale:
   NSLog(@"OutOfScale - %@", layer.name);
  case AGSLayerViewStatusError:
   NSLog(@"Error - %@", layer.name);
   NSLog(@"Unknown - %@", layer.name);

Share data between maps and map views

Sharing the same map instance simultaneously among two or more map views, or a layer instance simultaneously between maps, is not supported and is likely to cause stability or performance issues. Working with graphics overlays or distinct feature layer instances that share the same data source (feature table, for example) can cause the same issues and is also not supported in multiple map views at the same time.

If you need to reuse a map in another map view, you should ensure that it is first removed from the previous control. The same technique can be used for reusing a layer instance between maps.

Monitor map drawing

If your users pan or zoom the map or the business logic in your app changes the visible area of the map, then new map content will need to be drawn. There will be a short time delay before this map drawing phase is completed. Your app may need to know that the drawing is complete. For example, you may want your app to take a snapshot, or screenshot, of the map only when the drawing has finished.

Use the map view's drawStatus to detect whether the map drawing is in progress or has completed. For example, this code displays an activity indicator if the drawing is still in progress.

For example, this code displays an activity indicator while drawing is in progress.

[self.mapView addObserver:self forKeyPath:"drawStatus" options:NSKeyValueObservingOptionNew context:nil];

-(void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary<NSString *,id> *)change context:(void *)context{
    if (self.mapView.drawStatus == AGSDrawStatusInProgress) {
    else {
        NSLog(@"Drawing complete");

Navigate the map

When a map is first loaded into a map view, it's displayed at a geographical location defined by the map's initial view point. User's can then pan or zoom the map with a range of that are built into the map view. You can access the visible area of the map as a polygon returned by the map view's visibleArea method. The visible area is returned as a polygon, and not an envelope, because the map may be rotated and each corner of the map may contain unique x-y coordinates.

AGSPolygon *polygon = self.mapView.visibleArea;

As a developer you can programmatically set the map's visible area in your app by calling one of the map view's many setViewpoint methods. Many options are available to choose from to allow you to:

  • Rotate the map to a specified angle.
  • Zoom the map to the specified scale.
  • Zoom or pan the map so that a given geometry fits the visible area of the map view.
  • Zoom or pan the map to a specified location.
  • Zoom or pan the map to a specific view point. You can define a view point using a:
    • Center and scale
    • Center, scale, and rotation
    • Latitude, longitude, and scale
    • Target extent
    • Target extent and rotation

For example, the code that follows sets the view point to a specific lat, long, and scale with an animation that lasts two seconds. Each method returns a boolean value so you can detect if the animation was interrupted by the user.

AGSViewpoint *viewpoint = [[AGSViewpoint alloc] initWithLatitude:27.3805833 longitude:33.6321389 scale:6e3];

[self.mapView setViewpoint:viewpoint duration:2 completion:^(BOOL finished) {
 if (!finished) {
  NSLog(@"Animation interrupted");

Configure the map view

You can enhance your user's map experience by showing the device's location, rotating the map display, or making the world map seamless.

Show the device's location (display the user's current location)

Many devices provide information about their location through Wi-Fi, cellular networks, or GPS. The device's operating system passes its location to the map view so you can display and track the device on a map. The map view always tries to get the most accurate location available but the reported location could be a best approximation based on signal strength, satellite positions, and other factors. By default, the map view displays the location with a blue, round symbol and a semi-transparent blue circle around this symbol to indicate the range of accuracy.

The display of the location on a map, the symbol used, the animation, and the autopan behavior are managed by an instance of AGSLocationDisplay. Each AGSMapView has its own instance of a location display.

Start displaying the device's location as follows:

[self.mapView.locationDisplay startWithCompletion:^(NSError * _Nullable error) {
 if (error != nil) {
 else {
  NSLog(@"Location Display Started");


Starting with iOS 8, apps must explicitly request authorization to access the device's location services. Two authorization modes are available, WhenInUse and Always, depending on whether the app wants access to location only in the foreground, or both the foreground and background respectively. By default, the map view requests for WhenInUse authorization. You need to add the NSLocationWhenInUseUsageDescription key to your app's Info.plist file along with the text to be displayed to the user when the app requests authorization from the user.

See AGSLocationDisplay in the API Reference.

Enable wrap around

Most flat representations of the earth extend up to 180 degrees east and west longitude and make it difficult to visualize areas that span across the 180th meridian. As we know the world is spherical and does not end at the 180th meridian. Enabling wrap around in the map view displays a 2D map extending seamlessly across the 180th meridian. For more information, see the wrap around maps topic.

Enable wrap around as follows:

self.mapView.wrapAroundMode = AGSWrapAroundModeEnabledWhenSupported;


If your map has wrap around enabled and you're working with map locations, map extents, or are editing or sketching geometries with a map, you must normalize the geometries.


Some maps do not support wrap around; maps that do support wrap around will automatically be displayed in wrap around

Rotate the map

You may not want your map to display in a North-South direction in your device. You can reorient your map in the map view by setting the viewpoint rotation. A positive rotation value rotates the map in an counterclockwise and a negative rotation value rotates the map in a clockwise direction.

//Rotate the map to 90 degrees (counterclockwise)   
[self.mapView setViewpointRotation:90 completion:^(BOOL finished) {
 if (!finished) {
  NSLog(@"User interrupted rotation animation");

Enhance the user's map interaction

You can provide extra functionality as your users interact with the map using the map view's touch delegate methods. Each delegate method returns both the screen and map coordinates at the position that the user interacted with the screen. You just need to add code within the delegate method to use these coordinates.

For iOS, map view touch delegates are available for tapping, long pressing, moving, and force touching on the device's screen. To enable touch delegates you need to:

  1. Adopt the AGSMapViewTouchDelegate protocol in your class.

    @interface ViewController : UIViewController <AGSMapViewTouchDelegate>

  2. Set your class as the mapview's touch delegate.

    self.mapView.touchDelegate = self;

  3. Implement one or more methods defined in the protocol. In this example, the map view's tap delegate is implemented to display the location of the tap point on the map.

    - (void)mapView:(AGSMapView *)mapView didTapAtPoint:(CGPoint)screen mapPoint:(nonnull AGSPoint *)mappoint features:(NSDictionary *)features {
        NSLog(@"User tapped on the map at %f,%f", mappoint.x, mappoint.y);

Take a snapshot of the map

Take a snapshot, or screen capture, of the visible area of a map using the map view's exportImageWithCompletion method. Use the image within the app or store it in a file to be shared, printed, or included in other documents.

  1. Zoom to the area of interest.
  2. Specify the image file path. Ensure that the file extension is appropriate for the image format.
    NSString *documentFolder = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, TRUE)[0];
    NSString *filepath = [documentFolder stringByAppendingString:@"/MyMapImage.jpg"];
  3. Export the map displayed in the map view to an image file. In this example the image data is returned in JPEG format that is written to a file in the documents folder.
    [self.mapView exportImageWithCompletion:^(UIImage * _Nullable image, NSError * _Nullable error) {
     if (error) {
      NSLog(@"Export image failed = %@", error.localizedDescription);
     else {
      NSData *imageData = UIImageJPEGRepresentation(image, 1.0);
      [imageData writeToFile:filepath atomically:YES];
      NSLog(@"Image file path = %@", filepath);         


If you want to store this image as a thumbnail of a portal item, be aware that the size limit of a thumbnail is 1 MB. Check the image size before saving the image as a thumbnail and, if necessary resize it.

Filter data by time

Some layer types are time-aware, meaning they contain temporal data and allow you to filter the data based on time values. You can filter data in time-aware layers by defining a time extent and applying it to the map or scene view. All time-aware layers in the map (or scene) displayed by the view will filter their data per the view's time extent (except when time filtering is not supported or is disabled).

To filter data by time, first create a time extent that captures the desired time range. For example, to include only data for the last 60 days, create two Dates, one for now and one for now minus 60 days:

The start time must be less than the end time - otherwise, an exception will be thrown.

Next, apply the time extent to the view:

All applicable layers in the map (or scene) contained by the view will now only show data from the last 60 days. These include layers that:

  • Support time filtering
  • Are connected to time-enabled data sources
  • Have not had time filtering disabled

You can explicitly exclude layers from participating in time filtering.

You can also detect if an otherwise time-aware layer is incapable of working with time (e.g. because it is connected to a data source without time values).