Display a scene

Learn how to create and display a with a and an . Set properties of the scene's to control the 3D perspective.

image

Like a , a contains of geographic data. It contains a and, optionally, one or more . To provide a realistic view of the terrain, you can also add to define the height of the surface across the scene. The 3D perspective of the scene is controlled by the scene's , which defines the position of the scene observer in 3D space.

In this tutorial, you create and display a using the imagery . The surface of the scene is defined with an and the is positioned to display an area of the Santa Monica Mountains in the .

The scene and code will be used as the starting point for other 3D tutorials.

Prerequisites

Before starting this tutorial:

  1. You need an ArcGIS Location Platform or ArcGIS Online account.

  2. Confirm that your system meets the system requirements.

  3. An IDE for Android development in Kotlin.

Steps

Create a new Android Studio project

Use Android Studio to create an app and configure it to reference the API.

  1. Open Android Studio.

    • In the menu bar, click File > New > New Project....
    • In the Create New Project window, make sure Phone and Tablet tab is selected, and then select Empty Activity. Click Next.
    • In the Configure your project window, set the following configuration options:
      • Name: Display a scene.
      • Package name: Change to com.example.app. Or change to match your organization.
      • Save location: Set to a new folder.
      • Language: Kotlin
      • Minimum SDK: API 23: Android 6.0 (Marshmallow)
  2. In the Project tool window, make sure that your current view is Android. These tutorial instructions refer to that view.

  3. From the Project tool window, open Gradle Scripts > build.gradle (Project: Display_a_scene). Replace the contents of the file with the following code:

    build.gradle (Project: Display_a_scene)
    1 2 3 4 5 6 7 8 9 10 11
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    // Top-level build file where you can add configuration options common to all sub-projects/modules.
    
    plugins {
        id 'com.android.application' version '7.2.1' apply false
        id 'com.android.library' version '7.2.1' apply false
        id 'org.jetbrains.kotlin.android' version '1.7.0' apply false
    }
    
    task clean(type: Delete) {
        delete rootProject.buildDir
    }
  4. From the Project tool window, open Gradle Scripts > build.gradle (Module: Display_a_scene.app). Replace the contents of the file with the following code:

    build.gradle (Module: Display_a_scene.app)
    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
    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
    plugins {
        id 'com.android.application'
        id 'org.jetbrains.kotlin.android'
    }
    
    android {
        compileSdkVersion 32
    
        defaultConfig {
            applicationId "com.example.app"
            minSdkVersion 23
            targetSdkVersion 32
            versionCode 1
            versionName "1.0"
        }
    
        buildTypes {
            release {
                minifyEnabled false
                proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
            }
        }
    
        compileOptions {
            sourceCompatibility JavaVersion.VERSION_1_8
            targetCompatibility JavaVersion.VERSION_1_8
        }
    
        kotlinOptions {
            jvmTarget = JavaVersion.VERSION_1_8.toString()
        }
    
        buildFeatures {
            viewBinding true
        }
    
        packagingOptions {
            exclude 'META-INF/DEPENDENCIES'
        }
    
    }
    
    dependencies {
        implementation fileTree(dir: "libs", include: ["*.jar"])
        implementation 'androidx.appcompat:appcompat:1.4.2'
        implementation 'androidx.constraintlayout:constraintlayout:2.1.4'
        implementation 'androidx.multidex:multidex:2.0.1'
        implementation 'com.google.android.material:material:1.6.1'
    
        implementation 'com.esri.arcgisruntime:arcgis-android:100.15.0'
    }
  5. From the Project tool window, open Gradle Scripts > settings.gradle. Replace the contents of the file with the following code:

    settings.gradle (Display a map)
    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    import org.gradle.api.initialization.resolve.RepositoriesMode
    
    pluginManagement {
        repositories {
            gradlePluginPortal()
            google()
            mavenCentral()
        }
    }
    dependencyResolutionManagement {
        repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
        repositories {
            google()
            mavenCentral()
    
            maven {
                url 'https://esri.jfrog.io/artifactory/arcgis'
            }
        }
    }
    
    rootProject.name = "Display a scene"
    
    include ':app'
  6. 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.

  7. From the Project tool window, open app > manifests > AndroidManifest.xml. Update the Android manifest to allow network access, and also to indicate the app uses OpenGL 2.0 or above.

    AndroidManifest.xml
    Expand
    3 4 5 6 7 8 9 10
    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
    <manifest xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:tools="http://schemas.android.com/tools"
        package="com.example.app">
    
        <uses-permission android:name="android.permission.INTERNET" />
        <uses-feature
            android:glEsVersion="0x00020000"
            android:required="true" />
    
    Expand

Add import statements

Open app > java > com.example.app MainActivity.kt, and add import statements to reference the ArcGIS Runtime API.

MainActivity.kt
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
package com.example.app

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle

