Display a map

Learn how to create and display a map with a basemap layer.

A map contains layers of geographic data. A map contains a basemap layer and, optionally, one or more data layers. You can display a specific area of a map by using a map view and setting the location and zoom level.

In this tutorial, you create and display a map of the Santa Monica Mountains in California using the topographic basemap layer.

The map and code will be used as the starting point for other 2D tutorials.

Prerequisites

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.

     More info

     Gradle is the default build tool in Android Studio. If you are unable to use Gradle, see Getting the API Manually.

   • In the Configure your project window, set the following configuration options:

     • Name: Display a map.
     • 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.

   More info

   If your view name is something other than Android (such as Project or Packages), click on the leftmost control in the title bar of the Project tool window, and select Android from the list.

   

3. From the Project tool window, open Gradle Scripts > build.gradle (Project: Display_a_map). Add the following lines to the repositories block in allprojects to reference the API from Esri's maven repository.

   build.gradle (Project: Display_a_map)

   Show more lines

   16 16 16 16 16 16 16 16 16 16 16 16 16 16 16 16 17 18 19 20 21 22 23 24 25 26 27 27 27 27 27

   Add line.Add line.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
   // Top-level build file where you can add configuration options common to all sub-projects/modules.
   buildscript {
       ext.kotlin_version = "1.4.21"
       repositories {
           google()
           jcenter()
       }
       dependencies {
           classpath "com.android.tools.build:gradle:4.1.1"
           classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
   
           // NOTE: Do not place your application dependencies here; they belong
           // in the individual module build.gradle files
       }
   }
   
   allprojects {
       repositories {
           google()
           jcenter()
   
           maven {
               url 'https://esri.jfrog.io/artifactory/arcgis'
           }
   
       }
   }
   
   task clean(type: Delete) {
       delete rootProject.buildDir
   }
   

   Show more lines

4. From the Project tool window, open Gradle Scripts > build.gradle (Module: Display_a_map.app). Add the following line (in green highlight) in the dependencies block to include the ArcGIS Runtime API for Android.

   build.gradle (Module: app)

   Show more lines

   21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 22 23 24 25 26 27 28 29 30 30 30 30 30 31 32 33 34 35 36 37 38 39 40 41

   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
   apply plugin: 'com.android.application'
   apply plugin: 'kotlin-android'
   
   android {
       compileSdkVersion 29
   
       defaultConfig {
           applicationId "com.example.app"
           minSdkVersion 23
           targetSdkVersion 29
           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
       }
   
   }
   
   dependencies {
       implementation fileTree(dir: "libs", include: ["*.jar"])
       implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
       implementation 'androidx.appcompat:appcompat:1.2.0'
       implementation 'androidx.constraintlayout:constraintlayout:2.0.4'
   
       implementation 'com.esri.arcgisruntime:arcgis-android:100.12.0'
   
   }
   

5. Enable view binding by adding it to a buildFeatures block in the android block.

   build.gradle (Module: app)

   Show more lines

   26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 27 28 29 30 31 32 33 33 33 33 33 33 33 33 33 33 33 33 33

   Add line.Add line.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
   apply plugin: 'com.android.application'
   apply plugin: 'kotlin-android'
   
   android {
       compileSdkVersion 29
   
       defaultConfig {
           applicationId "com.example.app"
           minSdkVersion 23
           targetSdkVersion 29
           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
       }
   
   }
   
   dependencies {
       implementation fileTree(dir: "libs", include: ["*.jar"])
       implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
       implementation 'androidx.appcompat:appcompat:1.2.0'
       implementation 'androidx.constraintlayout:constraintlayout:2.0.4'
   
       implementation 'com.esri.arcgisruntime:arcgis-android:100.12.0'
   
   }
   

   Show more lines

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.

   More info

   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

   1 2 3 4 5 6 7 8 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9

   Add line.Add line.Add line.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
   <?xml version="1.0" encoding="utf-8"?>
   <manifest xmlns:android="http://schemas.android.com/apk/res/android"
       package="com.example.app">
   
       <uses-permission android:name="android.permission.INTERNET" />
       <uses-feature
           android:glEsVersion="0x00020000"
           android:required="true" />
   
       <application
           android:allowBackup="true"
           android:icon="@mipmap/ic_launcher"
           android:label="@string/app_name"
           android:roundIcon="@mipmap/ic_launcher_round"
           android:supportsRtl="true"
           android:theme="@style/AppTheme">
           <activity android:name="com.example.app.MainActivity">
               <intent-filter>
                   <action android:name="android.intent.action.MAIN" />
   
                   <category android:name="android.intent.category.LAUNCHER" />
               </intent-filter>
           </activity>
       </application>
   
   </manifest>

   Show more lines

