Learn how to create and display a scene with a basemap layer and an elevation layer. Set properties of the scene's camera to control the 3D perspective.
Like a map, a scene contains layers of geographic data. It contains a basemap layer and, optionally, one or more data layers. To provide a realistic view of the terrain, you can also add elevation layers to define the height of the surface across the scene. The 3D perspective of the scene is controlled by the scene's camera, which defines the position of the scene observer in 3D space.
In this tutorial, you create and display a scene using the imagery basemap layer. The surface of the scene is defined with an elevation layer and the camera is positioned to display an area of the Santa Monica Mountains in the scene view.
The scene and code will be used as the starting point for other 3D tutorials.
Mapping and location services guideFor more background information about the topics in this tutorial, visit Scenes (3D) and Basemaps.
PrerequisitesBefore starting this tutorial, you need the following:
An ArcGIS Location Platform or ArcGIS Online account.
A development and deployment environment that meets the system requirements.
An IDE for Android development in Kotlin.
It is recommended that you use the latest stable version Android Studio to create this tutorial app. The code described in the steps below, however, should work in any up-to-date Android IDE that supports Kotlin.
Set up authenticationTo access the secure ArcGIS location services used in this tutorial, you must implement API key authentication or user authentication using an ArcGIS Location Platform or an ArcGIS Online account.
You can implement API key authentication or user authentication in this tutorial. Compare the differences below:
API key authentication
Learn more in API key authentication.
User authentication
Learn more in User authentication.
Security and authentication guideTo learn more about the different types of authentication, visit Types of authentication.
Create a new API key access token with privileges to access the secure resources used in this tutorial.
Complete the Create an API key tutorial and create an API key with the following privilege(s):
Copy and paste the API key access token into a safe location. It will be used in a later step.
Create new OAuth credentials to access the secure resources used in this tutorial.
Complete the Create OAuth credentials for user authentication tutorial to obtain a Client ID and Redirect URL.
A Client ID uniquely identifies your app on the authenticating server. If the server cannot find an app with the provided Client ID, it will not proceed with authentication.
The Redirect URL (also referred to as a callback url) is used to identify a response from the authenticating server when the system returns control back to your app after an OAuth login. Since it does not necessarily represent a valid endpoint that a user could navigate to, the redirect URL can use a custom scheme, such as my-app://auth. It is important to make sure the redirect URL used in your app's code matches a redirect URL configured on the authenticating server.
Copy and paste the Client ID and Redirect URL into a safe location. They will be used in a later step.
All users that access this application need account privileges to access the ArcGIS Basemap Styles service.
Develop or downloadYou have two options for completing this tutorial:
Option 1: Develop the code Create a new Android Studio projectUse Android Studio to create an app and configure it to reference the API.
Open Android Studio.
In the Welcome to Android Studio window, click New Project.
Or if you already have Android Studio opened, click File > New > New Project in the menu bar.
In the New Project window, make sure Phone and Tablet tab is selected, and then select Empty Activity. Click Next.
In the next window, set the following options and then click Finish.
Display a scene.com.example.app. Or change to match your organization.In the Android view, make sure that your current view is Android. These tutorial instructions refer to that view.
If your view name is something other than Android (such as Project or Packages), click on the dropdown arrow and select Android from the list
From the Android view, open Gradle Scripts > build.gradle.kts (Project: Tutorial). Replace the contents of the file with the following code:
build.gradle.kts (Project: Tutorial)
Use dark colors for code blocks
1
2
3
4
5
6
// Top-level build file where you can add configuration options common to all sub-projects/modules.
plugins {
alias(libs.plugins.android.application) apply false
alias(libs.plugins.kotlin.android) apply false
alias(libs.plugins.kotlin.compose) apply false
}From the Android view, open Gradle Scripts > build.gradle.kts (Module :app). Replace the contents of the file with the expanded code below:
build.gradle.kts (Module: app)
Expand
Use dark colors for code blocks1
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
// ArcGIS Maps for Kotlin - SDK dependency
implementation(libs.arcgis.maps.kotlin)
// Toolkit dependencies
implementation(platform(libs.arcgis.maps.kotlin.toolkit.bom))
implementation(libs.arcgis.maps.kotlin.toolkit.geoview.compose)
implementation(libs.arcgis.maps.kotlin.toolkit.authentication)
From the Android view, open Gradle Scripts > libs.versions.toml` and replace its contents with the expanded code below.
Gradle version catalogs are the standard Android approach to declaring dependency versions. They are preferred over specifying versions numbers in the build.gradle.kts or listing version numbers in a version.gradle. Note that in recent releases of Android Studio, the New Project Wizard generates build.gradle.kts and gradle/libs.versions.toml files that support this standard.
The highlights below indicate lines that we are adding to the default gradle/libs.versions.toml generated by the Android Studio New Project Wizard.
gradle/libs.versions.toml
Use dark colors for code blocks Copy
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
[versions]
arcgisMapsKotlin = "200.8.0"
From the Android view, open Gradle Scripts > settings.gradle.kts. Replace the contents of the file with the expanded code below:
settings.gradle.kts (Project Settings)
Expand
Use dark colors for code blocks1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
dependencyResolutionManagement {
repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
repositories {
google()
mavenCentral()
maven { url = uri("https://esri.jfrog.io/artifactory/arcgis") }
}
}
rootProject.name = "Display a scene"
include(":app")Sync the Gradle changes. Click the Sync now prompt or click the refresh icon (Sync Project with Gradle Files) in the toolbar. This may take several minutes.
From the Android view, open app > manifests > AndroidManifest.xml. Update the Android manifest to allow internet access.
Insert these new elements within the manifest element. Do not alter or remove any other statements.
Depending on what ArcGIS functionality you add in future tutorials, it is likely you will need to add additional permissions to your manifest.
AndroidManifest.xml
Expand
Use dark colors for code blocks2 2 3 4 5 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6
Add line.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
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools">
<uses-permission android:name="android.permission.INTERNET" />
From the Android view, right click on app > kotlin+java > com.example.app, select New > package from the list. Enter com.example.app.screens as the package name. Hit Enter on your keyboard. This step creates a new package that will contain all the UI files.
Right click on the screens package you just created, select New > Kotlin Class/File from the list. In the pop-up window, select File and enter MainScreen as the file name. Hit Enter on your keyboard.
In MainScreen.kt, delete any lines of code that were inserted automatically by Android Studio. Then add the following OptIn annotation, package name, and imports.
NoteEnsure that you import the composable function com.arcgismaps.tookit.geoviewcompose.SceneView, shown in the code block below. It is defined in the ArcGIS Maps SDK for Kotlin Toolkit. For Composable-enabled code, do not use the class named SceneView from the ArcGIS Maps SDK API.
MainScreen.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
@file:OptIn(ExperimentalMaterial3Api::class)
package com.example.app.screens
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.Scaffold
import androidx.compose.material3.Text
import androidx.compose.material3.TopAppBar
import androidx.compose.runtime.Composable
import androidx.compose.runtime.remember
import androidx.compose.ui.Modifier
import androidx.compose.ui.res.stringResource
import com.arcgismaps.geometry.Point
import com.arcgismaps.geometry.SpatialReference
import com.arcgismaps.mapping.ArcGISScene
import com.arcgismaps.mapping.ArcGISTiledElevationSource
import com.arcgismaps.mapping.BasemapStyle
import com.arcgismaps.mapping.Surface
import com.arcgismaps.mapping.Viewpoint
import com.arcgismaps.mapping.view.Camera
import com.arcgismaps.toolkit.geoviewcompose.SceneView
import com.example.app.R
You will start by creating a function named createScene().
Inside that function, you will create an ArcGISScene, assign a base surface to it, and use the top-level composable function remember to retain state across recompositions.
Then you will create a camera location and a Camera, use them to create a Viewpoint, and then assign the view point to the initialViewpoint property of the ArcGISScene.
Create a top-level function named createScene() that returns an ArcGISScene.
MainScreen.kt
Expand
Use dark colors for code blocks1
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
fun createScene(): ArcGISScene {
}Create a new ArcGISTiledElevationSource. Then create a Surface and, inside the apply block for Surface, add the elevation source to the elevationSources property, and set the elevationExaggeration property to 2.5f, which increases the 3D effect of the elevation.
An elevation source can define a surface with 3D terrain in a scene. Without an elevation source, the default globe surface is used to display the scene.
MainScreen.kt
Expand
Use dark colors for code blocks1
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
fun createScene(): ArcGISScene {
// add base surface for elevation data
val elevationSource = ArcGISTiledElevationSource("https://elevation3d.arcgis.com/arcgis/rest/services/WorldElevation3D/Terrain3D/ImageServer")
val surface = Surface().apply {
elevationSources.add(elevationSource)
// add an exaggeration factor to increase the 3D effect of the elevation.
elevationExaggeration = 2.5f
}
}Create a Point for the camera and assign it to the variable cameraLocation. Then create a Camera, passing the camera ocation and values for the camera's heading, pitch, and roll.
MainScreen.kt
Expand
Use dark colors for code blocks1
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
fun createScene(): ArcGISScene {
// add base surface for elevation data
val elevationSource = ArcGISTiledElevationSource("https://elevation3d.arcgis.com/arcgis/rest/services/WorldElevation3D/Terrain3D/ImageServer")
val surface = Surface().apply {
elevationSources.add(elevationSource)
// add an exaggeration factor to increase the 3D effect of the elevation.
elevationExaggeration = 2.5f
}
val cameraLocation = Point(
x = -118.794,
y = 33.909,
z = 5330.0,
spatialReference = SpatialReference.wgs84()
)
val camera = Camera(
locationPoint = cameraLocation,
heading = 355.0,
pitch = 72.0,
roll = 0.0
)
}Create an ArcGISScene with a BasemapStyle.ArcGISImagery. Then call apply() on the new ArcGISScene. The createScene() function returns this ArcGISScene.
MainScreen.kt
Expand
Use dark colors for code blocks1
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
fun createScene(): ArcGISScene {
// add base surface for elevation data
val elevationSource = ArcGISTiledElevationSource("https://elevation3d.arcgis.com/arcgis/rest/services/WorldElevation3D/Terrain3D/ImageServer")
val surface = Surface().apply {
elevationSources.add(elevationSource)
// add an exaggeration factor to increase the 3D effect of the elevation.
elevationExaggeration = 2.5f
}
val cameraLocation = Point(
x = -118.794,
y = 33.909,
z = 5330.0,
spatialReference = SpatialReference.wgs84()
)
val camera = Camera(
locationPoint = cameraLocation,
heading = 355.0,
pitch = 72.0,
roll = 0.0
)
return ArcGISScene(BasemapStyle.ArcGISImagery).apply {
}
}In the apply block, set the baseSurface property of the ArcGISScene to surface.
MainScreen.kt
Expand
Use dark colors for code blocks1
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
fun createScene(): ArcGISScene {
// add base surface for elevation data
val elevationSource = ArcGISTiledElevationSource("https://elevation3d.arcgis.com/arcgis/rest/services/WorldElevation3D/Terrain3D/ImageServer")
val surface = Surface().apply {
elevationSources.add(elevationSource)
// add an exaggeration factor to increase the 3D effect of the elevation.
elevationExaggeration = 2.5f
}
val cameraLocation = Point(
x = -118.794,
y = 33.909,
z = 5330.0,
spatialReference = SpatialReference.wgs84()
)
val camera = Camera(
locationPoint = cameraLocation,
heading = 355.0,
pitch = 72.0,
roll = 0.0
)
return ArcGISScene(BasemapStyle.ArcGISImagery).apply {
baseSurface = surface
}
}Create a Viewpoint using cameraLocation and camera and set it as the initial viewpoint for the scene.
MainScreen.kt
Expand
Use dark colors for code blocks1
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
fun createScene(): ArcGISScene {
// add base surface for elevation data
val elevationSource = ArcGISTiledElevationSource("https://elevation3d.arcgis.com/arcgis/rest/services/WorldElevation3D/Terrain3D/ImageServer")
val surface = Surface().apply {
elevationSources.add(elevationSource)
// add an exaggeration factor to increase the 3D effect of the elevation.
elevationExaggeration = 2.5f
}
val cameraLocation = Point(
x = -118.794,
y = 33.909,
z = 5330.0,
spatialReference = SpatialReference.wgs84()
)
val camera = Camera(
locationPoint = cameraLocation,
heading = 355.0,
pitch = 72.0,
roll = 0.0
)
return ArcGISScene(BasemapStyle.ArcGISImagery).apply {
baseSurface = surface
initialViewpoint = Viewpoint(cameraLocation, camera)
}
}In MainScreen.kt, create a composable function named MainScreen, which will call SceneView.
MainScreen.kt
Expand
Use dark colors for code blocks1
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
@Composable
fun MainScreen() {
}
Add a remember block and call createScene() inside it. Assign remember to a local variable named scene.
The top-level composable function remember is used to retain state across recompositions.
MainScreen.kt
Expand
Use dark colors for code blocks1
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
@Composable
fun MainScreen() {
val scene = remember {
createScene()
}
}
You will now call several composable functions from Android Jetpack Compose. Call Scaffold and pass a TopAppBar with a Text that contains the app name (R.string.app_name).
MainScreen.kt
Expand
Use dark colors for code blocks1
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
@Composable
fun MainScreen() {
val scene = remember {
createScene()
}
Scaffold(
topBar = { TopAppBar(title = { Text(text = stringResource(id = R.string.app_name)) }) }
) {
}
}
In the trailing lambda for Scaffold, call the SceneView composable defined in the ArcGIS Maps SDK for Kotlin Toolkit. Pass a Modifier that has maximum size and default padding. And pass scene as the arcGISScene parameter
MainScreen.kt
Expand
Use dark colors for code blocks1
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
@Composable
fun MainScreen() {
val scene = remember {
createScene()
}
Scaffold(
topBar = { TopAppBar(title = { Text(text = stringResource(id = R.string.app_name)) }) }
) {
SceneView(
modifier = Modifier.fillMaxSize().padding(it),
arcGISScene = scene
)
}
}
Open the app > kotlin+java > com.example.app > MainActivity.kt. Delete all lines of code in the file. Then add the package declaration, import statements, and the MainActivity class.
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
package com.example.app
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import com.arcgismaps.ApiKey
import com.arcgismaps.ArcGISEnvironment
import com.arcgismaps.httpcore.authentication.OAuthUserConfiguration
import com.arcgismaps.toolkit.authentication.AuthenticatorState
import com.arcgismaps.toolkit.authentication.DialogAuthenticator
import com.example.app.screens.MainScreen
import com.example.app.ui.theme.TutorialTheme
class MainActivity : ComponentActivity() {
}In the setContent block of the onCreate() lifecycle function, you will call the composable function MainScreen, with default theming applied. To do this, add onCreate() with the following 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
class MainActivity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
enableEdgeToEdge()
setContent {
TutorialTheme {
MainScreen()
}
}
}
}To allow your app users to access ArcGIS Location Services, use the developer credentials that you created in the Set up authentication step to authenticate requests for resources.
In the Android view of Android Studio, open app > kotlin+java > com.example.app > MainActivity.
In the onCreate() lifecycle method of the MainActivity class, set the ArcGISEnvironment.apiKeyâ property by calling ApiKey.create(). Pass in your API key access token as a string and don't forget the double quotes. Do this before the setContent block.
MainActivity.kt
Expand
Use dark colors for code blocks1
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
class MainActivity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
ArcGISEnvironment.apiKey = ApiKey.create("YOUR_ACCESS_TOKEN")
enableEdgeToEdge()
setContent {
TutorialTheme {
MainScreen()
}
}
}
}Best Practice: The access token is stored directly in the code as a convenience for this tutorial. Do not store credentials directly in source code in a production environment.
In the Android view of Android Studio, open app > kotlin+java > com.example.app > MainActivity. In the MainActivity class, create an instance of AuthenticatorState, which is from the authentication module of ArcGIS Maps SDK for Kotlin Toolkit. Add this before the setContent block.
MainActivity.kt
Expand
Use dark colors for code blocks1
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
class MainActivity : ComponentActivity() {
private val authenticatorState = AuthenticatorState()
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
enableEdgeToEdge()
setContent {
TutorialTheme {
MainScreen()
}
}
}
}In the onCreate() lifecycle method of the MainActivity class, set the authenticatorState.oAuthUserConfigurations property by instantiating OAuthUserConfiguration, adding it to a list, and assigning the list. Pass in the clientId and redirectURL that you created in an earlier step.
A redirectURL is composed of a scheme and a host component. The format for the redirect url is scheme://host. For example, if the redirect url is myscheme://myhost then the scheme is myscheme and the host is myhost. You must use the RedirectURL that you supplied for your app in the user authentication part of the Set up authentication step.
MainActivity.kt
Expand
Use dark colors for code blocks1
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
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
authenticatorState.oAuthUserConfigurations = listOf(
OAuthUserConfiguration(
portalUrl = "https://www.arcgis.com",
clientId = "YOUR_CLIENT_ID",
redirectUrl = "YOUR_REDIRECT_URL"
)
)
enableEdgeToEdge()
setContent {
TutorialTheme {
MainScreen()
}
}
}
In the setContent block, call the DialogAuthenticator composable function and pass in the authenticatorState. Call DialogAuthenticator after MainScreen().
MainActivity.kt
Expand
Use dark colors for code blocks1
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
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
authenticatorState.oAuthUserConfigurations = listOf(
OAuthUserConfiguration(
portalUrl = "https://www.arcgis.com",
clientId = "YOUR_CLIENT_ID",
redirectUrl = "YOUR_REDIRECT_URL"
)
)
enableEdgeToEdge()
setContent {
TutorialTheme {
MainScreen()
DialogAuthenticator(authenticatorState)
}
}
}
Open app > manifests > AndroidManifest.xml. Add an <activity> tag that declares the OAuth user sign-in activity. Set the android:scheme and android:host using the scheme and host from your RedirectURL.
A redirectURL is composed of a scheme and a host component. The format for the redirect url is scheme://host. For example, if the redirect url is myscheme://myhost then the scheme is myscheme and the host is myhost. You must use the RedirectURL that you supplied for your app in the user authentication part of the Set up authentication step.
AndroidManifest.xml
Expand
Use dark colors for code blocks1
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
<activity
android:name="com.arcgismaps.toolkit.authentication.AuthenticationActivity"
android:configChanges="keyboard|keyboardHidden|orientation|screenSize"
android:exported="true"
android:launchMode="singleTop" >
<intent-filter>
<action android:name="android.intent.action.VIEW" />
<category android:name="android.intent.category.DEFAULT" />
<category android:name="android.intent.category.BROWSABLE" />
<data
android:scheme="your_redirect_url_scheme"
android:host="your_redirect_url_host" />
</intent-filter>
</activity>
Best Practice: The OAuth credentials are stored directly in the code as a convenience for this tutorial. Do not store credentials directly in source code in a production environment.
Run your appClick Run > Run > app to run the app.
In Android Studio, you have two choices for running your app: an actual Android device or the Android Emulator.
Android deviceConnect your computer to your Android device, using USB or Wi-Fi. For more details, see How to connect your Android device.
Android EmulatorCreate an AVD (Android Virtual Device) to run in the Android Emulator. For details, see Run apps on the Android Emulator.
Selecting a deviceWhen you build and run an app in Android Studio, you must first select a device. From the Android Studio toolbar, you can access the drop-down list of your currently available devices, both virtual and physical.
.
If you cannot access the list on the toolbar, click Tools > Device Manager.
You should see a scene with the imagery basemap layer centered on the Santa Monica Mountains in California. Pinch, drag, and double-tap the scene view to explore the scene.
If your app displays but the scene view is blank, you might need to adjust your emulator's settings.
With the emulator displayed, do the following:
Click the Extended Controls icon in the upper right corner of the emulator window.
In the Extended Controls dialog, click on Settings > Advanced > OpenGL ES API Level (requires restart).
Click the dropdown menu, and select Renderer maximum (up to OpenGL ES 3.1).
Restart your emulator.
Alternatively, you can download the tutorial solution, as follows.
Option 2: Download the solutionClick the Download solution link in the right-hand side of this page.
Unzip the file to a location on your machine.
Run Android Studio.
Go to File > Open.... Navigate to the solution folder and click Open.
On Windows: If you are in the Welcome to Android Studio dialog, click Open and navigate to the solution folder. Then click Open.
Since the downloaded solution does not contain authentication credentials, you must add the developer credentials that you created in the Set up authentication section.
Set developer credentials in the solutionTo allow your app users to access ArcGIS location services, use the developer credentials that you created in the Set up authentication step to authenticate requests for resources.
In the Android view of Android Studio, open app > kotlin+java > com.example.app > MainActivity. Set the AuthenticationMode to .API_KEY.
MainActivity.kt
Expand
Use dark colors for code blocks1
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
class MainActivity : ComponentActivity() {
private enum class AuthenticationMode { API_KEY, USER_AUTH }
private val authenticationMode = AuthenticationMode.API_KEY
Set the apiKey property with your API key access token.
MainActivity.kt
Expand
Use dark colors for code blocks1
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
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
when (authenticationMode) {
AuthenticationMode.API_KEY -> {
ArcGISEnvironment.apiKey = ApiKey.create("YOUR_ACCESS_TOKEN")
}
Best Practice: The access token is stored directly in the code as a convenience for this tutorial. Do not store credentials directly in source code in a production environment.
In the Android view of Android Studio, open app > kotlin+java > com.example.app > MainActivity. Set the AuthenticationMode to .USER_AUTH.
MainActivity.kt
Use dark colors for code blocks
1
2
3
4
class MainActivity : ComponentActivity() {
private enum class AuthenticationMode { API_KEY, USER_AUTH }
private val authenticationMode = AuthenticationMode.USER_AUTHSet your clientID and redirectURL values. You must use the RedirectURL that you supplied for your app in the user authentication part of the Set up authentication step.
MainActivity.kt
Expand
Use dark colors for code blocks1
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
AuthenticationMode.USER_AUTH -> {
authenticatorState.oAuthUserConfigurations = listOf(
OAuthUserConfiguration(
portalUrl = "https://www.arcgis.com",
clientId = "YOUR_CLIENT_ID",
redirectUrl = "YOUR_REDIRECT_URL"
)
)
Open app > manifests > AndroidManifest.xml.
Set the android:scheme and android:host using the scheme and host from your RedirectURL.
A redirectURL is composed of a scheme and a host component. The format for the redirect url is scheme://host. For example, if the redirect url is myscheme://myhost then the scheme is myscheme and the host is myhost.
AndroidManifest.xml
Expand
Use dark colors for code blocks1
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
<data
android:scheme="your_redirect_url_scheme"
android:host="your_redirect_url_host" />
Best Practice: The OAuth credentials are stored directly in the code as a convenience for this tutorial. Do not store credentials directly in source code in a production environment.
Run the appClick Run > Run > app to run the app.
You should see a scene with the imagery basemap layer centered on the Santa Monica Mountains in California. Pinch, drag, and double-tap the scene view to explore the scene.
What's next?Learn how to use additional API features, ArcGIS location services, and ArcGIS tools in these tutorials:
RetroSearch is an open source project built by @garambo | Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4