import com.esri.arcgisruntime.ArcGISRuntimeEnvironment
import com.esri.arcgisruntime.geometry.Point
import com.esri.arcgisruntime.geometry.SpatialReferences
import com.esri.arcgisruntime.mapping.ArcGISScene
import com.esri.arcgisruntime.mapping.ArcGISTiledElevationSource
import com.esri.arcgisruntime.mapping.BasemapStyle
import com.esri.arcgisruntime.mapping.Surface
import com.esri.arcgisruntime.mapping.view.Camera
import com.esri.arcgisruntime.mapping.view.SceneView

import com.example.app.databinding.ActivityMainBinding

Add a UI for the scene view

A is a UI component that displays a . It also handles user interactions with the scene, including navigating with touch gestures. Use XML to add a scene view to the UI and make it available to the main activity source code.

  1. In app > res > layout > activity_main.xml, replace the entire TextView element with a SceneView element.

    activity_main.xml
    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    <?xml version="1.0" encoding="utf-8"?>
    <androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:app="http://schemas.android.com/apk/res-auto"
        xmlns:tools="http://schemas.android.com/tools"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        tools:context=".MainActivity">
    
        <com.esri.arcgisruntime.mapping.view.SceneView
            android:id="@+id/sceneView"
            android:layout_width="0dp"
            android:layout_height="0dp"
            app:layout_constraintBottom_toBottomOf="parent"
            app:layout_constraintEnd_toEndOf="parent"
            app:layout_constraintStart_toStartOf="parent"
            app:layout_constraintTop_toTopOf="parent" />
    
    </androidx.constraintlayout.widget.ConstraintLayout>
  2. In MainActivity.kt, create a read-only local variable named activityMainBinding referencing the generated Android class ActivityMainBinding.

    MainActivity.kt
    Expand
    35 36 37 38 39 40
    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
    class MainActivity : AppCompatActivity() {
    
        private val activityMainBinding: ActivityMainBinding by lazy {
            ActivityMainBinding.inflate(layoutInflater)
        }
    
    
    Expand
  3. Create a read-only variable named sceneView and bind it to the sceneView created in activity_main.xml.

    MainActivity.kt
    Expand
    35 36 37 38 39 40 41 42 43
    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
    class MainActivity : AppCompatActivity() {
    
        private val activityMainBinding: ActivityMainBinding by lazy {
            ActivityMainBinding.inflate(layoutInflater)
        }
    
        private val sceneView: SceneView by lazy {
            activityMainBinding.sceneView
        }
    
    Expand

Add a scene

Use the to display a centered on the Santa Monica Mountains in California. The scene will contain a imagery .

  1. In MainActivity.kt, add a new setupScene() method in your MainActivity class and create an ArcGISScene with an imagery basemap.

    MainActivity.kt
    Expand
    52 53 54 55 56 55
    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
        // set up your scene here. You will call this method from onCreate()
        private fun setupScene() {
    
            val scene = ArcGISScene(BasemapStyle.ARCGIS_IMAGERY_STANDARD)
    
        }
    
    Expand
  2. Set the scene property of sceneView to the new ArcGISScene.

    MainActivity.kt
    Expand
    52 53 54 55 56 57 58 59 58
    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
        // set up your scene here. You will call this method from onCreate()
        private fun setupScene() {
    
            val scene = ArcGISScene(BasemapStyle.ARCGIS_IMAGERY_STANDARD)
    
            // set the scene on the scene view
            sceneView.scene = scene
    
        }
    
    Expand
  3. Create a new ArcGISTiledElevationSource and use it to create a new Surface. Then set the elevationExaggeration property on the surface to 2.5f to increase the 3D effect of the elevation.

    MainActivity.kt
    Expand
    52 53 54 55 56 57 58 59 60 61 62 63 64 65 64
    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
        // set up your scene here. You will call this method from onCreate()
        private fun setupScene() {
    
            val scene = ArcGISScene(BasemapStyle.ARCGIS_IMAGERY_STANDARD)
    
            // set the scene on the scene view
            sceneView.scene = scene
    
            // add base surface for elevation data
            val elevationSource = ArcGISTiledElevationSource("https://elevation3d.arcgis.com/arcgis/rest/services/WorldElevation3D/Terrain3D/ImageServer")
            val surface = Surface(listOf(elevationSource))
            // add an exaggeration factor to increase the 3D effect of the elevation.
            surface.elevationExaggeration = 2.5f
    
        }
    
    Expand
  4. Set the baseSurface property of the scene to the surface.

    MainActivity.kt
    Expand
    52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68
    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
        // set up your scene here. You will call this method from onCreate()
        private fun setupScene() {
    
            val scene = ArcGISScene(BasemapStyle.ARCGIS_IMAGERY_STANDARD)
    
            // set the scene on the scene view
            sceneView.scene = scene
    
            // add base surface for elevation data
            val elevationSource = ArcGISTiledElevationSource("https://elevation3d.arcgis.com/arcgis/rest/services/WorldElevation3D/Terrain3D/ImageServer")
            val surface = Surface(listOf(elevationSource))
            // add an exaggeration factor to increase the 3D effect of the elevation.
            surface.elevationExaggeration = 2.5f
    
            scene.baseSurface = surface
    
        }
    
    Expand
  5. Create a Point for the and assign it to cameraLocation. Then create a Camera, passing the cameraLocation and values for the camera's heading, pitch, and roll.

    MainActivity.kt
    Expand
    52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73
    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
        // set up your scene here. You will call this method from onCreate()
        private fun setupScene() {
    
            val scene = ArcGISScene(BasemapStyle.ARCGIS_IMAGERY_STANDARD)
    
            // set the scene on the scene view
            sceneView.scene = scene
    
            // add base surface for elevation data
            val elevationSource = ArcGISTiledElevationSource("https://elevation3d.arcgis.com/arcgis/rest/services/WorldElevation3D/Terrain3D/ImageServer")
            val surface = Surface(listOf(elevationSource))
            // add an exaggeration factor to increase the 3D effect of the elevation.
            surface.elevationExaggeration = 2.5f
    
            scene.baseSurface = surface
    
            // Point(x, y, z, spatialReference)
            val cameraLocation = Point(-118.794, 33.909, 5330.0, SpatialReferences.getWgs84())
            // Camera(location, heading, pitch, roll)
            val camera = Camera(cameraLocation, 355.0, 72.0, 0.0)
    
        }
    
    Expand
  6. Call setViewpointCamera() on the sceneView and pass in the camera.

    MainActivity.kt
    Expand
    52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75
    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
        // set up your scene here. You will call this method from onCreate()
        private fun setupScene() {
    
            val scene = ArcGISScene(BasemapStyle.ARCGIS_IMAGERY_STANDARD)
    
            // set the scene on the scene view
            sceneView.scene = scene
    
            // add base surface for elevation data
            val elevationSource = ArcGISTiledElevationSource("https://elevation3d.arcgis.com/arcgis/rest/services/WorldElevation3D/Terrain3D/ImageServer")
            val surface = Surface(listOf(elevationSource))
            // add an exaggeration factor to increase the 3D effect of the elevation.
            surface.elevationExaggeration = 2.5f
    
            scene.baseSurface = surface
    
            // Point(x, y, z, spatialReference)
            val cameraLocation = Point(-118.794, 33.909, 5330.0, SpatialReferences.getWgs84())
            // Camera(location, heading, pitch, roll)
            val camera = Camera(cameraLocation, 355.0, 72.0, 0.0)
    
            sceneView.setViewpointCamera(camera)
    
        }
    
    Expand
  7. In the onCreate() method, modify the setContentView() call to take activityMainBinding.root as its parameter. Next, call setupScene().

    MainActivity.kt
    Expand
    45 46 47 48 49 50 51 52
    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
        override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
    
        setContentView(activityMainBinding.root)
    
        setupScene()
    
        }
    
    Expand
  8. Override the Android life cycle methods onPause(), onResume(), and onDestroy() to pause, resume and dispose of the sceneView.

    MainActivity.kt
    Expand
    54 55 56 57 58 59 60 61 62 63 64 65 66 67
    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
        override fun onPause() {
            sceneView.pause()
            super.onPause()
        }
    
        override fun onResume() {
            super.onResume()
            sceneView.resume()
        }
    
        override fun onDestroy() {
            sceneView.dispose()
            super.onDestroy()
        }
    
    Expand

Get an access token

You need an to use the used in this tutorial.

  1. Go to the Create an API key tutorial to obtain an using your or account.

  2. Ensure that the following is enabled: Location services > Basemaps > Basemap styles service.

  3. Copy the access token as it will be used in the next step.

To learn more about other ways to get an access token, go to Types of authentication.

Set your API key

  1. Create the setApiKeyForApp() method, in which you set the apiKey property on the ArcGISRuntimeEnvironment using the . Paste your access token inside the quotes, replacing YOUR_ACCESS_TOKEN.

    MainActivity.kt
    Expand
    64 65 66 67 68 69 70 71 72 73 74 75 76 77 78
    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
        override fun onDestroy() {
            sceneView.dispose()
            super.onDestroy()
        }
    
        private fun setApiKeyForApp(){
    
            ArcGISRuntimeEnvironment.setApiKey("YOUR_ACCESS_TOKEN")
    
        }
    
        // set up your scene here. You will call this method from onCreate()
        private fun setupScene() {
    
            val scene = ArcGISScene(BasemapStyle.ARCGIS_IMAGERY_STANDARD)
    
    Expand
  2. In onCreate(), call setAPIKeyForApp().

    MainActivity.kt
    Expand
    45 46 47 48 49 50 51 52 53 54
    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
        override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
    
        setContentView(activityMainBinding.root)
    
        setApiKeyForApp()
    
        setupScene()
    
        }
    
    Expand
  3. Click Run > Run > app to run the app.

You should see a with the imagery 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:

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

You can no longer sign into this site. Go to your ArcGIS portal or the ArcGIS Location Platform dashboard to perform management tasks.

Your ArcGIS portal

Create, manage, and access API keys and OAuth 2.0 developer credentials, hosted layers, and data services.

Your ArcGIS Location Platform dashboard

Manage billing, monitor service usage, and access additional resources.

Learn more about these changes in the What's new in Esri Developers June 2024 blog post.

Close