Offline data

Offline data is downloaded from a feature service as a geodatabase file.

The steps to download offline data from a feature service are:

1. Create a Geodatabase Sync Task referencing the feature service.
   ArcGIS Runtime API for .NETArcGIS Runtime API for .NETArcGIS Runtime API for AndroidArcGIS Runtime API for .iOSArcGIS Runtime API for JavaArcGIS Runtime API for Qt (C++)ArcGIS Runtime API for Qt (QML)

   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
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   GeodatabaseSyncTask geodatabaseSyncTask = await GeodatabaseSyncTask.CreateAsync(featureServiceUrl);
   

   Go to sample
2. Use the Geodatabase Sync Task to create a Generate Geodatabase Job specifying the requested geographic area, and the download location for the geodatabase file that will be created.
   ArcGIS Runtime API for .NETArcGIS Runtime API for .NETArcGIS Runtime API for AndroidArcGIS Runtime API for .iOSArcGIS Runtime API for JavaArcGIS Runtime API for Qt (C++)ArcGIS Runtime API for Qt (QML)

   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
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   GenerateGeodatabaseParameters gdbParams = await geodatabaseSyncTask.CreateDefaultGenerateGeodatabaseParametersAsync(areaOfInterest);
   
   GenerateGeodatabaseJob generateJob = geodatabaseSyncTask.GenerateGeodatabase(gdbParams, "path\\to\\file.geodatabase");
   

   Go to sample
3. Start the job and wait for it to complete, returning a ready to use Geodatabase that references the downloaded geodatabase file. Use this to access Geodatabase Feature Tables which can be queried and edited. You can use a Geodatabase Feature Table to create an Feature Layer, which can be added to a map.
   ArcGIS Runtime API for .NETArcGIS Runtime API for .NETArcGIS Runtime API for AndroidArcGIS Runtime API for .iOSArcGIS Runtime API for JavaArcGIS Runtime API for Qt (C++)ArcGIS Runtime API for Qt (QML)

   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
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   Geodatabase generateResult = await generateJob.GetResultAsync();
   

   Go to sample

Offline data is downloaded from a vector tile service or the basemap layer service as a vector tile package (VTPK) and typically an item resource cache.

The steps to download offline data as a vector tile package (VTPK) are:

1. Create an Export Vector Tiles Task referencing the vector tile service or basemap layer service.
   ArcGIS Runtime API for .NETArcGIS Runtime API for .NETArcGIS Runtime API for AndroidArcGIS Runtime API for .iOSArcGIS Runtime API for JavaArcGIS Runtime API for Qt (C++)ArcGIS Runtime API for Qt (QML)

   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
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   ExportVectorTilesTask exportVectorTilesTask = await ExportVectorTilesTask.CreateAsync(vectorServiceUri);
   

   Go to API reference
2. Use the Export Vector Tiles Task to create an Export Vector Tiles Job specifying the requested geographic area, and the download location for both the VTPK and the item resource cache that will be created.

   When downloading vector tiles from the basemap layer service, by default the item resource cache will include a full set of fonts for multiple languages. Applications that only need Latin fonts can opt-in to downloading a smaller set of fonts. This typically reduces the size of the downloaded fonts by about 80MB.

   ArcGIS Runtime API for .NETArcGIS Runtime API for .NETArcGIS Runtime API for AndroidArcGIS Runtime API for .iOSArcGIS Runtime API for JavaArcGIS Runtime API for Qt (C++)ArcGIS Runtime API for Qt (QML)

   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
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   ExportVectorTilesParameters exportVectorTilesParams = await exportVectorTilesTask.CreateDefaultExportVectorTilesParametersAsync(areaOfInterest, 0);
   ExportVectorTilesJob exportVectorTilesJob = exportVectorTilesTask.ExportVectorTiles(exportVectorTilesParams, "path\\to\\file.vtpk", "\\path\\to\\cache\\dir");
   

   Go to API reference
3. Start the job and wait for it to complete, returning a ready to use Vector Tile Cache that references the downloaded VTPK file and an Item Resource Cache that references the downloaded item resource cache. Use these to create an ArcGIS Vector Tiled Layer which can be added to a map.
   ArcGIS Runtime API for .NETArcGIS Runtime API for .NETArcGIS Runtime API for AndroidArcGIS Runtime API for .iOSArcGIS Runtime API for JavaArcGIS Runtime API for Qt (C++)ArcGIS Runtime API for Qt (QML)

   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
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   ExportVectorTilesResult vectorExportResult = await exportVectorTilesJob.GetResultAsync();
   ArcGISVectorTiledLayer vectorTileLayer = new ArcGISVectorTiledLayer(vectorExportResult.VectorTileCache, vectorExportResult.ItemResourceCache);
   

   Go to API reference

