Another option to constrain the map is to set the minimum and maximum scale so that users can only zoom in or out so far. This can be important for novice users because they can zoom in too far and not see any detail and not realize that they just need to zoom out with their mouse or a gesture. The two properties are MaxScale and MinScale. You can use them alone or together. For example, you may want to restrict the user from zooming in beyond a scale of 1:1,000.

Giving your users the ability to click on an object on the map is a nice feature that your users will enjoy when they interact with the map. Otherwise known as MapTips, overlays define what happens when your user clicks on an object using XAML or in code. For example, the following XAML code sets the overlay for a single layer that is using a field named MYFIELD from a layer named FeatureLayer:

<esri:MapView.Overlays>
    <esri:OverlayItemsControl x:Name="overlayItemsControl">
        <Border 
            CornerRadius="10" 
            BorderBrush="Black" 
            Margin="0,0,25,25" Visibility="Hidden"
            BorderThickness="2" Background="#995C90B2" >

            <StackPanel Orientation="Vertical" Margin="5,10,18,15">
                <StackPanel Orientation="Horizontal">
                    <TextBlock Text="" FontWeight="Normal" 
                Foreground="Black"/>
                </StackPanel>
                <Line X1="0" X2="200" Y1="0"  Y2="0" 
                     Stroke="White"
                StrokeThickness="2" />
                <StackPanel Orientation="Horizontal">
                    <TextBlock Text="Name: " FontWeight="Normal" 
                     Foreground="Black"/>
                    <TextBlock Text="{Binding [MYFIELD]}" 
                        FontWeight="Normal" 
                    Foreground="Black" />  
                </StackPanel>
            </StackPanel>
        </Border>
    </esri:OverlayItemsControl>   
</esri:MapView.Overlays> 

The FeatureLayers are a kind of layer that contains geometry such as points, lines, polygons, and attributes. With an overlay, you can click on a point and see information about that point as shown here:

Displays the information about the point

In order to edit layers that allow editing, the MapView container contains an Editor class. Once you have a reference to MapView, the Editor class is available to add, update, and delete objects on the map, such as points, lines, arrows, triangles, and polygons. With this single class, you can edit both online and offline layers, which makes editing pretty easy to accomplish. Editing not only includes the ability to manipulate geometry, it also includes the ability to edit attributes (fields) of the data too. If the data resides in an online service, the edits you make will be immediately reflected online. If you allow your users to edit offline data, the edits will be stored in a local store until you synchronize them to an online service or copy them to an enterprise geodatabase for other uses.

WrapAround is a nice property if you want to give your users the ability to pan east or west around the globe. When they pan the map, they will automatically go around the International Date Line. Just set this property to true to activate it.

With the LocationDisplay property on the MapView container, you can get your current location via a location provider. A location provider can be the GPS in your device, an attached GPS, or a custom location provider, such as a random location simulator.

The MapView container also has many events that aid in the development of providing your app with a rich user experience. Some of the more interesting and useful events are Initialized, MapViewDoubleTapped, MouseDoubleClick, MouseDown, MouseMove, StylusButtonDown, StylusDown, TouchDown, TouchMove, and TouchUp. Depending on whether the app is being interacted with via mouse, stylus, or touch, will determine the events that you need to handle and the requirements you are trying to implement.

When it comes to how the user interacts with the map, you have many options you can control. You can enable the zoom options, whether double-tapping is enabled, whether a zoom box is enabled, whether rotation and panning are allowed, and so on. To set this in XAML, add the following example code after you've defined the MapView container and before the Map XAML line:

<esri:MapView.InteractionOptions>
    <esri:InteractionOptions>
        <esri:InteractionOptions.ZoomOptions>
            <esri:ZoomOptions IsEnabled="True"  
                IsDoubleTappedEnabled="False"
                IsZoomBoxEnabled="True"
                IsMouseWheelEnabled="True"
                IsPinchEnabled="True"
                IsTwoFingerTapEnabled="True"
            IsKeyboardEnabled="False" />
        </esri:InteractionOptions.ZoomOptions>
        <esri:InteractionOptions.RotationOptions >
            <esri:RotationOptions IsEnabled="False" />
        </esri:InteractionOptions.RotationOptions>
        <esri:InteractionOptions.PanOptions>
            <esri:PanOptions IsEnabled="True"
                IsDragEnabled="True"
                IsFlickEnabled="True"
            IsKeyboardEnabled="True" />
        </esri:InteractionOptions.PanOptions>
    </esri:InteractionOptions>
