Query a feature layer (SQL)

Learn how to execute a SQL query to return features from a feature layer based on spatial and attribute criteria.

A feature layer can contain a large number of features stored in ArcGIS. You can query a layer to access a subset of its features using any combination of spatial and attribute criteria. You can control whether or not each feature's geometry is returned, as well as which attributes are included in the results. Queries allow you to return a well-defined subset of your hosted data for analysis or display in your app.

In this tutorial, you'll write code to perform SQL queries that return a subset of features in the LA County Parcel feature layer (containing over 2.4 million features). Features that meet the query criteria are selected in the map.

Prerequisites

Steps

Open an Android Studio project

1. To start this tutorial, complete the Display a map tutorial. Or download and unzip the Display a map solution in a new folder.

2. Modify the old project for use in this new tutorial. Expand More info for instructions.

   More info

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

   2. In the Android tool window, 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

      Use dark colors for code blocks

      1
      2
      3
      4
      5
      <resources>
      
          <string name="app_name">Query a feature layer (SQL)</string>
      
      </resources>

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

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

      settings.gradle.kts

      Expand

      Use dark colors for code blocks

      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
      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. The UI theme composable in Display a map tutorial was DisplayAMapTheme. Rename the theme composable throughout the tutorial by refactoring DisplayAMapTheme.

      In the Android tool window, open app > kotlin+java > com.exmple.app > ui.theme > Theme.kt.

      Right-click the function name DisplayAMapTheme and select Refactor -> Rename. Replace the name with QueryAFeatureLayerSQLTheme.

      Theme.kt

      Use dark colors for code blocksCopy

      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
      @Composable
      fun DisplayAMapTheme(
      
          darkTheme: Boolean = isSystemInDarkTheme(),
          // Dynamic color is available on Android 12+
          dynamicColor: Boolean = true,
          content: @Composable () -> Unit
      ) {
          val colorScheme = when {
              dynamicColor && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S -> {
                  val context = LocalContext.current
                  if (darkTheme) dynamicDarkColorScheme(context) else dynamicLightColorScheme(context)
              }
      
              darkTheme -> DarkColorScheme
              else -> LightColorScheme
          }
      

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

3. If you downloaded the solution, get an access token and set the API key in MainActivity.kt.

   Instructions to set the API Key

   An API Key gives your app access to secure resources used in this tutorial.

   1. Go to the Create an API key tutorial to obtain a new API key access token. Ensure that the following privilege is enabled: Location services > Basemaps > Basemap styles service. Copy the access token as it will be used in the next step.

   2. In Android Studio: in the Android tool window, open app > java > com.example.app > MainActivity.

   3. In the setApiKey() function, find the ApiKey.create() call and paste your access token inside the double quotes, replacing YOUR_ACCESS_TOKEN.

      MainActivity.kt

      Use dark colors for code blocksCopy

      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
          private fun setApiKey() {
      
              ArcGISEnvironment.apiKey = ApiKey.create("YOUR_ACCESS_TOKEN")
      
          }
      

Add import statements

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

   MainScreen.kt

   Use dark colors for code blocks

   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67
   68
   69
   70
   71
   72
   73
   74
   75
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   92
   93
   94
   95
   96
   97
   98
   99
   100
   101
   102
   103
   104
   105
   106
   107
   108
   109
   110
   111
   112
   113
   114
   115
   116
   117
   118
   119
   120
   121
   122
   123
   124
   125
   126
   127
   128
   129
   130
   131
   132
   133
   134
   135
   136
   137
   138
   139
   140
   141
   142
   143
   144
   145
   146
   147
   148
   149
   150
   151
   152
   153
   154
   155
   156
   157
   158
   159
   160
   161
   162
   163
   164
   165
   166
   167
   168
   169
   170
   171
   172
   173
   174
   175
   176
   177
   178
   179
   180
   181
   182
   183
   184
   185
   186
   187
   188
   189
   190
   191
   192
   193
   194
   195
   196
   197
   198
   199
   200
   201
   202
   203
   204
   205
   206
   207
   208
   209
   @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.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
   
   

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

   MainScreen.kt

   Use dark colors for code blocks

   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67
   68
   69
   70
   71
   72
   73
   74
   75
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   92
   93
   94
   95
   96
   97
   98
   99
   100
   101
   102
   103
   104
   105
   106
   107
   108
   109
   110
   111
   112
   113
   114
   115
   116
   117
   118
   119
   120
   121
   122
   123
   124
   125
   126
   127
   128
   129
   130
   131
   132
   133
   134
   135
   136
   137
   138
   139
   140
   141
   142
   143
   144
   145
   146
   147
   148
   149
   150
   151
   152
   153
   154
   155
   156
   157
   158
   159
   160
   161
   162
   163
   164
   165
   166
   167
   168
   169
   170
   171
   172
   173
   174
   175
   176
   177
   178
   179
   180
   181
   182
   183
   184
   185
   186
   187
   188
   189
   190
   191
   192
   193
   194
   195
   196
   197
   198
   199
   200
   201
   202
   203
   204
   205
   206
   207
   208
   209
   @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.

Steps

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

   Use dark colors for code blocks

   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67
   68
   69
   70
   71
   72
   73
   74
   75
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   92
   93
   94
   95
   96
   97
   98
   99
   100
   101
   102
   103
   104
   105
   106
   107
   108
   109
   110
   111
   112
   113
   114
   115
   116
   117
   118
   119
   120
   121
   122
   123
   124
   125
   126
   127
   128
   129
   130
   131
   132
   133
   134
   135
   136
   137
   138
   139
   140
   141
   142
   143
   144
   145
   146
   147
   148
   149
   150
   151
   152
   153
   154
   155
   156
   157
   158
   159
   160
   161
   162
   163
   164
   165
   166
   167
   168
   169
   170
   171
   172
   173
   174
   175
   176
   177
   178
   179
   180
   181
   182
   183
   184
   185
   186
   187
   188
   189
   190
   191
   192
   193
   194
   195
   196
   197
   198
   199
   200
   201
   202
   203
   204
   205
   206
   207
   208
   209
   @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

   Expand

   Use dark colors for code blocks

   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67
   68
   69
   70
   71
   72
   73
   74
   75
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   92
   93
   94
   95
   96
   97
   98
   99
   100
   101
   102
   103
   104
   105
   106
   107
   108
   109
   110
   111
   112
   113
   114
   115
   116
   117
   118
   119
   120
   121
   122
   123
   124
   125
   126
   127
   128
   129
   130
   131
   132
   133
   134
   135
   136
   137
   138
   139
   140
   141
   142
   143
   144
   145
   146
   147
   148
   149
   150
   151
   152
   153
   154
   155
   156
   157
   158
   159
   160
   161
   162
   163
   164
   165
   166
   167
   168
   169
   170
   171
   172
   173
   174
   175
   176
   177
   178
   179
   180
   181
   182
   183
   184
   185
   186
   187
   188
   189
   190
   191
   192
   193
   194
   195
   196
   197
   198
   199
   200
   201
   202
   203
   204
   205
   206
   207
   208
   209
   fun createMap(featureLayer: FeatureLayer): ArcGISMap {
   
       return ArcGISMap(BasemapStyle.ArcGISTopographic).apply {
           initialViewpoint = Viewpoint(
               latitude = 34.0270,
               longitude = -118.8050,
               scale = 72000.0
           )
   
           operationalLayers.add(featureLayer)
   
       }
   }
   

   Expand

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

   MainScreen.kt

   Expand

   Use dark colors for code blocks

   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67
   68
   69
   70
   71
   72
   73
   74
   75
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   92
   93
   94
   95
   96
   97
   98
   99
   100
   101
   102
   103
   104
   105
   106
   107
   108
   109
   110
   111
   112
   113
   114
   115
   116
   117
   118
   119
   120
   121
   122
   123
   124
   125
   126
   127
   128
   129
   130
   131
   132
   133
   134
   135
   136
   137
   138
   139
   140
   141
   142
   143
   144
   145
   146
   147
   148
   149
   150
   151
   152
   153
   154
   155
   156
   157
   158
   159
   160
   161
   162
   163
   164
   165
   166
   167
   168
   169
   170
   171
   172
   173
   174
   175
   176
   177
   178
   179
   180
   181
   182
   183
   184
   185
   186
   187
   188
   189
   190
   191
   192
   193
   194
   195
   196
   197
   198
   199
   200
   201
   202
   203
   204
   205
   206
   207
   208
   209
   @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,
   
               )
   
       }
   
   }
   

   Expand

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

   Expand

   Use dark colors for code blocks

   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67
   68
   69
   70
   71
   72
   73
   74
   75
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   92
   93
   94
   95
   96
   97
   98
   99
   100
   101
   102
   103
   104
   105
   106
   107
   108
   109
   110
   111
   112
   113
   114
   115
   116
   117
   118
   119
   120
   121
   122
   123
   124
   125
   126
   127
   128
   129
   130
   131
   132
   133
   134
   135
   136
   137
   138
   139
   140
   141
   142
   143
   144
   145
   146
   147
   148
   149
   150
   151
   152
   153
   154
   155
   156
   157
   158
   159
   160
   161
   162
   163
   164
   165
   166
   167
   168
   169
   170
   171
   172
   173
   174
   175
   176
   177
   178
   179
   180
   181
   182
   183
   184
   185
   186
   187
   188
   189
   190
   191
   192
   193
   194
   195
   196
   197
   198
   199
   200
   201
   202
   203
   204
   205
   206
   207
   208
   209
   /**
    *  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?
   ) {
   
   }
   

   Expand

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

   MainScreen.kt

   Expand

   Use dark colors for code blocks

   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67
   68
   69
   70
   71
   72
   73
   74
   75
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   92
   93
   94
   95
   96
   97
   98
   99
   100
   101
   102
   103
   104
   105
   106
   107
   108
   109
   110
   111
   112
   113
   114
   115
   116
   117
   118
   119
   120
   121
   122
   123
   124
   125
   126
   127
   128
   129
   130
   131
   132
   133
   134
   135
   136
   137
   138
   139
   140
   141
   142
   143
   144
   145
   146
   147
   148
   149
   150
   151
   152
   153
   154
   155
   156
   157
   158
   159
   160
   161
   162
   163
   164
   165
   166
   167
   168
   169
   170
   171
   172
   173
   174
   175
   176
   177
   178
   179
   180
   181
   182
   183
   184
   185
   186
   187
   188
   189
   190
   191
   192
   193
   194
   195
   196
   197
   198
   199
   200
   201
   202
   203
   204
   205
   206
   207
   208
   209
   /**
    *  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
       }
   
   }
   

   Expand

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

   Expand

   Use dark colors for code blocks

   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67
   68
   69
   70
   71
   72
   73
   74
   75
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   92
   93
   94
   95
   96
   97
   98
   99
   100
   101
   102
   103
   104
   105
   106
   107
   108
   109
   110
   111
   112
   113
   114
   115
   116
   117
   118
   119
   120
   121
   122
   123
   124
   125
   126
   127
   128
   129
   130
   131
   132
   133
   134
   135
   136
   137
   138
   139
   140
   141
   142
   143
   144
   145
   146
   147
   148
   149
   150
   151
   152
   153
   154
   155
   156
   157
   158
   159
   160
   161
   162
   163
   164
   165
   166
   167
   168
   169
   170
   171
   172
   173
   174
   175
   176
   177
   178
   179
   180
   181
   182
   183
   184
   185
   186
   187
   188
   189
   190
   191
   192
   193
   194
   195
   196
   197
   198
   199
   200
   201
   202
   203
   204
   205
   206
   207
   208
   209
   /**
    *  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}")
   
       }
   
   }
   

   Expand

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

   Expand

   Use dark colors for code blocks

   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67
   68
   69
   70
   71
   72
   73
   74
   75
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   92
   93
   94
   95
   96
   97
   98
   99
   100
   101
   102
   103
   104
   105
   106
   107
   108
   109
   110
   111
   112
   113
   114
   115
   116
   117
   118
   119
   120
   121
   122
   123
   124
   125
   126
   127
   128
   129
   130
   131
   132
   133
   134
   135
   136
   137
   138
   139
   140
   141
   142
   143
   144
   145
   146
   147
   148
   149
   150
   151
   152
   153
   154
   155
   156
   157
   158
   159
   160
   161
   162
   163
   164
   165
   166
   167
   168
   169
   170
   171
   172
   173
   174
   175
   176
   177
   178
   179
   180
   181
   182
   183
   184
   185
   186
   187
   188
   189
   190
   191
   192
   193
   194
   195
   196
   197
   198
   199
   200
   201
   202
   203
   204
   205
   206
   207
   208
   209
   @Composable
   fun QueryDropDownMenu(onItemClicked: (String) -> Unit) {
       val expanded = remember { mutableStateOf(false) }
       val selection = remember { mutableStateOf("") }
       val sqlQueryExpressions = listOf(
           "UseType = \'Government\'",
           "UseType = \'Residential\'",
           "UseType = \'Irrigated Farm\'",
           "TaxRateArea = 10853",
           "TaxRateArea = 10860",
           "Roll_LandValue > 1000000",
           "Roll_LandValue < 1000000"
       )
   
   }
   

   Expand

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

   Expand

   Use dark colors for code blocks

   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67
   68
   69
   70
   71
   72
   73
   74
   75
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   92
   93
   94
   95
   96
   97
   98
   99
   100
   101
   102
   103
   104
   105
   106
   107
   108
   109
   110
   111
   112
   113
   114
   115
   116
   117
   118
   119
   120
   121
   122
   123
   124
   125
   126
   127
   128
   129
   130
   131
   132
   133
   134
   135
   136
   137
   138
   139
   140
   141
   142
   143
   144
   145
   146
   147
   148
   149
   150
   151
   152
   153
   154
   155
   156
   157
   158
   159
   160
   161
   162
   163
   164
   165
   166
   167
   168
   169
   170
   171
   172
   173
   174
   175
   176
   177
   178
   179
   180
   181
   182
   183
   184
   185
   186
   187
   188
   189
   190
   191
   192
   193
   194
   195
   196
   197
   198
   199
   200
   201
   202
   203
   204
   205
   206
   207
   208
   209
   @Composable
   fun QueryDropDownMenu(onItemClicked: (String) -> Unit) {
       val expanded = remember { mutableStateOf(false) }
       val selection = remember { mutableStateOf("") }
       val sqlQueryExpressions = 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.fillMaxWidth().menuAnchor(),
               readOnly = true,
               value = selection.value,
               onValueChange = { },
               label = { Text("Select a query expression") },
           )
   
       }
   
   }
   

   Expand

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

   Expand

   Use dark colors for code blocks

   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67
   68
   69
   70
   71
   72
   73
   74
   75
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   92
   93
   94
   95
   96
   97
   98
   99
   100
   101
   102
   103
   104
   105
   106
   107
   108
   109
   110
   111
   112
   113
   114
   115
   116
   117
   118
   119
   120
   121
   122
   123
   124
   125
   126
   127
   128
   129
   130
   131
   132
   133
   134
   135
   136
   137
   138
   139
   140
   141
   142
   143
   144
   145
   146
   147
   148
   149
   150
   151
   152
   153
   154
   155
   156
   157
   158
   159
   160
   161
   162
   163
   164
   165
   166
   167
   168
   169
   170
   171
   172
   173
   174
   175
   176
   177
   178
   179
   180
   181
   182
   183
   184
   185
   186
   187
   188
   189
   190
   191
   192
   193
   194
   195
   196
   197
   198
   199
   200
   201
   202
   203
   204
   205
   206
   207
   208
   209
   @Composable
   fun QueryDropDownMenu(onItemClicked: (String) -> Unit) {
       val expanded = remember { mutableStateOf(false) }
       val selection = remember { mutableStateOf("") }
       val sqlQueryExpressions = 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.fillMaxWidth().menuAnchor(),
               readOnly = true,
               value = selection.value,
               onValueChange = { },
               label = { Text("Select a query expression") },
           )
   
           ExposedDropdownMenu(
               expanded = expanded.value,
               onDismissRequest = {
                   expanded.value = false
               }
           ) {
               sqlQueryExpressions.forEach { selectionOption ->
                   DropdownMenuItem(
                       text = { Text(text = selectionOption) },
                       onClick = {
                           selection.value = selectionOption
                           expanded.value = false
                           onItemClicked(selection.value)
                       }
                   )
               }
           }
   
       }
   
   }
   

   Expand

In Scaffold, call the QueryDropDownMenu composable.

1. Inside the Scaffold block, find the MapView from the Display a map tutorial and replace it with a call of Column. A Column allows you to display the drop-down menu at the top of the screen and the map view directly below.

   MainScreen.kt

   Expand

   Use dark colors for code blocks

   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67
   68
   69
   70
   71
   72
   73
   74
   75
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   92
   93
   94
   95
   96
   97
   98
   99
   100
   101
   102
   103
   104
   105
   106
   107
   108
   109
   110
   111
   112
   113
   114
   115
   116
   117
   118
   119
   120
   121
   122
   123
   124
   125
   126
   127
   128
   129
   130
   131
   132
   133
   134
   135
   136
   137
   138
   139
   140
   141
   142
   143
   144
   145
   146
   147
   148
   149
   150
   151
   152
   153
   154
   155
   156
   157
   158
   159
   160
   161
   162
   163
   164
   165
   166
   167
   168
   169
   170
   171
   172
   173
   174
   175
   176
   177
   178
   179
   180
   181
   182
   183
   184
   185
   186
   187
   188
   189
   190
   191
   192
   193
   194
   195
   196
   197
   198
   199
   200
   201
   202
   203
   204
   205
   206
   207
   208
   209
       Scaffold(
           topBar = { TopAppBar(title = { Text(text = stringResource(id = R.string.app_name)) }) }
       ) {
   
           Column(
               Modifier.fillMaxSize().padding(it)
           ) {
   
           }
   
       }
   

   Expand

2. Call the QueryDropDownMenu composable function you created above. For the onItemClicked parameter, pass a lambda that does the following:

   • Cancels any coroutine Job that is currently running.
   • Launches a coroutine.
   • Within the launch block, calls the queryFeatureLayer() function you defined above. You should pass the arguments shown below. Note that the sqlQueryExpression is the parameter passed to the lambda.
   MainScreen.kt

   Expand

   Use dark colors for code blocks

   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67
   68
   69
   70
   71
   72
   73
   74
   75
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   92
   93
   94
   95
   96
   97
   98
   99
   100
   101
   102
   103
   104
   105
   106
   107
   108
   109
   110
   111
   112
   113
   114
   115
   116
   117
   118
   119
   120
   121
   122
   123
   124
   125
   126
   127
   128
   129
   130
   131
   132
   133
   134
   135
   136
   137
   138
   139
   140
   141
   142
   143
   144
   145
   146
   147
   148
   149
   150
   151
   152
   153
   154
   155
   156
   157
   158
   159
   160
   161
   162
   163
   164
   165
   166
   167
   168
   169
   170
   171
   172
   173
   174
   175
   176
   177
   178
   179
   180
   181
   182
   183
   184
   185
   186
   187
   188
   189
   190
   191
   192
   193
   194
   195
   196
   197
   198
   199
   200
   201
   202
   203
   204
   205
   206
   207
   208
   209
       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
                           )
                       }
                   })
   
           }
   
       }
   

   Expand

3. Add back the MapView.

   MainScreen.kt

   Expand

   Use dark colors for code blocks

   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67
   68
   69
   70
   71
   72
   73
   74
   75
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   92
   93
   94
   95
   96
   97
   98
   99
   100
   101
   102
   103
   104
   105
   106
   107
   108
   109
   110
   111
   112
   113
   114
   115
   116
   117
   118
   119
   120
   121
   122
   123
   124
   125
   126
   127
   128
   129
   130
   131
   132
   133
   134
   135
   136
   137
   138
   139
   140
   141
   142
   143
   144
   145
   146
   147
   148
   149
   150
   151
   152
   153
   154
   155
   156
   157
   158
   159
   160
   161
   162
   163
   164
   165
   166
   167
   168
   169
   170
   171
   172
   173
   174
   175
   176
   177
   178
   179
   180
   181
   182
   183
   184
   185
   186
   187
   188
   189
   190
   191
   192
   193
   194
   195
   196
   197
   198
   199
   200
   201
   202
   203
   204
   205
   206
   207
   208
   209
       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,
   
               )
   
           }
   
       }
   

   Expand

4. Pass the onViewpointChangedForBoundingGeometry parameter to MapView. For that parameter, pass a lambda that assigns the current viewpoint's extent to the state value of the currentExtent variable.

   MainScreen.kt

   Expand

   Use dark colors for code blocks

   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67
   68
   69
   70
   71
   72
   73
   74
   75
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   92
   93
   94
   95
   96
   97
   98
   99
   100
   101
   102
   103
   104
   105
   106
   107
   108
   109
   110
   111
   112
   113
   114
   115
   116
   117
   118
   119
   120
   121
   122
   123
   124
   125
   126
   127
   128
   129
   130
   131
   132
   133
   134
   135
   136
   137
   138
   139
   140
   141
   142
   143
   144
   145
   146
   147
   148
   149
   150
   151
   152
   153
   154
   155
   156
   157
   158
   159
   160
   161
   162
   163
   164
   165
   166
   167
   168
   169
   170
   171
   172
   173
   174
   175
   176
   177
   178
   179
   180
   181
   182
   183
   184
   185
   186
   187
   188
   189
   190
   191
   192
   193
   194
   195
   196
   197
   198
   199
   200
   201
   202
   203
   204
   205
   206
   207
   208
   209
       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
                   }
   
               )
   
           }
   
       }
   

   Expand

5. (Optional) The code in this tutorial calls a function to display messages to the user. One possible implementation of showMessage() is the following.

   MainScreen.kt

   Expand

   Use dark colors for code blocks

   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67
   68
   69
   70
   71
   72
   73
   74
   75
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   92
   93
   94
   95
   96
   97
   98
   99
   100
   101
   102
   103
   104
   105
   106
   107
   108
   109
   110
   111
   112
   113
   114
   115
   116
   117
   118
   119
   120
   121
   122
   123
   124
   125
   126
   127
   128
   129
   130
   131
   132
   133
   134
   135
   136
   137
   138
   139
   140
   141
   142
   143
   144
   145
   146
   147
   148
   149
   150
   151
   152
   153
   154
   155
   156
   157
   158
   159
   160
   161
   162
   163
   164
   165
   166
   167
   168
   169
   170
   171
   172
   173
   174
   175
   176
   177
   178
   179
   180
   181
   182
   183
   184
   185
   186
   187
   188
   189
   190
   191
   192
   193
   194
   195
   196
   197
   198
   199
   200
   201
   202
   203
   204
   205
   206
   207
   208
   209
   fun showMessage(context: Context, message: String) {
       Toast.makeText(context, message, Toast.LENGTH_LONG).show()
   }

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

The app loads with the map centered on the Santa Monica Mountains in California with the parcels feature layer displayed. Choose an attribute expression, and parcels in the current extent that meet the selected criteria will display in the specified selection color.

What's next?

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

• Add a point, line, and polygon
• Add a feature layer