Offline data is downloaded from an image tile service or the basemap layer service as an image tile package (TPK).

The steps to download offline data as an image tile package (TPK) are:

1. Create an Export Tile Cache Task referencing the image tile service or basemap layer service.
   ArcGIS Runtime API for .NETArcGIS Runtime API for .NETArcGIS Runtime API for AndroidArcGIS Runtime API for .iOSArcGIS Runtime API for JavaArcGIS Runtime API for Qt (C++)ArcGIS Runtime API for Qt (QML)

   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
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   ExportTileCacheTask exportImageTilesTask = await ExportTileCacheTask.CreateAsync(imageTileUrl);
   

   Go to sample
2. Use the Export Tile Cache Task to create an Export Tile Cache Job specifying the requested geographic area, minimum and maximum scales to include image tiles, and the download location for the tile package that will be created. The minimum scale is particularly important as the number of image tiles that are included goes up exponentially as you zoom further into the map, increasing the size of the offline data TPK and the time it takes to generate it.
   ArcGIS Runtime API for .NETArcGIS Runtime API for .NETArcGIS Runtime API for AndroidArcGIS Runtime API for .iOSArcGIS Runtime API for JavaArcGIS Runtime API for Qt (C++)ArcGIS Runtime API for Qt (QML)

   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
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   ExportTileCacheParameters exportImageTileParams = await exportImageTilesTask.CreateDefaultExportTileCacheParametersAsync(
       areaOfInterest: areaOfInterest,
       minScale: 500_000_000,
       maxScale: 10_000_000);
   
   ExportTileCacheJob exportImageTilesJob = exportImageTilesTask.ExportTileCache(exportImageTileParams, "\\path\\to\\file.tpk");
   

   Go to sample
3. Start the job and wait for it to complete, returning a ready to use Tile Cache that references the downloaded TPK file. Use this to create an ArcGIS Tiled Layer which can be added to a map.
   ArcGIS Runtime API for .NETArcGIS Runtime API for .NETArcGIS Runtime API for AndroidArcGIS Runtime API for .iOSArcGIS Runtime API for JavaArcGIS Runtime API for Qt (C++)ArcGIS Runtime API for Qt (QML)

   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
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   TileCache exportImageTileCacheResult = await exportImageTilesJob.GetResultAsync();
   
   ArcGISTiledLayer imageTiledLayer = new ArcGISTiledLayer(exportImageTileCacheResult);
   

   Go to sample

Access previously downloaded offline data from a feature service by creating a Geodatabase from the downloaded geodatabase file:

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
79
80
81
82
83
84
85
86
87
88
89
90
91
Geodatabase offlineGeodatabase = await Geodatabase.OpenAsync("path\\to\\file.geodatabase");

Use the Geodatabase to create Geodatabase Feature Tables which can be queried and edited. A Geodatabase Feature Table can be used to create a Feature Layer which can be added to a map.

The steps to access previously downloaded offline data from a VTPK are:

1. Create a Vector Tile Cache from the downloaded VTPK file.

2. Optionally create an Item Resource Cache from the downloaded item resource cache folder.

   ArcGIS Runtime API for .NETArcGIS Runtime API for .NETArcGIS Runtime API for AndroidArcGIS Runtime API for .iOSArcGIS Runtime API for JavaArcGIS Runtime API for Qt (C++)ArcGIS Runtime API for Qt (QML)

   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
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   VectorTileCache vectorTileCache = await VectorTileCache.CreateAsync("\\path\\to\\file.vtpk");
   ItemResourceCache itemResourceCache = new ItemResourceCache("\\path\\to\\cache\\dir");
   ArcGISVectorTiledLayer offlineVectorTileLayer = new ArcGISVectorTiledLayer(vectorTileCache, itemResourceCache);
   

   Go to API reference

Use the Vector Tile Cache and optional Item Resource Cache to create an ArcGIS Vector Tiled Layer which can be added to a map

Access previously downloaded offline data from an image tile package (TPK) by creating a Tile Cache from the downloaded TPK file:

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
79
80
81
82
83
84
85
86
87
88
89
90
91
TileCache offlineTileCache = new TileCache("\\path\\to\\file.tpk");
ArcGISTiledLayer reopenedImagedTileLayer = new ArcGISTiledLayer(offlineTileCache);

Use the Tile Cache to create an ArcGIS Tiled Layer which can be added to a map.