</esri:MapView.InteractionOptions>

Every time you zoom in and out, panning whether with a mouse or your finger, you are changing the extent of the map you are viewing. The extent is set with coordinates, hence it's important for you to understand your coordinate system. The extent is rectangular with a minimum and maximum x and minimum and maximum y value. You can set the initial extent of the map in XAML like this:

<esri:MapView x:Name="MyMapView">
    <esri:Map x:Name="MyMap">
        <esri:Map.InitialViewpoint>
            <esri:Map.InitialViewpoint >
                <esri:ViewpointExtent XMin="12.34" YMin="41.85" 
                XMax="12.55" YMax="41.95"
                SpatialReferenceID="4326" />
            </esri:Map.InitialViewpoint>
        </esri:Map.InitialViewpoint>
    </esri:Map>
</esri:MapView>

You're now looking at Rome, Italy. This will work no matter the projection of the first layer in the map because the spatial reference was also set using SpatialReferenceID. If your map shows up in an incorrect location, the first thing to check is the extent coordinates and the spatial reference.

You can also just use ViewpointCenter to set the x and y fields and the scale too. This property will place the map at the exact x and y coordinates and the scale you provide.

These are the only two parameters that you can use to set the extent using XAML. All other parameters have to be set with code, which would reside in the ViewModel classes. Setting the extent is handled with the following methods: SetView, SetViewAsync, ZoomAsync, and ZoomToScaleAsync. The extent can be set with MapPoint and Viewpoint with geometry such as a bounding rectangle, or scale. Here is an example:

MapPoint point =  new Esri.ArcGISRuntime.Geometry.MapPoint(12.5, 
    41.9, new SpatialReference(4326));
mapView.SetViewAsync(point, 100000);

This code has the same effect as the previous code except that it zooms out to a scale of 1:100,000 around Rome.

A dynamic map service is a map with one or more layers, which users can interact with just as they do from ArcGIS Desktop. In other words, users are able to view and interact with the geometry and fields of the layers. A user can search, change symbology if enabled, identify, and so on. Every time the user zooms or pans, an image is generated on the fly. This can be an expensive process because this step involves taking a snapshot of the extent with the geometry and sending it to the client.

To access these services, all you have to do is specify the REST endpoint from either in the cloud via AGOL or from your own implementation of the ArcGIS Server.

You can think of a tiled map service as a high-performance approach to taking many geometry-based (vector) and/or imagery-based (raster) layers and converting them to tiled images. When you look at one of these layers across the entire earth, you are actually looking at a few images, which are actually snapshots. Basically, the earth is being divided up into a series of tiled images. So, instead of seeing the original geometry, which would be too slow to visualize, you are seeing pictures broken up at different scales.

Many of these layers are called basemaps because they contain a set of layers that have been merged to form a picture that is fast and can move quickly across the Internet due to the fact that the images have been compressed in some cases.

Creating these tiles is done with ArcGIS Desktop, and then published to AGOL or ArcGIS Server. Although the process to generate these tiles can be slow, sometimes very slow, the end result is that users of these kinds of layers get very fast rendering times because they are just looking at pictures (tiles). As we are only viewing tiles, you can't do anything else with the tiles, such as querying, identifying, and the other things you can do with dynamic map services and feature services.

As you've seen many times now, all you have to do is specify the URI and name and you now have a basemap layer. There are many basemaps available, which has lessened the need for most organizations to develop their own.

Navigate to the following link to see a complete list:

http://www.arcgis.com/home/group.html?owner=esri&title=Tiled%20Basemaps

Click on Details under the snapshot of the basemap, and then find the REST endpoint in the description or Map Contents section. You can use as many of these maps as you want, but always remember that the more you add, the slower the performance, so choose the best one for your app.

A local tiled layer is similar in concept to the ArcGISTiledMapServiceLayer, except that it resides on a local disk for disconnected viewing. The tiles are cached to a disk using ArcGIS Desktop into a single .tpk file and copied to the device for offline use. As such, it is very fast because it doesn't rely on an Internet connection.

The feature service is a service in some ways like a dynamic map service except that no image is generated when it is drawn. What actually happens is that the geometry and attributes are returned across the Web in the form of JSON to the client, which users can view, query, change symbology, and edit. The editing capability is the primary reason to use the feature service. This is an important type of service because it allows for both connected and disconnected editing on a device. In fact, with this service, you can download data, go disconnected, perform edits, and then synchronize your edits when you go back online. Or, if you're always connected, you can just edit this service directly at all times.