Add import statements

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

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
/*
 * Copyright 2020 Esri
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.example.app


import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity
import com.esri.arcgisruntime.ArcGISRuntimeEnvironment
import com.esri.arcgisruntime.mapping.ArcGISMap
import com.esri.arcgisruntime.mapping.BasemapStyle
import com.esri.arcgisruntime.mapping.Viewpoint
import com.esri.arcgisruntime.mapping.view.MapView
import com.example.app.databinding.ActivityMainBinding


class MainActivity : AppCompatActivity() {

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

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

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

        setContentView(activityMainBinding.root)

        setupMap()

    }

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

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

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


    // set up your map here. You will call this method from onCreate()
    private fun setupMap() {

        // set your API key
        // Note: it is not best practice to store API keys in source code. The API key is referenced
        // here for the convenience of this tutorial.
        ArcGISRuntimeEnvironment.setApiKey("YOUR_API_KEY")

        // create a map with the BasemapStyle streets
        val map = ArcGISMap(BasemapStyle.ARCGIS_TOPOGRAPHIC)

        // set the map to be displayed in the layout's MapView
        mapView.map = map
        // set the viewpoint, Viewpoint(latitude, longitude, scale)
        mapView.setViewpoint(Viewpoint(34.0270, -118.8050, 72000.0))

    }

}

Add a UI for the map view

A map view is a UI component that displays a map. It also handles user interactions with the map, including navigating with touch gestures. Use XML to add a map 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 MapView element.

   More info

   If you do not see the XML code, select the Code tab to switch out of design mode and display the XML code in the editor.

   Your MapView element creates an instance of the MapView class from the ArcGIS Runtime API for Android.

   In your main activity source code, you can access that MapView instance using an implicit property, which is declared in the value of the android:id attribute. In this case, the property will be named mapView.

   activity_main.xml

   1 2 3 4 5 6 7 8 9 10 11 12 13

   Change lineChange lineChange lineChange line

   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   <?xml version="1.0" encoding="utf-8"?>
   <androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
       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.MapView
           android:id="@+id/mapView"
           android:layout_width="match_parent"
           android:layout_height="match_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

   Show more lines

   29 29 29 29 29 29 29 29 29 29 29 29 29 29 29 29 29 29 29 29 29 29 29 29 29 29 29 29 29 30 31 32 33 34 35 35 35 35 34 33 32 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 -1 -2 -3 -4 -5 -6 -7 -8 -9 -9

   Add line.Add line.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
   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
   /*
    * Copyright 2020 Esri
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    *    https://www.apache.org/licenses/LICENSE-2.0
    *
    * Unless required by applicable law or agreed to in writing, software
    * distributed under the License is distributed on an "AS IS" BASIS,
    * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    * See the License for the specific language governing permissions and
    * limitations under the License.
    */
   
   package com.example.app
   
   
   import android.os.Bundle
   import androidx.appcompat.app.AppCompatActivity
   import com.esri.arcgisruntime.ArcGISRuntimeEnvironment
   import com.esri.arcgisruntime.mapping.ArcGISMap
   import com.esri.arcgisruntime.mapping.BasemapStyle
   import com.esri.arcgisruntime.mapping.Viewpoint
   import com.esri.arcgisruntime.mapping.view.MapView
   import com.example.app.databinding.ActivityMainBinding
   
   
   class MainActivity : AppCompatActivity() {
   
       private val activityMainBinding by lazy {
         ActivityMainBinding.inflate(layoutInflater)
       }
   
       private val mapView: MapView by lazy {
         activityMainBinding.mapView
       }
   
       override fun onCreate(savedInstanceState: Bundle?) {
           super.onCreate(savedInstanceState)
   
           setContentView(activityMainBinding.root)
   
           setupMap()
   
       }
   
       override fun onPause() {
           mapView.pause()
           super.onPause()
       }
   
       override fun onResume() {
           super.onResume()
           mapView.resume()
       }
   
       override fun onDestroy() {
           mapView.dispose()
           super.onDestroy()
       }
   
   
       // set up your map here. You will call this method from onCreate()
       private fun setupMap() {
   
           // set your API key
           // Note: it is not best practice to store API keys in source code. The API key is referenced
           // here for the convenience of this tutorial.
           ArcGISRuntimeEnvironment.setApiKey("YOUR_API_KEY")
   
           // create a map with the BasemapStyle streets
           val map = ArcGISMap(BasemapStyle.ARCGIS_TOPOGRAPHIC)
   
           // set the map to be displayed in the layout's MapView
           mapView.map = map
           // set the viewpoint, Viewpoint(latitude, longitude, scale)
           mapView.setViewpoint(Viewpoint(34.0270, -118.8050, 72000.0))
   
       }
   
   }
   

   Show more lines

