feat: Dynamic polygon location and sizing with DataStore

- Added Places SDK integration to dynamically set the center of the Animated Polygon based on user search.
- Added DataStore bindings in SettingsRepository for persisting polygon dimensions (width/height in miles) and center coordinates.
- Added Robolectric and Coroutines test dependencies and created SettingsRepositoryTest to verify persistence logic.
- Updated TopAppBar title to 'Animated Polygon with Settings'.
- Refined AnimatedPolygonActivity UI with explanatory comments and automatic camera/altitude bounds resetting upon new location selection.

Author: dkhawk

Maps3DSamples/advanced/app/build.gradle.kts

@@ -143,12 +143,17 @@ dependencies {
     debugImplementation(libs.androidx.ui.test.manifest)
 
     implementation(libs.kotlinx.datetime)
+    testImplementation(libs.kotlinx.coroutines.test)
+    testImplementation(libs.robolectric)
+    testImplementation(libs.androidx.test.core)
+    testImplementation(libs.androidx.junit)
     implementation(libs.dagger)
     ksp(libs.hilt.android.compiler)
     implementation(libs.hilt.android)
 
     implementation(libs.play.services.base)
     implementation(libs.play.services.maps3d)
+    implementation(libs.play.services.places)
 
     testImplementation(libs.google.truth)
 

Maps3DSamples/advanced/app/src/main/java/com/example/advancedmaps3dsamples/MainActivity.kt

@@ -42,6 +42,7 @@ import androidx.compose.ui.unit.dp
 import com.example.advancedmaps3dsamples.scenarios.ScenariosActivity
 import com.example.advancedmaps3dsamples.animatedpolygon.AnimatedPolygonActivity
 import com.example.advancedmaps3dsamples.ui.theme.AdvancedMaps3DSamplesTheme
+import com.google.android.libraries.places.api.Places
 import dagger.hilt.android.AndroidEntryPoint
 
 data class MapSample(@StringRes val label: Int, val clazz: Class<*>)
@@ -57,6 +58,11 @@ private val samples =
 class MainActivity : ComponentActivity() {
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
+        
+        if (!Places.isInitialized()) {
+            Places.initializeWithNewPlacesApiEnabled(applicationContext, BuildConfig.MAPS3D_API_KEY)
+        }
+        
         enableEdgeToEdge()
         setContent {
             AdvancedMaps3DSamplesTheme {

Maps3DSamples/advanced/app/src/main/java/com/example/advancedmaps3dsamples/animatedpolygon/AnimatedPolygonActivity.kt

@@ -43,13 +43,23 @@ import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
+import android.app.Activity
+import androidx.activity.result.contract.ActivityResultContracts
+import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.compose.material.icons.filled.Search
 import com.example.advancedmaps3dsamples.R
 import com.example.advancedmaps3dsamples.ui.theme.AdvancedMaps3DSamplesTheme
 import com.example.advancedmaps3dsamples.utils.toValidCamera
+import com.google.android.gms.maps.model.LatLng
+import com.google.android.libraries.places.api.model.Place
+import com.google.android.libraries.places.widget.Autocomplete
+import com.google.android.libraries.places.widget.model.AutocompleteActivityMode
 import com.google.android.gms.maps3d.model.AltitudeMode
 import com.google.android.gms.maps3d.model.Camera
+import com.google.android.gms.maps3d.model.camera
 import com.google.android.gms.maps3d.model.Map3DMode
 import com.google.android.gms.maps3d.model.latLngAltitude
+import com.google.android.gms.maps3d.model.LatLngAltitude
 import com.google.android.gms.maps3d.model.polygonOptions
 import dagger.hilt.android.AndroidEntryPoint
 import com.google.android.gms.maps3d.Map3DOptions
@@ -77,6 +87,42 @@ class AnimatedPolygonActivity : ComponentActivity() {
         var showSettingsDialog by mutableStateOf(false)
 
         setContent {
+            val launcher = rememberLauncherForActivityResult(ActivityResultContracts.StartActivityForResult()) { result ->
+                if (result.resultCode == Activity.RESULT_OK) {
+                    result.data?.let { intent ->
+                        // Retrieve the Place selected by the user.
+                        val place = Autocomplete.getPlaceFromIntent(intent)
+                        place.latLng?.let { latLng ->
+                            // When a new location is picked, we persist the coordinates to DataStore
+                            // so that the 3D polygon's geometry is recalculated around this new center.
+                            viewModel.savePolygonCenter(latLng.latitude, latLng.longitude)
+                            
+                            // Reset the user's zoom/altitude bounds. Since we don't know the exact elevation of the new place,
+                            // expanding the bounds from 0 to 15K feet allows them to easily find the polygon.
+                            viewModel.saveMinAltitude(0f)
+                            viewModel.saveMaxAltitude(15000f)
+                            
+                            // Immediately fly the camera to the new location to center it in the view,
+                            // overriding whatever camera position the user previously had.
+                            val newCam = camera {
+                                center = latLngAltitude {
+                                    latitude = latLng.latitude
+                                    longitude = latLng.longitude
+                                    altitude = 10000.0
+                                }
+                                heading = 0.0
+                                tilt = 0.0
+                            }
+                            viewModel.setCamera(newCam)
+                            
+                            // Force a save of the new camera right away so that if the user backgrounds
+                            // the app before the map becomes "steady", they don't lose this new location.
+                            viewModel.saveCameraSettings(newCam)
+                        }
+                    }
+                }
+            }
+
             AdvancedMaps3DSamplesTheme {
                 Scaffold(
                     modifier = Modifier.fillMaxSize(),
@@ -87,9 +133,20 @@ class AnimatedPolygonActivity : ComponentActivity() {
                                 titleContentColor = MaterialTheme.colorScheme.primary,
                             ),
                             title = {
-                                Text(stringResource(R.string.scenarios_altitude_slider))
+                                Text(stringResource(R.string.map_sample_animated_polygon))
                             },
                             actions = {
+                                IconButton(onClick = { 
+                                    val fields = listOf(Place.Field.ID, Place.Field.NAME, Place.Field.LAT_LNG)
+                                    val intent = Autocomplete.IntentBuilder(AutocompleteActivityMode.OVERLAY, fields)
+                                        .build(this@AnimatedPolygonActivity)
+                                    launcher.launch(intent)
+                                }) {
+                                    Icon(
+                                        imageVector = Icons.Filled.Search,
+                                        contentDescription = "Search Location"
+                                    )
+                                }
                                 IconButton(onClick = { showSettingsDialog = true }) {
                                     Icon(
                                         imageVector = Icons.Filled.Settings,
@@ -137,6 +194,11 @@ fun AnimatedPolygon(
     val sweepSpeed by viewModel.sweepSpeedFlow.collectAsStateWithLifecycle(initialValue = 50f)
     val savedCamera by viewModel.savedCameraFlow.collectAsStateWithLifecycle(initialValue = null)
 
+    val centerLat by viewModel.polygonCenterLatFlow.collectAsStateWithLifecycle(initialValue = 40.0)
+    val centerLng by viewModel.polygonCenterLngFlow.collectAsStateWithLifecycle(initialValue = -105.5)
+    val widthMiles by viewModel.polygonWidthMilesFlow.collectAsStateWithLifecycle(initialValue = 26f)
+    val heightMiles by viewModel.polygonHeightMilesFlow.collectAsStateWithLifecycle(initialValue = 27f)
+    
     // Ensure altitude is clamped within the min and max bounds
     var altitudeFeet by remember(minAltitude, maxAltitude) { 
         mutableFloatStateOf((minAltitude + maxAltitude) / 2f) 
@@ -145,12 +207,26 @@ fun AnimatedPolygon(
     var isSweeping by remember { mutableStateOf(false) }
     var sweepDirection by remember(sweepSpeed) { mutableFloatStateOf(sweepSpeed) }
 
-    val boulderPolygonPoints = remember {
+    val boulderPolygonPoints = remember(centerLat, centerLng, widthMiles, heightMiles) {
+        val center = LatLng(centerLat, centerLng)
+        val widthMeters = widthMiles * 1609.34
+        val heightMeters = heightMiles * 1609.34
+        
+        // 0=North, 90=East, 180=South, 270=West
+        val north = com.google.maps.android.SphericalUtil.computeOffset(center, heightMeters / 2.0, 0.0)
+        val south = com.google.maps.android.SphericalUtil.computeOffset(center, heightMeters / 2.0, 180.0)
+        
+        // Compute corners by offsetting north/south points east/west
+        val nw = com.google.maps.android.SphericalUtil.computeOffset(north, widthMeters / 2.0, 270.0)
+        val ne = com.google.maps.android.SphericalUtil.computeOffset(north, widthMeters / 2.0, 90.0)
+        val sw = com.google.maps.android.SphericalUtil.computeOffset(south, widthMeters / 2.0, 270.0)
+        val se = com.google.maps.android.SphericalUtil.computeOffset(south, widthMeters / 2.0, 90.0)
+
         listOf(
-            latLngAltitude { latitude = 40.20; longitude = -105.26; altitude = 0.0 }, // NW
-            latLngAltitude { latitude = 40.20; longitude = -105.77; altitude = 0.0 }, // NE
-            latLngAltitude { latitude = 39.80; longitude = -105.77; altitude = 0.0 }, // SE
-            latLngAltitude { latitude = 39.80; longitude = -105.26; altitude = 0.0 }  // SW
+            latLngAltitude { latitude = nw.latitude; longitude = nw.longitude; altitude = 0.0 }, // NW
+            latLngAltitude { latitude = ne.latitude; longitude = ne.longitude; altitude = 0.0 }, // NE
+            latLngAltitude { latitude = se.latitude; longitude = se.longitude; altitude = 0.0 }, // SE
+            latLngAltitude { latitude = sw.latitude; longitude = sw.longitude; altitude = 0.0 }  // SW
         )
     }
 
@@ -256,6 +332,8 @@ fun AnimatedPolygon(
             var tempMin by remember(minAltitude) { mutableStateOf(minAltitude.toInt().toString()) }
             var tempMax by remember(maxAltitude) { mutableStateOf(maxAltitude.toInt().toString()) }
             var tempSpeed by remember(sweepSpeed) { mutableStateOf(sweepSpeed.toInt().toString()) }
+            var tempWidth by remember(widthMiles) { mutableStateOf(widthMiles.toString()) }
+            var tempHeight by remember(heightMiles) { mutableStateOf(heightMiles.toString()) }
 
             AlertDialog(
                 onDismissRequest = onDismissSettings,
@@ -281,6 +359,20 @@ fun AnimatedPolygon(
                             onValueChange = { tempSpeed = it },
                             label = { Text("Sweep Speed (ft/frame)") },
                             keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Number),
+                            modifier = Modifier.fillMaxWidth().padding(bottom = 8.dp)
+                        )
+                        OutlinedTextField(
+                            value = tempWidth,
+                            onValueChange = { tempWidth = it },
+                            label = { Text("Width (miles)") },
+                            keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Number),
+                            modifier = Modifier.fillMaxWidth().padding(bottom = 8.dp)
+                        )
+                        OutlinedTextField(
+                            value = tempHeight,
+                            onValueChange = { tempHeight = it },
+                            label = { Text("Height (miles)") },
+                            keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Number),
                             modifier = Modifier.fillMaxWidth()
                         )
                     }
@@ -294,6 +386,13 @@ fun AnimatedPolygon(
                             // Match the current direction (positive or negative) with the new speed magnitude
                             sweepDirection = if (sweepDirection < 0) -it else it
                         }
+                        
+                        val w = tempWidth.toFloatOrNull()
+                        val h = tempHeight.toFloatOrNull()
+                        if (w != null && h != null) {
+                            viewModel.savePolygonDimensions(w, h)
+                        }
+                        
                         onDismissSettings()
                     }) {
                         Text("Save")

Maps3DSamples/advanced/app/src/main/java/com/example/advancedmaps3dsamples/data/SettingsRepository.kt

@@ -18,6 +18,15 @@ import javax.inject.Singleton
 
 private val Context.dataStore: DataStore<Preferences> by preferencesDataStore(name = "altitude_settings")
 
+/**
+ * Repository for persisting application preferences via Jetpack DataStore.
+ *
+ * This class abstracts the DataStore implementation from the rest of the application,
+ * providing a clean, reactive API for observing and updating settings such as
+ * the 3D polygon's dimensions, sweep speed, and the last known camera position.
+ * The use of DataStore ensures asynchronous, safe, and consistent reads/writes,
+ * moving away from traditional SharedPreferences which are prone to UI thread blocking.
+ */
 @Singleton
 class SettingsRepository @Inject constructor(@ApplicationContext private val context: Context) {
 
@@ -39,6 +48,15 @@ class SettingsRepository @Inject constructor(@ApplicationContext private val con
         val CAMERA_TILT_KEY = doublePreferencesKey("camera_tilt")
         val CAMERA_ROLL_KEY = doublePreferencesKey("camera_roll")
         val CAMERA_RANGE_KEY = doublePreferencesKey("camera_range")
+
+        val POLYGON_CENTER_LAT_KEY = doublePreferencesKey("polygon_center_lat")
+        val POLYGON_CENTER_LNG_KEY = doublePreferencesKey("polygon_center_lng")
+        val POLYGON_WIDTH_MILES_KEY = floatPreferencesKey("polygon_width_miles")
+        val POLYGON_HEIGHT_MILES_KEY = floatPreferencesKey("polygon_height_miles")
+        const val DEFAULT_POLYGON_CENTER_LAT = 40.0
+        const val DEFAULT_POLYGON_CENTER_LNG = -105.5
+        const val DEFAULT_POLYGON_WIDTH_MILES = 26f
+        const val DEFAULT_POLYGON_HEIGHT_MILES = 27f
     }
 
     val minAltitudeFlow: Flow<Float> = dataStore.data
@@ -74,6 +92,25 @@ class SettingsRepository @Inject constructor(@ApplicationContext private val con
         }
     }
 
+    val polygonCenterLatFlow: Flow<Double> = dataStore.data.map { it[POLYGON_CENTER_LAT_KEY] ?: DEFAULT_POLYGON_CENTER_LAT }
+    val polygonCenterLngFlow: Flow<Double> = dataStore.data.map { it[POLYGON_CENTER_LNG_KEY] ?: DEFAULT_POLYGON_CENTER_LNG }
+    val polygonWidthMilesFlow: Flow<Float> = dataStore.data.map { it[POLYGON_WIDTH_MILES_KEY] ?: DEFAULT_POLYGON_WIDTH_MILES }
+    val polygonHeightMilesFlow: Flow<Float> = dataStore.data.map { it[POLYGON_HEIGHT_MILES_KEY] ?: DEFAULT_POLYGON_HEIGHT_MILES }
+
+    suspend fun savePolygonCenter(lat: Double, lng: Double) {
+        dataStore.edit { preferences ->
+            preferences[POLYGON_CENTER_LAT_KEY] = lat
+            preferences[POLYGON_CENTER_LNG_KEY] = lng
+        }
+    }
+
+    suspend fun savePolygonDimensions(width: Float, height: Float) {
+        dataStore.edit { preferences ->
+            preferences[POLYGON_WIDTH_MILES_KEY] = width
+            preferences[POLYGON_HEIGHT_MILES_KEY] = height
+        }
+    }
+
     val cameraFlow: Flow<Camera?> = dataStore.data.map { preferences ->
         val lat = preferences[CAMERA_LAT_KEY]
         val lng = preferences[CAMERA_LNG_KEY]

Maps3DSamples/advanced/app/src/main/java/com/example/advancedmaps3dsamples/scenarios/ScenariosViewModel.kt

@@ -88,6 +88,11 @@ class ScenariosViewModel @Inject constructor(
   val sweepSpeedFlow = settingsRepository.sweepSpeedFlow
   val savedCameraFlow = settingsRepository.cameraFlow
 
+  val polygonCenterLatFlow = settingsRepository.polygonCenterLatFlow
+  val polygonCenterLngFlow = settingsRepository.polygonCenterLngFlow
+  val polygonWidthMilesFlow = settingsRepository.polygonWidthMilesFlow
+  val polygonHeightMilesFlow = settingsRepository.polygonHeightMilesFlow
+
   fun saveMinAltitude(min: Float) = viewModelScope.launch {
       settingsRepository.saveMinAltitude(min)
   }
@@ -104,6 +109,14 @@ class ScenariosViewModel @Inject constructor(
       settingsRepository.saveCamera(camera)
   }
 
+  fun savePolygonCenter(lat: Double, lng: Double) = viewModelScope.launch {
+      settingsRepository.savePolygonCenter(lat, lng)
+  }
+
+  fun savePolygonDimensions(width: Float, height: Float) = viewModelScope.launch {
+      settingsRepository.savePolygonDimensions(width, height)
+  }
+
   init {
     viewModelScope.launch {
       viewState

Maps3DSamples/advanced/app/src/main/res/values/strings.xml

@@ -19,6 +19,7 @@
 
     <string name="map_sample_title" translatable="false">3D Map Samples</string>
     <string name="map_sample_scenarios" translatable="false">Scenarios (video visuals)</string>
+    <string name="map_sample_animated_polygon" translatable="false">Animated Polygon with Settings</string>
 
     <!--
     Distance in feet, formatted to 0 decimal places.