Query a feature layer (SQL)

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

Open an Android Studio project

1. Open the project you created by completing the Display a map tutorial.

2. Continue with the following instructions to execute a SQL query to return features from a feature layer based on spatial and attribute criteria.

3. Modify the old project for use in this new tutorial.

   Expand for detailed instructions

   1. On your file system, delete the .idea folder, if present, at the top level of your project.

   2. In the Android view, open app > res > values > strings.xml.

      In the <string name="app_name"> element, change the text content to Query a feature layer (SQL).

      strings.xml

      <resources>
      
          <string name="app_name">Query a feature layer (SQL)</string>
      
      </resources>

   3. In the Android view, open Gradle Scripts > settings.gradle.kts.

      Change the value of rootProject.name to “Query a feature layer (SQL)”.

      settings.gradle.kts

      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 = "Query a feature layer (SQL)"
      include(":app")

   4. Click File > Sync Project with Gradle files. Android Studio will recognize your changes and create a new .idea folder.

Add import statements

1. Modify import statements to reference the packages and classes required for this tutorial.

   MainScreen.kt

   @file:OptIn(ExperimentalMaterial3Api::class)
   
   package com.example.app.screens
   
   import android.content.Context
   import android.widget.Toast
   import androidx.compose.foundation.layout.Column
   import androidx.compose.foundation.layout.fillMaxSize
   import androidx.compose.foundation.layout.fillMaxWidth
   import androidx.compose.foundation.layout.padding
   import androidx.compose.material3.DropdownMenuItem
   import androidx.compose.material3.ExperimentalMaterial3Api
   import androidx.compose.material3.ExposedDropdownMenuBox
   import androidx.compose.material3.MenuAnchorType
   import androidx.compose.material3.Scaffold
   import androidx.compose.material3.Text
   import androidx.compose.material3.TextField
   import androidx.compose.material3.TopAppBar
   import androidx.compose.runtime.Composable
   import androidx.compose.runtime.mutableStateOf
   import androidx.compose.runtime.remember
   import androidx.compose.runtime.rememberCoroutineScope
   import androidx.compose.ui.Modifier
   import androidx.compose.ui.platform.LocalContext
   import androidx.compose.ui.res.stringResource
   import com.arcgismaps.data.QueryParameters
   import com.arcgismaps.data.ServiceFeatureTable
   import com.arcgismaps.geometry.Envelope
   import com.arcgismaps.mapping.ArcGISMap
   import com.arcgismaps.mapping.BasemapStyle
   import com.arcgismaps.mapping.Viewpoint
   import com.arcgismaps.mapping.layers.FeatureLayer
   import com.arcgismaps.toolkit.geoviewcompose.MapView
   import com.example.app.R
   import kotlinx.coroutines.Job

2. In the MainScreen composable, create variables that will be passed to various functions in the MainScreen.kt file.

   MainScreen.kt

   @Composable
   fun MainScreen() {
   
       val context = LocalContext.current
       val coroutineScope = rememberCoroutineScope()
       val currentQueryJob = remember { mutableStateOf<Job?>(null) }
       // Store the current viewpoint geometry extent of the map.
       val currentExtent = remember { mutableStateOf<Envelope?>(null) }
   
       Scaffold(
           topBar = { TopAppBar(title = { Text(text = stringResource(id = R.string.app_name)) }) }
       ) {
   
               MapView(
                   modifier = Modifier.fillMaxSize(),
                   arcGISMap = map,
   
               )
   
       }
   
   }
   More info

   Most of these are remembered variables and use either remember() or rememberCoroutineScope()

   Briefly, these variables are:

   • context: The local context of your app.

   • coroutineScope: Set to rememberCoroutineScope(). You will use this variable to launch a coroutine.

   • currentQueryJob: Of type MutableState<Job?>, which references the Kotlin coroutine Job. (It does not reference the interface Job from ArcGIS Maps SDK for Kotlin.) Note that coroutineScope.launch {} returns a Kotlin coroutine Job.

   • currentExtent: Of type MutableState<Envelope?>. The extent (which is an Envelope) of the current FeatureLayer. Your query will be limited to this extent.

Create the Parcels feature layer and create a map with it

You will create a service feature table from a feature service URL. Then you will create a feature layer from that table and create an ArcGISMap with the feature layer.

1. In the MainScreen block, create a ServiceFeatureTable using the feature service URL. Next, create a FeatureLayer using that service feature table. Define both serviceFeatureTable and featureLayer as local variables in the MainScreen composable.

   More info

   The features in this feature service are land parcels in Los Angeles county.

   MainScreen.kt

   @Composable
   fun MainScreen() {
   
       val context = LocalContext.current
       val coroutineScope = rememberCoroutineScope()
       val currentQueryJob = remember { mutableStateOf<Job?>(null) }
       // Store the current viewpoint geometry extent of the map.
       val currentExtent = remember { mutableStateOf<Envelope?>(null) }
   
       // Create a service feature table from a Los Angeles County parcels feature service.
       val serviceFeatureTable = ServiceFeatureTable(
           uri = "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/LA_County_Parcels/FeatureServer/0"
       )
       val featureLayer = remember { FeatureLayer.createWithFeatureTable(serviceFeatureTable) }
   
       Scaffold(
           topBar = { TopAppBar(title = { Text(text = stringResource(id = R.string.app_name)) }) }
       ) {
   
               MapView(
                   modifier = Modifier.fillMaxSize(),
                   arcGISMap = map,
   
               )
   
       }
   
   }