3. Create a read-only variable named mapView and bind it to the mapView created in activity_main.xml.

   MainActivity.kt

   Show more lines

   29 29 29 29 29 29 29 29 29 29 29 29 29 29 29 29 29 29 29 29 29 29 29 29 29 29 29 29 29 30 31 32 33 34 35 36 37 38 38 37 36 35 34 33 32 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 -1 -2 -3 -4 -5 -5

   Add line.Add line.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
   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
   /*
    * Copyright 2020 Esri
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    *    https://www.apache.org/licenses/LICENSE-2.0
    *
    * Unless required by applicable law or agreed to in writing, software
    * distributed under the License is distributed on an "AS IS" BASIS,
    * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    * See the License for the specific language governing permissions and
    * limitations under the License.
    */
   
   package com.example.app
   
   
   import android.os.Bundle
   import androidx.appcompat.app.AppCompatActivity
   import com.esri.arcgisruntime.ArcGISRuntimeEnvironment
   import com.esri.arcgisruntime.mapping.ArcGISMap
   import com.esri.arcgisruntime.mapping.BasemapStyle
   import com.esri.arcgisruntime.mapping.Viewpoint
   import com.esri.arcgisruntime.mapping.view.MapView
   import com.example.app.databinding.ActivityMainBinding
   
   
   class MainActivity : AppCompatActivity() {
   
       private val activityMainBinding by lazy {
         ActivityMainBinding.inflate(layoutInflater)
       }
   
       private val mapView: MapView by lazy {
         activityMainBinding.mapView
       }
   
       override fun onCreate(savedInstanceState: Bundle?) {
           super.onCreate(savedInstanceState)
   
           setContentView(activityMainBinding.root)
   
           setupMap()
   
       }
   
       override fun onPause() {
           mapView.pause()
           super.onPause()
       }
   
       override fun onResume() {
           super.onResume()
           mapView.resume()
       }
   
       override fun onDestroy() {
           mapView.dispose()
           super.onDestroy()
       }
   
   
       // set up your map here. You will call this method from onCreate()
       private fun setupMap() {
   
           // set your API key
           // Note: it is not best practice to store API keys in source code. The API key is referenced
           // here for the convenience of this tutorial.
           ArcGISRuntimeEnvironment.setApiKey("YOUR_API_KEY")
   
           // create a map with the BasemapStyle streets
           val map = ArcGISMap(BasemapStyle.ARCGIS_TOPOGRAPHIC)
   
           // set the map to be displayed in the layout's MapView
           mapView.map = map
           // set the viewpoint, Viewpoint(latitude, longitude, scale)
           mapView.setViewpoint(Viewpoint(34.0270, -118.8050, 72000.0))
   
       }
   
   }
   

   Show more lines

Add a map

Use the map view to display a map centered on the Santa Monica Mountains in California. The map will contain a topographic basemap layer.

