Display a scene

Before starting this tutorial, you need the following:

1. An ArcGIS Location Platform or ArcGIS Online account.

2. A development and deployment environment that meets the system requirements.

3. An IDE for Android development in Kotlin.

Option 1: Develop the code

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 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.

     • Name: SceneTutorial.
     • Package name: Change to com.example.app. Or change to match your organization.
     • Save location: Set to a new folder.
     • Minimum SDK: API 28 (“Pie”; Android 9.0)
     • Build configuration language: Kotlin DSL (build.gradle.kts)

2. In the Android view, make sure that your current view is Android. These tutorial instructions refer to that view.

   More info

   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.

   

3. 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)

   // 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
   }

4. 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)

   63 collapsed lines
   plugins {
       alias(libs.plugins.android.application)
       alias(libs.plugins.kotlin.android)
       alias(libs.plugins.kotlin.compose)
   }
   
   android {
       namespace = "com.example.app"
       compileSdk = libs.versions.compileSdk.get().toInt()
   
       defaultConfig {
           applicationId = "com.example.app"
           minSdk = libs.versions.minSdk.get().toInt()
           targetSdk = libs.versions.targetSdk.get().toInt()
           versionCode = 1
           versionName = "1.0"
           testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
           vectorDrawables {
               useSupportLibrary = true
           }
       }
   
       buildTypes {
           release {
               isMinifyEnabled = false
               proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro")
           }
       }
       compileOptions {
           sourceCompatibility = JavaVersion.VERSION_17
           targetCompatibility = JavaVersion.VERSION_17
       }
       kotlinOptions {
           jvmTarget = "17"
       }
       buildFeatures {
           compose = true
       }
       packaging {
           resources {
               excludes += "/META-INF/{AL2.0,LGPL2.1}"
           }
       }
   }
   
   dependencies {
   
       implementation(libs.androidx.core.ktx)
       implementation(libs.androidx.lifecycle.runtime.ktx)
       implementation(libs.androidx.activity.compose)
       implementation(platform(libs.androidx.compose.bom))
       implementation(libs.androidx.ui)
       implementation(libs.androidx.ui.graphics)
       implementation(libs.androidx.ui.tooling.preview)
       implementation(libs.androidx.material3)
       testImplementation(libs.junit)
       androidTestImplementation(libs.androidx.junit)
       androidTestImplementation(libs.androidx.espresso.core)
       androidTestImplementation(platform(libs.androidx.compose.bom))
       androidTestImplementation(libs.androidx.ui.test.junit4)
       debugImplementation(libs.androidx.ui.tooling)
       debugImplementation(libs.androidx.ui.test.manifest)
   
       // 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)
   2 collapsed lines
   
   }