To create this kind of layer, you must create it using ArcGIS Desktop. It is, by default, not enabled when a service is created. Once the service is created, you can access it by using the following code:

<esri:FeatureLayer ID="Incidents">
    <esri:ServiceFeatureTable 
        ServiceUri="http://sampleserver6.arcgisonline.com/arcgis/rest/services/SF311/FeatureServer/0" />
</esri:FeatureLayer>

Note that in the REST endpoint, it denotes this service as FeatureServer/0. This indicates that it's a feature service and we're accessing the zero layer, which is the first layer in this service. Also, note that we define the layer using FeatureLayer, and then inside the FeatureLayer class, there is a ServiceFeatureTable property. Using ServiceFeatureTable indicates that this service is coming from an online source. Alternatively, you can use a FeatureLayer class to access an offline data source coming from an ArcGIS Runtime geodatabase via ArcGISFeatureTable. The first thing you will need to do is open the Runtime geodatabase with the following code:

var gdb = await Geodatabase.OpenAsync(gdbPath);

Once you have an access to the geodatabase, you can find and add layers to the map with the following code:

// loop thru all tables in the geodatabase
foreach (var table in gdb.FeatureTables.ToList())
{
    // create a new feature layer to display each table
    var lyr = new FeatureLayer
    {
        ID = table.Name + "Offline", 
        DisplayName = table.Name,
        FeatureTable = table
    };
    
    // add each layer to the map
    MyMapView.Map.Layers.Add(lyr);
}

If you navigate to http://sampleserver6.arcgisonline.com/arcgis/rest/services, you will find many feature services. Any service listed with (FeatureServer) beside its name is FeatureService:

Later on in this chapter, we will explore how to open a Runtime geodatabase without using a feature service. Also, in Chapter 9, Editing Features, we will explore the editing pattern in much more detail.

The image services are accessed via the ArcGISImageServiceLayer. These kinds of layers can come from both online and offline local sources in the form of aerial photography, for example. To add one of these kinds of services from XAML, use this code:

<esri:ArcGISImageServiceLayer ID="Imagery of Toronto"
    ServiceUri="http://sampleserver6.arcgisonline.com/arcgis/rest/services/Toronto/ImageServer">

</esri:ArcGISImageServiceLayer>

The following site has some image services that you can use: https://sampleserver3.arcgisonline.com/ArcGIS/rest/services/World.

A graphics layer is used for showing dynamic content or any content that is temporary in nature. For example, you may want to give your user the ability to mark up a map or show the real-time position of a fast-moving drone on the map. You can add as many graphic layers as you need, but typically, you'll find that you need three or less. To add a graphics layer via code, you'd enter something like the following:

var graphicsLayer = new Esri.ArcGISRuntime.Layers.GraphicsLayer();
graphicsLayer.ID = "MyGraphicsLayer";

// add the graphics layer to the map
MyMapView.Map.Layers.Add(graphicsLayer);

However, this only creates the layer; it doesn't actually add anything to the layer. To accomplish this, you will need to input the following code:

// create a symbol (large cyan circle) for displaying a point
var markerSym = new Esri.ArcGISRuntime.Symbology.SimpleMarkerSymbol();
markerSym.Color = Colors.Cyan;

markerSym.Size = 18;
markerSym.Style = Esri.ArcGISRuntime.Symbology.SimpleMarkerStyle.Circle;

// create a marker graphic for the center of the map's extent
var pointGraphic = new Esri.ArcGISRuntime.Layers.Graphic(MyMapView.Extent.GetCenter(), markerSym);

// add the graphic to the graphics layer for display on the map
graphicsLayer.Graphics.Add(pointGraphic);

This code creates a symbol with a certain color, size, and style, and then creates a graphic from a point using the center of the map, and finally adds the resulting graphic to the graphics layer. More details on symbology will be covered in Chapter 5, Geometry and Symbology.

A CSV layer is a layer from a CSV file, which contains text data that is delimited by some characters for each column. Each line of the file contains a row. The CsvLayer class is a type of GraphicsLayer.