2. Modify the top-level function createMap() to take a FeatureLayer. Then add the feature layer to the operationalLayers property of MapView.

   MainScreen.kt

   66 collapsed lines
   @file:OptIn(ExperimentalMaterial3Api::class)
   
   package com.example.app.screens
   
   import android.content.Context
   import android.widget.Toast
   import androidx.compose.foundation.layout.Column
   import androidx.compose.foundation.layout.fillMaxSize
   import androidx.compose.foundation.layout.fillMaxWidth
   import androidx.compose.foundation.layout.padding
   import androidx.compose.material3.DropdownMenuItem
   import androidx.compose.material3.ExperimentalMaterial3Api
   import androidx.compose.material3.ExposedDropdownMenuBox
   import androidx.compose.material3.MenuAnchorType
   import androidx.compose.material3.Scaffold
   import androidx.compose.material3.Text
   import androidx.compose.material3.TextField
   import androidx.compose.material3.TopAppBar
   import androidx.compose.runtime.Composable
   import androidx.compose.runtime.mutableStateOf
   import androidx.compose.runtime.remember
   import androidx.compose.runtime.rememberCoroutineScope
   import androidx.compose.ui.Modifier
   import androidx.compose.ui.platform.LocalContext
   import androidx.compose.ui.res.stringResource
   import com.arcgismaps.data.QueryParameters
   import com.arcgismaps.data.ServiceFeatureTable
   import com.arcgismaps.geometry.Envelope
   import com.arcgismaps.mapping.ArcGISMap
   import com.arcgismaps.mapping.BasemapStyle
   import com.arcgismaps.mapping.Viewpoint
   import com.arcgismaps.mapping.layers.FeatureLayer
   import com.arcgismaps.toolkit.geoviewcompose.MapView
   import com.example.app.R
   import kotlinx.coroutines.Job
   import kotlinx.coroutines.launch
   
   @Composable
   fun MainScreen() {
   
       val context = LocalContext.current
       val coroutineScope = rememberCoroutineScope()
       val currentQueryJob = remember { mutableStateOf<Job?>(null) }
       // Store the current viewpoint geometry extent of the map.
       val currentExtent = remember { mutableStateOf<Envelope?>(null) }
   
       // Create a service feature table from a Los Angeles County parcels feature service.
       val serviceFeatureTable = ServiceFeatureTable(
           uri = "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/LA_County_Parcels/FeatureServer/0"
       )
       val featureLayer = remember { FeatureLayer.createWithFeatureTable(serviceFeatureTable) }
   
       Scaffold(
           topBar = { TopAppBar(title = { Text(text = stringResource(id = R.string.app_name)) }) }
       ) {
   
               MapView(
                   modifier = Modifier.fillMaxSize(),
                   arcGISMap = map,
   
               )
   
       }
   
   }
   
   fun createMap(featureLayer: FeatureLayer): ArcGISMap {
   
       return ArcGISMap(BasemapStyle.ArcGISTopographic).apply {
           initialViewpoint = Viewpoint(
               latitude = 34.0270,
               longitude = -118.8050,
               scale = 72000.0
           )
   
           operationalLayers.add(featureLayer)
   
       }
   }
   49 collapsed lines
   
   /**
    *  Query the [serviceFeatureTable] based on the [whereExpression] on the given
    *  [queryExtent] and select the resulting features on the [featureLayer]
    */
   suspend fun queryFeatureLayer(
       context: Context,
       serviceFeatureTable: ServiceFeatureTable,
       featureLayer: FeatureLayer,
       whereExpression: String,
       queryExtent: Envelope?
   ) {
   
       // Clear any previous selections.
       featureLayer.clearSelection()
       // Create query parameters with the where expression and the current extent
       // and have geometry values returned in the results.
       val queryParameters = QueryParameters().apply {
           whereClause = whereExpression
           returnGeometry = true
           geometry = queryExtent
       }
   
       try {
           // Query the feature table with the query parameters.
           val featureQueryResult = serviceFeatureTable.queryFeatures(queryParameters).getOrThrow()
           // Iterate through the result and select the features on the feature layer.
           val resultIterator = featureQueryResult.iterator()
           if (resultIterator.hasNext()) {
               resultIterator.forEach { feature ->
                   featureLayer.selectFeature(feature)
               }
           } else {
               showMessage(
                   context,
                   "No parcels found in the current extent, using Where expression: $whereExpression"
               )
           }
       } catch (e: Exception) {
   
           showMessage(context, "Feature search failed for: $whereExpression, ${e.message}")
   
       }
   
   }
   
   fun showMessage(context: Context, message: String) {
       Toast.makeText(context, message, Toast.LENGTH_LONG).show()
   }

3. In the MainScreen composable, modify the existing createMap() call by passing featureLayer as a parameter.

   MainScreen.kt

   37 collapsed lines
   @file:OptIn(ExperimentalMaterial3Api::class)
   
   package com.example.app.screens
   
   import android.content.Context
   import android.widget.Toast
   import androidx.compose.foundation.layout.Column
   import androidx.compose.foundation.layout.fillMaxSize
   import androidx.compose.foundation.layout.fillMaxWidth
   import androidx.compose.foundation.layout.padding
   import androidx.compose.material3.DropdownMenuItem
   import androidx.compose.material3.ExperimentalMaterial3Api
   import androidx.compose.material3.ExposedDropdownMenuBox
   import androidx.compose.material3.MenuAnchorType
   import androidx.compose.material3.Scaffold
   import androidx.compose.material3.Text
   import androidx.compose.material3.TextField
   import androidx.compose.material3.TopAppBar
   import androidx.compose.runtime.Composable
   import androidx.compose.runtime.mutableStateOf
   import androidx.compose.runtime.remember
   import androidx.compose.runtime.rememberCoroutineScope
   import androidx.compose.ui.Modifier
   import androidx.compose.ui.platform.LocalContext
   import androidx.compose.ui.res.stringResource
   import com.arcgismaps.data.QueryParameters
   import com.arcgismaps.data.ServiceFeatureTable
   import com.arcgismaps.geometry.Envelope
   import com.arcgismaps.mapping.ArcGISMap
   import com.arcgismaps.mapping.BasemapStyle
   import com.arcgismaps.mapping.Viewpoint
   import com.arcgismaps.mapping.layers.FeatureLayer
   import com.arcgismaps.toolkit.geoviewcompose.MapView
   import com.example.app.R
   import kotlinx.coroutines.Job
   import kotlinx.coroutines.launch
   
   @Composable
   fun MainScreen() {
   
       val context = LocalContext.current
       val coroutineScope = rememberCoroutineScope()
       val currentQueryJob = remember { mutableStateOf<Job?>(null) }
       // Store the current viewpoint geometry extent of the map.
       val currentExtent = remember { mutableStateOf<Envelope?>(null) }
   
       // Create a service feature table from a Los Angeles County parcels feature service.
       val serviceFeatureTable = ServiceFeatureTable(
           uri = "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/LA_County_Parcels/FeatureServer/0"
       )
       val featureLayer = remember { FeatureLayer.createWithFeatureTable(serviceFeatureTable) }
   
       val map = remember {
   
           createMap(featureLayer)
   
       }
   
       Scaffold(
           topBar = { TopAppBar(title = { Text(text = stringResource(id = R.string.app_name)) }) }
       ) {
   
               MapView(
                   modifier = Modifier.fillMaxSize(),
                   arcGISMap = map,
   
               )
   
       }
   
   }
   63 collapsed lines
   
   fun createMap(featureLayer: FeatureLayer): ArcGISMap {
   
       return ArcGISMap(BasemapStyle.ArcGISTopographic).apply {
           initialViewpoint = Viewpoint(
               latitude = 34.0270,
               longitude = -118.8050,
               scale = 72000.0
           )
   
           operationalLayers.add(featureLayer)
   
       }
   }
   
   /**
    *  Query the [serviceFeatureTable] based on the [whereExpression] on the given
    *  [queryExtent] and select the resulting features on the [featureLayer]
    */
   suspend fun queryFeatureLayer(
       context: Context,
       serviceFeatureTable: ServiceFeatureTable,
       featureLayer: FeatureLayer,
       whereExpression: String,
       queryExtent: Envelope?
   ) {
   
       // Clear any previous selections.
       featureLayer.clearSelection()
       // Create query parameters with the where expression and the current extent
       // and have geometry values returned in the results.
       val queryParameters = QueryParameters().apply {
           whereClause = whereExpression
           returnGeometry = true
           geometry = queryExtent
       }
   
       try {
           // Query the feature table with the query parameters.
           val featureQueryResult = serviceFeatureTable.queryFeatures(queryParameters).getOrThrow()
           // Iterate through the result and select the features on the feature layer.
           val resultIterator = featureQueryResult.iterator()
           if (resultIterator.hasNext()) {
               resultIterator.forEach { feature ->
                   featureLayer.selectFeature(feature)
               }
           } else {
               showMessage(
                   context,
                   "No parcels found in the current extent, using Where expression: $whereExpression"
               )
           }
       } catch (e: Exception) {
   
           showMessage(context, "Feature search failed for: $whereExpression, ${e.message}")
   
       }
   
   }
   
   fun showMessage(context: Context, message: String) {
       Toast.makeText(context, message, Toast.LENGTH_LONG).show()
   }

