Offline data

What is offline data?

Offline data is data that is generated and downloaded from an offline-enabled data serviceData services, also known as hosted data services, are services created dynamically to store and provide access to your data in ArcGIS. Examples are feature services, vector tile services, map tile services, image services, and scene services.Learn more, such as the basemap styles serviceThe ArcGIS Basemap Styles service, also referred to as the Basemap Styles service, is a location service that provides basemap styles and data for the world. It returns styles as Mapbox styles and web maps, and data as vector tiles and/or map tiles. It supports all of the styles in the ArcGIS Basemap style and Open Basemap style family. An ArcGIS Location Platform or ArcGIS Online account is required to use the service.Learn more (including default basemap styles and custom basemap styles created using the Vector Tile Style EditorThe ArcGIS Vector Tile Style Editor is a web-based application used to create, edit, and save a custom style for vector tile basemap layer.Learn more), feature servicesA feature service is a data service that provides access to spatial and non-spatial data in feature layers, feature layer views, and tables.Learn more, vector tile servicesA vector tile service is a data service that provides access to vector tile data and a style definition.Learn more, and map tile servicesA map tile service, formerly known as image tile service, is a data service that provides access to static, pre-rendered map tiles. The tiles are typically retrieved in PNG format by specifying a specific level, row, and column value.Learn more.

You use offline data to create offline apps that:

• Support disaster recovery operations when infrastructure has been damaged.
• Enable mobile workers to collect and edit data.
• Provide current, detailed maps to large workforces.
• Display offline vector tile or map tile basemap layers.

Types of offline data

There are two types of offline data:

• Feature data is data created from a feature service. The offline data is downloaded as a geodatabaseA geodatabase is a spatial data storage format that can contain multiple datasets of geographic features and non-spatial tabular data, as well as attachments, field domain definitions, and relationships between layers/tables.Learn more file that can contain data for feature layers, non-spatial tables, and attachments. This data can be created, updated, or deleted according to the capabilities of the source feature service. Offline data edits can be synchronized with the source feature service whenever a network connection is available. To support offline data, the feature service must be sync-enabled. Later, when the offline data is no longer needed, you should unregister geodatabase to clean up the tracking metadata stored on the feature service.

• Tile data is data created from one of the following service types and downloaded as a read-only package of static tiles. Depending on the type of service, tiles will be downloaded as vector tiles or map tiles:

  Source tile service type	Downloaded files
  Basemap styles service (vector basemap layerA basemap layer is the layer in a map or scene that displays basemap data. The data source for a basemap layer is typically a basemap service.Learn more)	VTPKA vector tile package, also known as a VTPK, is a read-only data file containing static tiles of vector data.Learn more + Item Resource CacheAn item resource cache is a package of style resources downloaded from a vector tile style item in ArcGIS.Learn more
  Basemap styles service (image basemap layerA basemap layer is the layer in a map or scene that displays basemap data. The data source for a basemap layer is typically a basemap service.Learn more)	TPKAn map tile package, formerly known as image tile package, is a read-only data file containing static, pre-rendered map tiles.Learn more
  Custom basemap style created with the Vector Tile Style Editor	VTPK + Item Resource CacheAn item resource cache is a package of style resources downloaded from a vector tile style item in ArcGIS.Learn more
  Offline-enabled vector tile service	VTPK
  Offline-enabled map tile service	TPKAn map tile package, formerly known as image tile package, is a read-only data file containing static, pre-rendered map tiles.Learn more

How to work with offline data

The general workflow to work with offline data in an offline applicationAn offline application, also known as offline app, is an application that runs on a phone, tablet, laptop or desktop device with limited or no network connection. Offline applications are built with ArcGIS Maps SDKs for Native Apps.Learn more is:

1. Create

To begin working with offline data, you need to create a data service. To create a data service, you use a data management toolData management tools are ArcGIS software applications and functionality in portal and ArcGIS Pro that can be used by developers to create, manage, and edit content and data such as web maps, hosted layers, and data services for their applications.Learn more to publish a new service. The most common workflow is to import data from external data sources to create new feature layers in a feature service. Once a feature layer (and feature service) is created, you can publish additional types of services such as vector tile services and map tile services. For each service published, a hosted layer (item) is also created so you can access and manage the service and the layers within it.