1. In MainActivity.kt, add a new setupMap method in your MainActivity class and create an ArcGISMap.

   More info

   Configure ArcGISMap using a specific basemap style named ARCGIS_TOPOGRAPHIC.

   MainActivity.kt

   Show more lines

   64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 63 63 63 63 63 63 63 63 63 63 63 63 63 63 62 61 61 61 60 59 58 57 56 55 54 53 52 51 50 49 48 47 46 45 46 47 48 48 48 48 48 48 49 50 51 51 51 51 51 51 52 52 52

   Add line.Add line.Add line.Add line.Add line.Add line.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
   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
   /*
    * Copyright 2020 Esri
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    *    https://www.apache.org/licenses/LICENSE-2.0
    *
    * Unless required by applicable law or agreed to in writing, software
    * distributed under the License is distributed on an "AS IS" BASIS,
    * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    * See the License for the specific language governing permissions and
    * limitations under the License.
    */
   
   package com.example.app
   
   
   import android.os.Bundle
   import androidx.appcompat.app.AppCompatActivity
   import com.esri.arcgisruntime.ArcGISRuntimeEnvironment
   import com.esri.arcgisruntime.mapping.ArcGISMap
   import com.esri.arcgisruntime.mapping.BasemapStyle
   import com.esri.arcgisruntime.mapping.Viewpoint
   import com.esri.arcgisruntime.mapping.view.MapView
   import com.example.app.databinding.ActivityMainBinding
   
   
   class MainActivity : AppCompatActivity() {
   
       private val activityMainBinding by lazy {
         ActivityMainBinding.inflate(layoutInflater)
       }
   
       private val mapView: MapView by lazy {
         activityMainBinding.mapView
       }
   
       override fun onCreate(savedInstanceState: Bundle?) {
           super.onCreate(savedInstanceState)
   
           setContentView(activityMainBinding.root)
   
           setupMap()
   
       }
   
       override fun onPause() {
           mapView.pause()
           super.onPause()
       }
   
       override fun onResume() {
           super.onResume()
           mapView.resume()
       }
   
       override fun onDestroy() {
           mapView.dispose()
           super.onDestroy()
       }
   
   
       // set up your map here. You will call this method from onCreate()
       private fun setupMap() {
   
           // set your API key
           // Note: it is not best practice to store API keys in source code. The API key is referenced
           // here for the convenience of this tutorial.
           ArcGISRuntimeEnvironment.setApiKey("YOUR_API_KEY")
   
           // create a map with the BasemapStyle streets
           val map = ArcGISMap(BasemapStyle.ARCGIS_TOPOGRAPHIC)
   
           // set the map to be displayed in the layout's MapView
           mapView.map = map
           // set the viewpoint, Viewpoint(latitude, longitude, scale)
           mapView.setViewpoint(Viewpoint(34.0270, -118.8050, 72000.0))
   
       }
   
   }
   

   Show more lines

2. Set the map property of mapView to the new ArcGISMap. Then create a ViewPoint and add it to the mapView.

   MainActivity.kt

   Show more lines

   64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 63 62 62 62 61 60 59 58 57 56 55 54 53 52 51 50 49 48 47 46 47 48 49 49 49 49 49 49 50 51 52 53 54 55 56 57 58 58 58

   Add line.Add line.Add line.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
   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
   /*
    * Copyright 2020 Esri
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    *    https://www.apache.org/licenses/LICENSE-2.0
    *
    * Unless required by applicable law or agreed to in writing, software
    * distributed under the License is distributed on an "AS IS" BASIS,
    * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    * See the License for the specific language governing permissions and
    * limitations under the License.
    */
   
   package com.example.app
   
   
   import android.os.Bundle
   import androidx.appcompat.app.AppCompatActivity
   import com.esri.arcgisruntime.ArcGISRuntimeEnvironment
   import com.esri.arcgisruntime.mapping.ArcGISMap
   import com.esri.arcgisruntime.mapping.BasemapStyle
   import com.esri.arcgisruntime.mapping.Viewpoint
   import com.esri.arcgisruntime.mapping.view.MapView
   import com.example.app.databinding.ActivityMainBinding
   
   
   class MainActivity : AppCompatActivity() {
   
       private val activityMainBinding by lazy {
         ActivityMainBinding.inflate(layoutInflater)
       }
   
       private val mapView: MapView by lazy {
         activityMainBinding.mapView
       }
   
       override fun onCreate(savedInstanceState: Bundle?) {
           super.onCreate(savedInstanceState)
   
           setContentView(activityMainBinding.root)
   
           setupMap()
   
       }
   
       override fun onPause() {
           mapView.pause()
           super.onPause()
       }
   
       override fun onResume() {
           super.onResume()
           mapView.resume()
       }
   
       override fun onDestroy() {
           mapView.dispose()
           super.onDestroy()
       }
   
   
       // set up your map here. You will call this method from onCreate()
       private fun setupMap() {
   
           // set your API key
           // Note: it is not best practice to store API keys in source code. The API key is referenced
           // here for the convenience of this tutorial.
           ArcGISRuntimeEnvironment.setApiKey("YOUR_API_KEY")
   
           // create a map with the BasemapStyle streets
           val map = ArcGISMap(BasemapStyle.ARCGIS_TOPOGRAPHIC)
   
           // set the map to be displayed in the layout's MapView
           mapView.map = map
           // set the viewpoint, Viewpoint(latitude, longitude, scale)
           mapView.setViewpoint(Viewpoint(34.0270, -118.8050, 72000.0))
   
       }
   
   }
   

   Show more lines

