Feature layer (geodatabase)

View inJavaKotlin
View on GitHub
Sample viewer app

Display features from a local geodatabase.

Image of feature layer geodatabase

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, Geodatabase(geodatabaseResourcePath).
  2. Wait for geodatabase to load by adding a listener with Geodatabase.addDoneLoadingListener().
  3. Get the 'Trailheads' GeodatabaseFeatureTable from the geodatabase, Geodatabase.getGeodatabaseFeatureTable("Trailheads").
  4. Create feature layer using the table from above, FeatureLayer(geodatabaseFeatureTable).
  5. Add feature layer to ArcGISMap with ArcGISMap.operationalLayers.add(featureLayer).

Relevant API

  • FeatureLayer
  • Geodatabase
  • GeodatabaseFeatureTable

Offline Data

  1. Download the data from ArcGIS Online.
  2. Extract the contents of the downloaded zip file to disk.
  3. Open your command prompt and navigate to the folder where you extracted the contents of the data from step 1.
  4. Push the data into the scoped storage of the sample app:

adb push LA_Trails.geodatabase /Android/data/com.esri.arcgisruntime.sample.featurelayergeodatabase/files/LA_Trails.geodatabase

About the data

The sample shows trailheads in the greater Los Angeles area displayed on top of a Streets 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 point to a Uri instead.

Tags

geodatabase, mobile, offline

Sample Code

MainActivity.kt
Use dark colors for code blocks
                                                                                                       
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
/* Copyright 2020 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.
 *
 */
package com.esri.arcgisruntime.sample.featurelayergeodatabase

import android.os.Bundle
import android.util.Log
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity
import com.esri.arcgisruntime.ArcGISRuntimeEnvironment
import com.esri.arcgisruntime.data.Geodatabase
import com.esri.arcgisruntime.layers.FeatureLayer
import com.esri.arcgisruntime.loadable.LoadStatus
import com.esri.arcgisruntime.mapping.ArcGISMap
import com.esri.arcgisruntime.mapping.Basemap
import com.esri.arcgisruntime.mapping.BasemapStyle
import com.esri.arcgisruntime.mapping.Viewpoint
import com.esri.arcgisruntime.mapping.view.MapView
import com.esri.arcgisruntime.sample.featurelayergeodatabase.databinding.ActivityMainBinding

class MainActivity : AppCompatActivity() {
  private val TAG =
    MainActivity::class.java.simpleName

  private val activityMainBinding by lazy {
    ActivityMainBinding.inflate(layoutInflater)
  }

  private val mapView: MapView by lazy {
    activityMainBinding.mapView
  }

  // objects that implement Loadable must be class fields to prevent being garbage collected before loading
  private val geodatabase: Geodatabase by lazy {
    Geodatabase(getExternalFilesDir(null)?.path + getString(R.string.geodb_name))
  }

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(activityMainBinding.root)

    // authentication with an API key or named user is required to access basemaps and other
    // location services
    ArcGISRuntimeEnvironment.setApiKey(BuildConfig.API_KEY)

    // create map and add to map view
    val map = ArcGISMap(BasemapStyle.ARCGIS_STREETS)
    mapView.map = map

    geodatabase.loadAsync()
    geodatabase.addDoneLoadingListener {
      if (geodatabase.loadStatus == LoadStatus.LOADED) {
        // access the geodatabase's feature table Trailheads
        val geodatabaseFeatureTable = geodatabase.getGeodatabaseFeatureTable("Trailheads")
        geodatabaseFeatureTable.loadAsync()
        // create a layer from the geodatabase feature table and add to map
        val featureLayer = FeatureLayer(geodatabaseFeatureTable)
        featureLayer.addDoneLoadingListener {
          if (featureLayer.loadStatus == LoadStatus.LOADED) {
            // set viewpoint to the feature layer's extent
            mapView.setViewpointAsync(Viewpoint(featureLayer.fullExtent))
          } else {
            Toast.makeText(this, "Feature Layer failed to load!", Toast.LENGTH_LONG)
              .show()
            Log.e(TAG, "Feature Layer failed to load!")
          }
        }
        // add feature layer to the map
        map.operationalLayers.add(featureLayer)
      } else {
        Toast.makeText(this, "Geodatabase failed to load!", Toast.LENGTH_LONG).show()
        Log.e(TAG, "Geodatabase failed to load!" + geodatabase.loadError)
      }
    }
  }

  override fun onPause() {
    mapView.pause()
    super.onPause()
  }

  override fun onResume() {
    super.onResume()
    mapView.resume()
  }

  override fun onDestroy() {
    mapView.dispose()
    super.onDestroy()
  }
}

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