The typical steps to create a feature service, vector tile service, or map tile service are:

2. Manage

Once your service is published, you need to enable it for offline use. Go to the Settings tab in the item page of the service to enable it for offline use. You also need to set a proper sharing level for your service in order for it to be discoverable.

The typical steps to manage a feature service, vector tile service, or map tile service are:

3. Access

After publishing a data service and enabling it for offline use, you can request a geographic area covered within that service to be taken offline. The service will generate offline data which you can then download to your device. You will also specify where to store the downloaded data on your local device.

After you download offline data, you can apply it to your map. The capabilities you can do with your offline data depend on the source service:

• If your source service is a feature service, you can query, edit features, and use feature layer in your map. You can also synchronize your offline edits with the source feature service, or unregister geodatabase when you no longer need the offline data.

  More info about geodatabase unregistration

  Geodatabase unregistration

  When you download offline data from a feature service, the offline data is downloaded as a geodatabase file and registered with the feature service. This allows the feature service to track edits and compare its state with the offline data, and enables synchronizing the offline data with the feature service. When the offline data is no longer needed, it is best practice to unregister it to clean up the tracking metadata stored on the feature service.

  Geodatabase unregistration is the process of removing the association between a local geodatabase containing offline data and the corresponding feature service on the server. Once unregistered, changes made to the local geodatabase will not synchronize back to the server. To unregister, a network connection is required.

• If your source service is a vector tile service, you can add the vector tile package (VTPK) and optional item resource cache as a basemap to your map.

• If your source service is a map tile service, you can add the tile package (TPK) as a basemap to your map.

There are two steps to access offline data:

1. When you download offline data and apply it on your map for the first time. This requires a network connection. The typical steps to access a feature service, vector tile service, or map tile service in your offline app are:

   Feature serviceVector tile serviceMap tile service

   1. Set up your project using one of the ArcGIS Maps SDKs for Native AppsArcGIS Maps SDKs for Native Apps, previously known as ArcGIS Runtime SDKs, are developer products for building mapping and spatial analysis applications for native devices.Learn more for your platform of choice within your preferred IDE.

   2. Define an area of interest from the feature layer you want to take offline.
   3. Create a GeodatabaseSyncTask referencing the hosted feature layer item.
   4. Get a set of default parameters to download the area of interest, and modify them to not download attachments.
   5. Create a GenerateGeodatabaseJob.
   6. Start the job and wait for it to complete, returning a ready to use Geodatabase that references the downloaded geodatabase file.
   7. Use this to access GeodatabaseFeatureTables. You can use a GeodatabaseFeatureTable to create an Feature Layer, which can be added to a map.

2. When you access previously downloaded offline data from your local storage. This does not require a network connection.

   Feature serviceVector tile serviceImage tile service

   If your source service is a feature service, you start by creating a Geodatabase from the downloaded geodatabase file:

   ArcGIS Maps SDK for .NETArcGIS Maps SDK for .NETArcGIS Maps SDK for SwiftArcGIS Maps SDK for KotlinArcGIS Maps SDK for JavaArcGIS Maps SDK for QtArcGIS Maps SDK for Flutter

   Use dark colors for code blocksCopy

   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67
   68
   69
   70
   71
   72
   73
   74
   75
   76
   77
   78
   Geodatabase offlineGeodatabase = await Geodatabase.OpenAsync("path\\to\\file.geodatabase");
   

   Go to API reference

Code examples

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
var featureServiceUri = new Uri("https://services2.arcgis.com/ZQgQTuoyBrtmoGdP/arcgis/rest/services/WaterDistributionNetwork/FeatureServer");
GeodatabaseSyncTask geodatabaseSyncTask = await GeodatabaseSyncTask.CreateAsync(featureServiceUri);

GenerateGeodatabaseParameters gdbGenerateParameters
    = await geodatabaseSyncTask.CreateDefaultGenerateGeodatabaseParametersAsync(areaOfInterest.Extent);
gdbGenerateParameters.ReturnAttachments = false;

GenerateGeodatabaseJob job = geodatabaseSyncTask.GenerateGeodatabase(gdbGenerateParameters, "path\\to\\file.geodatabase");