3. In the onCreate method, set the content view with setContentView(activityMainBinding.root), then call setupMap.

   More info

   Creating a new Android Studio project for Kotlin or Java automatically uses setContentView(R.layout.activity_main). You can run the map view from the activity_main layout, but this requires a separate extension in the gradle script.

   MainActivity.kt

   Show more lines

   39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 40 41 42 43 44 45 46 47 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33 32 31 31 31 31 30 29 28 27 26 26 26 26 26 26 26 26 26 26 26 26

   Change lineAdd 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
   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
   /*
    * Copyright 2020 Esri
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    *    https://www.apache.org/licenses/LICENSE-2.0
    *
    * Unless required by applicable law or agreed to in writing, software
    * distributed under the License is distributed on an "AS IS" BASIS,
    * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    * See the License for the specific language governing permissions and
    * limitations under the License.
    */
   
   package com.example.app
   
   
   import android.os.Bundle
   import androidx.appcompat.app.AppCompatActivity
   import com.esri.arcgisruntime.ArcGISRuntimeEnvironment
   import com.esri.arcgisruntime.mapping.ArcGISMap
   import com.esri.arcgisruntime.mapping.BasemapStyle
   import com.esri.arcgisruntime.mapping.Viewpoint
   import com.esri.arcgisruntime.mapping.view.MapView
   import com.example.app.databinding.ActivityMainBinding
   
   
   class MainActivity : AppCompatActivity() {
   
       private val activityMainBinding by lazy {
         ActivityMainBinding.inflate(layoutInflater)
       }
   
       private val mapView: MapView by lazy {
         activityMainBinding.mapView
       }
   
       override fun onCreate(savedInstanceState: Bundle?) {
           super.onCreate(savedInstanceState)
   
           setContentView(activityMainBinding.root)
   
           setupMap()
   
       }
   
       override fun onPause() {
           mapView.pause()
           super.onPause()
       }
   
       override fun onResume() {
           super.onResume()
           mapView.resume()
       }
   
       override fun onDestroy() {
           mapView.dispose()
           super.onDestroy()
       }
   
   
       // set up your map here. You will call this method from onCreate()
       private fun setupMap() {
   
           // set your API key
           // Note: it is not best practice to store API keys in source code. The API key is referenced
           // here for the convenience of this tutorial.
           ArcGISRuntimeEnvironment.setApiKey("YOUR_API_KEY")
   
           // create a map with the BasemapStyle streets
           val map = ArcGISMap(BasemapStyle.ARCGIS_TOPOGRAPHIC)
   
           // set the map to be displayed in the layout's MapView
           mapView.map = map
           // set the viewpoint, Viewpoint(latitude, longitude, scale)
           mapView.setViewpoint(Viewpoint(34.0270, -118.8050, 72000.0))
   
       }
   
   }
   

   Show more lines

4. Override the onPause, onResume, and onDestroy methods of the MainActivity class.

   More info

   The MapView needs to know when your app goes to the background or is restored from background in order to properly manage the view. When the view is no longer needed, its resources should be released with a call to dispose.

   You can place these methods anywhere inside your MainActivity class definition.

   MainActivity.kt

   Show more lines

   48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 63 63 63 63 62 61 60 59 58 58 58 58 58 58 58 58 58 58 58 58

   Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.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
   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
   /*
    * Copyright 2020 Esri
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    *    https://www.apache.org/licenses/LICENSE-2.0
    *
    * Unless required by applicable law or agreed to in writing, software
    * distributed under the License is distributed on an "AS IS" BASIS,
    * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    * See the License for the specific language governing permissions and
    * limitations under the License.
    */
   
   package com.example.app
   
   
   import android.os.Bundle
   import androidx.appcompat.app.AppCompatActivity
   import com.esri.arcgisruntime.ArcGISRuntimeEnvironment
   import com.esri.arcgisruntime.mapping.ArcGISMap
   import com.esri.arcgisruntime.mapping.BasemapStyle
   import com.esri.arcgisruntime.mapping.Viewpoint
   import com.esri.arcgisruntime.mapping.view.MapView
   import com.example.app.databinding.ActivityMainBinding
   
   
   class MainActivity : AppCompatActivity() {
   
       private val activityMainBinding by lazy {
         ActivityMainBinding.inflate(layoutInflater)
       }
   
       private val mapView: MapView by lazy {
         activityMainBinding.mapView
       }
   
       override fun onCreate(savedInstanceState: Bundle?) {
           super.onCreate(savedInstanceState)
   
           setContentView(activityMainBinding.root)
   
           setupMap()
   
       }
   
       override fun onPause() {
           mapView.pause()
           super.onPause()
       }
   
       override fun onResume() {
           super.onResume()
           mapView.resume()
       }
   
       override fun onDestroy() {
           mapView.dispose()
           super.onDestroy()
       }
   
   
       // set up your map here. You will call this method from onCreate()
       private fun setupMap() {
   
           // set your API key
           // Note: it is not best practice to store API keys in source code. The API key is referenced
           // here for the convenience of this tutorial.
           ArcGISRuntimeEnvironment.setApiKey("YOUR_API_KEY")
   
           // create a map with the BasemapStyle streets
           val map = ArcGISMap(BasemapStyle.ARCGIS_TOPOGRAPHIC)
   
           // set the map to be displayed in the layout's MapView
           mapView.map = map
           // set the viewpoint, Viewpoint(latitude, longitude, scale)
           mapView.setViewpoint(Viewpoint(34.0270, -118.8050, 72000.0))
   
       }
   
   }
   

   Show more lines