Create a function to query the feature layer

Create a function that clears any currently selected features and executes a new query to find features in the map’s current extent that meet the selected attribute expression (the SQL WHERE expression). It then gets the features returned by FeatureQueryResult and selects them (in yellow highlight) in the parcels layer.

1. Define a top-level suspend function named queryFeatureLayer(). Declare the parameters shown below.

   MainScreen.kt

   137 collapsed lines
   @file:OptIn(ExperimentalMaterial3Api::class)
   
   package com.example.app.screens
   
   import android.content.Context
   import android.widget.Toast
   import androidx.compose.foundation.layout.Column
   import androidx.compose.foundation.layout.fillMaxSize
   import androidx.compose.foundation.layout.fillMaxWidth
   import androidx.compose.foundation.layout.padding
   import androidx.compose.material3.DropdownMenuItem
   import androidx.compose.material3.ExperimentalMaterial3Api
   import androidx.compose.material3.ExposedDropdownMenuBox
   import androidx.compose.material3.MenuAnchorType
   import androidx.compose.material3.Scaffold
   import androidx.compose.material3.Text
   import androidx.compose.material3.TextField
   import androidx.compose.material3.TopAppBar
   import androidx.compose.runtime.Composable
   import androidx.compose.runtime.mutableStateOf
   import androidx.compose.runtime.remember
   import androidx.compose.runtime.rememberCoroutineScope
   import androidx.compose.ui.Modifier
   import androidx.compose.ui.platform.LocalContext
   import androidx.compose.ui.res.stringResource
   import com.arcgismaps.data.QueryParameters
   import com.arcgismaps.data.ServiceFeatureTable
   import com.arcgismaps.geometry.Envelope
   import com.arcgismaps.mapping.ArcGISMap
   import com.arcgismaps.mapping.BasemapStyle
   import com.arcgismaps.mapping.Viewpoint
   import com.arcgismaps.mapping.layers.FeatureLayer
   import com.arcgismaps.toolkit.geoviewcompose.MapView
   import com.example.app.R
   import kotlinx.coroutines.Job
   import kotlinx.coroutines.launch
   
   @Composable
   fun MainScreen() {
   
       val context = LocalContext.current
       val coroutineScope = rememberCoroutineScope()
       val currentQueryJob = remember { mutableStateOf<Job?>(null) }
       // Store the current viewpoint geometry extent of the map.
       val currentExtent = remember { mutableStateOf<Envelope?>(null) }
   
       // Create a service feature table from a Los Angeles County parcels feature service.
       val serviceFeatureTable = ServiceFeatureTable(
           uri = "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/LA_County_Parcels/FeatureServer/0"
       )
       val featureLayer = remember { FeatureLayer.createWithFeatureTable(serviceFeatureTable) }
   
       val map = remember {
   
           createMap(featureLayer)
   
       }
   
       Scaffold(
           topBar = { TopAppBar(title = { Text(text = stringResource(id = R.string.app_name)) }) }
       ) {
   
               MapView(
                   modifier = Modifier.fillMaxSize(),
                   arcGISMap = map,
   
               )
   
       }
   
   }
   
   @Composable
   fun QueryDropDownMenu(onItemClicked: (String) -> Unit) {
       val expanded = remember { mutableStateOf(false) }
       var selectedText = remember { mutableStateOf("") }
       val options = listOf(
           "UseType = \'Government\'",
           "UseType = \'Residential\'",
           "UseType = \'Irrigated Farm\'",
           "TaxRateArea = 10853",
           "TaxRateArea = 10860",
           "Roll_LandValue > 1000000",
           "Roll_LandValue < 1000000"
       )
   
       ExposedDropdownMenuBox(
           expanded = expanded.value,
           onExpandedChange = {
               expanded.value = !expanded.value
           }
       ) {
   
           TextField(
               modifier = Modifier.menuAnchor(type = MenuAnchorType.PrimaryNotEditable, enabled = true),
               value = selectedText.value,
               onValueChange = {},
               readOnly = true,
               label = { Text("Select a query expression") }
           )
   
           ExposedDropdownMenu(
               expanded = expanded.value,
               onDismissRequest = {
                   expanded.value = false
               }
           ) {
               options.forEach { selectionOption ->
                   DropdownMenuItem(
                       text = { Text(text = selectionOption) },
                       onClick = {
                           selectedText.value = selectionOption
                           expanded.value = false
                           onItemClicked(selectedText.value)
                       }
                   )
               }
           }
   
       }
   
   }
   
   fun createMap(featureLayer: FeatureLayer): ArcGISMap {
   
       return ArcGISMap(BasemapStyle.ArcGISTopographic).apply {
           initialViewpoint = Viewpoint(
               latitude = 34.0270,
               longitude = -118.8050,
               scale = 72000.0
           )
   
           operationalLayers.add(featureLayer)
   
       }
   }
   
   /**
    *  Query the [serviceFeatureTable] based on the [whereExpression] on the given
    *  [queryExtent] and select the resulting features on the [featureLayer]
    */
   suspend fun queryFeatureLayer(
       context: Context,
       serviceFeatureTable: ServiceFeatureTable,
       featureLayer: FeatureLayer,
       whereExpression: String,
       queryExtent: Envelope?
   ) {
   
   }
   4 collapsed lines
   
   fun showMessage(context: Context, message: String) {
       Toast.makeText(context, message, Toast.LENGTH_LONG).show()
   }

