Work with data files

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
        // Path to the vector tile cache package (.vtpk file) on the device file system.
        val vectorTileCachePath =
            context.getExternalFilesDir(null)?.path + File.separator + getString(context, R.string.app_name) + File.separator + "myVectorTileCache.vtpk"

        // Create a VectorTileCache instance with the vector tile cache package.
        val cache = VectorTileCache(vectorTileCachePath)

        // Use the vector tile cache to create an ArcGISVectorTiledLayer.
        val tiledLayer = ArcGISVectorTiledLayer(cache)

        // Create a new basemap with the tiled layer, and create an ArcGISMap with that basemap.
        // Display the map by assigning it to the mutable map property used by the Composable MapView.
        map = ArcGISMap(Basemap(tiledLayer))

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
        // Create a vector tile cache from the local data.
        val cache = TileCache(imageTileCachePath)

        // Use the tile cache to create an ArcGISTiledLayer.
        val tiledLayer = ArcGISTiledLayer(cache)

        // Create a new basemap with the tiled layer, and create an ArcGISMap with that basemap.
        // Display the map by assigning it to the mutable map property used by the Composable MapView.
        map = ArcGISMap(Basemap(tiledLayer))

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
        // Path to the local package (.tpkx or .tpkx file).
        val elevationTilesPath = context.getExternalFilesDir(null)?.path + File.separator + getString(context, R.string.app_name) + File.separator + "MontereyElevation.tpkx"

        // Create a tile cache from the local data.
        val elevationCache = TileCache(elevationTilesPath)

        // Use the tile cache to create an ArcGISTiledElevationSource.
        val localElevationSource = ArcGISTiledElevationSource(elevationCache)

        // Create a surface with the elevation source.
        val elevationSurface = Surface().apply {
            // Add the elevation source to the surface
            elevationSources.add(localElevationSource)
        }

        val arcGISScene = ArcGISScene(BasemapStyle.ArcGISImageryStandard).apply {
            // Set the elevation surface as the base surface of the scene.
            baseSurface = elevationSurface
        }
        // Display the new scene by updating the mutable scene property used by the Composable MapView.
        scene = arcGISScene

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
        val localGeodatabasePath =
            context.getExternalFilesDir(null)?.path + File.separator + getString(context, R.string.app_name) + File.separator + "LA_Trails.geodatabase"

        // Instantiate GeoDatabase with the path to the .geodatabase file.
        val geodatabase = Geodatabase(localGeodatabasePath)
        coroutineScope.launch {
            geodatabase.load().onSuccess {
                // Access the feature table named "Trailheads" in the geodatabase.
                val featureTable = geodatabase.getFeatureTable("Trailheads")
                    ?: return@launch logErr("Feature table not found in geodatabase.")

                // Create a feature layer from the geodatabase feature table.
                val featureLayer = FeatureLayer.createWithFeatureTable(featureTable)

                // Add the feature layer to the mutable map's operational layers used by the MapView composable.
                map.operationalLayers.add(featureLayer)

            }.onFailure { error ->
                return@launch logErr("Mobile geodatabase failed to load. ${error.message}")
            }
        }

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
        // Get the path to a geoPackage on the device file system.
        val localGeoPackagePath =
            context.getExternalFilesDir(null)?.path + File.separator + getString(context, R.string.app_name) + File.separator + "AuroraCO.gpkg"

        // Instantiate the geopackage with the file path.
        val geoPackage = GeoPackage(localGeoPackagePath)
        coroutineScope.launch {
            // Load the geopackage.
            geoPackage.load().onSuccess {
                // Get the first feature table in the GeoPackage.
                val geoPackageFeatureTable = geoPackage.geoPackageFeatureTables.first()
                // Create a feature layer with the feature table.
                val featureLayer = FeatureLayer.createWithFeatureTable(geoPackageFeatureTable)

                // Add the new layer to the map.
                map.operationalLayers.add(featureLayer)

            }.onFailure { error ->
                logErr("Error loading geopackage: ${error.message}")
            }
        }

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
        // Get the path to a shapefile on the device file system.
        val localShapeFilePath =
            context.getExternalFilesDir(null)?.path + File.separator + getString(context, R.string.app_name) + File.separator + "ScottishWildlifeTrust_ReserveBoundaries_20201102.shp"

        // Create a shapefile feature table using the path.
        val shapeFileTable = ShapefileFeatureTable(localShapeFilePath)
        coroutineScope.launch  {
            shapeFileTable.load().onSuccess {
                // Create a feature layer from the shapefile feature table.
                val featureLayer = FeatureLayer.createWithFeatureTable(shapeFileTable)

                // Adds the new layer to the map.
                map.operationalLayers.add(featureLayer)

            }.onFailure { error ->
                logErr("Error loading shapefile: ${error.message}")
            }
        }