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 files stored locally on your user's device. Local data files support scenarios where your users never have a network connection.
Mobile geodatabase You can create a geodatabase file (SQLite database) with this API, using ArcGIS Pro or ArcMap, or by downloading offline data from a feature service.
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 create a vector tiled layer from the vector tile package (.vtpk), instantiate an ArcGISVectorTiledLayer object with the vector tile package's file URL. The default style will be loaded directly from the vector tile package.
Image tiled layers are typically used to display pregenerated tiled data as basemaps. A tile cache can also be used to provide offline elevation data for visualizing 3D terrain in a scene. 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 package, you must specify area of interest, the tiling scheme, the levels of detail, and the tile format using one of the following approaches:
In ArcMap, choose File > Share As > Tile Package to create a tile package file, as described in the ArcMap topic, How to create a tile package.
In ArcMap, choose Share as > ArcGIS Runtime Content to export the map's basemap layer to a tile package file (.tpk) that is output within the ArcGIS Runtime Content folder. For details, see the ArcMap topic Creating ArcGIS Runtime content, which is available with ArcGIS 10.2.1 for Desktop or later. Also see ArcMap's tile packages.
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.
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.
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 geometry and attributes, and, when using a mobile geodatabase, can also edit attachments and related records.
Mobile geodatabase
Mobile geodatabases (.geodatabase) can be created with ArcGIS Pro (2.7 or later) or ArcMap (10.2.1 or later). At version 100.14, they can also be created in your app.
To create a mobile geodatabase that you can sideload for use in your app:
Use the static function Geodatabase::create() to create a new geodatabase at the provided path.
To display tables from a mobile geodatabase:
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.
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.
The following code opens a geodatabase at the given path. If it doesn't exist, a new geodatabase is created at that location and a new table and domain are added. Finally, the table is displayed as a feature layer in the map.
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
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
voidWorkDataFiles::featureLayerMobileGeodatabase(){
// Get the path to a local geodatabase. QString myDocumentsFolder = QStandardPaths::standardLocations(QStandardPaths::TempLocation).at(0);
QString geodatabasePath(QDir::toNativeSeparators(myDocumentsFolder + "/recreation.geodatabase"));
// Open the geodatabase if the file exists at the specified path.if (QFile(geodatabasePath).exists())
{
// Get the geodatabase using the path. Geodatabase* localGdb = newGeodatabase(geodatabasePath, this);
// Wait for the geodatabase to load.connect(localGdb, &Geodatabase::doneLoading, this, [this, localGdb](Error loadError)
{
if (!loadError.isEmpty())
{
qDebug() << "Geodatabase load error: " << loadError.message() << " : " << loadError.additionalMessage();
}
// Access one of the feature tables in the geodatabase using its name. GeodatabaseFeatureTable* trailheadsTable = localGdb->geodatabaseFeatureTable("Trailheads");
// Create a feature layer from the table and add it to the map's operational layers. FeatureLayer* trailheadsLayer = newFeatureLayer(trailheadsTable);
m_map->operationalLayers()->append(trailheadsLayer);
});
localGdb->load();
}
else// If the geodatabase doesn't exist, create it. {
Geodatabase* localGdb = Geodatabase::instance();
connect(localGdb, &Geodatabase::errorOccurred, this, [](Error e)
{
if (!e.isEmpty())
{
qDebug() << "Geodatabase load error: " << e.message() << ": " << e.additionalMessage();
}
});
// Output folder must be a read and write location and the filename must have a '.geodatabase' extension.auto task = Geodatabase::create(geodatabasePath);
connect(localGdb, &Geodatabase::createCompleted, this, [this](QUuid /*taskId*/, Geodatabase* geodatabaseResult)
{
// Create a new domain in the geodatabase for rating values from 1-10. RangeDomainDescription* domainDescription = newRangeDomainDescription("RatingDomain", FieldType::Int16, QVariant(1), QVariant(10), this);
connect(geodatabaseResult, &Geodatabase::createDomainCompleted, this, [geodatabaseResult, this]()
{
// Create a table description for a "Trailheads" table that will store points.auto tableDef = newTableDescription("Trailheads", SpatialReference::wgs84(), GeometryType::Point);
// Add field descriptions to define "Name" and "Difficulty" fields. tableDef->fieldDescriptions()->append(newFieldDescription("Name", FieldType::Text, this));
FieldDescription* difficultyFieldDescription = newFieldDescription("Difficulty", FieldType::Int16, this);
difficultyFieldDescription->setDomainName("RatingDomain");
tableDef->fieldDescriptions()->append(difficultyFieldDescription);
// Create a new trailheads table in the geodatabase using the table description.connect(geodatabaseResult, &Geodatabase::createTableCompleted, this, [this](const QUuid& /*taskId*/, GeodatabaseFeatureTable* featureTableResult)
{
// Create a feature layer from the table and add it to the map. FeatureLayer* trailheadsLayer = newFeatureLayer(featureTableResult);
m_mapView->map()->operationalLayers()->append(trailheadsLayer);
});
geodatabaseResult->createTable(tableDef);
});
geodatabaseResult->createDomain(domainDescription);
});
}
}
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:
Instantiate the GeoPackage with the .gpkg file path.
A shapefile 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 four 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:
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.
Raster data consists of a matrix of cells in which each individual cell contains a value representing information. For example, satellite or aerial images and photographs for visualizing an area. You can define renderers to display the raster data. Several raster formats are supported. 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, See Add raster data.