2. Create a QueryParameters instance, and set the whereClause, returnGeometry, and geometry properties on the query parameters.

   MainScreen.kt

   137 collapsed lines
   @file:OptIn(ExperimentalMaterial3Api::class)
   
   package com.example.app.screens
   
   import android.content.Context
   import android.widget.Toast
   import androidx.compose.foundation.layout.Column
   import androidx.compose.foundation.layout.fillMaxSize
   import androidx.compose.foundation.layout.fillMaxWidth
   import androidx.compose.foundation.layout.padding
   import androidx.compose.material3.DropdownMenuItem
   import androidx.compose.material3.ExperimentalMaterial3Api
   import androidx.compose.material3.ExposedDropdownMenuBox
   import androidx.compose.material3.MenuAnchorType
   import androidx.compose.material3.Scaffold
   import androidx.compose.material3.Text
   import androidx.compose.material3.TextField
   import androidx.compose.material3.TopAppBar
   import androidx.compose.runtime.Composable
   import androidx.compose.runtime.mutableStateOf
   import androidx.compose.runtime.remember
   import androidx.compose.runtime.rememberCoroutineScope
   import androidx.compose.ui.Modifier
   import androidx.compose.ui.platform.LocalContext
   import androidx.compose.ui.res.stringResource
   import com.arcgismaps.data.QueryParameters
   import com.arcgismaps.data.ServiceFeatureTable
   import com.arcgismaps.geometry.Envelope
   import com.arcgismaps.mapping.ArcGISMap
   import com.arcgismaps.mapping.BasemapStyle
   import com.arcgismaps.mapping.Viewpoint
   import com.arcgismaps.mapping.layers.FeatureLayer
   import com.arcgismaps.toolkit.geoviewcompose.MapView
   import com.example.app.R
   import kotlinx.coroutines.Job
   import kotlinx.coroutines.launch
   
   @Composable
   fun MainScreen() {
   
       val context = LocalContext.current
       val coroutineScope = rememberCoroutineScope()
       val currentQueryJob = remember { mutableStateOf<Job?>(null) }
       // Store the current viewpoint geometry extent of the map.
       val currentExtent = remember { mutableStateOf<Envelope?>(null) }
   
       // Create a service feature table from a Los Angeles County parcels feature service.
       val serviceFeatureTable = ServiceFeatureTable(
           uri = "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/LA_County_Parcels/FeatureServer/0"
       )
       val featureLayer = remember { FeatureLayer.createWithFeatureTable(serviceFeatureTable) }
   
       val map = remember {
   
           createMap(featureLayer)
   
       }
   
       Scaffold(
           topBar = { TopAppBar(title = { Text(text = stringResource(id = R.string.app_name)) }) }
       ) {
   
               MapView(
                   modifier = Modifier.fillMaxSize(),
                   arcGISMap = map,
   
               )
   
       }
   
   }
   
   @Composable
   fun QueryDropDownMenu(onItemClicked: (String) -> Unit) {
       val expanded = remember { mutableStateOf(false) }
       var selectedText = remember { mutableStateOf("") }
       val options = listOf(
           "UseType = \'Government\'",
           "UseType = \'Residential\'",
           "UseType = \'Irrigated Farm\'",
           "TaxRateArea = 10853",
           "TaxRateArea = 10860",
           "Roll_LandValue > 1000000",
           "Roll_LandValue < 1000000"
       )
   
       ExposedDropdownMenuBox(
           expanded = expanded.value,
           onExpandedChange = {
               expanded.value = !expanded.value
           }
       ) {
   
           TextField(
               modifier = Modifier.menuAnchor(type = MenuAnchorType.PrimaryNotEditable, enabled = true),
               value = selectedText.value,
               onValueChange = {},
               readOnly = true,
               label = { Text("Select a query expression") }
           )
   
           ExposedDropdownMenu(
               expanded = expanded.value,
               onDismissRequest = {
                   expanded.value = false
               }
           ) {
               options.forEach { selectionOption ->
                   DropdownMenuItem(
                       text = { Text(text = selectionOption) },
                       onClick = {
                           selectedText.value = selectionOption
                           expanded.value = false
                           onItemClicked(selectedText.value)
                       }
                   )
               }
           }
   
       }
   
   }
   
   fun createMap(featureLayer: FeatureLayer): ArcGISMap {
   
       return ArcGISMap(BasemapStyle.ArcGISTopographic).apply {
           initialViewpoint = Viewpoint(
               latitude = 34.0270,
               longitude = -118.8050,
               scale = 72000.0
           )
   
           operationalLayers.add(featureLayer)
   
       }
   }
   
   /**
    *  Query the [serviceFeatureTable] based on the [whereExpression] on the given
    *  [queryExtent] and select the resulting features on the [featureLayer]
    */
   suspend fun queryFeatureLayer(
       context: Context,
       serviceFeatureTable: ServiceFeatureTable,
       featureLayer: FeatureLayer,
       whereExpression: String,
       queryExtent: Envelope?
   ) {
   
       // Clear any previous selections.
       featureLayer.clearSelection()
       // Create query parameters with the where expression and the current extent
       // and have geometry values returned in the results.
       val queryParameters = QueryParameters().apply {
           whereClause = whereExpression
           returnGeometry = true
           geometry = queryExtent
       }
   
   }
   4 collapsed lines
   
   fun showMessage(context: Context, message: String) {
       Toast.makeText(context, message, Toast.LENGTH_LONG).show()
   }