A Bing layer is a service provided by Microsoft's Bing tiled map services. The key difference between this service and other services that we've discussed is that it's accessed via SOAP as opposed to REST. Also, you must acquire a key using a Bing account from https://www.bingmapsportal.com/.

Once you've acquired this key, you can add a layer using the following code:

var bingMapLayer = new Esri.ArcGISRuntime.Layers.BingLayer();
bingMapLayer.Key = "gqw%2ss@2";
bingMapLayer.MapStyle = Esri.ArcGISRuntime.Layers.BingLayer.LayerType.AerialWithLabels;

Keyhole Markup Language (KML) is an XML notation for representing geographic data in 2D and 3D in Google Maps and Google Earth. Since its inception in 2004, it has become very popular with both GIS and non-GIS professionals as a means to make layers. To add a layer via code to the map is just as easy as the previous examples:

// create a KML layer from an online file
var sourceUri = new Uri("http://earthquake.usgs.gov/earthquakes/feed/v1.0/summary/1.0_week_age_link.kml");
var kmlLayer = new KmlLayer(sourceUri);

// Add the kml layer to the map
MyMapView.Map.Layers.Add(kmlLayer);

A group layer is a mechanism to logically group your layers. For example, you can group all of our operational layers (FeatureLayers) into a group so that when they show up in a legend they are under one branch (folder) in the legend. The group layers don't store data themselves, they just contain other kinds of layers. You can create as many group layers as you need. Here is an example of creating a group layer in XAML:

<esri:GroupLayer DisplayName="Basemap Group">
    <esri:ArcGISTiledMapServiceLayer 
        DisplayName="Imagery" IsVisible="False"
        ServiceUri="http://services.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer" />
    <esri:ArcGISTiledMapServiceLayer DisplayName="Street"
        ServiceUri="http://services.arcgisonline.com/ArcGIS/rest/services/World_Street_Map/MapServer" />
</esri:GroupLayer>

A message layer displays military symbols using graphics that conform to the MIL-STD-2525C or APP6B standards by having a message using a Symbol ID Code (SIC) sent to this layer type.

A message sublayer is a sublayer of a message layer and it's where messages are sent for display on the map.

A scene layer is a layer for rendering 3D content in a scene/scene view. This kind of layer can't be viewed in a MapView/Map container. With this kind of layer, 3D content such as buildings, trees, and transmission towers, and generic 3D objects such as spheres, pyramids, and cones can also be viewed. This kind of layer will be discussed in the next chapter.

The web map service layer allow you to add Open Geospatial Consortium (OGC) services to a map. Typically, this layer is a basemap layer or an operational layer in the form of a dynamic map service.

The OpenStreetMap editor is a crowd source basemap based on tiles, which you can utilize via the OpenStreetMapLayer.

A local tiled package is similar in concept to a tiled service from an online source except that it is saved into a file, which can be side loaded on a device. Refer to the following ArcGIS site for help and more details about creating a tile package: http://desktop.arcgis.com/en/desktop/latest/map/working-with-arcmap/how-to-create-a-tile-package.htm.

Let's create a new app based on San Francisco that allows us to visualize this great city using the MVVM pattern in case we need to have offline access:

As you can see in this screenshot, our map contains the tile package that covers the bay area. We are no longer using a web service of the world. We had to instantiate the layer using the path to the tile package, initialize it, and then add it to the map. All of this occurred in our ViewModel class.

A map package is simply a compact representation of an ArcGIS Desktop map document. With ArcGIS Runtime, it's possible to view and query this data in the map. This is accomplished by instantiating a local server that allows you to interact with the map as if you were interacting with a map service from ArcGIS Server. Did you catch that? A local server is like a mini version of ArcGIS Server running on your desktop machine. With this local server, you are the administrator and consumer of the data. You have full control over how the local server is configured, including the service life cycle. In fact, it's up to you to start and stop the local server just like you would run ArcGIS Server.

To create a map package via ArcGIS Desktop, navigate here:

http://desktop.arcgis.com/en/desktop/latest/map/working-with-arcmap/creating-a-map-package.htm

We will once again use some sample data and make use of a map package:

A Runtime geodatabase is basically a SQLLite database, which is ideal for a mobile app. It can contain feature layers for editing on a device. For more details on how to create this kind of geodatabase, see the ArcGIS Desktop help here: http://desktop.arcgis.com/en/desktop/latest/map/working-with-arcmap/creating-arcgis-runtime-content.htm

Let's add a Runtime geodatabase to our app: