Feature layer (geodatabase)

View inQMLC++
View on GitHub
Sample viewer app

Display features from a local geodatabase.

screenshot

Use case

Accessing data from a local geodatabase is useful when working in an environment that has an inconsistent internet connection or that does not have an internet connection at all. For example, a department of transportation field worker might source map data from a local geodatabase when conducting signage inspections in rural areas with poor network coverage.

How to use the sample

Pan and zoom around the map. View the data loaded from the geodatabase.

How it works

  1. Create a geodatabase using the provided local resource, new Geodatabase(geodatabaseResourceUrl).
  2. Wait for geodatabase to load, Geodatabase::doneLoading.
  3. Get the 'Trailheads' GeodatabaseFeatureTable from the geodatabase, Geodatabase::geodatabaseFeatureTable(tableName).
  4. Create feature layer using the table from above, new FeatureLayer(geodatabaseFeatureTable).
  5. Add feature layer to Map with Map::operationalLayers()::append(featureLayer).

Relevant API

  • FeatureLayer
  • Geodatabase
  • GeodatabaseFeatureTable

Offline Data

To set up the sample's offline data, see the Use offline data in the samples section of the Qt Samples repository overview.

Link Local Location
Los Angeles Vector Tile Package <userhome>/ArcGIS/Runtime/Data/vtpk/LosAngeles.vtpk
Los Angeles Trailheads <userhome>/ArcGIS/Runtime/Data/geodatabase/LA_Trails.geodatabase

About the data

The sample shows trailheads in the greater Los Angeles area displayed on top of a vector tile basemap.

Additional information

One of the ArcGIS Runtime data set types that can be accessed via the local storage of the device (i.e. hard drive, flash drive, micro SD card, USB stick, etc.) is a mobile geodatabase. A mobile geodatabase can be provisioned for use in an ArcGIS Runtime application by ArcMap. The following provide some helpful tips on how to create a mobile geodatabase file:

In ArcMap, choose File > Share As > ArcGIS Runtime Content from the menu items to create the .geodatabase file (see the document: http://desktop.arcgis.com/en/arcmap/latest/map/working-with-arcmap/creating-arcgis-runtime-content.htm).

Note: You could also use the 'Services Pattern' and access the Geodatabase class via a Feature Service served up via ArcGIS Online or ArcGIS Enterprise. Instead of using the Geodatabase class to access the .geodatabase file on disk, you would use GeodatabaseSyncTask to point to a URL instead.

Tags

geodatabase, mobile, offline

Sample Code

FeatureLayerGeodatabase.cppFeatureLayerGeodatabase.cppFeatureLayerGeodatabase.hFeatureLayerGeodatabase.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
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
// [WriteFile Name=FeatureLayerGeodatabase, Category=Features]
// [Legal]
// Copyright 2016 Esri.

// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0

// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// [Legal]

#ifdef PCH_BUILD
#include "pch.hpp"
#endif // PCH_BUILD

#include "FeatureLayerGeodatabase.h"

#include "Map.h"
#include "MapQuickView.h"
#include "FeatureLayer.h"
#include "Basemap.h"
#include "GeodatabaseFeatureTable.h"
#include "Geodatabase.h"
#include "ArcGISVectorTiledLayer.h"
#include "SpatialReference.h"
#include "Point.h"
#include "Viewpoint.h"

#include <QDir>
#include <QtCore/qglobal.h>
#include <QUrl>

#ifdef Q_OS_IOS
#include <QStandardPaths>
#endif // Q_OS_IOS

using namespace Esri::ArcGISRuntime;

// helper method to get cross platform data path
namespace
{
  QString defaultDataPath()
  {
    QString dataPath;

  #ifdef Q_OS_ANDROID
    dataPath = "/sdcard";
  #elif defined Q_OS_IOS
    dataPath = QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation);
  #else
    dataPath = QDir::homePath();
  #endif

    return dataPath;
  }
} // namespace

FeatureLayerGeodatabase::FeatureLayerGeodatabase(QQuickItem* parent) :
  QQuickItem(parent),
  m_dataPath(defaultDataPath() + "/ArcGIS/Runtime/Data/")
{
}

FeatureLayerGeodatabase::~FeatureLayerGeodatabase() = default;

void FeatureLayerGeodatabase::init()
{
  qmlRegisterType<MapQuickView>("Esri.Samples", 1, 0, "MapView");
  qmlRegisterType<FeatureLayerGeodatabase>("Esri.Samples", 1, 0, "FeatureLayerGeodatabaseSample");
}

void FeatureLayerGeodatabase::logError(Esri::ArcGISRuntime::Error error)
{
  setErrorMessage(QString("%1: %2").arg(error.message(), error.additionalMessage()));
}

QString FeatureLayerGeodatabase::errorMessage() const
{
  return m_errorMsg;
}

void FeatureLayerGeodatabase::setErrorMessage(const QString& msg)
{
  m_errorMsg = msg;
  qDebug() << m_errorMsg;
  emit errorMessageChanged();
}

void FeatureLayerGeodatabase::componentComplete()
{
  QQuickItem::componentComplete();

  // find QML MapView component
  m_mapView = findChild<MapQuickView*>("mapView");
  m_mapView->setWrapAroundMode(WrapAroundMode::Disabled);

  //! [FeatureLayer Geodatabase add basemap]
  // Create a map using a local vector tile package
  ArcGISVectorTiledLayer* vectorTiledLayer = new ArcGISVectorTiledLayer(QUrl::fromLocalFile(m_dataPath + "vtpk/LosAngeles.vtpk"), this);
  Basemap* basemap = new Basemap(vectorTiledLayer, this);
  m_map = new Map(basemap, this);
  //! [FeatureLayer Geodatabase add basemap]

  connect(m_map, &Map::errorOccurred, this, &FeatureLayerGeodatabase::logError);
  connect(m_mapView, &MapQuickView::errorOccurred, this, &FeatureLayerGeodatabase::logError);

  // set initial viewpoint
  m_map->setInitialViewpoint(Viewpoint(Point(-13214155, 4040194, SpatialReference(3857)), 35e4));

  // Set map to map view
  m_mapView->setMap(m_map);

  //! [FeatureLayer Geodatabase create gdb]
  // create the geodatabase using a local file path
  m_geodatabase = new Geodatabase(m_dataPath + "geodatabase/LA_Trails.geodatabase", this);
  //! [FeatureLayer Geodatabase create gdb]

  connect(m_geodatabase, &Geodatabase::errorOccurred, this, &FeatureLayerGeodatabase::logError);

  // connect to doneLoading signal of geodatabase to access feature tables
  connect(m_geodatabase, &Geodatabase::doneLoading, this, [this](Error error)
  {
    if (error.isEmpty())
    {
      //! [FeatureLayer Geodatabase create feature layer]
      // access the feature table by name
      GeodatabaseFeatureTable* featureTable = m_geodatabase->geodatabaseFeatureTable("Trailheads");

      // create a feature layer from the feature table
      FeatureLayer* featureLayer = new FeatureLayer(featureTable, this);
      //! [FeatureLayer Geodatabase create feature layer]

      //! [FeatureLayer Geodatabase add to map]
      // add the feature layer to the map
      m_map->operationalLayers()->append(featureLayer);
      //! [FeatureLayer Geodatabase add to map]
    }
  });

  // load the geodatabase
  m_geodatabase->load();
}

Your browser is no longer supported. Please upgrade your browser for the best experience. See our browser deprecation post for more details.