3. Within try-catch statements, call ServiceFeatureTable.queryFeatures(), passing queryParameters.

   Next, get the iterator on featureQueryResult. If the resultIterator has any features to return, then iterate over those features and select them (with highlight) on the feature layer.

   Then show a message if the query returns no features in the current extent. Last, display a message in the catch clause in case the feature search failed.

   MainScreen.kt

   156 collapsed lines
   @file:OptIn(ExperimentalMaterial3Api::class)
   
   package com.example.app.screens
   
   import android.content.Context
   import android.widget.Toast
   import androidx.compose.foundation.layout.Column
   import androidx.compose.foundation.layout.fillMaxSize
   import androidx.compose.foundation.layout.fillMaxWidth
   import androidx.compose.foundation.layout.padding
   import androidx.compose.material3.DropdownMenuItem
   import androidx.compose.material3.ExperimentalMaterial3Api
   import androidx.compose.material3.ExposedDropdownMenuBox
   import androidx.compose.material3.MenuAnchorType
   import androidx.compose.material3.Scaffold
   import androidx.compose.material3.Text
   import androidx.compose.material3.TextField
   import androidx.compose.material3.TopAppBar
   import androidx.compose.runtime.Composable
   import androidx.compose.runtime.mutableStateOf
   import androidx.compose.runtime.remember
   import androidx.compose.runtime.rememberCoroutineScope
   import androidx.compose.ui.Modifier
   import androidx.compose.ui.platform.LocalContext
   import androidx.compose.ui.res.stringResource
   import com.arcgismaps.data.QueryParameters
   import com.arcgismaps.data.ServiceFeatureTable
   import com.arcgismaps.geometry.Envelope
   import com.arcgismaps.mapping.ArcGISMap
   import com.arcgismaps.mapping.BasemapStyle
   import com.arcgismaps.mapping.Viewpoint
   import com.arcgismaps.mapping.layers.FeatureLayer
   import com.arcgismaps.toolkit.geoviewcompose.MapView
   import com.example.app.R
   import kotlinx.coroutines.Job
   import kotlinx.coroutines.launch
   
   @Composable
   fun MainScreen() {
   
       val context = LocalContext.current
       val coroutineScope = rememberCoroutineScope()
       val currentQueryJob = remember { mutableStateOf<Job?>(null) }
       // Store the current viewpoint geometry extent of the map.
       val currentExtent = remember { mutableStateOf<Envelope?>(null) }
   
       // Create a service feature table from a Los Angeles County parcels feature service.
       val serviceFeatureTable = ServiceFeatureTable(
           uri = "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/LA_County_Parcels/FeatureServer/0"
       )
       val featureLayer = remember { FeatureLayer.createWithFeatureTable(serviceFeatureTable) }
   
       val map = remember {
   
           createMap(featureLayer)
   
       }
   
       Scaffold(
           topBar = { TopAppBar(title = { Text(text = stringResource(id = R.string.app_name)) }) }
       ) {
   
           Column(
               Modifier.fillMaxSize().padding(it)
           ) {
   
               QueryDropDownMenu(
                   onItemClicked = { sqlQueryExpression ->
                       // Cancel the previous query job if it exists.
                       currentQueryJob.value?.cancel()
                       currentQueryJob.value = coroutineScope.launch {
                           queryFeatureLayer(
                               context = context,
                               serviceFeatureTable = serviceFeatureTable,
                               featureLayer = featureLayer,
                               whereExpression = sqlQueryExpression,
                               queryExtent = currentExtent.value
                           )
                       }
                   })
   
               MapView(
                   modifier = Modifier.fillMaxSize(),
                   arcGISMap = map,
   
               )
   
       }
   
   }
   
   @Composable
   fun QueryDropDownMenu(onItemClicked: (String) -> Unit) {
       val expanded = remember { mutableStateOf(false) }
       var selectedText = remember { mutableStateOf("") }
       val options = listOf(
           "UseType = \'Government\'",
           "UseType = \'Residential\'",
           "UseType = \'Irrigated Farm\'",
           "TaxRateArea = 10853",
           "TaxRateArea = 10860",
           "Roll_LandValue > 1000000",
           "Roll_LandValue < 1000000"
       )
   
       ExposedDropdownMenuBox(
           expanded = expanded.value,
           onExpandedChange = {
               expanded.value = !expanded.value
           }
       ) {
   
           TextField(
               modifier = Modifier.menuAnchor(type = MenuAnchorType.PrimaryNotEditable, enabled = true),
               value = selectedText.value,
               onValueChange = {},
               readOnly = true,
               label = { Text("Select a query expression") }
           )
   
           ExposedDropdownMenu(
               expanded = expanded.value,
               onDismissRequest = {
                   expanded.value = false
               }
           ) {
               options.forEach { selectionOption ->
                   DropdownMenuItem(
                       text = { Text(text = selectionOption) },
                       onClick = {
                           selectedText.value = selectionOption
                           expanded.value = false
                           onItemClicked(selectedText.value)
                       }
                   )
               }
           }
   
       }
   
   }
   
   fun createMap(featureLayer: FeatureLayer): ArcGISMap {
   
       return ArcGISMap(BasemapStyle.ArcGISTopographic).apply {
           initialViewpoint = Viewpoint(
               latitude = 34.0270,
               longitude = -118.8050,
               scale = 72000.0
           )
   
           operationalLayers.add(featureLayer)
   
       }
   }
   
   /**
    *  Query the [serviceFeatureTable] based on the [whereExpression] on the given
    *  [queryExtent] and select the resulting features on the [featureLayer]
    */
   suspend fun queryFeatureLayer(
       context: Context,
       serviceFeatureTable: ServiceFeatureTable,
       featureLayer: FeatureLayer,
       whereExpression: String,
       queryExtent: Envelope?
   ) {
   
       // Clear any previous selections.
       featureLayer.clearSelection()
       // Create query parameters with the where expression and the current extent
       // and have geometry values returned in the results.
       val queryParameters = QueryParameters().apply {
           whereClause = whereExpression
           returnGeometry = true
           geometry = queryExtent
       }
   
       try {
           // Query the feature table with the query parameters.
           val featureQueryResult = serviceFeatureTable.queryFeatures(queryParameters).getOrThrow()
           // Iterate through the result and select the features on the feature layer.
           val resultIterator = featureQueryResult.iterator()
           if (resultIterator.hasNext()) {
               resultIterator.forEach { feature ->
                   featureLayer.selectFeature(feature)
               }
           } else {
               showMessage(
                   context,
                   "No parcels found in the current extent, using Where expression: $whereExpression"
               )
           }
       } catch (e: Exception) {
   
           showMessage(context, "Feature search failed for: $whereExpression, ${e.message}")
   
       }
   
   }
   4 collapsed lines
   
   fun showMessage(context: Context, message: String) {
       Toast.makeText(context, message, Toast.LENGTH_LONG).show()
   }

Create a drop-down menu for query expressions

Create a drop-down menu that allows the user to choose from a list of pre-defined SQL query expressions.

1. Define a composable function named QueryDropDownMenu. Declare an onItemClicked parameter that takes a lambda to be invoked when the user selects an item from the drop-down menu.

   In the QueryDropDownMenu block, create two remember variables named expanded and selection.

   • The expanded variable holds a state value, of type MutableState<Boolean>, that indicates whether the drop-down menu is visually expanded on the device screen.

   • The selection variable holds a state value, of type MutableState<String>, indicates the item that the user chose from the drop-down menu.

   Create a list of the SQL query expressions and assign it to a variable named sqlQueryExpressions. Each expression is a string.

   MainScreen.kt

   72 collapsed lines
   @file:OptIn(ExperimentalMaterial3Api::class)
   
   package com.example.app.screens
   
   import android.content.Context
   import android.widget.Toast
   import androidx.compose.foundation.layout.Column
   import androidx.compose.foundation.layout.fillMaxSize
   import androidx.compose.foundation.layout.fillMaxWidth
   import androidx.compose.foundation.layout.padding
   import androidx.compose.material3.DropdownMenuItem
   import androidx.compose.material3.ExperimentalMaterial3Api
   import androidx.compose.material3.ExposedDropdownMenuBox
   import androidx.compose.material3.MenuAnchorType
   import androidx.compose.material3.Scaffold
   import androidx.compose.material3.Text
   import androidx.compose.material3.TextField
   import androidx.compose.material3.TopAppBar
   import androidx.compose.runtime.Composable
   import androidx.compose.runtime.mutableStateOf
   import androidx.compose.runtime.remember
   import androidx.compose.runtime.rememberCoroutineScope
   import androidx.compose.ui.Modifier
   import androidx.compose.ui.platform.LocalContext
   import androidx.compose.ui.res.stringResource
   import com.arcgismaps.data.QueryParameters
   import com.arcgismaps.data.ServiceFeatureTable
   import com.arcgismaps.geometry.Envelope
   import com.arcgismaps.mapping.ArcGISMap
   import com.arcgismaps.mapping.BasemapStyle
   import com.arcgismaps.mapping.Viewpoint
   import com.arcgismaps.mapping.layers.FeatureLayer
   import com.arcgismaps.toolkit.geoviewcompose.MapView
   import com.example.app.R
   import kotlinx.coroutines.Job
   import kotlinx.coroutines.launch
   
   @Composable
   fun MainScreen() {
   
       val context = LocalContext.current
       val coroutineScope = rememberCoroutineScope()
       val currentQueryJob = remember { mutableStateOf<Job?>(null) }
       // Store the current viewpoint geometry extent of the map.
       val currentExtent = remember { mutableStateOf<Envelope?>(null) }
   
       // Create a service feature table from a Los Angeles County parcels feature service.
       val serviceFeatureTable = ServiceFeatureTable(
           uri = "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/LA_County_Parcels/FeatureServer/0"
       )
       val featureLayer = remember { FeatureLayer.createWithFeatureTable(serviceFeatureTable) }
   
       val map = remember {
   
           createMap(featureLayer)
   
       }
   
       Scaffold(
           topBar = { TopAppBar(title = { Text(text = stringResource(id = R.string.app_name)) }) }
       ) {
   
               MapView(
                   modifier = Modifier.fillMaxSize(),
                   arcGISMap = map,
   
               )
   
       }
   
   }
   
   @Composable
   fun QueryDropDownMenu(onItemClicked: (String) -> Unit) {
       val expanded = remember { mutableStateOf(false) }
       var selectedText = remember { mutableStateOf("") }
       val options = listOf(
           "UseType = \'Government\'",
           "UseType = \'Residential\'",
           "UseType = \'Irrigated Farm\'",
           "TaxRateArea = 10853",
           "TaxRateArea = 10860",
           "Roll_LandValue > 1000000",
           "Roll_LandValue < 1000000"
       )
   
   }
   63 collapsed lines
   
   fun createMap(featureLayer: FeatureLayer): ArcGISMap {
   
       return ArcGISMap(BasemapStyle.ArcGISTopographic).apply {
           initialViewpoint = Viewpoint(
               latitude = 34.0270,
               longitude = -118.8050,
               scale = 72000.0
           )
   
           operationalLayers.add(featureLayer)
   
       }
   }
   
   /**
    *  Query the [serviceFeatureTable] based on the [whereExpression] on the given
    *  [queryExtent] and select the resulting features on the [featureLayer]
    */
   suspend fun queryFeatureLayer(
       context: Context,
       serviceFeatureTable: ServiceFeatureTable,
       featureLayer: FeatureLayer,
       whereExpression: String,
       queryExtent: Envelope?
   ) {
   
       // Clear any previous selections.
       featureLayer.clearSelection()
       // Create query parameters with the where expression and the current extent
       // and have geometry values returned in the results.
       val queryParameters = QueryParameters().apply {
           whereClause = whereExpression
           returnGeometry = true
           geometry = queryExtent
       }
   
       try {
           // Query the feature table with the query parameters.
           val featureQueryResult = serviceFeatureTable.queryFeatures(queryParameters).getOrThrow()
           // Iterate through the result and select the features on the feature layer.
           val resultIterator = featureQueryResult.iterator()
           if (resultIterator.hasNext()) {
               resultIterator.forEach { feature ->
                   featureLayer.selectFeature(feature)
               }
           } else {
               showMessage(
                   context,
                   "No parcels found in the current extent, using Where expression: $whereExpression"
               )
           }
       } catch (e: Exception) {
   
           showMessage(context, "Feature search failed for: $whereExpression, ${e.message}")
   
       }
   
   }
   
   fun showMessage(context: Context, message: String) {
       Toast.makeText(context, message, Toast.LENGTH_LONG).show()
   }

2. Call the ExposedDropDownMenuBox composable. Pass the following parameters:

   • The state value of the expanded variable.
   • A lambda that toggles the state value of the expanded variable. The lambda is automatically called when the exposed dropdown menu is clicked and the expansion state changes.

   In the ExposedDropDownMenuBox block, call the composable TextField. Pass the parameters shown below. For the value parameter, pass the state value of the selection variable.

   MainScreen.kt

   97 collapsed lines
   @file:OptIn(ExperimentalMaterial3Api::class)
   
   package com.example.app.screens
   
   import android.content.Context
   import android.widget.Toast
   import androidx.compose.foundation.layout.Column
   import androidx.compose.foundation.layout.fillMaxSize
   import androidx.compose.foundation.layout.fillMaxWidth
   import androidx.compose.foundation.layout.padding
   import androidx.compose.material3.DropdownMenuItem
   import androidx.compose.material3.ExperimentalMaterial3Api
   import androidx.compose.material3.ExposedDropdownMenuBox
   import androidx.compose.material3.MenuAnchorType
   import androidx.compose.material3.Scaffold
   import androidx.compose.material3.Text
   import androidx.compose.material3.TextField
   import androidx.compose.material3.TopAppBar
   import androidx.compose.runtime.Composable
   import androidx.compose.runtime.mutableStateOf
   import androidx.compose.runtime.remember
   import androidx.compose.runtime.rememberCoroutineScope
   import androidx.compose.ui.Modifier
   import androidx.compose.ui.platform.LocalContext
   import androidx.compose.ui.res.stringResource
   import com.arcgismaps.data.QueryParameters
   import com.arcgismaps.data.ServiceFeatureTable
   import com.arcgismaps.geometry.Envelope
   import com.arcgismaps.mapping.ArcGISMap
   import com.arcgismaps.mapping.BasemapStyle
   import com.arcgismaps.mapping.Viewpoint
   import com.arcgismaps.mapping.layers.FeatureLayer
   import com.arcgismaps.toolkit.geoviewcompose.MapView
   import com.example.app.R
   import kotlinx.coroutines.Job
   import kotlinx.coroutines.launch
   
   @Composable
   fun MainScreen() {
   
       val context = LocalContext.current
       val coroutineScope = rememberCoroutineScope()
       val currentQueryJob = remember { mutableStateOf<Job?>(null) }
       // Store the current viewpoint geometry extent of the map.
       val currentExtent = remember { mutableStateOf<Envelope?>(null) }
   
       // Create a service feature table from a Los Angeles County parcels feature service.
       val serviceFeatureTable = ServiceFeatureTable(
           uri = "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/LA_County_Parcels/FeatureServer/0"
       )
       val featureLayer = remember { FeatureLayer.createWithFeatureTable(serviceFeatureTable) }
   
       val map = remember {
   
           createMap(featureLayer)
   
       }
   
       Scaffold(
           topBar = { TopAppBar(title = { Text(text = stringResource(id = R.string.app_name)) }) }
       ) {
   
           Column(
               Modifier.fillMaxSize().padding(it)
           ) {
   
               QueryDropDownMenu(
                   onItemClicked = { sqlQueryExpression ->
                       // Cancel the previous query job if it exists.
                       currentQueryJob.value?.cancel()
                       currentQueryJob.value = coroutineScope.launch {
                           queryFeatureLayer(
                               context = context,
                               serviceFeatureTable = serviceFeatureTable,
                               featureLayer = featureLayer,
                               whereExpression = sqlQueryExpression,
                               queryExtent = currentExtent.value
                           )
                       }
                   })
   
               MapView(
                   modifier = Modifier.fillMaxSize(),
                   arcGISMap = map,
   
                   onViewpointChangedForBoundingGeometry = { viewpoint ->
                       currentExtent.value = viewpoint.targetGeometry.extent
                   }
   
               )
   
           }
   
       }
   
   }
   
   @Composable
   fun QueryDropDownMenu(onItemClicked: (String) -> Unit) {
       val expanded = remember { mutableStateOf(false) }
       var selectedText = remember { mutableStateOf("") }
       val options = listOf(
           "UseType = \'Government\'",
           "UseType = \'Residential\'",
           "UseType = \'Irrigated Farm\'",
           "TaxRateArea = 10853",
           "TaxRateArea = 10860",
           "Roll_LandValue > 1000000",
           "Roll_LandValue < 1000000"
       )
   
       ExposedDropdownMenuBox(
           expanded = expanded.value,
           onExpandedChange = {
               expanded.value = !expanded.value
           }
       ) {
   
           TextField(
               modifier = Modifier.menuAnchor(type = MenuAnchorType.PrimaryNotEditable, enabled = true),
               value = selectedText.value,
               onValueChange = {},
               readOnly = true,
               label = { Text("Select a query expression") }
           )
   
       }
   
   }
   63 collapsed lines
   
   fun createMap(featureLayer: FeatureLayer): ArcGISMap {
   
       return ArcGISMap(BasemapStyle.ArcGISTopographic).apply {
           initialViewpoint = Viewpoint(
               latitude = 34.0270,
               longitude = -118.8050,
               scale = 72000.0
           )
   
           operationalLayers.add(featureLayer)
   
       }
   }
   
   /**
    *  Query the [serviceFeatureTable] based on the [whereExpression] on the given
    *  [queryExtent] and select the resulting features on the [featureLayer]
    */
   suspend fun queryFeatureLayer(
       context: Context,
       serviceFeatureTable: ServiceFeatureTable,
       featureLayer: FeatureLayer,
       whereExpression: String,
       queryExtent: Envelope?
   ) {
   
       // Clear any previous selections.
       featureLayer.clearSelection()
       // Create query parameters with the where expression and the current extent
       // and have geometry values returned in the results.
       val queryParameters = QueryParameters().apply {
           whereClause = whereExpression
           returnGeometry = true
           geometry = queryExtent
       }
   
       try {
           // Query the feature table with the query parameters.
           val featureQueryResult = serviceFeatureTable.queryFeatures(queryParameters).getOrThrow()
           // Iterate through the result and select the features on the feature layer.
           val resultIterator = featureQueryResult.iterator()
           if (resultIterator.hasNext()) {
               resultIterator.forEach { feature ->
                   featureLayer.selectFeature(feature)
               }
           } else {
               showMessage(
                   context,
                   "No parcels found in the current extent, using Where expression: $whereExpression"
               )
           }
       } catch (e: Exception) {
   
           showMessage(context, "Feature search failed for: $whereExpression, ${e.message}")
   
       }
   
   }
   
   fun showMessage(context: Context, message: String) {
       Toast.makeText(context, message, Toast.LENGTH_LONG).show()
   }

3. Continuing in the ExposedDropDownMenuBox composable: call ExposedDropdownMenu. Pass the state value of the expanded variable. Also pass a lambda that sets the state value of expanded to false (that is, hides the displayed drop-down menu).

   In the ExposedDropDownMenu block, loop over the list of SQL query expressions. For each expression, call the DropDownMenuItem composable. Pass values for the following parameters.

   • For text, pass a lambda that adds a Text displaying the current SQL query expression.

   • For onClick, pass a lambda that does the following:

     • Assigns the selectionOption to the state value of the selection variable.
     • Sets the state value of the expanded variable to false (to hide the exposed drop-down menu when the user selects an item from the menu).
     • Call the onItemClicked parameter (the function passed to the QueryDropDownMenu) and pass the state value of the selection variable.
   MainScreen.kt

   97 collapsed lines
   @file:OptIn(ExperimentalMaterial3Api::class)
   
   package com.example.app.screens
   
   import android.content.Context
   import android.widget.Toast
   import androidx.compose.foundation.layout.Column
   import androidx.compose.foundation.layout.fillMaxSize
   import androidx.compose.foundation.layout.fillMaxWidth
   import androidx.compose.foundation.layout.padding
   import androidx.compose.material3.DropdownMenuItem
   import androidx.compose.material3.ExperimentalMaterial3Api
   import androidx.compose.material3.ExposedDropdownMenuBox
   import androidx.compose.material3.MenuAnchorType
   import androidx.compose.material3.Scaffold
   import androidx.compose.material3.Text
   import androidx.compose.material3.TextField
   import androidx.compose.material3.TopAppBar
   import androidx.compose.runtime.Composable
   import androidx.compose.runtime.mutableStateOf
   import androidx.compose.runtime.remember
   import androidx.compose.runtime.rememberCoroutineScope
   import androidx.compose.ui.Modifier
   import androidx.compose.ui.platform.LocalContext
   import androidx.compose.ui.res.stringResource
   import com.arcgismaps.data.QueryParameters
   import com.arcgismaps.data.ServiceFeatureTable
   import com.arcgismaps.geometry.Envelope
   import com.arcgismaps.mapping.ArcGISMap
   import com.arcgismaps.mapping.BasemapStyle
   import com.arcgismaps.mapping.Viewpoint
   import com.arcgismaps.mapping.layers.FeatureLayer
   import com.arcgismaps.toolkit.geoviewcompose.MapView
   import com.example.app.R
   import kotlinx.coroutines.Job
   import kotlinx.coroutines.launch
   
   @Composable
   fun MainScreen() {
   
       val context = LocalContext.current
       val coroutineScope = rememberCoroutineScope()
       val currentQueryJob = remember { mutableStateOf<Job?>(null) }
       // Store the current viewpoint geometry extent of the map.
       val currentExtent = remember { mutableStateOf<Envelope?>(null) }
   
       // Create a service feature table from a Los Angeles County parcels feature service.
       val serviceFeatureTable = ServiceFeatureTable(
           uri = "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/LA_County_Parcels/FeatureServer/0"
       )
       val featureLayer = remember { FeatureLayer.createWithFeatureTable(serviceFeatureTable) }
   
       val map = remember {
   
           createMap(featureLayer)
   
       }
   
       Scaffold(
           topBar = { TopAppBar(title = { Text(text = stringResource(id = R.string.app_name)) }) }
       ) {
   
           Column(
               Modifier.fillMaxSize().padding(it)
           ) {
   
               QueryDropDownMenu(
                   onItemClicked = { sqlQueryExpression ->
                       // Cancel the previous query job if it exists.
                       currentQueryJob.value?.cancel()
                       currentQueryJob.value = coroutineScope.launch {
                           queryFeatureLayer(
                               context = context,
                               serviceFeatureTable = serviceFeatureTable,
                               featureLayer = featureLayer,
                               whereExpression = sqlQueryExpression,
                               queryExtent = currentExtent.value
                           )
                       }
                   })
   
               MapView(
                   modifier = Modifier.fillMaxSize(),
                   arcGISMap = map,
   
                   onViewpointChangedForBoundingGeometry = { viewpoint ->
                       currentExtent.value = viewpoint.targetGeometry.extent
                   }
   
               )
   
           }
   
       }
   
   }
   
   @Composable
   fun QueryDropDownMenu(onItemClicked: (String) -> Unit) {
       val expanded = remember { mutableStateOf(false) }
       var selectedText = remember { mutableStateOf("") }
       val options = listOf(
           "UseType = \'Government\'",
           "UseType = \'Residential\'",
           "UseType = \'Irrigated Farm\'",
           "TaxRateArea = 10853",
           "TaxRateArea = 10860",
           "Roll_LandValue > 1000000",
           "Roll_LandValue < 1000000"
       )
   
       ExposedDropdownMenuBox(
           expanded = expanded.value,
           onExpandedChange = {
               expanded.value = !expanded.value
           }
       ) {
   
           TextField(
               modifier = Modifier.menuAnchor(type = MenuAnchorType.PrimaryNotEditable, enabled = true),
               value = selectedText.value,
               onValueChange = {},
               readOnly = true,
               label = { Text("Select a query expression") }
           )
   
           ExposedDropdownMenu(
               expanded = expanded.value,
               onDismissRequest = {
                   expanded.value = false
               }
           ) {
               options.forEach { selectionOption ->
                   DropdownMenuItem(
                       text = { Text(text = selectionOption) },
                       onClick = {
                           selectedText.value = selectionOption
                           expanded.value = false
                           onItemClicked(selectedText.value)
                       }
                   )
               }
           }
   
       }
   
   }
   63 collapsed lines
   
   fun createMap(featureLayer: FeatureLayer): ArcGISMap {
   
       return ArcGISMap(BasemapStyle.ArcGISTopographic).apply {
           initialViewpoint = Viewpoint(
               latitude = 34.0270,
               longitude = -118.8050,
               scale = 72000.0
           )
   
           operationalLayers.add(featureLayer)
   
       }
   }
   
   /**
    *  Query the [serviceFeatureTable] based on the [whereExpression] on the given
    *  [queryExtent] and select the resulting features on the [featureLayer]
    */
   suspend fun queryFeatureLayer(
       context: Context,
       serviceFeatureTable: ServiceFeatureTable,
       featureLayer: FeatureLayer,
       whereExpression: String,
       queryExtent: Envelope?
   ) {
   
       // Clear any previous selections.
       featureLayer.clearSelection()
       // Create query parameters with the where expression and the current extent
       // and have geometry values returned in the results.
       val queryParameters = QueryParameters().apply {
           whereClause = whereExpression
           returnGeometry = true
           geometry = queryExtent
       }
   
       try {
           // Query the feature table with the query parameters.
           val featureQueryResult = serviceFeatureTable.queryFeatures(queryParameters).getOrThrow()
           // Iterate through the result and select the features on the feature layer.
           val resultIterator = featureQueryResult.iterator()
           if (resultIterator.hasNext()) {
               resultIterator.forEach { feature ->
                   featureLayer.selectFeature(feature)
               }
           } else {
               showMessage(
                   context,
                   "No parcels found in the current extent, using Where expression: $whereExpression"
               )
           }
       } catch (e: Exception) {
   
           showMessage(context, "Feature search failed for: $whereExpression, ${e.message}")
   
       }
   
   }
   
   fun showMessage(context: Context, message: String) {
       Toast.makeText(context, message, Toast.LENGTH_LONG).show()
   }