Work with data files

Just as layers in your app can use data sourced from online services, such as ArcGIS Online, WFS, or WMS services, layers can also use data from data filesA data file is a stand-alone file containing geographic data that can be sideloaded on to a device. It is typically used in offline applications that never connect to a network.Learn more stored locally on your user's device. Local data files support scenarios where your users never have a network connection.

This page describes what you can do with data files and lists supported data file formats. It also provides details on how to use a data file in your app, which are summarized in the following steps:

1. Create, sideloadSideloading is the process of deploying a file or package to a device without using a network.Learn more, or download the data fileA data file is a stand-alone file containing geographic data that can be sideloaded on to a device. It is typically used in offline applications that never connect to a network.Learn more onto your user's device.
2. Access the data fileA data file is a stand-alone file containing geographic data that can be sideloaded on to a device. It is typically used in offline applications that never connect to a network.Learn more.
3. Create a layerA layer is a reference to a collection of geographic data that is used to access and display data. The data for layers are typically provided by the basemap layer service and data services.Learn more referencing the data fileA data file is a stand-alone file containing geographic data that can be sideloaded on to a device. It is typically used in offline applications that never connect to a network.Learn more.
4. Apply a rendererA renderer is a collection of rules and symbols used to display the data in a layer.Learn more to define symbolsA symbol defines the properties used to display a geometry or text.Learn more for features in the layer (Optional).
5. Add the layerA layer is a reference to a collection of geographic data that is used to access and display data. The data for layers are typically provided by the basemap layer service and data services.Learn more to a mapA map is a collection of layers that are displayed in 2D. It is typically composed of a basemap layer and data layers.Learn more or sceneA scene is a collection of layers that are displayed in 3D. It is typically composed of a basemap layer, data layers, and 3D data.Learn more.

For information on mobile map packages and mobile scene packages, which are also stand-alone files, see Offline maps, scenes, and data or the ArcGIS Pro topics Share a mobile map package and Share a mobile scene package. For details on working with data from services while offline, see Work with offline data.

What you can do with data files

You can do the following types of things in your app using local data files:

• Display maps or scenes without a network connection.
• Access, display, and analyze geospatial data.
• Include data with the installation of your app.
• Collect data on devices that never have access to a network connection.
• Create new mobile geodatabases, tables, and domains.
• Share datasets between applications using peer-to-peer technology.

Supported data file formats

The following data files are supported:

Vector tile package

Vector tiled layers contain vector representations of data across a range of scales. Unlike raster tiles, they can adapt to the resolution of their display device as you zoom in and out.

When you create a vector tile package, it must be in the same spatial reference as the map in which it will be displayed.

To use a local vector tile package (.vtpk file) with your app, copy or sideload the .vtpk file onto project's assets folder, and then instantiate a vector tiled layer, ArcGISVectorTiledLayer, with the following code:

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
// Load the vector tile package data from assets.
final vectorTilePackageData = await rootBundle.load(
  'assets/vtpk/$vectorTilePackageName',
);

// Get the temporary directory path on the platform.
final platformTempDir = await getTemporaryDirectory();
final pathToFile =
    '${platformTempDir.absolute.path}/$vectorTilePackageName';

// Create a file in the temporary directory and write the vector
// tile package data to it.
final vectorTilePackageFile = File(pathToFile);
vectorTilePackageFile.writeAsBytesSync(
  vectorTilePackageData.buffer.asUint8List(),
  flush: true,
);

// Create a vector tiled layer using the URI of the file.
final vectorTiledLayer = ArcGISVectorTiledLayer.withUri(
  Uri.file(pathToFile),
);

// Create a basemap with the vector tiled layer as the base layer.
final basemap = Basemap.withBaseLayer(vectorTiledLayer);

// Create a map with the basemap and set it to the map view controller.
final map = ArcGISMap.withBasemap(basemap);
mapViewController.arcGISMap = map;

Image tile package

Image tiled layers are typically used to display pregenerated tiled data as basemapsA basemap is the foundational layer and data that provides the overall visual and geographic context for a map or scene. It typically includes geographic features and labels for land, water, roads, buildings, cities, places, and administrative boundaries, but can also include raster data such as satellite and areal images.Learn more. A tile cache can also be used to provide offline elevation data for visualizing 3D terrain in a sceneA scene is a collection of layers that are displayed in 3D. It is typically composed of a basemap layer, data layers, and 3D data.Learn more. You can take a portion of tiled data and store it within a single tile package (.tpk or .tpkx) file for completely disconnected scenarios. To store a portion of tile data as a tile packageA tile package is a tiled layer that has been bundled into a single .tpk/.tpkx file. The file contains a tile cache of the data and metadata about the layer, packaged into a single, portable file.Learn more, you must specify area of interest, the tiling scheme, the levels of detail, and the tile format using the following approach:

• To create a tile package file, run the ArcGIS Pro geoprocessing tool Create Map Tile Package.

When you create a tile package, it must have the same spatial reference as the map in which it will be displayed.

To create a tiled layer from a tile package file, instantiate an ArcGISTiledLayer object with the path to the tile package file on the device.

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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
// Get the application documents directory.
final appDir = await getApplicationDocumentsDirectory();

// Create a tile cache, specifying the path to the local tile package.
const tilePackageName = 'SanFrancisco.tpkx';
final pathToFile = '${appDir.absolute.path}/$tilePackageName';
final tileCache = TileCache.withFileUri(Uri.parse(pathToFile));

// Create a tiled layer with the tile cache.
final tiledLayer = ArcGISTiledLayer.withTileCache(tileCache);

// Create a basemap with the tiled layer.
final basemap = Basemap.withBaseLayer(tiledLayer);

// Create a map with the basemap.
final map = ArcGISMap.withBasemap(basemap);

// Set the map to the map view controller.
mapViewController.arcGISMap = map;

Create elevation source from tile package

To create an elevation source from a tile package file, instantiate an ArcGISTiledElevationSource object with the path to the tile package file on the device.

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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
// Get the application documents directory.
final appDir = await getApplicationDocumentsDirectory();

// Create a tile cache, specifying the path to the local tile package.
const tilePackageName = 'WorldElevation3DTiles.tpkx';
final pathToFile = '${appDir.absolute.path}/$tilePackageName';
final tileCache = TileCache.withFileUri(Uri.parse(pathToFile));

// Use the tile cache to create an ArcGIS tiled elevation source.
final localElevationSource =
    ArcGISTiledElevationSource.withTileCache(tileCache);

// Create a surface with the elevation source.
final elevationSurface = Surface()
  ..elevationSources.add(localElevationSource);

// Set the elevation source into your scene as its base surface.
final scene = ArcGISScene()..baseSurface = elevationSurface;

// Set the scene to the scene view controller.
sceneViewController.arcGISScene = scene;

Feature layer

Feature layers allow you to display, select, edit, and query individual features and their attributes. You can work with features offline using features stored in a data file, such as a mobile geodatabase file (.geodatabase), a GeoPackage file (.gpkg), or a shapefile (.shp). You can edit feature geometryA geometry is a geometric shape, such as a point, polyline, or polygon, that contains one or more coordinates and a spatial reference.Learn more and attributesAttributes are fields and values for a single feature or non-spatial record. They are typically stored in a database or service such as a feature service.Learn more, and, when using a mobile geodatabaseA mobile geodatabase (.geodatabase) is a spatial data storage format in a single file on disk that can store, query, and manage spatial and nonspatial data. In applications built with the ArcGIS Maps SDKs for Native Apps, mobile geodatabases can be used in offline workflows when taking maps and features offline from services or in desktop-based scenarios as standalone mobile geodatabases from ArcGIS Pro.Learn more, can also edit attachmentsAn attachment is a file, such as a photograph (for example, a .png file) or a document, that is associated with individual features in a geodatabase or feature layer.Learn more and related records.

Mobile geodatabase

Mobile geodatabasesA mobile geodatabase (.geodatabase) is a spatial data storage format in a single file on disk that can store, query, and manage spatial and nonspatial data. In applications built with the ArcGIS Maps SDKs for Native Apps, mobile geodatabases can be used in offline workflows when taking maps and features offline from services or in desktop-based scenarios as standalone mobile geodatabases from ArcGIS Pro.Learn more (.geodatabase) can be created with ArcGIS Pro 2.7 or later. At version 100.14, they can also be created with this SDK.

To create a mobile geodatabase that you can sideloadSideloading is the process of deploying a file or package to a device without using a network.Learn more for use in your app:

• In ArcGIS Pro, follow the instructions in the ArcGIS Pro help topic Create a mobile geodatabase.

To create a mobile geodatabase with this SDK:

• Use the static method Geodatabase.create() to create a new geodatabase at the provided path.

To display tables from a mobile geodatabase:

1. Instantiate the Geodatabase object by opening an existing geodatabase or creating a new one. In either case, you need to specify a path to the .geodatabase file.
2. Instantiate a FeatureTable from one of the mobile geodatabase's tables or create a new one using a TableDescription and associated FieldDescription objects and calling Geodatabase.createTable().
3. Create a new FeatureLayer from the feature table and add it to the map. Optionally, create a new Renderer to symbolize features in the layer. If the layer is based on a new geodatabase table, nothing will appear in the layer until features are created.