5. From the Android view, open Gradle Scripts > libs.versions.toml. In the [versions]section, you need to declare the version number for <ProductName />. And in the[libraries]` section, you need to add the library declarations for the following:

   • arcgis-maps-kotlin
   • arcgis-maps-kotlin-toolkit-bom
   • arcgis-maps-kotlin-toolkit-geoview-compose
   • arcgis-maps-kotlin-toolkit-authentication

   The version for the Toolkit BOM applies to all the Toolkit modules you declare.

   Gradle version catalogs

   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.

   Gradle version catalogs can also use BOM files to specify a single version number for all artifacts in the BOM. For more details, see Using the BOM in the README of the ArcGIS Maps SDK for Kotlin Toolkit.

   Expand the code below, copy the entire expanded contents, and paste it into libs.version.toml file, replacing the original contents generated by the New Project Wizard.

   gradle/libs.versions.toml

   [versions]
   arcgisMapsKotlin = "200.8.2"
   
   # Version numbers added by Android Studio New Project Wizard
   agp = "8.9.2"
   kotlin = "2.1.20"
   coreKtx = "1.16.0"
   37 collapsed lines
   junit = "4.13.2"
   junitVersion = "1.2.1"
   espressoCore = "3.6.1"
   lifecycleRuntimeKtx = "2.8.7"
   activityCompose = "1.10.1"
   composeBom = "2025.04.00"
   
   # Other version numbers
   compileSdk = "36"
   minSdk = "28"
   targetSdk = "36"
   
   [libraries]
   arcgis-maps-kotlin = { group = "com.esri", name = "arcgis-maps-kotlin", version.ref = "arcgisMapsKotlin" }
   arcgis-maps-kotlin-toolkit-bom = { group = "com.esri", name = "arcgis-maps-kotlin-toolkit-bom", version.ref = "arcgisMapsKotlin" }
   arcgis-maps-kotlin-toolkit-geoview-compose = { group = "com.esri", name = "arcgis-maps-kotlin-toolkit-geoview-compose" }
   arcgis-maps-kotlin-toolkit-authentication = { group = "com.esri", name = "arcgis-maps-kotlin-toolkit-authentication" }
   
   androidx-core-ktx = { group = "androidx.core", name = "core-ktx", version.ref = "coreKtx" }
   junit = { group = "junit", name = "junit", version.ref = "junit" }
   androidx-junit = { group = "androidx.test.ext", name = "junit", version.ref = "junitVersion" }
   androidx-espresso-core = { group = "androidx.test.espresso", name = "espresso-core", version.ref = "espressoCore" }
   androidx-lifecycle-runtime-ktx = { group = "androidx.lifecycle", name = "lifecycle-runtime-ktx", version.ref = "lifecycleRuntimeKtx" }
   androidx-activity-compose = { group = "androidx.activity", name = "activity-compose", version.ref = "activityCompose" }
   androidx-compose-bom = { group = "androidx.compose", name = "compose-bom", version.ref = "composeBom" }
   androidx-ui = { group = "androidx.compose.ui", name = "ui" }
   androidx-ui-graphics = { group = "androidx.compose.ui", name = "ui-graphics" }
   androidx-ui-tooling = { group = "androidx.compose.ui", name = "ui-tooling" }
   androidx-ui-tooling-preview = { group = "androidx.compose.ui", name = "ui-tooling-preview" }
   androidx-ui-test-manifest = { group = "androidx.compose.ui", name = "ui-test-manifest" }
   androidx-ui-test-junit4 = { group = "androidx.compose.ui", name = "ui-test-junit4" }
   androidx-material3 = { group = "androidx.compose.material3", name = "material3" }
   
   [plugins]
   android-application = { id = "com.android.application", version.ref = "agp" }
   kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" }
   kotlin-compose = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" }

6. 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)

   14 collapsed lines
   pluginManagement {
       repositories {
           google {
               content {
                   includeGroupByRegex("com\\.android.*")
                   includeGroupByRegex("com\\.google.*")
                   includeGroupByRegex("androidx.*")
               }
           }
           mavenCentral()
           gradlePluginPortal()
       }
   }
   
   dependencyResolutionManagement {
       repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
       repositories {
           google()
           mavenCentral()
           maven { url = uri("https://esri.jfrog.io/artifactory/arcgis") }
       }
   }
   rootProject.name = "SceneTutorial"
   include(":app")

7. 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.

8. 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

   2 collapsed lines
   1
   <?xml version="1.0" encoding="utf-8"?>
   2
   
   3
   <manifest xmlns:android="http://schemas.android.com/apk/res/android"
   4
       xmlns:tools="http://schemas.android.com/tools">
   5
   
   6
       <uses-permission android:name="android.permission.INTERNET" />
   41 collapsed lines
   7
   
   8
       <application
   9
           android:allowBackup="true"
   10
           android:dataExtractionRules="@xml/data_extraction_rules"
   11
           android:fullBackupContent="@xml/backup_rules"
   12
           android:icon="@mipmap/ic_launcher"
   13
           android:label="@string/app_name"
   14
           android:roundIcon="@mipmap/ic_launcher_round"
   15
           android:supportsRtl="true"
   16
           android:theme="@style/Theme.SceneTutorial"
   17
           tools:targetApi="31">
   18
           <activity
   19
               android:name=".MainActivity"
   20
               android:exported="true"
   21
               android:label="@string/app_name"
   22
               android:theme="@style/Theme.SceneTutorial">
   23
               <intent-filter>
   24
                   <action android:name="android.intent.action.MAIN" />
   25
   
   26
                   <category android:name="android.intent.category.LAUNCHER" />
   27
               </intent-filter>
   28
           </activity>
   29
           <activity
   30
               android:name="com.arcgismaps.toolkit.authentication.AuthenticationActivity"
   31
               android:configChanges="keyboard|keyboardHidden|orientation|screenSize"
   32
               android:exported="true"
   33
               android:launchMode="singleTop" >
   34
               <intent-filter>
   35
                   <action android:name="android.intent.action.VIEW" />
   36
   
   37
                   <category android:name="android.intent.category.DEFAULT" />
   38
                   <category android:name="android.intent.category.BROWSABLE" />
   39
   
   40
                   <data
   41
                       android:scheme="your_redirect_url_scheme"
   42
                       android:host="your_redirect_url_host" />
   43
               </intent-filter>
   44
           </activity>
   45
       </application>
   46
   
   47
   </manifest>

Create a scene

1. 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.

2. 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.

3. 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.

   MainScreen.kt

   @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

4. 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.

   1. Create a top-level function named createScene() that returns an ArcGISScene.

      MainScreen.kt

      25 collapsed lines
      @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
      
      fun createScene(): ArcGISScene {
      
      }

   2. 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.

      More info

      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

      25 collapsed lines
      @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
      
      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
          }
      
      }

   3. 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

      25 collapsed lines
      @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
      
      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
          )
      
      }

   4. Create an ArcGISScene with a BasemapStyle.ArcGISImagery. Then call apply() on the new ArcGISScene. The createScene() function returns this ArcGISScene.

      More info

      For more information on apply(), see Kotlin scope functions.

      MainScreen.kt

      25 collapsed lines
      @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
      
      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 {
      
          }
      
      }

   5. In the apply block, set the baseSurface property of the ArcGISScene to surface.

      MainScreen.kt

      25 collapsed lines
      @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
      
      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
      
          }
      
      }

   6. Create a Viewpoint using cameraLocation and camera and set it as the initial viewpoint for the scene.

      MainScreen.kt

      25 collapsed lines
      @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
      
      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)
      
          }
      
      }

Create a MainScreen to hold the scene

1. In MainScreen.kt, create a composable function named MainScreen, which will call SceneView.

   MainScreen.kt

   59 collapsed lines
   @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
   
   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)
   
       }
   
   }
   
   @Composable
   fun MainScreen() {
   
   }

2. Add a remember block and call createScene() inside it. Assign remember to a local variable named scene.

   More info

   The top-level composable function remember is used to retain state across recompositions.

   MainScreen.kt

   59 collapsed lines
   @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
   
   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)
   
       }
   
   }
   
   @Composable
   fun MainScreen() {
   
       val scene = remember {
           createScene()
       }
   
   }

3. 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

   59 collapsed lines
   @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
   
   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)
   
       }
   
   }
   
   @Composable
   fun MainScreen() {
   
       val scene = remember {
           createScene()
       }
   
       Scaffold(
           topBar = { TopAppBar(title = { Text(text = stringResource(id = R.string.app_name)) }) }
       ) {
   
       }
   
   }

4. 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

   59 collapsed lines
   @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
   
   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)
   
       }
   
   }
   
   @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
           )
   
       }
   
   }

Call MainScreen inside MainActivity class

1. 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

   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.SceneTutorialTheme
   
   class MainActivity : ComponentActivity() {
   
   }

2. 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

   class MainActivity : ComponentActivity() {
   
       override fun onCreate(savedInstanceState: Bundle?) {
           super.onCreate(savedInstanceState)
   
           enableEdgeToEdge()
   
           setContent {
               SceneTutorialTheme {
                   MainScreen()
   
               }
           }
       }
   
   }

Set developer credentials

To allow your app users to access ArcGIS Location Services ArcGIS Location Services, also referred to as Location Services, are services hosted by Esri that provide geospatial functionality for developing mapping applications. They include the ArcGIS Basemap Styles service, ArcGIS Static Basemap Tiles service, ArcGIS Places service, ArcGIS Geocoding service, ArcGIS Routing service, ArcGIS GeoEnrichment service, and ArcGIS Elevation service. An ArcGIS Location Platform or ArcGIS Online account is required to use the services. Learn more , use the developer credentials that you created in the Set up authentication step to authenticate requests for resources.

Run your app

1. Click Run > Run > app to run the app.

   More info

   In Android Studio, you have two choices for running your app: an actual Android device or the Android Emulator.

   Android device

   Connect your computer to your Android device, using USB or Wi-Fi. For more details, see How to connect your Android device.

   Android Emulator

   Create an AVD (Android Virtual Device) to run in the Android Emulator. For details, see Run apps on the Android Emulator.

   Selecting a device

   When 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 A scene is a collection of layers that are displayed in 3D. It is typically composed of a basemap layer, data layers, and 3D data. Learn more with the imagery basemap layer A basemap layer is the layer in a map or scene that displays basemap data. The data source for a basemap layer is typically a basemap service. Learn more 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.

Option 2: Download the solution

1. Click the Download solution link in the right-hand side of this page.

2. Unzip the file to a location on your machine.

3. Run Android Studio.

4. 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 solution

To allow your app users to access ArcGIS location services ArcGIS Location Services, also referred to as Location Services, are services hosted by Esri that provide geospatial functionality for developing mapping applications. They include the ArcGIS Basemap Styles service, ArcGIS Static Basemap Tiles service, ArcGIS Places service, ArcGIS Geocoding service, ArcGIS Routing service, ArcGIS GeoEnrichment service, and ArcGIS Elevation service. An ArcGIS Location Platform or ArcGIS Online account is required to use the services. Learn more , use the developer credentials that you created in the Set up authentication step to authenticate requests for resources.

Run the app

Click Run > Run > app to run the app.

You should see a scene A scene is a collection of layers that are displayed in 3D. It is typically composed of a basemap layer, data layers, and 3D data. Learn more with the imagery basemap layer A basemap layer is the layer in a map or scene that displays basemap data. The data source for a basemap layer is typically a basemap service. Learn more centered on the Santa Monica Mountains in California. Pinch, drag, and double-tap the scene view to explore the scene.