// Optionally listen for progress changes
job.ProgressChanged += (o,e) => { };

Geodatabase generateResult = await job.GetResultAsync();

MainMapView.Map.OperationalLayers.AddRange(
    generateResult.GeodatabaseFeatureTables.Select(table => new FeatureLayer(table))
  );

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
ExportVectorTilesTask exportVectorTileCacheTask = await ExportVectorTilesTask.CreateAsync(hostedItem);

ExportVectorTilesParameters exportVectorTilesParams = await exportVectorTileCacheTask.CreateDefaultExportVectorTilesParametersAsync(
    areaOfInterest: areaOfInterest,
    maxScale: 100);

ExportVectorTilesJob exportJob = exportVectorTileCacheTask.ExportVectorTiles(
    parameters: exportVectorTilesParams,
    vectorTileCachePath: "path\\to\\something.vtpk",
    itemResourceCachePath: "path\\to\\cache\\dir");

ExportVectorTilesResult exportResult = await exportJob.GetResultAsync();

var offlineVectorTileLayer = new ArcGISVectorTiledLayer(
    vectorTileCache: exportResult.VectorTileCache,
    itemResourceCache: exportResult.ItemResourceCache
);

MainMapView.Map.Basemap = new Basemap(offlineVectorTileLayer);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
ExportTileCacheTask exportImageTilesTask = await ExportTileCacheTask.CreateAsync(imageTileUrl);

ExportTileCacheParameters exportImageTileParams = await exportImageTilesTask.CreateDefaultExportTileCacheParametersAsync(
    areaOfInterest: areaOfInterest,
    minScale: 500_000_000,
    maxScale: 10_000_000);

ExportTileCacheJob exportImageTilesJob = exportImageTilesTask.ExportTileCache(exportImageTileParams, "\\path\\to\\file.tpk");

TileCache exportImageTileCacheResult = await exportImageTilesJob.GetResultAsync();

ArcGISTiledLayer imageTiledLayer = new ArcGISTiledLayer(exportImageTileCacheResult);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
var newFeature = geodatabaseFeatureTable.CreateFeature();
newFeature.Geometry = new MapPoint(x: -117.157, y: 32.707, spatialReference: SpatialReferences.Wgs84);
newFeature.SetAttributeValue("Name", "Friar's house");
try
{
    await geodatabaseFeatureTable.AddFeatureAsync(newFeature);
}
catch(Exception ex)
{
    // Report the error
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
existingFeature.Geometry = new MapPoint(x: -1.9025, y: 52.4559, spatialReference: SpatialReferences.Wgs84);
existingFeature.SetAttributeValue("Name", "Edgbaston");
if (existingFeature.FeatureTable is FeatureTable featureTable)
{
    try
    {
        await featureTable.UpdateFeatureAsync(existingFeature);
    }
    catch (Exception ex)
    {
        // Report the error
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
if (existingFeature.FeatureTable is FeatureTable featureTable)
{
    try
    {
        await featureTable.DeleteFeatureAsync(existingFeature);
    }
    catch (Exception ex)
    {
        // Report the error
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
Uri serviceUrl = offlineGeodatabase.Source;
GeodatabaseSyncTask gdbSyncTask = await GeodatabaseSyncTask.CreateAsync(serviceUrl);
SyncGeodatabaseParameters offlineSyncParams = await gdbSyncTask.CreateDefaultSyncGeodatabaseParametersAsync(offlineGeodatabase);

SyncGeodatabaseJob syncJob = gdbSyncTask.SyncGeodatabase(offlineSyncParams, offlineGeodatabase);
IReadOnlyList<SyncLayerResult> syncResult = await syncJob.GetResultAsync();

if (syncJob.Status != Esri.ArcGISRuntime.Tasks.JobStatus.Succeeded)
{
    // Handle errors
}

Tutorials

How-tosTutorialsSamples

Create an offline app with predefined areas

Learn how to build an offline app using an offline-enabled web map and feature layer using the ahead-of-time workflow.

Create an offline app with user-defined areas

Learn how to build an offline app using an offline-enabled web map and feature layer using the on-demand workflow.