If you have copied the geodatabase into the app's documents directory, you can instantiate a feature layer.

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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
// Get the application documents directory.
final appDir = await getApplicationDocumentsDirectory();

// Create a file to the geodatabase.
final geodatabaseFile = File(
  '${appDir.absolute.path}/LA_Trails/LA_Trails.geodatabase',
);

// Create a geodatabase with the file uri and load the geodatabase.
final geodatabase = Geodatabase.withFileUri(geodatabaseFile.uri);
await geodatabase.load();

// Get the feature table using the table name.
final geodatabaseFeatureTable = geodatabase.getGeodatabaseFeatureTable(
  tableName: 'Trailheads',
);

// Check if the feature table is not null.
if (geodatabaseFeatureTable != null) {
  // Create a feature layer with the feature table.
  final geodatabaseFeatureLayer = FeatureLayer.withFeatureTable(
    geodatabaseFeatureTable,
  );

  // Clear the operational layers and add the feature layer to the map.
  map.operationalLayers.clear();
  map.operationalLayers.add(geodatabaseFeatureLayer);
}

GeoPackage

GeoPackage is an open, standards-based, platform-independent, portable, self-describing, compact format for transferring geospatial information. It uses a single SQLite file (.gpkg) that conforms to the OGC GeoPackage standard. You can create a GeoPackage file from your own data using the Create SQLite Database tool in ArcGIS Pro.

To display features stored in a GeoPackage file, you must do the following:

1. Instantiate the GeoPackage with the .gpkg file path.

2. Load the GeoPackage and then examine its list of GeoPackageFeatureTables.

3. Create a FeatureLayer from one of the GeoPackageFeatureTables and add it as an operational layer to the map.

If you have copied the geodatabase file into the app's documents directory, you can instantiate a feature layer.

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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
// Get the application documents directory.
final appDir = await getApplicationDocumentsDirectory();

// Create a file to the geopackage.
final geopackageFile = File(
  '${appDir.absolute.path}/AuroraCO/AuroraCO.gpkg',
);

// Create a geopackage with the file uri and load it.
final geopackage = GeoPackage.withFileUri(geopackageFile.uri);
await geopackage.load();

// Get the geopackage feature tables.
final geopackageFeatureTables = geopackage.geoPackageFeatureTables;

// Create a feature layer with the first geopackage feature table.
final geopackageFeatureLayer = FeatureLayer.withFeatureTable(
  geopackageFeatureTables.first,
);

// Clear the operational layers and add the geopackage feature layer
// to the map.
map.operationalLayers.clear();
map.operationalLayers.add(geopackageFeatureLayer);

Shapefiles

A shapefileA shapefile is a vector data storage format that contains geometry and attribute data for geographic features. It can also include spatial and non-spatial indexes.Learn more is a vector data storage format that contains geometry and attribute data for geographic features. Despite the name, a shapefile dataset is composed of at least three physical files: .shp, .dbf, and .shx. A shapefile may include several other files, such as projection information, spatial indices, attribute indices, and so on.

To create a feature layer from a shapefile (.shp), do the following:

1. Instantiate the ShapefileFeatureTable with the path to the shapefile. This path must point to the .shp file. The .shp file's associated files (.shx, .dbf, and so on) must be present at the same location.

2. Create a FeatureLayer from the ShapefileFeatureTable and add it to the map.

If you have copied the shapefiles into the app's documents directory, you can instantiate a feature layer.

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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
// Get the application documents directory.
final appDir = await getApplicationDocumentsDirectory();

// Get the Shapefile from the download resource.
final shapefile = File(
  '${appDir.absolute.path}/ScottishWildlifeTrust_reserves/ScottishWildlifeTrust_ReserveBoundaries_20201102.shp',
);

// Create a feature table from the shapefile uri.
final shapefileFeatureTable = ShapefileFeatureTable.withFileUri(
  shapefile.uri,
);

// Create a feature layer for the Shapefile feature table.
final shapefileFeatureLayer = FeatureLayer.withFeatureTable(
  shapefileFeatureTable,
);

// Clear the operational layers and add the feature layer to the map.
map.operationalLayers.clear();
map.operationalLayers.add(shapefileFeatureLayer);

Raster layer

Raster data consists of a matrix of cells in which each individual cell contains a value representing information. You can visualize this raster data by defining specific renderers. Several raster formats are supported that allow you to use data from satellite and aerial images or photographs, for example. To work offline, copy the raster data onto your device and add the raster dataset to your app using the Raster class. For more information and a list of supported raster formats, Add raster data.