Set your API key

If you haven't already, go to your developer dashboard to get your API key. For these tutorials, use your default API key. It is scoped to include all of the services demonstrated in the tutorials.

1. Before running your app, set the apiKey property on the ArcGISRuntimeEnvironment using the API Key.

   MainActivity.kt

   Show more lines

   64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 65 66 67 68 69 70 71 71 71 71 71 71 71 71 71 71 71 71 71

   Add line.Add line.Add line.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
   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
   /*
    * Copyright 2020 Esri
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    *    https://www.apache.org/licenses/LICENSE-2.0
    *
    * Unless required by applicable law or agreed to in writing, software
    * distributed under the License is distributed on an "AS IS" BASIS,
    * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    * See the License for the specific language governing permissions and
    * limitations under the License.
    */
   
   package com.example.app
   
   
   import android.os.Bundle
   import androidx.appcompat.app.AppCompatActivity
   import com.esri.arcgisruntime.ArcGISRuntimeEnvironment
   import com.esri.arcgisruntime.mapping.ArcGISMap
   import com.esri.arcgisruntime.mapping.BasemapStyle
   import com.esri.arcgisruntime.mapping.Viewpoint
   import com.esri.arcgisruntime.mapping.view.MapView
   import com.example.app.databinding.ActivityMainBinding
   
   
   class MainActivity : AppCompatActivity() {
   
       private val activityMainBinding by lazy {
         ActivityMainBinding.inflate(layoutInflater)
       }
   
       private val mapView: MapView by lazy {
         activityMainBinding.mapView
       }
   
       override fun onCreate(savedInstanceState: Bundle?) {
           super.onCreate(savedInstanceState)
   
           setContentView(activityMainBinding.root)
   
           setupMap()
   
       }
   
       override fun onPause() {
           mapView.pause()
           super.onPause()
       }
   
       override fun onResume() {
           super.onResume()
           mapView.resume()
       }
   
       override fun onDestroy() {
           mapView.dispose()
           super.onDestroy()
       }
   
   
       // set up your map here. You will call this method from onCreate()
       private fun setupMap() {
   
           // set your API key
           // Note: it is not best practice to store API keys in source code. The API key is referenced
           // here for the convenience of this tutorial.
           ArcGISRuntimeEnvironment.setApiKey("YOUR_API_KEY")
   
           // create a map with the BasemapStyle streets
           val map = ArcGISMap(BasemapStyle.ARCGIS_TOPOGRAPHIC)
   
           // set the map to be displayed in the layout's MapView
           mapView.map = map
           // set the viewpoint, Viewpoint(latitude, longitude, scale)
           mapView.setViewpoint(Viewpoint(34.0270, -118.8050, 72000.0))
   
       }
   
   }
   

   Show more lines

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

   More info

   An emulator should display, running your app.

   If your app builds but no emulator displays, you need to add an emulator. Click Tools > AVD Manager > Create Virtual Device...

You should see a map with the topographic basemap layer centered on the Santa Monica Mountains in California. Pinch, drag, and double-tap the map view to explore the map.

What's next?

Learn how to use additional API features, ArcGIS platform services, and ArcGIS tools in these tutorials:

• Add a point, line, and polygon
• Add a feature layer
• Search for an address
• Find a route and directions