Show popup | ArcGIS Maps SDK for Kotlin

View on GitHub

Sample viewer app

Show a predefined popup from a web map.

Show popup screenshot

Use case

Many web maps contain predefined popups which are used to display the attributes associated with each feature layer in the map, such as hiking trails, land values, or unemployment rates. You can display text, attachments, images, charts, and web links. Rather than creating new popups to display information, you can easily access and display the predefined popups.

How to use the sample

Tap on the features to prompt a popup that displays information about the feature.

How it works

Create and load an ArcGISMap using a URL.
Create a MapViewProxy and set it to the composable MapView.
Use the mapViewProxy.identify(...) function to identify the top-most feature.
From the identified feature get the Popup.
Pass the Popup to the composable Popup to display it.

Relevant API

ArcGISMap
IdentifyLayerResult
Popup

About the data

This sample uses a feature layer that displays reported information about mountains in the Sierra Nevada.

Additional information

This sample uses the Popup toolkit component. For information about setting up the toolkit, as well as code for the underlying component, visit the toolkit docs.

Sample Code

MainActivity.kt

ShowPopupViewModel.kt

ShowPopupScreen.kt

/* Copyright 2025 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
 *
 *    http://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.esri.arcgismaps.sample.showpopup

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Surface
import androidx.compose.runtime.Composable
import com.arcgismaps.ApiKey
import com.arcgismaps.ArcGISEnvironment
import com.esri.arcgismaps.sample.sampleslib.theme.SampleAppTheme
import com.esri.arcgismaps.sample.showpopup.screens.ShowPopupScreen

class MainActivity : ComponentActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // authentication with an API key or named user is
        // required to access basemaps and other location services
        ArcGISEnvironment.apiKey = ApiKey.create(BuildConfig.ACCESS_TOKEN)
        enableEdgeToEdge()
        setContent {
            SampleAppTheme {
                ShowPopupApp()
            }
        }
    }

    @Composable
    private fun ShowPopupApp() {
        Surface(color = MaterialTheme.colorScheme.background) {
            ShowPopupScreen(
                sampleName = getString(R.string.show_popup_app_name)
            )
        }
    }
}

/* Copyright 2025 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
 *
 *    http://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.esri.arcgismaps.sample.showpopup.components

import android.app.Application
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.compose.ui.unit.dp
import androidx.lifecycle.AndroidViewModel
import androidx.lifecycle.viewModelScope
import com.arcgismaps.data.Feature
import com.arcgismaps.geometry.GeometryType
import com.arcgismaps.mapping.ArcGISMap
import com.arcgismaps.mapping.PortalItem
import com.arcgismaps.mapping.layers.FeatureLayer
import com.arcgismaps.mapping.popup.Popup
import com.arcgismaps.mapping.view.SingleTapConfirmedEvent
import com.arcgismaps.portal.Portal
import com.arcgismaps.toolkit.geoviewcompose.MapViewProxy
import com.esri.arcgismaps.sample.sampleslib.components.MessageDialogViewModel
import kotlinx.coroutines.launch

class ShowPopupViewModel(application: Application) : AndroidViewModel(application) {

    val mapViewProxy = MapViewProxy()

    // Create a portal and load a map with information about mountains in the Sierra Nevada
    private val portal = Portal("https://arcgis.com/")
    private val portalItem = PortalItem(portal, "9f3a674e998f461580006e626611f9ad")
    val arcGISMap = ArcGISMap(portalItem)

    // Get the first visible feature layer with a popup definition
    private val featureLayer: FeatureLayer
        get() {
            return arcGISMap.operationalLayers.filterIsInstance<FeatureLayer>().first { featureLayer ->
                (featureLayer.featureTable?.geometryType == GeometryType.Point)
                    .and(featureLayer.isVisible)
                    .and(featureLayer.isPopupEnabled)
                    .and(featureLayer.popupDefinition != null)
            }
        }

    // Popup that gets passed to the main screen composable
    var popup: Popup? by mutableStateOf(null)
        private set

    // Keep track of the identified feature
    private var identifiedFeature: Feature? = null

    // Create a message dialog view model for handling error messages
    val messageDialogVM = MessageDialogViewModel()

    init {
        viewModelScope.launch {
            arcGISMap.load().onFailure { error ->
                messageDialogVM.showMessageDialog(
                    title = "Failed to load map",
                    description = error.message.toString()
                )
            }
        }
    }

    /**
     * Identify the feature at the given screen coordinate, select the feature, and show the popup for it.
     */
    fun identifyForPopup(singleTapConfirmedEvent: SingleTapConfirmedEvent) {
        viewModelScope.launch {
            mapViewProxy.identify(
                layer = featureLayer,
                screenCoordinate = singleTapConfirmedEvent.screenCoordinate,
                tolerance = 12.dp,
                returnPopupsOnly = true
            ).onSuccess { result ->
                popup = result.popups.first().also { popup ->
                    identifiedFeature = (popup.geoElement as Feature).also { identifiedFeature ->
                        featureLayer.selectFeature(identifiedFeature)
                    }
                }
            }.onFailure { error ->
                messageDialogVM.showMessageDialog(
                    title = "Failed to identify: ${error.message}",
                    description = error.message.toString()
                )
            }
        }
    }

    /**
     * Dismiss the popup and unselect the identified feature.
     */
    fun onDismissRequest() {
        popup = null
        identifiedFeature?.let { featureLayer.unselectFeature(it) }
    }
}

/* Copyright 2025 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
 *
 *    http://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.esri.arcgismaps.sample.showpopup.screens

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.wrapContentSize
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.ModalBottomSheet
import androidx.compose.material3.Scaffold
import androidx.compose.material3.rememberModalBottomSheetState
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.lifecycle.viewmodel.compose.viewModel
import com.arcgismaps.toolkit.geoviewcompose.MapView
import com.arcgismaps.toolkit.popup.Popup
import com.esri.arcgismaps.sample.sampleslib.components.MessageDialog
import com.esri.arcgismaps.sample.sampleslib.components.SampleTopAppBar
import com.esri.arcgismaps.sample.showpopup.components.ShowPopupViewModel

/**
 * Main screen layout for the sample app
 */
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun ShowPopupScreen(sampleName: String) {
    val mapViewModel: ShowPopupViewModel = viewModel()

    val sheetState = rememberModalBottomSheetState()

    Scaffold(
        topBar = { SampleTopAppBar(title = sampleName) },
        content = {
            Column(
                modifier = Modifier
                    .fillMaxSize()
                    .padding(it),
            ) {
                MapView(
                    modifier = Modifier
                        .fillMaxSize()
                        .weight(1f),
                    arcGISMap = mapViewModel.arcGISMap,
                    mapViewProxy = mapViewModel.mapViewProxy,
                    onSingleTapConfirmed = mapViewModel::identifyForPopup
                )
                mapViewModel.popup?.let { popup ->
                    ModalBottomSheet(
                        modifier = Modifier.wrapContentSize(),
                        onDismissRequest = { mapViewModel.onDismissRequest() },
                        sheetState = sheetState
                    ) {
                        Popup(
                            popup = popup,
                            modifier = Modifier.fillMaxSize()
                        )
                    }
                }
            }

            mapViewModel.messageDialogVM.apply {
                if (dialogStatus) {
                    MessageDialog(
                        title = messageTitle,
                        description = messageDescription,
                        onDismissRequest = ::dismissDialog
                    )
                }
            }
        }
    )
}