diff --git a/Maps3DSamples/ApiDemos/common/build.gradle.kts b/Maps3DSamples/ApiDemos/common/build.gradle.kts
index 9102fdae..6721cede 100644
--- a/Maps3DSamples/ApiDemos/common/build.gradle.kts
+++ b/Maps3DSamples/ApiDemos/common/build.gradle.kts
@@ -60,6 +60,10 @@ android {
     }
 }
 
+composeCompiler {
+    stabilityConfigurationFiles.add(rootProject.layout.projectDirectory.file("compose_stability.conf"))
+}
+
 dependencies {
     coreLibraryDesugaring(libs.desugar.jdk.libs)
 
diff --git a/Maps3DSamples/ApiDemos/common/src/main/java/com/example/maps3d/common/Map3DQuickSettingsButton.kt b/Maps3DSamples/ApiDemos/common/src/main/java/com/example/maps3d/common/Map3DQuickSettingsButton.kt
new file mode 100644
index 00000000..d9d11f73
--- /dev/null
+++ b/Maps3DSamples/ApiDemos/common/src/main/java/com/example/maps3d/common/Map3DQuickSettingsButton.kt
@@ -0,0 +1,230 @@
+/*
+ * Copyright 2026 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.example.maps3d.common
+
+import android.app.Activity
+import android.content.Context
+import android.content.ContextWrapper
+import android.util.AttributeSet
+import android.view.ViewGroup
+import androidx.appcompat.app.AlertDialog
+import androidx.core.view.WindowCompat
+import androidx.core.view.WindowInsetsCompat
+import androidx.core.view.WindowInsetsControllerCompat
+import com.example.maps3dcommon.R
+import com.google.android.gms.maps3d.GoogleMap3D
+import com.google.android.gms.maps3d.model.Map3DMode
+import com.google.android.material.floatingactionbutton.FloatingActionButton
+
+// [START maps_3d_quick_settings_button]
+/**
+ * A self-contained settings button overlay for 3D map activities.
+ *
+ * Can be positioned anywhere in a layout (e.g., top-end or bottom-end of the map).
+ * Clicking the button opens a modal [Map3DQuickSettingsDialog] allowing the user
+ * to switch map modes (Satellite, Hybrid, Roadmap), color schemes (System, Light, Dark),
+ * and camera UI controls.
+ *
+ * Defaults to [Map3DSettingsController.shared] so user choices stay consistent across
+ * all samples during an app session.
+ */
+class Map3DQuickSettingsButton @JvmOverloads constructor(
+    context: Context,
+    attrs: AttributeSet? = null,
+    defStyleAttr: Int = com.google.android.material.R.attr.floatingActionButtonStyle,
+) : FloatingActionButton(context, attrs, defStyleAttr) {
+
+    fun interface OnSettingsChangedListener {
+        fun onSettingsChanged(settings: Map3DSettings)
+    }
+
+    private val controllerListener: (Map3DSettings) -> Unit = { updatedSettings ->
+        val map = attachedMap ?: mapProvider?.invoke()
+        map?.let { updatedSettings.applyTo(it) }
+        updateTopMarginForUiControls(updatedSettings.uiControls)
+        onSettingsChangedListener?.onSettingsChanged(updatedSettings)
+    }
+
+    /**
+     * Controller backing this button's settings state.
+     * Defaults to the application-scoped [Map3DSettingsController.shared] instance.
+     */
+    var settingsController: Map3DSettingsController = Map3DSettingsController.shared
+        set(value) {
+            if (field !== value) {
+                field.removeListener(controllerListener)
+                field = value
+                if (isAttachedToWindow) {
+                    field.addListener(controllerListener)
+                }
+                updateTopMarginForUiControls(field.getSettings().uiControls)
+            }
+        }
+
+    /**
+     * The hosting sample's default [Map3DMode], restored if the user taps "Reset to Defaults".
+     */
+    @Map3DMode
+    var sampleDefaultMapMode: Int = Map3DMode.HYBRID
+
+    /**
+     * Additional top inset (in pixels) to add when the map and button are laid out edge-to-edge
+     * behind the status bar.
+     */
+    var statusBarTopOffsetPx: Int = 0
+        set(value) {
+            if (field != value) {
+                field = value
+                updateTopMarginForUiControls()
+            }
+        }
+
+    private var attachedMap: GoogleMap3D? = null
+    private var mapProvider: (() -> GoogleMap3D?)? = null
+    private var activeDialog: AlertDialog? = null
+    private var onSettingsChangedListener: OnSettingsChangedListener? = null
+
+    init {
+        setImageResource(R.drawable.settings_24px)
+        contentDescription = context.getString(R.string.map3d_settings_button_description)
+        size = SIZE_MINI
+
+        setOnClickListener {
+            showDialog()
+        }
+    }
+
+    override fun onAttachedToWindow() {
+        super.onAttachedToWindow()
+        hideHostSystemBars()
+        settingsController.addListener(controllerListener)
+        updateTopMarginForUiControls()
+        post {
+            hideHostSystemBars()
+            updateTopMarginForUiControls()
+        }
+    }
+
+    override fun onWindowFocusChanged(hasWindowFocus: Boolean) {
+        super.onWindowFocusChanged(hasWindowFocus)
+        if (hasWindowFocus) {
+            hideHostSystemBars()
+        }
+    }
+
+    private fun hideHostSystemBars() {
+        var ctx: Context? = context
+        while (ctx is ContextWrapper) {
+            if (ctx is Activity) {
+                val window = ctx.window
+                val insetsController = WindowCompat.getInsetsController(window, window.decorView)
+                insetsController.systemBarsBehavior =
+                    WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
+                insetsController.hide(WindowInsetsCompat.Type.systemBars())
+                break
+            }
+            ctx = ctx.baseContext
+        }
+    }
+
+    override fun onDetachedFromWindow() {
+        activeDialog?.dismiss()
+        activeDialog = null
+        settingsController.removeListener(controllerListener)
+        super.onDetachedFromWindow()
+    }
+
+    private fun resolveEffectiveStatusBarOffsetPx(): Int {
+        if (statusBarTopOffsetPx > 0) return statusBarTopOffsetPx
+        val parentGroup = parent as? ViewGroup ?: return 0
+        val mapView = parentGroup.findViewById<ViewGroup?>(R.id.map3dView)
+        return Map3DSettings.resolveStatusBarOverlapPx(mapView ?: parentGroup)
+    }
+
+    /**
+     * Adjusts this button's top margin so it sits directly below the active trailing camera UI
+     * controls ([Map3DUiControls.zoom], [Map3DUiControls.tilt], [Map3DUiControls.rotate]).
+     */
+    @JvmOverloads
+    fun updateTopMarginForUiControls(uiControls: Map3DUiControls = getSettings().uiControls) {
+        val lp = layoutParams as? ViewGroup.MarginLayoutParams ?: return
+        val density = resources.displayMetrics.density
+        val baseMarginDp = uiControls.calculateFabMarginDp()
+        val effectiveStatusBarOffset = resolveEffectiveStatusBarOffsetPx()
+        val targetTopMargin = effectiveStatusBarOffset + (baseMarginDp * density).toInt()
+        if (lp.topMargin != targetTopMargin) {
+            lp.topMargin = targetTopMargin
+            layoutParams = lp
+        }
+    }
+
+    /**
+     * Attaches a [GoogleMap3D] instance.
+     *
+     * Settings changes will automatically be applied to this map instance.
+     */
+    fun attachMap(googleMap3D: GoogleMap3D?) {
+        this.attachedMap = googleMap3D
+        val currentSettings = settingsController.getSettings()
+        updateTopMarginForUiControls(currentSettings.uiControls)
+        if (googleMap3D != null) {
+            currentSettings.applyTo(googleMap3D)
+            // Re-apply after a short delay to ensure native engine layout pass preserves controls
+            postDelayed({
+                if (attachedMap == googleMap3D) {
+                    val latest = settingsController.getSettings()
+                    latest.applyTo(googleMap3D)
+                    updateTopMarginForUiControls(latest.uiControls)
+                }
+            }, 350L)
+        }
+    }
+
+    /**
+     * Sets a provider lambda that resolves the active [GoogleMap3D] instance on demand.
+     */
+    fun setMapProvider(provider: () -> GoogleMap3D?) {
+        this.mapProvider = provider
+    }
+
+    /** Returns the current [Map3DSettings] snapshot. */
+    fun getSettings(): Map3DSettings = settingsController.getSettings()
+
+    /** Programmatically sets new [Map3DSettings]. */
+    fun setSettings(settings: Map3DSettings) {
+        settingsController.setSettings(settings)
+    }
+
+    /** Sets a callback invoked whenever the user updates settings in the dialog. */
+    fun setOnSettingsChangedListener(listener: OnSettingsChangedListener?) {
+        this.onSettingsChangedListener = listener
+    }
+
+    /** Displays the [Map3DQuickSettingsDialog] modal. */
+    fun showDialog() {
+        val map = attachedMap ?: mapProvider?.invoke()
+        activeDialog?.dismiss()
+        activeDialog = Map3DQuickSettingsDialog.show(
+            context = context,
+            controller = settingsController,
+            googleMap3D = map,
+            sampleDefaultMapMode = sampleDefaultMapMode,
+            onDismiss = { activeDialog = null },
+        )
+    }
+}
+// [END maps_3d_quick_settings_button]
diff --git a/Maps3DSamples/ApiDemos/common/src/main/java/com/example/maps3d/common/Map3DQuickSettingsDialog.kt b/Maps3DSamples/ApiDemos/common/src/main/java/com/example/maps3d/common/Map3DQuickSettingsDialog.kt
new file mode 100644
index 00000000..fd58f501
--- /dev/null
+++ b/Maps3DSamples/ApiDemos/common/src/main/java/com/example/maps3d/common/Map3DQuickSettingsDialog.kt
@@ -0,0 +1,199 @@
+/*
+ * Copyright 2026 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.example.maps3d.common
+
+import android.content.Context
+import android.view.LayoutInflater
+import android.view.WindowManager
+import android.widget.Button
+import android.widget.RadioGroup
+import androidx.appcompat.app.AlertDialog
+import androidx.core.view.WindowCompat
+import androidx.core.view.WindowInsetsCompat
+import androidx.core.view.WindowInsetsControllerCompat
+import com.example.maps3dcommon.R
+import com.google.android.gms.maps3d.GoogleMap3D
+import com.google.android.gms.maps3d.model.Map3DMode
+import com.google.android.material.checkbox.MaterialCheckBox
+import com.google.android.material.dialog.MaterialAlertDialogBuilder
+import com.google.android.material.materialswitch.MaterialSwitch
+
+// [START maps_3d_quick_settings_dialog]
+/**
+ * Modal dialog for inspecting and adjusting 3D map settings.
+ *
+ * Provides single-choice radio controls for Map Mode (Satellite, Hybrid, Roadmap)
+ * and Color Scheme (Follow System, Light, Dark), plus toggles for built-in camera UI controls
+ * and a Reset to Defaults action.
+ * Directly applies changes to [GoogleMap3D] and app theme for instant live feedback.
+ */
+object Map3DQuickSettingsDialog {
+
+    /**
+     * Builds and displays the modal [AlertDialog].
+     *
+     * @param context Host Android UI [Context].
+     * @param controller The [Map3DSettingsController] managing settings state.
+     * @param googleMap3D Optional [GoogleMap3D] instance to apply settings immediately.
+     * @param sampleDefaultMapMode The hosting sample's default [Map3DMode] used when resetting.
+     * @param onDismiss Optional callback invoked when the dialog is closed.
+     * @return The displayed [AlertDialog] instance.
+     */
+    fun show(
+        context: Context,
+        controller: Map3DSettingsController = Map3DSettingsController.shared,
+        googleMap3D: GoogleMap3D? = null,
+        @Map3DMode sampleDefaultMapMode: Int = Map3DMode.HYBRID,
+        onDismiss: (() -> Unit)? = null,
+    ): AlertDialog {
+        val view = LayoutInflater.from(context).inflate(
+            R.layout.dialog_map3d_quick_settings,
+            null,
+            false,
+        )
+
+        val rgMapMode = view.findViewById<RadioGroup>(R.id.rg_map_mode)
+        val rgColorScheme = view.findViewById<RadioGroup>(R.id.rg_color_scheme)
+        val switchAll = view.findViewById<MaterialSwitch>(R.id.switch_toggle_all_controls)
+        val cbZoom = view.findViewById<MaterialCheckBox>(R.id.cb_control_zoom)
+        val cbTilt = view.findViewById<MaterialCheckBox>(R.id.cb_control_tilt)
+        val cbRotate = view.findViewById<MaterialCheckBox>(R.id.cb_control_rotate)
+        val cbCompass = view.findViewById<MaterialCheckBox>(R.id.cb_control_compass)
+        val cbPanV = view.findViewById<MaterialCheckBox>(R.id.cb_control_pan_v)
+        val cbPanH = view.findViewById<MaterialCheckBox>(R.id.cb_control_pan_h)
+        val btnReset = view.findViewById<Button>(R.id.btn_reset_settings)
+
+        var isUpdatingUi = false
+
+        fun syncCheckboxes(ui: Map3DUiControls) {
+            isUpdatingUi = true
+            switchAll.isChecked = ui.allEnabled
+            cbZoom.isChecked = ui.zoom
+            cbTilt.isChecked = ui.tilt
+            cbRotate.isChecked = ui.rotate
+            cbCompass.isChecked = ui.compass
+            cbPanV.isChecked = ui.panVertical
+            cbPanH.isChecked = ui.panHorizontal
+            isUpdatingUi = false
+        }
+
+        fun syncAllControls(settings: Map3DSettings) {
+            isUpdatingUi = true
+            val modeId = when (settings.mapMode) {
+                Map3DMode.SATELLITE -> R.id.rb_mode_satellite
+                Map3DMode.ROADMAP -> R.id.rb_mode_roadmap
+                else -> R.id.rb_mode_hybrid
+            }
+            rgMapMode.check(modeId)
+
+            val schemeId = when (settings.colorScheme) {
+                Map3DColorScheme.LIGHT -> R.id.rb_scheme_light
+                Map3DColorScheme.DARK -> R.id.rb_scheme_dark
+                else -> R.id.rb_scheme_system
+            }
+            rgColorScheme.check(schemeId)
+            isUpdatingUi = false
+
+            syncCheckboxes(settings.uiControls)
+        }
+
+        syncAllControls(controller.getSettings())
+
+        // Listen for Map Mode changes
+        rgMapMode.setOnCheckedChangeListener { _, checkedId ->
+            if (isUpdatingUi) return@setOnCheckedChangeListener
+            val newMode = when (checkedId) {
+                R.id.rb_mode_satellite -> Map3DMode.SATELLITE
+                R.id.rb_mode_roadmap -> Map3DMode.ROADMAP
+                else -> Map3DMode.HYBRID
+            }
+            controller.setMapMode(newMode)
+        }
+
+        // Listen for Color Scheme changes
+        rgColorScheme.setOnCheckedChangeListener { _, checkedId ->
+            if (isUpdatingUi) return@setOnCheckedChangeListener
+            val newScheme = when (checkedId) {
+                R.id.rb_scheme_light -> Map3DColorScheme.LIGHT
+                R.id.rb_scheme_dark -> Map3DColorScheme.DARK
+                else -> Map3DColorScheme.FOLLOW_SYSTEM
+            }
+            controller.setColorScheme(newScheme)
+        }
+
+        // Master switch toggle
+        switchAll.setOnCheckedChangeListener { _, isChecked ->
+            if (isUpdatingUi) return@setOnCheckedChangeListener
+            val updated = controller.setAllUiControls(isChecked)
+            syncCheckboxes(updated.uiControls)
+        }
+
+        // Helper for individual checkboxes
+        fun onIndividualControlToggled() {
+            if (isUpdatingUi) return
+            val updated = controller.updateUiControl(
+                zoom = cbZoom.isChecked,
+                tilt = cbTilt.isChecked,
+                rotate = cbRotate.isChecked,
+                compass = cbCompass.isChecked,
+                panVertical = cbPanV.isChecked,
+                panHorizontal = cbPanH.isChecked,
+            )
+            isUpdatingUi = true
+            switchAll.isChecked = updated.uiControls.allEnabled
+            isUpdatingUi = false
+        }
+
+        cbZoom.setOnCheckedChangeListener { _, _ -> onIndividualControlToggled() }
+        cbTilt.setOnCheckedChangeListener { _, _ -> onIndividualControlToggled() }
+        cbRotate.setOnCheckedChangeListener { _, _ -> onIndividualControlToggled() }
+        cbCompass.setOnCheckedChangeListener { _, _ -> onIndividualControlToggled() }
+        cbPanV.setOnCheckedChangeListener { _, _ -> onIndividualControlToggled() }
+        cbPanH.setOnCheckedChangeListener { _, _ -> onIndividualControlToggled() }
+
+        btnReset?.setOnClickListener {
+            val resetSettings = controller.reset(sampleDefaultMapMode)
+            syncAllControls(resetSettings)
+        }
+
+        val dialog = MaterialAlertDialogBuilder(context)
+            .setTitle(R.string.map3d_settings_title)
+            .setView(view)
+            .setPositiveButton(R.string.map3d_settings_done) { d, _ ->
+                d.dismiss()
+            }
+            .setOnDismissListener {
+                onDismiss?.invoke()
+            }
+            .create()
+
+        dialog.window?.setFlags(
+            WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE,
+            WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE,
+        )
+        dialog.show()
+        dialog.window?.let { dialogWindow ->
+            val insetsController = WindowCompat.getInsetsController(dialogWindow, dialogWindow.decorView)
+            insetsController.systemBarsBehavior =
+                WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
+            insetsController.hide(WindowInsetsCompat.Type.systemBars())
+            dialogWindow.clearFlags(WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE)
+        }
+        return dialog
+    }
+}
+// [END maps_3d_quick_settings_dialog]
diff --git a/Maps3DSamples/ApiDemos/common/src/main/java/com/example/maps3d/common/Map3DQuickSettingsWidget.kt b/Maps3DSamples/ApiDemos/common/src/main/java/com/example/maps3d/common/Map3DQuickSettingsWidget.kt
new file mode 100644
index 00000000..2852ee46
--- /dev/null
+++ b/Maps3DSamples/ApiDemos/common/src/main/java/com/example/maps3d/common/Map3DQuickSettingsWidget.kt
@@ -0,0 +1,374 @@
+/*
+ * Copyright 2026 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.example.maps3d.common
+
+import android.app.Activity
+import android.content.Context
+import android.content.ContextWrapper
+import androidx.compose.foundation.isSystemInDarkTheme
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.selection.selectable
+import androidx.compose.foundation.selection.selectableGroup
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.Checkbox
+import androidx.compose.material3.FloatingActionButton
+import androidx.compose.material3.HorizontalDivider
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.RadioButton
+import androidx.compose.material3.Switch
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.material3.darkColorScheme
+import androidx.compose.material3.lightColorScheme
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.SideEffect
+import androidx.compose.runtime.State
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalView
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.semantics.Role
+import androidx.compose.ui.unit.dp
+import androidx.core.view.WindowCompat
+import androidx.core.view.WindowInsetsCompat
+import androidx.core.view.WindowInsetsControllerCompat
+import com.example.maps3dcommon.R
+import com.google.android.gms.maps3d.GoogleMap3D
+import com.google.android.gms.maps3d.model.Map3DMode
+import kotlin.time.Duration.Companion.milliseconds
+import kotlinx.coroutines.delay
+
+// [START maps_3d_quick_settings_compose_widget]
+/**
+ * Remembers and observes the application-level [Map3DSettings] session state for a Compose screen.
+ *
+ * Automatically notifies [controller] via [Map3DSettingsController.onSampleEntered] with
+ * [defaultMapMode] so that if the user has not explicitly overridden the map mode during the
+ * current session, the sample starts in its natural default mode.
+ *
+ * @param defaultMapMode The sample's default [Map3DMode] (defaults to [Map3DMode.HYBRID]).
+ * @param controller The [Map3DSettingsController] managing session state.
+ */
+@Composable
+fun rememberMap3DSessionSettings(
+    @Map3DMode defaultMapMode: Int = Map3DMode.HYBRID,
+    controller: Map3DSettingsController = Map3DSettingsController.shared,
+): State<Map3DSettings> {
+    val view = LocalView.current
+    if (!view.isInEditMode) {
+        SideEffect {
+            var ctx: Context? = view.context
+            while (ctx is ContextWrapper) {
+                if (ctx is Activity) {
+                    val window = ctx.window
+                    val insetsController = WindowCompat.getInsetsController(window, window.decorView)
+                    insetsController.systemBarsBehavior =
+                        WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
+                    insetsController.hide(WindowInsetsCompat.Type.systemBars())
+                    break
+                }
+                ctx = ctx.baseContext
+            }
+        }
+    }
+    remember(defaultMapMode, controller) {
+        controller.onSampleEntered(defaultMapMode)
+        true
+    }
+    return controller.settings.collectAsState()
+}
+
+/**
+ * Material3 theme wrapper that selects [darkColorScheme] or [lightColorScheme] based on
+ * the current [Map3DSettings.colorScheme] in [controller].
+ */
+@Composable
+fun Map3DSessionTheme(
+    controller: Map3DSettingsController = Map3DSettingsController.shared,
+    content: @Composable () -> Unit,
+) {
+    val settings by controller.settings.collectAsState()
+    val useDarkTheme = when (settings.colorScheme) {
+        Map3DColorScheme.LIGHT -> false
+        Map3DColorScheme.DARK -> true
+        Map3DColorScheme.FOLLOW_SYSTEM -> isSystemInDarkTheme()
+    }
+    MaterialTheme(
+        colorScheme = if (useDarkTheme) darkColorScheme() else lightColorScheme(),
+        content = content,
+    )
+}
+
+/**
+ * A self-contained Jetpack Compose quick settings widget for 3D map layouts.
+ *
+ * Renders a compact [FloatingActionButton] that opens a modal [AlertDialog] to select
+ * Map Mode (Satellite, Hybrid, Roadmap), Color Scheme (Follow System, Light, Dark),
+ * toggle camera UI controls, and reset to defaults.
+ *
+ * @param modifier Layout modifier applied to the button (e.g. alignment inside a Box).
+ * @param settingsController The [Map3DSettingsController] backing the widget (defaults to [Map3DSettingsController.shared]).
+ * @param sampleDefaultMapMode The hosting sample's default [Map3DMode] restored on Reset.
+ * @param googleMap3D Optional live [GoogleMap3D] instance to automatically apply settings changes.
+ * @param onSettingsChanged Optional callback invoked when map settings are modified.
+ */
+@Composable
+fun Map3DQuickSettingsWidget(
+    modifier: Modifier = Modifier,
+    settingsController: Map3DSettingsController = Map3DSettingsController.shared,
+    @Map3DMode sampleDefaultMapMode: Int = Map3DMode.HYBRID,
+    googleMap3D: GoogleMap3D? = null,
+    onSettingsChanged: (Map3DSettings) -> Unit = {},
+) {
+    val settings by settingsController.settings.collectAsState()
+    var showDialog by remember { mutableStateOf(false) }
+
+    LaunchedEffect(googleMap3D, settings) {
+        if (googleMap3D != null) {
+            settings.applyTo(googleMap3D)
+        }
+    }
+
+    LaunchedEffect(googleMap3D) {
+        if (googleMap3D != null) {
+            delay(350.milliseconds)
+            settingsController.settings.value.applyTo(googleMap3D)
+        }
+    }
+
+    val extraTopPadding = (settings.uiControls.calculateFabMarginDp() - 8).coerceAtLeast(0).dp
+
+    Map3DSessionTheme(controller = settingsController) {
+        FloatingActionButton(
+            onClick = { showDialog = true },
+            modifier = modifier
+                .padding(top = extraTopPadding, end = 8.dp)
+                .size(40.dp),
+            containerColor = MaterialTheme.colorScheme.surfaceContainerHigh,
+            contentColor = MaterialTheme.colorScheme.onSurface,
+        ) {
+            Icon(
+                painter = painterResource(id = R.drawable.settings_24px),
+                contentDescription = stringResource(id = R.string.map3d_settings_button_description),
+                modifier = Modifier.size(20.dp),
+            )
+        }
+
+        if (showDialog) {
+        AlertDialog(
+            onDismissRequest = { showDialog = false },
+            title = {
+                Text(
+                    text = stringResource(id = R.string.map3d_settings_title),
+                    style = MaterialTheme.typography.titleMedium,
+                )
+            },
+            text = {
+                Column(Modifier.verticalScroll(rememberScrollState())) {
+                    // Map Mode Section
+                    Text(
+                        text = stringResource(id = R.string.map3d_mode_section),
+                        style = MaterialTheme.typography.titleSmall,
+                        color = MaterialTheme.colorScheme.primary,
+                        modifier = Modifier.padding(bottom = 4.dp),
+                    )
+
+                    Column(Modifier.selectableGroup()) {
+                        val modes = listOf(
+                            Map3DMode.SATELLITE to stringResource(id = R.string.map3d_mode_satellite),
+                            Map3DMode.HYBRID to stringResource(id = R.string.map3d_mode_hybrid),
+                            Map3DMode.ROADMAP to stringResource(id = R.string.map3d_mode_roadmap),
+                        )
+                        modes.forEach { (mode, label) ->
+                            Row(
+                                modifier = Modifier
+                                    .fillMaxWidth()
+                                    .height(40.dp)
+                                    .selectable(
+                                        selected = (settings.mapMode == mode),
+                                        onClick = {
+                                            val updated = settingsController.setMapMode(mode)
+                                            onSettingsChanged(updated)
+                                        },
+                                        role = Role.RadioButton,
+                                    ),
+                                verticalAlignment = Alignment.CenterVertically,
+                            ) {
+                                RadioButton(
+                                    selected = (settings.mapMode == mode),
+                                    onClick = null,
+                                )
+                                Text(
+                                    text = label,
+                                    style = MaterialTheme.typography.bodyMedium,
+                                    modifier = Modifier.padding(start = 8.dp),
+                                )
+                            }
+                        }
+                    }
+
+                    HorizontalDivider(modifier = Modifier.padding(vertical = 12.dp))
+
+                    // Color Scheme Section
+                    Text(
+                        text = stringResource(id = R.string.map3d_color_scheme_section),
+                        style = MaterialTheme.typography.titleSmall,
+                        color = MaterialTheme.colorScheme.primary,
+                        modifier = Modifier.padding(bottom = 4.dp),
+                    )
+
+                    Column(Modifier.selectableGroup()) {
+                        val schemes = listOf(
+                            Map3DColorScheme.FOLLOW_SYSTEM to stringResource(id = R.string.map3d_color_scheme_system),
+                            Map3DColorScheme.LIGHT to stringResource(id = R.string.map3d_color_scheme_light),
+                            Map3DColorScheme.DARK to stringResource(id = R.string.map3d_color_scheme_dark),
+                        )
+                        schemes.forEach { (scheme, label) ->
+                            Row(
+                                modifier = Modifier
+                                    .fillMaxWidth()
+                                    .height(40.dp)
+                                    .selectable(
+                                        selected = (settings.colorScheme == scheme),
+                                        onClick = {
+                                            val updated = settingsController.setColorScheme(scheme)
+                                            onSettingsChanged(updated)
+                                        },
+                                        role = Role.RadioButton,
+                                    ),
+                                verticalAlignment = Alignment.CenterVertically,
+                            ) {
+                                RadioButton(
+                                    selected = (settings.colorScheme == scheme),
+                                    onClick = null,
+                                )
+                                Text(
+                                    text = label,
+                                    style = MaterialTheme.typography.bodyMedium,
+                                    modifier = Modifier.padding(start = 8.dp),
+                                )
+                            }
+                        }
+                    }
+
+                    HorizontalDivider(modifier = Modifier.padding(vertical = 12.dp))
+
+                    // UI Controls Section
+                    Row(
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .height(40.dp),
+                        verticalAlignment = Alignment.CenterVertically,
+                        horizontalArrangement = Arrangement.SpaceBetween,
+                    ) {
+                        Text(
+                            text = stringResource(id = R.string.map3d_controls_section),
+                            style = MaterialTheme.typography.titleSmall,
+                            color = MaterialTheme.colorScheme.primary,
+                        )
+                        Switch(
+                            checked = settings.uiControls.allEnabled,
+                            onCheckedChange = { checked ->
+                                val updated = settingsController.setAllUiControls(checked)
+                                onSettingsChanged(updated)
+                            },
+                        )
+                    }
+
+                    val controlItems = listOf(
+                        Triple(stringResource(id = R.string.map3d_control_zoom), settings.uiControls.zoom) { checked: Boolean ->
+                            val updated = settingsController.updateUiControl(zoom = checked)
+                            onSettingsChanged(updated)
+                        },
+                        Triple(stringResource(id = R.string.map3d_control_tilt), settings.uiControls.tilt) { checked: Boolean ->
+                            val updated = settingsController.updateUiControl(tilt = checked)
+                            onSettingsChanged(updated)
+                        },
+                        Triple(stringResource(id = R.string.map3d_control_rotate), settings.uiControls.rotate) { checked: Boolean ->
+                            val updated = settingsController.updateUiControl(rotate = checked)
+                            onSettingsChanged(updated)
+                        },
+                        Triple(stringResource(id = R.string.map3d_control_pan_v), settings.uiControls.panVertical) { checked: Boolean ->
+                            val updated = settingsController.updateUiControl(panVertical = checked)
+                            onSettingsChanged(updated)
+                        },
+                        Triple(stringResource(id = R.string.map3d_control_pan_h), settings.uiControls.panHorizontal) { checked: Boolean ->
+                            val updated = settingsController.updateUiControl(panHorizontal = checked)
+                            onSettingsChanged(updated)
+                        },
+                        Triple(stringResource(id = R.string.map3d_control_compass), settings.uiControls.compass) { checked: Boolean ->
+                            val updated = settingsController.updateUiControl(compass = checked)
+                            onSettingsChanged(updated)
+                        },
+                    )
+
+                    controlItems.forEach { (label, isChecked, onToggle) ->
+                        Row(
+                            modifier = Modifier
+                                .fillMaxWidth()
+                                .height(40.dp),
+                            verticalAlignment = Alignment.CenterVertically,
+                        ) {
+                            Checkbox(
+                                checked = isChecked,
+                                onCheckedChange = onToggle,
+                            )
+                            Text(
+                                text = label,
+                                style = MaterialTheme.typography.bodyMedium,
+                                modifier = Modifier.padding(start = 8.dp),
+                            )
+                        }
+                    }
+                }
+            },
+            dismissButton = {
+                TextButton(
+                    onClick = {
+                        val updated = settingsController.reset(sampleDefaultMapMode)
+                        onSettingsChanged(updated)
+                    },
+                ) {
+                    Text(text = stringResource(id = R.string.map3d_settings_reset))
+                }
+            },
+            confirmButton = {
+                TextButton(onClick = { showDialog = false }) {
+                    Text(text = stringResource(id = R.string.map3d_settings_done))
+                }
+            },
+        )
+        }
+    }
+}
+// [END maps_3d_quick_settings_compose_widget]
diff --git a/Maps3DSamples/ApiDemos/common/src/main/java/com/example/maps3d/common/Map3DSettings.kt b/Maps3DSamples/ApiDemos/common/src/main/java/com/example/maps3d/common/Map3DSettings.kt
new file mode 100644
index 00000000..2538cea6
--- /dev/null
+++ b/Maps3DSamples/ApiDemos/common/src/main/java/com/example/maps3d/common/Map3DSettings.kt
@@ -0,0 +1,258 @@
+/*
+ * Copyright 2026 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.example.maps3d.common
+
+import android.annotation.SuppressLint
+import android.util.Log
+import android.view.View
+import android.view.ViewGroup
+import androidx.appcompat.app.AppCompatDelegate
+import androidx.core.view.ViewCompat
+import androidx.core.view.WindowInsetsCompat
+import androidx.core.view.isVisible
+import com.example.maps3dcommon.R
+import com.google.android.gms.maps3d.GoogleMap3D
+import com.google.android.gms.maps3d.UiControlSettings.ControlOrientation
+import com.google.android.gms.maps3d.UiControlSettings.ControlPlacement
+import com.google.android.gms.maps3d.model.CompassControl
+import com.google.android.gms.maps3d.model.Map3DControl
+import com.google.android.gms.maps3d.model.Map3DMode
+import com.google.android.gms.maps3d.model.PanHorizontalControl
+import com.google.android.gms.maps3d.model.PanVerticalControl
+import com.google.android.gms.maps3d.model.RotateControl
+import com.google.android.gms.maps3d.model.TiltControl
+import com.google.android.gms.maps3d.model.ZoomControl
+
+// [START maps_3d_quick_settings_model]
+/**
+ * Supported color schemes for 3D map and sample UI styling.
+ */
+enum class Map3DColorScheme(val value: Int) {
+    FOLLOW_SYSTEM(2),
+    LIGHT(0),
+    DARK(1);
+
+    companion object {
+        fun fromValue(value: Int): Map3DColorScheme {
+            return entries.firstOrNull { it.value == value } ?: FOLLOW_SYSTEM
+        }
+    }
+}
+
+// [START maps_3d_quick_settings_ui_controls_model]
+/**
+ * Visibility and placement state for built-in 3D camera UI controls.
+ *
+ * @property zoom Zoom in/out (+ / -) control.
+ * @property tilt Pitch up/down control.
+ * @property rotate Heading rotation (CW / CCW) control.
+ * @property compass North orientation indicator & reset control.
+ * @property panVertical North/South pan control.
+ * @property panHorizontal East/West pan control.
+ * @property controlsPosition Screen edge for main controls ([ControlPlacement.TRAILING] or [ControlPlacement.LEADING]); pan and compass controls are placed on the opposite edge.
+ */
+data class Map3DUiControls @JvmOverloads constructor(
+    val zoom: Boolean = true,
+    val tilt: Boolean = true,
+    val rotate: Boolean = true,
+    val compass: Boolean = true,
+    val panVertical: Boolean = true,
+    val panHorizontal: Boolean = true,
+    @param:ControlPlacement @get:ControlPlacement
+    val controlsPosition: Int = ControlPlacement.TRAILING,
+) {
+    val allEnabled: Boolean
+        get() = zoom && tilt && rotate && compass && panVertical && panHorizontal
+
+    val noneEnabled: Boolean
+        get() = !zoom && !tilt && !rotate && !compass && !panVertical && !panHorizontal
+
+    fun withAll(enabled: Boolean): Map3DUiControls = copy(
+        zoom = enabled,
+        tilt = enabled,
+        rotate = enabled,
+        compass = enabled,
+        panVertical = enabled,
+        panHorizontal = enabled,
+    )
+
+    /**
+     * Calculates the top margin (in dp) required to place a floating action button directly
+     * below the active top-anchored trailing camera controls.
+     *
+     * SDK control dimensions:
+     * - Dual-button controls (Zoom, Tilt, Rotate, Pan): 104dp (two 48dp touch targets + 8dp spacing).
+     * - Single-button control (Compass): 56dp (48dp touch target + padding).
+     * - Inter-control and screen edge spacing: 16dp initial offset + 8dp margin per visible control.
+     */
+    fun calculateFabMarginDp(): Int {
+        var totalHeightDp = 0
+        if (controlsPosition == ControlPlacement.LEADING) {
+            if (panVertical) totalHeightDp += 104
+            if (panHorizontal) totalHeightDp += 104
+            if (compass) totalHeightDp += 56
+        } else {
+            if (zoom) totalHeightDp += 104
+            if (tilt) totalHeightDp += 104
+            if (rotate) totalHeightDp += 104
+        }
+        return if (totalHeightDp > 0) 16 + totalHeightDp + 8 else 16
+    }
+}
+// [END maps_3d_quick_settings_ui_controls_model]
+
+/**
+ * Immutable configuration snapshot for 3D map-level settings.
+ *
+ * Encapsulates global rendering options that apply to the 3D map surface itself
+ * rather than individual scene objects (markers, polylines, or models).
+ *
+ * @property mapMode The 3D map rendering mode: [Map3DMode.HYBRID], [Map3DMode.SATELLITE], or [Map3DMode.ROADMAP].
+ * @property colorScheme The map color scheme: [Map3DColorScheme.FOLLOW_SYSTEM], [Map3DColorScheme.LIGHT], or [Map3DColorScheme.DARK].
+ * @property uiControls Visibility state for built-in 3D camera UI controls.
+ */
+data class Map3DSettings(
+    @param:Map3DMode @get:Map3DMode val mapMode: Int = Map3DMode.HYBRID,
+    val colorScheme: Map3DColorScheme = Map3DColorScheme.FOLLOW_SYSTEM,
+    val uiControls: Map3DUiControls = Map3DUiControls(),
+) {
+    /**
+     * Applies this configuration to a live [GoogleMap3D] instance and updates app day/night theme.
+     */
+    fun applyTo(googleMap3D: GoogleMap3D) {
+        googleMap3D.setMapMode(mapMode)
+
+        // Apply dark / light mode via AppCompatDelegate
+        val nightMode = when (colorScheme) {
+            Map3DColorScheme.LIGHT -> AppCompatDelegate.MODE_NIGHT_NO
+            Map3DColorScheme.DARK -> AppCompatDelegate.MODE_NIGHT_YES
+            Map3DColorScheme.FOLLOW_SYSTEM -> AppCompatDelegate.MODE_NIGHT_FOLLOW_SYSTEM
+        }
+        if (AppCompatDelegate.getDefaultNightMode() != nightMode) {
+            AppCompatDelegate.setDefaultNightMode(nightMode)
+        }
+
+        // Forward to SDK delegate if available at runtime
+        try {
+            val method = googleMap3D.javaClass.getMethod(
+                "setMapColorScheme",
+                Int::class.javaPrimitiveType,
+            )
+            method.invoke(googleMap3D, colorScheme.value)
+        } catch (_: NoSuchMethodException) {
+            // Unexported in current SDK RC client stub; handled by AppCompatDelegate
+        } catch (e: Exception) {
+            Log.w("Map3DSettings", "Could not apply colorScheme directly to GoogleMap3D", e)
+        }
+
+        // Apply built-in UI controls configuration
+        try {
+            googleMap3D.getUiControlSettings()?.let { settings ->
+                val mainControls = mutableListOf<Map3DControl>()
+                if (uiControls.zoom) mainControls.add(ZoomControl(ControlOrientation.VERTICAL))
+                if (uiControls.tilt) mainControls.add(TiltControl(ControlOrientation.VERTICAL))
+                if (uiControls.rotate) mainControls.add(RotateControl(ControlOrientation.VERTICAL))
+
+                val panControls = mutableListOf<Map3DControl>()
+                if (uiControls.panVertical) panControls.add(PanVerticalControl(ControlOrientation.VERTICAL))
+                if (uiControls.panHorizontal) panControls.add(PanHorizontalControl(ControlOrientation.VERTICAL))
+                if (uiControls.compass) panControls.add(CompassControl())
+
+                val mainPosition = if (uiControls.controlsPosition == ControlPlacement.LEADING) {
+                    ControlPlacement.LEADING
+                } else {
+                    ControlPlacement.TRAILING
+                }
+                val panPosition = if (mainPosition == ControlPlacement.TRAILING) {
+                    ControlPlacement.LEADING
+                } else {
+                    ControlPlacement.TRAILING
+                }
+
+                settings.setUiControlsPlacement(mainControls, mainPosition)
+                settings.setUiControlsPlacement(panControls, panPosition)
+            }
+        } catch (e: Throwable) {
+            Log.e("Map3DSettings", "Could not apply UI controls placement to GoogleMap3D", e)
+        }
+    }
+
+    companion object {
+        /**
+         * Resolves the status bar height (in pixels) for the given [view].
+         */
+        @SuppressLint("InternalInsetResource", "DiscouragedApi")
+        @JvmStatic
+        @JvmOverloads
+        fun resolveStatusBarHeightPx(view: View, explicitStatusBarTop: Int? = null): Int {
+            if (explicitStatusBarTop != null && explicitStatusBarTop > 0) {
+                return explicitStatusBarTop
+            }
+            val rootInsets = ViewCompat.getRootWindowInsets(view)
+            if (rootInsets != null) {
+                val barType = WindowInsetsCompat.Type.statusBars() or
+                    WindowInsetsCompat.Type.displayCutout()
+                val visibleTop = rootInsets.getInsets(barType).top
+                if (visibleTop > 0) {
+                    return visibleTop
+                }
+                if (!rootInsets.isVisible(WindowInsetsCompat.Type.statusBars())) {
+                    return rootInsets.getInsets(WindowInsetsCompat.Type.displayCutout()).top
+                }
+            }
+            val resId = view.resources.getIdentifier("status_bar_height", "dimen", "android")
+            return if (resId > 0) view.resources.getDimensionPixelSize(resId) else 0
+        }
+
+        /**
+         * Computes how many vertical pixels of the status bar overlap the top of [view].
+         *
+         * Returns `> 0` for full-screen maps that extend behind the status bar, and `0` when
+         * the map is positioned below a non-overlay toolbar (`top_bar`).
+         */
+        @JvmStatic
+        @JvmOverloads
+        fun resolveStatusBarOverlapPx(view: View, explicitStatusBarTop: Int? = null): Int {
+            val parentView = view.parent as? ViewGroup
+            val topBar = parentView?.findViewById<View?>(R.id.top_bar)
+            val appBarLayout = parentView?.findViewById<View?>(R.id.app_bar_layout)
+            if (topBar != null && appBarLayout == null) {
+                if (view.isLaidOut && topBar.isLaidOut && topBar.isVisible) {
+                    val viewLoc = IntArray(2)
+                    val barLoc = IntArray(2)
+                    view.getLocationInWindow(viewLoc)
+                    topBar.getLocationInWindow(barLoc)
+                    val barBottom = barLoc[1] + topBar.height
+                    return (barBottom - viewLoc[1]).coerceAtLeast(0)
+                }
+                return 0
+            }
+            val statusBarTop = resolveStatusBarHeightPx(view, explicitStatusBarTop)
+            if (statusBarTop <= 0) return 0
+
+            return if (view.isLaidOut) {
+                val location = IntArray(2)
+                view.getLocationInWindow(location)
+                val viewTopInWindow = location[1]
+                (statusBarTop - viewTopInWindow).coerceAtLeast(0)
+            } else {
+                statusBarTop
+            }
+        }
+    }
+}
+// [END maps_3d_quick_settings_model]
diff --git a/Maps3DSamples/ApiDemos/common/src/main/java/com/example/maps3d/common/Map3DSettingsController.kt b/Maps3DSamples/ApiDemos/common/src/main/java/com/example/maps3d/common/Map3DSettingsController.kt
new file mode 100644
index 00000000..9423748d
--- /dev/null
+++ b/Maps3DSamples/ApiDemos/common/src/main/java/com/example/maps3d/common/Map3DSettingsController.kt
@@ -0,0 +1,232 @@
+/*
+ * Copyright 2026 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.example.maps3d.common
+
+import com.google.android.gms.maps3d.UiControlSettings.ControlPlacement
+import com.google.android.gms.maps3d.model.Map3DMode
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+
+// [START maps_3d_quick_settings_controller]
+/**
+ * Pure Kotlin state machine controller for managing 3D map settings.
+ *
+ * Manages transitions between map rendering modes, color schemes, and camera UI controls.
+ * Completely decoupled from Android UI and Views for deterministic JVM unit testing.
+ *
+ * @param initialSettings Initial settings snapshot (defaults to [Map3DMode.HYBRID] and [Map3DColorScheme.FOLLOW_SYSTEM]).
+ */
+class Map3DSettingsController(
+    initialSettings: Map3DSettings = Map3DSettings(),
+) {
+    companion object {
+        /**
+         * Application-scoped in-memory singleton instance.
+         *
+         * Persists user choices across sample activities during a single app session
+         * and resets cleanly when a new process session starts.
+         */
+        @JvmStatic
+        val shared = Map3DSettingsController()
+    }
+
+    private val _settings = MutableStateFlow(initialSettings)
+
+    /** Reactive stream of the current [Map3DSettings] snapshot. */
+    @get:JvmName("getSettingsFlow")
+    val settings: StateFlow<Map3DSettings> = _settings.asStateFlow()
+
+    /**
+     * Tracks whether the user has explicitly selected a Map Mode during the current session.
+     *
+     * When `false`, entering a sample via [onSampleEntered] adopts that sample's default map mode.
+     * When `true`, the user's explicit choice is preserved across all samples until [reset] is called.
+     */
+    var hasUserOverriddenMapMode: Boolean = false
+        private set
+
+    private val listeners = mutableListOf<(Map3DSettings) -> Unit>()
+
+    /** Returns the current [Map3DSettings] snapshot. */
+    fun getSettings(): Map3DSettings = _settings.value
+
+    /**
+     * Called when a sample activity or screen is entered.
+     *
+     * If the user has not explicitly overridden the map mode during this session,
+     * updates the active map mode to [sampleDefaultMapMode].
+     */
+    fun onSampleEntered(@Map3DMode sampleDefaultMapMode: Int) {
+        if (!hasUserOverriddenMapMode) {
+            val sanitized = sanitizeMapMode(sampleDefaultMapMode) ?: return
+            if (sanitized != _settings.value.mapMode) {
+                _settings.value = _settings.value.copy(mapMode = sanitized)
+                notifyListeners()
+            }
+        }
+    }
+
+    /**
+     * Resets all settings to defaults (`FOLLOW_SYSTEM`, all UI controls enabled,
+     * and [sampleDefaultMapMode]) and clears [hasUserOverriddenMapMode].
+     */
+    @JvmOverloads
+    fun reset(@Map3DMode sampleDefaultMapMode: Int = Map3DMode.HYBRID): Map3DSettings {
+        hasUserOverriddenMapMode = false
+        val sanitized = sanitizeMapMode(sampleDefaultMapMode) ?: Map3DMode.HYBRID
+        val defaultSettings = Map3DSettings(mapMode = sanitized)
+        if (_settings.value != defaultSettings) {
+            _settings.value = defaultSettings
+            notifyListeners()
+        }
+        return _settings.value
+    }
+
+    /**
+     * Updates the map rendering mode ([Map3DMode.SATELLITE], [Map3DMode.HYBRID], or [Map3DMode.ROADMAP]).
+     *
+     * Marks [hasUserOverriddenMapMode] as `true` for valid modes so the user's choice persists
+     * across samples. Invalid or unknown modes are ignored.
+     */
+    fun setMapMode(@Map3DMode mode: Int): Map3DSettings {
+        val sanitized = sanitizeMapMode(mode) ?: return _settings.value
+        hasUserOverriddenMapMode = true
+        if (sanitized == _settings.value.mapMode) {
+            return _settings.value
+        }
+        _settings.value = _settings.value.copy(mapMode = sanitized)
+        notifyListeners()
+        return _settings.value
+    }
+
+    /**
+     * Updates the color scheme ([Map3DColorScheme.FOLLOW_SYSTEM], [Map3DColorScheme.LIGHT], or [Map3DColorScheme.DARK]).
+     */
+    fun setColorScheme(scheme: Map3DColorScheme): Map3DSettings {
+        if (scheme == _settings.value.colorScheme) {
+            return _settings.value
+        }
+        _settings.value = _settings.value.copy(colorScheme = scheme)
+        notifyListeners()
+        return _settings.value
+    }
+
+    /**
+     * Updates the UI controls visibility configuration.
+     */
+    fun setUiControls(uiControls: Map3DUiControls): Map3DSettings {
+        if (uiControls == _settings.value.uiControls) {
+            return _settings.value
+        }
+        _settings.value = _settings.value.copy(uiControls = uiControls)
+        notifyListeners()
+        return _settings.value
+    }
+
+    /**
+     * Toggles all UI controls on or off simultaneously.
+     */
+    fun setAllUiControls(enabled: Boolean): Map3DSettings {
+        return setUiControls(_settings.value.uiControls.withAll(enabled))
+    }
+
+    /**
+     * Updates the screen placement edge ([ControlPlacement.TRAILING] or [ControlPlacement.LEADING])
+     * for the main camera controls, placing pan controls on the opposite edge.
+     */
+    fun setControlsPosition(@ControlPlacement position: Int): Map3DSettings {
+        val sanitized = if (position == ControlPlacement.LEADING) {
+            ControlPlacement.LEADING
+        } else {
+            ControlPlacement.TRAILING
+        }
+        return setUiControls(_settings.value.uiControls.copy(controlsPosition = sanitized))
+    }
+
+    /**
+     * Updates individual UI control visibility or placement flags.
+     */
+    @JvmOverloads
+    fun updateUiControl(
+        zoom: Boolean = _settings.value.uiControls.zoom,
+        tilt: Boolean = _settings.value.uiControls.tilt,
+        rotate: Boolean = _settings.value.uiControls.rotate,
+        compass: Boolean = _settings.value.uiControls.compass,
+        panVertical: Boolean = _settings.value.uiControls.panVertical,
+        panHorizontal: Boolean = _settings.value.uiControls.panHorizontal,
+        @ControlPlacement controlsPosition: Int = _settings.value.uiControls.controlsPosition,
+    ): Map3DSettings {
+        val updatedControls = _settings.value.uiControls.copy(
+            zoom = zoom,
+            tilt = tilt,
+            rotate = rotate,
+            compass = compass,
+            panVertical = panVertical,
+            panHorizontal = panHorizontal,
+            controlsPosition = controlsPosition,
+        )
+        return setUiControls(updatedControls)
+    }
+
+    /**
+     * Replaces the entire settings snapshot.
+     */
+    fun setSettings(newSettings: Map3DSettings): Map3DSettings {
+        if (newSettings == _settings.value) {
+            return _settings.value
+        }
+        val sanitizedMode = sanitizeMapMode(newSettings.mapMode) ?: _settings.value.mapMode
+        if (sanitizedMode != _settings.value.mapMode) {
+            hasUserOverriddenMapMode = true
+        }
+        _settings.value = Map3DSettings(
+            mapMode = sanitizedMode,
+            colorScheme = newSettings.colorScheme,
+            uiControls = newSettings.uiControls,
+        )
+        notifyListeners()
+        return _settings.value
+    }
+
+    /** Registers a listener invoked whenever settings change. */
+    fun addListener(listener: (Map3DSettings) -> Unit) {
+        if (!listeners.contains(listener)) {
+            listeners.add(listener)
+        }
+    }
+
+    /** Unregisters a previously registered listener. */
+    fun removeListener(listener: (Map3DSettings) -> Unit) {
+        listeners.remove(listener)
+    }
+
+    private fun sanitizeMapMode(mode: Int): Int? {
+        return when (mode) {
+            Map3DMode.HYBRID, Map3DMode.SATELLITE, Map3DMode.ROADMAP -> mode
+            else -> null
+        }
+    }
+
+    private fun notifyListeners() {
+        val currentSnapshot = _settings.value
+        for (listener in listeners.toList()) {
+            listener(currentSnapshot)
+        }
+    }
+}
+// [END maps_3d_quick_settings_controller]
diff --git a/Maps3DSamples/ApiDemos/common/src/main/res/drawable/settings_24px.xml b/Maps3DSamples/ApiDemos/common/src/main/res/drawable/settings_24px.xml
new file mode 100644
index 00000000..51fa2bab
--- /dev/null
+++ b/Maps3DSamples/ApiDemos/common/src/main/res/drawable/settings_24px.xml
@@ -0,0 +1,25 @@
+<!--
+  ~ Copyright 2026 Google LLC
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~     https://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+  -->
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="960"
+    android:viewportHeight="960"
+    android:tint="?attr/colorControlNormal">
+  <path
+      android:fillColor="@android:color/white"
+      android:pathData="M440,880Q423,880 411.5,868Q400,856 400,840L400,772Q381,764 363.5,754Q346,744 330,732L268,758Q252,764 237.5,759.5Q223,755 214,741L154,637Q146,623 149.5,607.5Q153,592 166,582L224,538Q222,527 221,514.5Q220,502 220,490Q220,478 221,465.5Q222,453 224,442L166,398Q153,388 149.5,372.5Q146,357 154,343L214,239Q223,225 237.5,220.5Q252,216 268,222L330,248Q346,236 363.5,226Q381,216 400,208L400,140Q400,124 411.5,112Q423,100 440,100L560,100Q577,100 588.5,112Q600,124 600,140L600,208Q619,216 636.5,226Q654,236 670,248L732,222Q748,216 762.5,220.5Q777,225 786,239L846,343Q854,357 850.5,372.5Q847,388 834,398L776,442Q778,453 779,465.5Q780,478 780,490Q780,502 779,514.5Q778,527 776,538L834,582Q847,592 850.5,607.5Q854,623 846,637L786,741Q777,755 762.5,759.5Q748,764 732,758L670,732Q654,744 636.5,754Q619,764 600,772L600,840Q600,856 588.5,868Q577,880 560,880L440,880ZM480,620Q534,620 572,582Q610,544 610,490Q610,436 572,398Q534,360 480,360Q426,360 388,398Q350,436 350,490Q350,544 388,582Q426,620 480,620Z"/>
+</vector>
diff --git a/Maps3DSamples/ApiDemos/common/src/main/res/layout/activity_camera_controls.xml b/Maps3DSamples/ApiDemos/common/src/main/res/layout/activity_camera_controls.xml
index 8b3ebd45..7535018b 100644
--- a/Maps3DSamples/ApiDemos/common/src/main/res/layout/activity_camera_controls.xml
+++ b/Maps3DSamples/ApiDemos/common/src/main/res/layout/activity_camera_controls.xml
@@ -211,4 +211,16 @@
 
     </androidx.cardview.widget.CardView>
 
+    <com.example.maps3d.common.Map3DQuickSettingsButton
+        android:id="@+id/quick_settings_button"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_marginTop="340dp"
+        android:layout_marginEnd="16dp"
+        android:elevation="8dp"
+        android:translationZ="8dp"
+        app:fabCustomSize="40dp"
+        app:layout_constraintEnd_toEndOf="parent"
+        app:layout_constraintTop_toBottomOf="@+id/top_bar" />
+
 </androidx.constraintlayout.widget.ConstraintLayout>
diff --git a/Maps3DSamples/ApiDemos/common/src/main/res/layout/activity_common_map.xml b/Maps3DSamples/ApiDemos/common/src/main/res/layout/activity_common_map.xml
index 175d9f17..a57d52d7 100644
--- a/Maps3DSamples/ApiDemos/common/src/main/res/layout/activity_common_map.xml
+++ b/Maps3DSamples/ApiDemos/common/src/main/res/layout/activity_common_map.xml
@@ -184,4 +184,16 @@
         </LinearLayout>
     </HorizontalScrollView>
 
+    <com.example.maps3d.common.Map3DQuickSettingsButton
+        android:id="@+id/quick_settings_button"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_marginEnd="16dp"
+        android:layout_marginTop="340dp"
+        android:elevation="8dp"
+        android:translationZ="8dp"
+        app:fabCustomSize="40dp"
+        app:layout_constraintEnd_toEndOf="parent"
+        app:layout_constraintTop_toTopOf="parent" />
+
 </androidx.constraintlayout.widget.ConstraintLayout>
diff --git a/Maps3DSamples/ApiDemos/common/src/main/res/layout/activity_hello_map.xml b/Maps3DSamples/ApiDemos/common/src/main/res/layout/activity_hello_map.xml
index 24629f3b..2b23032f 100644
--- a/Maps3DSamples/ApiDemos/common/src/main/res/layout/activity_hello_map.xml
+++ b/Maps3DSamples/ApiDemos/common/src/main/res/layout/activity_hello_map.xml
@@ -53,12 +53,24 @@
         map3d:maxHeading="360"
         map3d:minTilt="0"
         map3d:maxTilt="90"
-        android:layout_width="match_parent"
-        android:layout_height="match_parent"
+        android:layout_width="0dp"
+        android:layout_height="0dp"
         app:layout_constraintBottom_toBottomOf="parent"
         app:layout_constraintEnd_toEndOf="parent"
         app:layout_constraintStart_toStartOf="parent"
         app:layout_constraintTop_toBottomOf="@+id/top_bar"
         />
 
+    <com.example.maps3d.common.Map3DQuickSettingsButton
+        android:id="@+id/quick_settings_button"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_marginTop="340dp"
+        android:layout_marginEnd="16dp"
+        android:elevation="8dp"
+        android:translationZ="8dp"
+        app:fabCustomSize="40dp"
+        app:layout_constraintEnd_toEndOf="parent"
+        app:layout_constraintTop_toBottomOf="@+id/top_bar" />
+
 </androidx.constraintlayout.widget.ConstraintLayout>
diff --git a/Maps3DSamples/ApiDemos/common/src/main/res/layout/activity_map_interactions.xml b/Maps3DSamples/ApiDemos/common/src/main/res/layout/activity_map_interactions.xml
index 5770ef51..e883dd97 100644
--- a/Maps3DSamples/ApiDemos/common/src/main/res/layout/activity_map_interactions.xml
+++ b/Maps3DSamples/ApiDemos/common/src/main/res/layout/activity_map_interactions.xml
@@ -3,6 +3,7 @@
     xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:map3d="http://schemas.android.com/apk/res-auto"
     xmlns:app="http://schemas.android.com/apk/res-auto"
+    android:id="@+id/map_container"
     android:layout_width="match_parent"
     android:layout_height="match_parent"
     >
@@ -56,4 +57,16 @@
         android:contentDescription="@string/map_interactions_clicked_info"
         />
 
+    <com.example.maps3d.common.Map3DQuickSettingsButton
+        android:id="@+id/quick_settings_button"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_marginTop="340dp"
+        android:layout_marginEnd="16dp"
+        android:elevation="8dp"
+        android:translationZ="8dp"
+        app:fabCustomSize="40dp"
+        app:layout_constraintEnd_toEndOf="parent"
+        app:layout_constraintTop_toTopOf="parent" />
+
 </androidx.constraintlayout.widget.ConstraintLayout>
diff --git a/Maps3DSamples/ApiDemos/common/src/main/res/layout/activity_path_following.xml b/Maps3DSamples/ApiDemos/common/src/main/res/layout/activity_path_following.xml
index 3ae39c80..1549b29c 100644
--- a/Maps3DSamples/ApiDemos/common/src/main/res/layout/activity_path_following.xml
+++ b/Maps3DSamples/ApiDemos/common/src/main/res/layout/activity_path_following.xml
@@ -14,19 +14,18 @@
  See the License for the specific language governing permissions and
  limitations under the License.
 -->
-<androidx.coordinatorlayout.widget.CoordinatorLayout
-    xmlns:android="http://schemas.android.com/apk/res/android"
+<androidx.coordinatorlayout.widget.CoordinatorLayout xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:app="http://schemas.android.com/apk/res-auto"
+    xmlns:map3d="http://schemas.android.com/apk/res-auto"
     android:layout_width="match_parent"
-    android:layout_height="match_parent"
-    >
+    android:layout_height="match_parent">
 
     <!-- Fullscreen 3D Map View -->
     <com.google.android.gms.maps3d.Map3DView
         android:id="@+id/map3dView"
         android:layout_width="match_parent"
         android:layout_height="match_parent"
-        />
+        map3d:mapMode="hybrid" />
 
     <!-- Transparent Touch Gesture Overlay replacing built-in map gestures -->
     <View
@@ -482,4 +481,16 @@
         </com.example.maps3d.common.MaxHeightScrollView>
         </LinearLayout>
     </androidx.cardview.widget.CardView>
+
+    <com.example.maps3d.common.Map3DQuickSettingsButton
+        android:id="@+id/quick_settings_button"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_gravity="top|end"
+        android:layout_marginTop="340dp"
+        android:layout_marginEnd="16dp"
+        android:elevation="8dp"
+        android:translationZ="8dp"
+        app:fabCustomSize="40dp" />
+
 </androidx.coordinatorlayout.widget.CoordinatorLayout>
diff --git a/Maps3DSamples/ApiDemos/common/src/main/res/layout/control_panel_ui_controls.xml b/Maps3DSamples/ApiDemos/common/src/main/res/layout/control_panel_ui_controls.xml
new file mode 100644
index 00000000..f9fc49b8
--- /dev/null
+++ b/Maps3DSamples/ApiDemos/common/src/main/res/layout/control_panel_ui_controls.xml
@@ -0,0 +1,233 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+ Copyright 2026 Google LLC
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-->
+<androidx.cardview.widget.CardView
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    android:id="@+id/control_panel"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    app:cardElevation="8dp"
+    app:cardCornerRadius="16dp"
+    android:layout_margin="12dp"
+    app:layout_constraintBottom_toBottomOf="parent"
+    app:layout_constraintStart_toStartOf="parent"
+    app:layout_constraintEnd_toEndOf="parent"
+    >
+
+    <LinearLayout
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:orientation="vertical"
+        >
+
+        <!-- Card Header with title and collapse/expand button -->
+        <LinearLayout
+            android:id="@+id/card_header"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:orientation="horizontal"
+            android:gravity="center_vertical"
+            android:paddingStart="16dp"
+            android:paddingEnd="8dp"
+            android:paddingTop="8dp"
+            android:paddingBottom="4dp"
+            >
+
+            <TextView
+                android:layout_width="0dp"
+                android:layout_height="wrap_content"
+                android:layout_weight="1"
+                android:text="@string/ui_controls_panel_title"
+                style="@style/TextAppearance.Material3.TitleSmall"
+                android:textStyle="bold"
+                />
+
+            <com.google.android.material.button.MaterialButton
+                android:id="@+id/btn_collapse"
+                style="?attr/materialIconButtonStyle"
+                android:layout_width="36dp"
+                android:layout_height="36dp"
+                android:padding="0dp"
+                app:icon="@drawable/expand_more_24px"
+                app:iconSize="20dp"
+                app:iconTint="?attr/colorOnSurfaceVariant"
+                android:contentDescription="@string/collapse_controls"
+                />
+        </LinearLayout>
+
+        <!-- Collapsible Content Section -->
+        <LinearLayout
+            android:id="@+id/card_content"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:orientation="vertical"
+            android:paddingStart="16dp"
+            android:paddingEnd="16dp"
+            android:paddingBottom="12dp"
+            >
+
+            <!-- Quick Preset Buttons: Show All / Hide All -->
+            <LinearLayout
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:orientation="horizontal"
+                android:gravity="center_vertical"
+                >
+
+                <TextView
+                    android:layout_width="0dp"
+                    android:layout_height="wrap_content"
+                    android:layout_weight="1"
+                    android:text="@string/ui_controls_visibility_label"
+                    style="@style/TextAppearance.Material3.LabelMedium"
+                    />
+
+                <com.google.android.material.button.MaterialButton
+                    android:id="@+id/btn_show_all"
+                    style="@style/Widget.Material3.Button.TextButton"
+                    android:layout_width="wrap_content"
+                    android:layout_height="36dp"
+                    android:minWidth="0dp"
+                    android:minHeight="0dp"
+                    android:paddingHorizontal="10dp"
+                    android:paddingVertical="0dp"
+                    android:text="@string/ui_controls_show_all"
+                    />
+
+                <com.google.android.material.button.MaterialButton
+                    android:id="@+id/btn_hide_all"
+                    style="@style/Widget.Material3.Button.TextButton"
+                    android:layout_width="wrap_content"
+                    android:layout_height="36dp"
+                    android:minWidth="0dp"
+                    android:minHeight="0dp"
+                    android:paddingHorizontal="10dp"
+                    android:paddingVertical="0dp"
+                    android:text="@string/ui_controls_hide_all"
+                    />
+            </LinearLayout>
+
+            <!-- FilterChips for individual 3D Camera UI Controls -->
+            <com.google.android.material.chip.ChipGroup
+                android:id="@+id/chip_group_controls"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                app:singleSelection="false"
+                app:chipSpacingHorizontal="6dp"
+                app:chipSpacingVertical="2dp"
+                >
+
+                <com.google.android.material.chip.Chip
+                    android:id="@+id/chip_zoom"
+                    style="@style/Widget.Material3.Chip.Filter"
+                    android:layout_width="wrap_content"
+                    android:layout_height="wrap_content"
+                    android:checkable="true"
+                    android:checked="true"
+                    android:text="@string/ui_control_chip_zoom"
+                    />
+
+                <com.google.android.material.chip.Chip
+                    android:id="@+id/chip_tilt"
+                    style="@style/Widget.Material3.Chip.Filter"
+                    android:layout_width="wrap_content"
+                    android:layout_height="wrap_content"
+                    android:checkable="true"
+                    android:checked="true"
+                    android:text="@string/ui_control_chip_tilt"
+                    />
+
+                <com.google.android.material.chip.Chip
+                    android:id="@+id/chip_rotate"
+                    style="@style/Widget.Material3.Chip.Filter"
+                    android:layout_width="wrap_content"
+                    android:layout_height="wrap_content"
+                    android:checkable="true"
+                    android:checked="true"
+                    android:text="@string/ui_control_chip_rotate"
+                    />
+
+                <com.google.android.material.chip.Chip
+                    android:id="@+id/chip_pan_vertical"
+                    style="@style/Widget.Material3.Chip.Filter"
+                    android:layout_width="wrap_content"
+                    android:layout_height="wrap_content"
+                    android:checkable="true"
+                    android:checked="true"
+                    android:text="@string/ui_control_chip_pan_vertical"
+                    />
+
+                <com.google.android.material.chip.Chip
+                    android:id="@+id/chip_pan_horizontal"
+                    style="@style/Widget.Material3.Chip.Filter"
+                    android:layout_width="wrap_content"
+                    android:layout_height="wrap_content"
+                    android:checkable="true"
+                    android:checked="true"
+                    android:text="@string/ui_control_chip_pan_horizontal"
+                    />
+
+                <com.google.android.material.chip.Chip
+                    android:id="@+id/chip_compass"
+                    style="@style/Widget.Material3.Chip.Filter"
+                    android:layout_width="wrap_content"
+                    android:layout_height="wrap_content"
+                    android:checkable="true"
+                    android:checked="true"
+                    android:text="@string/ui_control_chip_compass"
+                    />
+            </com.google.android.material.chip.ChipGroup>
+
+            <!-- Placement Toggle Section: Trailing (Right) vs Leading (Left) -->
+            <TextView
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:layout_marginTop="6dp"
+                android:text="@string/ui_controls_placement_label"
+                style="@style/TextAppearance.Material3.LabelMedium"
+                />
+
+            <RadioGroup
+                android:id="@+id/rg_controls_placement"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:orientation="horizontal"
+                android:gravity="center_vertical"
+                >
+
+                <RadioButton
+                    android:id="@+id/rb_placement_trailing"
+                    android:layout_width="0dp"
+                    android:layout_height="wrap_content"
+                    android:layout_weight="1"
+                    android:checked="true"
+                    android:text="@string/ui_controls_placement_trailing"
+                    />
+
+                <RadioButton
+                    android:id="@+id/rb_placement_leading"
+                    android:layout_width="0dp"
+                    android:layout_height="wrap_content"
+                    android:layout_weight="1"
+                    android:text="@string/ui_controls_placement_leading"
+                    />
+            </RadioGroup>
+
+        </LinearLayout>
+
+    </LinearLayout>
+</androidx.cardview.widget.CardView>
diff --git a/Maps3DSamples/ApiDemos/common/src/main/res/layout/dialog_map3d_quick_settings.xml b/Maps3DSamples/ApiDemos/common/src/main/res/layout/dialog_map3d_quick_settings.xml
new file mode 100644
index 00000000..fdc69df5
--- /dev/null
+++ b/Maps3DSamples/ApiDemos/common/src/main/res/layout/dialog_map3d_quick_settings.xml
@@ -0,0 +1,205 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright 2026 Google LLC
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~     https://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+  -->
+<ScrollView xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:paddingStart="24dp"
+    android:paddingEnd="24dp"
+    android:paddingTop="12dp"
+    android:paddingBottom="12dp">
+
+    <LinearLayout
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:orientation="vertical">
+
+        <!-- Map Mode Section Header -->
+        <TextView
+            android:id="@+id/tv_header_map_mode"
+            style="@style/TextAppearance.Material3.TitleSmall"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:text="@string/map3d_mode_section"
+            android:textColor="?attr/colorPrimary" />
+
+        <!-- Map Mode Radio Group -->
+        <RadioGroup
+            android:id="@+id/rg_map_mode"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:layout_marginTop="4dp"
+            android:layout_marginBottom="12dp">
+
+            <com.google.android.material.radiobutton.MaterialRadioButton
+                android:id="@+id/rb_mode_satellite"
+                style="@style/TextAppearance.Material3.BodyMedium"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:text="@string/map3d_mode_satellite" />
+
+            <com.google.android.material.radiobutton.MaterialRadioButton
+                android:id="@+id/rb_mode_hybrid"
+                style="@style/TextAppearance.Material3.BodyMedium"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:text="@string/map3d_mode_hybrid" />
+
+            <com.google.android.material.radiobutton.MaterialRadioButton
+                android:id="@+id/rb_mode_roadmap"
+                style="@style/TextAppearance.Material3.BodyMedium"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:text="@string/map3d_mode_roadmap" />
+        </RadioGroup>
+
+        <!-- Section Divider -->
+        <com.google.android.material.divider.MaterialDivider
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:layout_marginBottom="12dp" />
+
+        <!-- Color Scheme Section Header -->
+        <TextView
+            android:id="@+id/tv_header_color_scheme"
+            style="@style/TextAppearance.Material3.TitleSmall"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:text="@string/map3d_color_scheme_section"
+            android:textColor="?attr/colorPrimary" />
+
+        <!-- Color Scheme Radio Group -->
+        <RadioGroup
+            android:id="@+id/rg_color_scheme"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:layout_marginTop="4dp"
+            android:layout_marginBottom="8dp">
+
+            <com.google.android.material.radiobutton.MaterialRadioButton
+                android:id="@+id/rb_scheme_system"
+                style="@style/TextAppearance.Material3.BodyMedium"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:text="@string/map3d_color_scheme_system" />
+
+            <com.google.android.material.radiobutton.MaterialRadioButton
+                android:id="@+id/rb_scheme_light"
+                style="@style/TextAppearance.Material3.BodyMedium"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:text="@string/map3d_color_scheme_light" />
+
+            <com.google.android.material.radiobutton.MaterialRadioButton
+                android:id="@+id/rb_scheme_dark"
+                style="@style/TextAppearance.Material3.BodyMedium"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:text="@string/map3d_color_scheme_dark" />
+        </RadioGroup>
+
+        <!-- Section Divider -->
+        <com.google.android.material.divider.MaterialDivider
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:layout_marginBottom="12dp" />
+
+        <!-- UI Controls Section Header & Master Toggle -->
+        <LinearLayout
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:orientation="horizontal"
+            android:gravity="center_vertical">
+
+            <TextView
+                android:id="@+id/tv_header_ui_controls"
+                style="@style/TextAppearance.Material3.TitleSmall"
+                android:layout_width="0dp"
+                android:layout_height="wrap_content"
+                android:layout_weight="1"
+                android:text="@string/map3d_controls_section"
+                android:textColor="?attr/colorPrimary" />
+
+            <com.google.android.material.materialswitch.MaterialSwitch
+                android:id="@+id/switch_toggle_all_controls"
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                android:contentDescription="@string/map3d_controls_toggle_all" />
+        </LinearLayout>
+
+        <!-- Individual Control Checkboxes -->
+        <LinearLayout
+            android:id="@+id/container_control_checkboxes"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:orientation="vertical"
+            android:layout_marginTop="4dp"
+            android:layout_marginBottom="8dp">
+
+            <com.google.android.material.checkbox.MaterialCheckBox
+                android:id="@+id/cb_control_zoom"
+                style="@style/TextAppearance.Material3.BodyMedium"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:text="@string/map3d_control_zoom" />
+
+            <com.google.android.material.checkbox.MaterialCheckBox
+                android:id="@+id/cb_control_tilt"
+                style="@style/TextAppearance.Material3.BodyMedium"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:text="@string/map3d_control_tilt" />
+
+            <com.google.android.material.checkbox.MaterialCheckBox
+                android:id="@+id/cb_control_rotate"
+                style="@style/TextAppearance.Material3.BodyMedium"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:text="@string/map3d_control_rotate" />
+
+            <com.google.android.material.checkbox.MaterialCheckBox
+                android:id="@+id/cb_control_pan_v"
+                style="@style/TextAppearance.Material3.BodyMedium"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:text="@string/map3d_control_pan_v" />
+
+            <com.google.android.material.checkbox.MaterialCheckBox
+                android:id="@+id/cb_control_pan_h"
+                style="@style/TextAppearance.Material3.BodyMedium"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:text="@string/map3d_control_pan_h" />
+
+            <com.google.android.material.checkbox.MaterialCheckBox
+                android:id="@+id/cb_control_compass"
+                style="@style/TextAppearance.Material3.BodyMedium"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:text="@string/map3d_control_compass" />
+        </LinearLayout>
+
+        <!-- Reset to Defaults Button -->
+        <com.google.android.material.button.MaterialButton
+            android:id="@+id/btn_reset_settings"
+            style="@style/Widget.Material3.Button.TextButton"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:layout_gravity="end"
+            android:text="@string/map3d_settings_reset" />
+
+    </LinearLayout>
+</ScrollView>
diff --git a/Maps3DSamples/ApiDemos/common/src/main/res/layout/main.xml b/Maps3DSamples/ApiDemos/common/src/main/res/layout/main.xml
index deda2097..6df220c7 100644
--- a/Maps3DSamples/ApiDemos/common/src/main/res/layout/main.xml
+++ b/Maps3DSamples/ApiDemos/common/src/main/res/layout/main.xml
@@ -40,6 +40,7 @@
             map3d:centerLng="-122.551679"
             map3d:defaultUiDisabled="false"
             map3d:heading="330"
+            map3d:mapMode="hybrid"
             map3d:maxAltitude="1000000"
             map3d:maxHeading="360"
             map3d:maxTilt="90"
diff --git a/Maps3DSamples/ApiDemos/common/src/main/res/values/strings.xml b/Maps3DSamples/ApiDemos/common/src/main/res/values/strings.xml
index 01f1b588..14c18464 100644
--- a/Maps3DSamples/ApiDemos/common/src/main/res/values/strings.xml
+++ b/Maps3DSamples/ApiDemos/common/src/main/res/values/strings.xml
@@ -43,6 +43,7 @@
     <string name="feature_title_data_visualization">Data Visualization</string>
     <string name="feature_title_cloud_styling">Cloud Map Styling</string>
     <string name="feature_title_roadmap_mode">Roadmap Mode</string>
+    <string name="feature_title_ui_controls">UI Controls</string>
     <string name="feature_title_field_of_view">Field Of View</string>
     <string name="feature_title_projection_3d">3D Screen Projection</string>
     <string name="feature_title_maps_localization">Maps Localization</string>
@@ -274,4 +275,41 @@
     <string name="localization_applied_format">Applied %1$s [%2$s]</string>
     <string name="localization_location">Location: San Francisco Bay, USA</string>
     <string name="navigate_up">Navigate up</string>
+
+    <!-- Map 3D Quick Settings -->
+    <string name="map3d_settings_title">3D Map Settings</string>
+    <string name="map3d_mode_section">Map Mode</string>
+    <string name="map3d_mode_satellite">Satellite (3D Mesh)</string>
+    <string name="map3d_mode_hybrid">Hybrid (3D Mesh + Roads &amp; Labels)</string>
+    <string name="map3d_mode_roadmap">Roadmap (Vector Roads)</string>
+    <string name="map3d_color_scheme_section">Color Scheme</string>
+    <string name="map3d_color_scheme_system">Follow System</string>
+    <string name="map3d_color_scheme_light">Light Mode</string>
+    <string name="map3d_color_scheme_dark">Dark Mode</string>
+    <string name="map3d_controls_section">Camera Controls</string>
+    <string name="map3d_controls_toggle_all">All Controls</string>
+    <string name="map3d_control_zoom">Zoom (+ / -)</string>
+    <string name="map3d_control_tilt">Tilt (Up / Down)</string>
+    <string name="map3d_control_rotate">Rotate (Heading)</string>
+    <string name="map3d_control_compass">Compass (Reset North)</string>
+    <string name="map3d_control_pan_v">Pan Vertical (Up / Down)</string>
+    <string name="map3d_control_pan_h">Pan Horizontal (Left / Right)</string>
+    <string name="map3d_settings_done">Done</string>
+    <string name="map3d_settings_reset">Reset to Defaults</string>
+    <string name="map3d_settings_button_description">Open 3D map quick settings</string>
+
+    <!-- Dedicated UI Controls Sample strings -->
+    <string name="ui_controls_panel_title">3D Map UI Controls</string>
+    <string name="ui_controls_visibility_label">Visible Controls</string>
+    <string name="ui_controls_placement_label">Main Controls Placement</string>
+    <string name="ui_controls_placement_trailing">Trailing (Right)</string>
+    <string name="ui_controls_placement_leading">Leading (Left)</string>
+    <string name="ui_controls_show_all">Show All</string>
+    <string name="ui_controls_hide_all">Hide All</string>
+    <string name="ui_control_chip_zoom">Zoom</string>
+    <string name="ui_control_chip_tilt">Tilt</string>
+    <string name="ui_control_chip_rotate">Rotate</string>
+    <string name="ui_control_chip_compass">Compass</string>
+    <string name="ui_control_chip_pan_vertical">Pan Vertical</string>
+    <string name="ui_control_chip_pan_horizontal">Pan Horizontal</string>
 </resources>
diff --git a/Maps3DSamples/ApiDemos/common/src/test/java/com/example/maps3d/common/Map3DSettingsControllerTest.kt b/Maps3DSamples/ApiDemos/common/src/test/java/com/example/maps3d/common/Map3DSettingsControllerTest.kt
new file mode 100644
index 00000000..653a6133
--- /dev/null
+++ b/Maps3DSamples/ApiDemos/common/src/test/java/com/example/maps3d/common/Map3DSettingsControllerTest.kt
@@ -0,0 +1,297 @@
+/*
+ * Copyright 2026 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.example.maps3d.common
+
+import com.google.android.gms.maps3d.UiControlSettings.ControlPlacement
+import com.google.android.gms.maps3d.model.Map3DMode
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+
+/**
+ * JVM Unit Tests for [Map3DSettingsController] and [Map3DSettings].
+ */
+class Map3DSettingsControllerTest {
+
+    private lateinit var controller: Map3DSettingsController
+
+    @Before
+    fun setup() {
+        controller = Map3DSettingsController()
+    }
+
+    @Test
+    fun initialState_isConfiguredWithDefaults() {
+        val state = controller.getSettings()
+        assertEquals(Map3DMode.HYBRID, state.mapMode)
+        assertEquals(Map3DColorScheme.FOLLOW_SYSTEM, state.colorScheme)
+    }
+
+    @Test
+    fun customInitialState_isPreserved() {
+        val custom = Map3DSettings(
+            mapMode = Map3DMode.SATELLITE,
+            colorScheme = Map3DColorScheme.DARK,
+        )
+        val customController = Map3DSettingsController(initialSettings = custom)
+        assertEquals(Map3DMode.SATELLITE, customController.getSettings().mapMode)
+        assertEquals(Map3DColorScheme.DARK, customController.getSettings().colorScheme)
+    }
+
+    @Test
+    fun setMapMode_satellite_updatesStateAndNotifiesListener() {
+        var notified = false
+        var capturedSettings: Map3DSettings? = null
+        controller.addListener { settings ->
+            notified = true
+            capturedSettings = settings
+        }
+
+        val updated = controller.setMapMode(Map3DMode.SATELLITE)
+
+        assertTrue(notified)
+        assertEquals(Map3DMode.SATELLITE, updated.mapMode)
+        assertEquals(Map3DMode.SATELLITE, capturedSettings?.mapMode)
+    }
+
+    @Test
+    fun setMapMode_roadmap_updatesState() {
+        val updated = controller.setMapMode(Map3DMode.ROADMAP)
+        assertEquals(Map3DMode.ROADMAP, updated.mapMode)
+    }
+
+    @Test
+    fun setMapMode_unknownOrInvalid_doesNotChangeState() {
+        var callCount = 0
+        controller.addListener { callCount++ }
+
+        val result = controller.setMapMode(999)
+
+        assertEquals(Map3DMode.HYBRID, result.mapMode)
+        assertEquals(0, callCount)
+    }
+
+    @Test
+    fun setMapMode_sameValue_doesNotNotifyListener() {
+        var callCount = 0
+        controller.addListener { callCount++ }
+
+        controller.setMapMode(Map3DMode.HYBRID) // Already HYBRID
+
+        assertEquals(0, callCount)
+    }
+
+    @Test
+    fun setColorScheme_dark_updatesStateAndNotifiesListener() {
+        var notified = false
+        controller.addListener { notified = true }
+
+        val updated = controller.setColorScheme(Map3DColorScheme.DARK)
+
+        assertTrue(notified)
+        assertEquals(Map3DColorScheme.DARK, updated.colorScheme)
+    }
+
+    @Test
+    fun setColorScheme_light_updatesState() {
+        val updated = controller.setColorScheme(Map3DColorScheme.LIGHT)
+        assertEquals(Map3DColorScheme.LIGHT, updated.colorScheme)
+    }
+
+    @Test
+    fun setColorScheme_sameValue_doesNotNotify() {
+        var callCount = 0
+        controller.addListener { callCount++ }
+
+        controller.setColorScheme(Map3DColorScheme.FOLLOW_SYSTEM) // Already FOLLOW_SYSTEM
+
+        assertEquals(0, callCount)
+    }
+
+    @Test
+    fun setSettings_updatesStateAndNotifiesListener() {
+        var callCount = 0
+        controller.addListener { callCount++ }
+
+        val newSettings = Map3DSettings(
+            mapMode = Map3DMode.SATELLITE,
+            colorScheme = Map3DColorScheme.DARK,
+        )
+        val updated = controller.setSettings(newSettings)
+
+        assertEquals(1, callCount)
+        assertEquals(Map3DMode.SATELLITE, updated.mapMode)
+        assertEquals(Map3DColorScheme.DARK, updated.colorScheme)
+    }
+
+    @Test
+    fun removeListener_stopsReceivingUpdates() {
+        var callCount = 0
+        val listener: (Map3DSettings) -> Unit = { callCount++ }
+
+        controller.addListener(listener)
+        controller.setMapMode(Map3DMode.SATELLITE)
+        assertEquals(1, callCount)
+
+        controller.removeListener(listener)
+        controller.setMapMode(Map3DMode.ROADMAP)
+        assertEquals(1, callCount)
+    }
+
+    @Test
+    fun initialState_uiControlsDefaultToEnabled() {
+        val state = controller.getSettings()
+        assertTrue(state.uiControls.allEnabled)
+        assertTrue(state.uiControls.zoom)
+        assertTrue(state.uiControls.tilt)
+        assertTrue(state.uiControls.rotate)
+        assertTrue(state.uiControls.compass)
+        assertTrue(state.uiControls.panVertical)
+        assertTrue(state.uiControls.panHorizontal)
+    }
+
+    @Test
+    fun setAllUiControls_false_disablesAllAndNotifies() {
+        var notified = false
+        controller.addListener { notified = true }
+
+        val updated = controller.setAllUiControls(false)
+
+        assertTrue(notified)
+        assertTrue(updated.uiControls.noneEnabled)
+        assertFalse(updated.uiControls.zoom)
+    }
+
+    @Test
+    fun setAllUiControls_true_enablesAll() {
+        controller.setAllUiControls(false)
+        val updated = controller.setAllUiControls(true)
+        assertTrue(updated.uiControls.allEnabled)
+    }
+
+    @Test
+    fun updateUiControl_togglesSingleControl() {
+        var captured: Map3DSettings? = null
+        controller.addListener { captured = it }
+
+        val updated = controller.updateUiControl(zoom = false)
+
+        assertFalse(updated.uiControls.zoom)
+        assertTrue(updated.uiControls.tilt)
+        assertFalse(captured?.uiControls?.zoom ?: true)
+    }
+
+    @Test
+    fun setUiControls_sameState_doesNotNotify() {
+        var callCount = 0
+        controller.addListener { callCount++ }
+
+        controller.setUiControls(Map3DUiControls()) // Already default
+
+        assertEquals(0, callCount)
+    }
+
+    @Test
+    fun onSampleEntered_whenNotOverridden_adoptsSampleDefaultMapMode() {
+        assertFalse(controller.hasUserOverriddenMapMode)
+
+        controller.onSampleEntered(Map3DMode.SATELLITE)
+        assertEquals(Map3DMode.SATELLITE, controller.settings.value.mapMode)
+        assertFalse(controller.hasUserOverriddenMapMode)
+
+        controller.onSampleEntered(Map3DMode.ROADMAP)
+        assertEquals(Map3DMode.ROADMAP, controller.settings.value.mapMode)
+        assertFalse(controller.hasUserOverriddenMapMode)
+    }
+
+    @Test
+    fun onSampleEntered_afterUserOverridesMapMode_preservesUserChoice() {
+        controller.setMapMode(Map3DMode.ROADMAP)
+        assertTrue(controller.hasUserOverriddenMapMode)
+        assertEquals(Map3DMode.ROADMAP, controller.settings.value.mapMode)
+
+        // Entering a sample that defaults to SATELLITE or HYBRID should NOT clobber user's choice
+        controller.onSampleEntered(Map3DMode.SATELLITE)
+        assertEquals(Map3DMode.ROADMAP, controller.settings.value.mapMode)
+
+        controller.onSampleEntered(Map3DMode.HYBRID)
+        assertEquals(Map3DMode.ROADMAP, controller.settings.value.mapMode)
+    }
+
+    @Test
+    fun setMapMode_sameAsCurrentDefault_stillMarksUserOverride() {
+        // Default is HYBRID; user explicitly selects HYBRID
+        controller.setMapMode(Map3DMode.HYBRID)
+        assertTrue(controller.hasUserOverriddenMapMode)
+
+        // Entering a SATELLITE sample should now keep HYBRID
+        controller.onSampleEntered(Map3DMode.SATELLITE)
+        assertEquals(Map3DMode.HYBRID, controller.settings.value.mapMode)
+    }
+
+    @Test
+    fun reset_restoresDefaultsAndClearsUserOverrideFlag() {
+        controller.setMapMode(Map3DMode.ROADMAP)
+        controller.setColorScheme(Map3DColorScheme.DARK)
+        controller.setAllUiControls(false)
+        assertTrue(controller.hasUserOverriddenMapMode)
+
+        val resetState = controller.reset(sampleDefaultMapMode = Map3DMode.SATELLITE)
+
+        assertFalse(controller.hasUserOverriddenMapMode)
+        assertEquals(Map3DMode.SATELLITE, resetState.mapMode)
+        assertEquals(Map3DColorScheme.FOLLOW_SYSTEM, resetState.colorScheme)
+        assertTrue(resetState.uiControls.allEnabled)
+        assertEquals(resetState, controller.settings.value)
+
+        // Subsequent sample navigation should again adopt sample defaults
+        controller.onSampleEntered(Map3DMode.HYBRID)
+        assertEquals(Map3DMode.HYBRID, controller.settings.value.mapMode)
+    }
+
+    @Test
+    fun calculateFabMarginDp_adjustsWithActiveTrailingControls() {
+        assertEquals(336, Map3DUiControls(zoom = true, tilt = true, rotate = true).calculateFabMarginDp())
+        assertEquals(232, Map3DUiControls(zoom = true, tilt = true, rotate = false).calculateFabMarginDp())
+        assertEquals(128, Map3DUiControls(zoom = true, tilt = false, rotate = false).calculateFabMarginDp())
+        assertEquals(16, Map3DUiControls(zoom = false, tilt = false, rotate = false).calculateFabMarginDp())
+    }
+
+    @Test
+    fun setControlsPosition_leading_updatesPlacementAndAdjustsFabMargin() {
+        assertEquals(ControlPlacement.TRAILING, controller.getSettings().uiControls.controlsPosition)
+
+        val updated = controller.setControlsPosition(ControlPlacement.LEADING)
+
+        assertEquals(ControlPlacement.LEADING, updated.uiControls.controlsPosition)
+        assertEquals(288, updated.uiControls.calculateFabMarginDp())
+        assertEquals(
+            232,
+            updated.uiControls.copy(compass = false).calculateFabMarginDp(),
+        )
+        assertEquals(
+            184,
+            updated.uiControls.copy(panHorizontal = false).calculateFabMarginDp(),
+        )
+        assertEquals(
+            16,
+            updated.uiControls.copy(panVertical = false, panHorizontal = false, compass = false).calculateFabMarginDp(),
+        )
+    }
+}
diff --git a/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/advancedcameraanimation/AdvancedCameraAnimationActivity.java b/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/advancedcameraanimation/AdvancedCameraAnimationActivity.java
index fbd71379..cc1229a8 100644
--- a/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/advancedcameraanimation/AdvancedCameraAnimationActivity.java
+++ b/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/advancedcameraanimation/AdvancedCameraAnimationActivity.java
@@ -52,6 +52,7 @@
 import com.google.android.gms.maps3d.model.FlyToOptions;
 import com.google.android.gms.maps3d.model.FlyAroundOptions;
 import com.google.android.gms.maps3d.model.LatLngAltitude;
+import com.google.android.gms.maps3d.model.Map3DMode;
 import com.google.android.material.appbar.MaterialToolbar;
 import com.google.android.material.button.MaterialButton;
 import com.google.android.material.chip.ChipGroup;
@@ -69,6 +70,12 @@ public String getTAG() {
         return "AdvancedCameraAnimationActivity";
     }
 
+    @Override
+    @Map3DMode
+    protected int getDefaultMapMode() {
+        return Map3DMode.SATELLITE;
+    }
+
 
     private AdvancedCameraAnimationViewModel viewModel;
     private final Map3DModelEntity airplaneEntity =
diff --git a/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/cameracontrols/CameraControlsActivity.java b/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/cameracontrols/CameraControlsActivity.java
index bbcfa56e..cc0564ac 100644
--- a/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/cameracontrols/CameraControlsActivity.java
+++ b/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/cameracontrols/CameraControlsActivity.java
@@ -20,12 +20,15 @@
 
 import android.os.Bundle;
 import android.util.Log;
+import android.view.View;
 import android.widget.RadioGroup;
 import android.widget.TextView;
 
 import androidx.annotation.NonNull;
 import androidx.core.view.WindowCompat;
 
+import com.example.maps3d.common.Map3DSettings;
+import com.example.maps3d.common.Map3DSettingsController;
 import com.example.maps3dcommon.R;
 import com.example.maps3djava.sampleactivity.SampleBaseActivity;
 import com.google.android.gms.maps3d.GoogleMap3D;
@@ -51,9 +54,16 @@ public final String getTAG() {
         return this.getClass().getSimpleName();
     }
 
+    @Override
+    @Map3DMode
+    protected int getDefaultMapMode() {
+        return Map3DMode.SATELLITE;
+    }
+
     private TextView cameraStateText;
     private Slider rollSlider;
     private TextView rollSliderLabel;
+    private boolean isSyncingRadioGroup = false;
 
     private final List<Polygon> restrictionCubeFaces = new ArrayList<>();
 
@@ -138,12 +148,20 @@ protected void onCreate(Bundle savedInstanceState) {
 
 
         ((RadioGroup) findViewById(R.id.map_mode_radio_group)).setOnCheckedChangeListener((group, checkedId) -> {
+            if (isSyncingRadioGroup) {
+                return;
+            }
+            int mode;
+            if (checkedId == R.id.map_mode_hybrid) {
+                mode = Map3DMode.HYBRID;
+            } else if (checkedId == R.id.map_mode_satellite) {
+                mode = Map3DMode.SATELLITE;
+            } else {
+                return;
+            }
+            Map3DSettingsController.getShared().setMapMode(mode);
             if (googleMap3D != null) {
-                if (checkedId == R.id.map_mode_hybrid) {
-                    googleMap3D.setMapMode(Map3DMode.HYBRID);
-                } else if (checkedId == R.id.map_mode_satellite) {
-                    googleMap3D.setMapMode(Map3DMode.SATELLITE);
-                }
+                Map3DSettingsController.getShared().getSettings().applyTo(googleMap3D);
             }
         });
 
@@ -163,6 +181,30 @@ protected void onCreate(Bundle savedInstanceState) {
         });
     }
 
+    @Override
+    protected void onQuickSettingsChanged(@NonNull Map3DSettings settings) {
+        RadioGroup group = findViewById(R.id.map_mode_radio_group);
+        if (group == null) {
+            return;
+        }
+        int targetId = View.NO_ID;
+        int mapMode = settings.getMapMode();
+        if (mapMode == Map3DMode.HYBRID) {
+            targetId = R.id.map_mode_hybrid;
+        } else if (mapMode == Map3DMode.SATELLITE) {
+            targetId = R.id.map_mode_satellite;
+        }
+        if (group.getCheckedRadioButtonId() != targetId) {
+            isSyncingRadioGroup = true;
+            if (targetId == View.NO_ID) {
+                group.clearCheck();
+            } else {
+                group.check(targetId);
+            }
+            isSyncingRadioGroup = false;
+        }
+    }
+
     private void updateRollSliderLabel(float value) {
         rollSliderLabel.setText(getString(R.string.camera_roll_label_dynamic, value));
     }
diff --git a/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/datavisualization/DataVisualizationActivity.java b/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/datavisualization/DataVisualizationActivity.java
index 242e9b4b..6694d3c7 100644
--- a/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/datavisualization/DataVisualizationActivity.java
+++ b/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/datavisualization/DataVisualizationActivity.java
@@ -41,7 +41,6 @@
 import com.google.android.gms.maps3d.model.Camera;
 import com.google.android.gms.maps3d.model.FlyToOptions;
 import com.google.android.gms.maps3d.model.LatLngAltitude;
-import com.google.android.gms.maps3d.model.Map3DMode;
 import com.google.android.gms.maps3d.model.Polygon;
 import com.google.android.gms.maps3d.model.PolygonOptions;
 import com.google.android.material.appbar.MaterialToolbar;
@@ -306,16 +305,10 @@ public boolean dispatchTouchEvent(MotionEvent ev) {
   // --- 3D Map Setup & Extrusion Engine ---
 
   @Override
-  public void onMap3DViewReady(@NonNull GoogleMap3D googleMap3D) {
-    super.onMap3DViewReady(googleMap3D);
-
-    googleMap3D.setMapMode(Map3DMode.HYBRID);
-
-    googleMap3D.setOnMapReadyListener(sceneReadiness -> {
-      googleMap3D.setOnMapReadyListener(null);
-      googleMap3D.flyCameraTo(new FlyToOptions(getInitialCamera(), 1200));
-      runOnUiThread(() -> updateFloodElevation(currentFloodElevation));
-    });
+  protected void onMapReady(@NonNull GoogleMap3D googleMap3D) {
+    super.onMapReady(googleMap3D);
+    googleMap3D.flyCameraTo(new FlyToOptions(getInitialCamera(), 1200));
+    runOnUiThread(() -> updateFloodElevation(currentFloodElevation));
   }
 
   /**
diff --git a/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/fieldofview/FieldOfViewActivity.java b/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/fieldofview/FieldOfViewActivity.java
index f2585ec2..d3d21c24 100644
--- a/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/fieldofview/FieldOfViewActivity.java
+++ b/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/fieldofview/FieldOfViewActivity.java
@@ -37,6 +37,7 @@
 import com.google.android.gms.maps3d.GoogleMap3D;
 import com.google.android.gms.maps3d.model.Camera;
 import com.google.android.gms.maps3d.model.LatLngAltitude;
+import com.google.android.gms.maps3d.model.Map3DMode;
 import com.google.android.material.appbar.MaterialToolbar;
 import com.google.android.material.button.MaterialButton;
 import com.google.android.material.slider.Slider;
@@ -117,6 +118,12 @@ public String getTAG() {
     return "FieldOfViewActivity";
   }
 
+  @Override
+  @Map3DMode
+  protected int getDefaultMapMode() {
+    return Map3DMode.SATELLITE;
+  }
+
   @NonNull
   @Override
   public Camera getInitialCamera() {
@@ -286,12 +293,9 @@ public boolean dispatchTouchEvent(MotionEvent ev) {
   // --- 3D Map Setup & Perspective Scaling Engine ---
 
   @Override
-  public void onMap3DViewReady(@NonNull GoogleMap3D googleMap3D) {
-    super.onMap3DViewReady(googleMap3D);
-    googleMap3D.setOnMapReadyListener(sceneReadiness -> {
-      googleMap3D.setOnMapReadyListener(null);
-      runOnUiThread(() -> updateFov((float) currentFov));
-    });
+  protected void onMapReady(@NonNull GoogleMap3D googleMap3D) {
+    super.onMapReady(googleMap3D);
+    runOnUiThread(() -> updateFov((float) currentFov));
   }
 
   /**
diff --git a/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/hellomap/HelloMapActivity.java b/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/hellomap/HelloMapActivity.java
index 6a9eb92f..3a756cc8 100644
--- a/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/hellomap/HelloMapActivity.java
+++ b/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/hellomap/HelloMapActivity.java
@@ -14,16 +14,18 @@
 
 package com.example.maps3djava.hellomap;
 
-import android.app.Activity;
+import androidx.appcompat.app.AppCompatActivity;
 import android.os.Bundle;
 import android.util.Log;
 import android.view.View;
 
 import androidx.annotation.NonNull;
-import androidx.core.graphics.Insets;
-import androidx.core.view.ViewCompat;
+import androidx.core.view.WindowCompat;
 import androidx.core.view.WindowInsetsCompat;
+import androidx.core.view.WindowInsetsControllerCompat;
 
+import com.example.maps3d.common.Map3DQuickSettingsButton;
+import com.example.maps3d.common.Map3DSettingsController;
 import com.google.android.gms.maps3d.GoogleMap3D;
 import com.google.android.gms.maps3d.Map3DView;
 import com.google.android.gms.maps3d.OnMap3DViewReadyCallback;
@@ -31,13 +33,14 @@
 import com.google.android.gms.maps3d.OnMapReadyListener;
 import com.google.android.gms.maps3d.model.Camera;
 import com.google.android.gms.maps3d.model.LatLngAltitude;
+import com.google.android.gms.maps3d.model.Map3DMode;
 
 /**
  * `HelloMapActivity` is an Android activity that demonstrates the usage of the `Map3DView`.  This
  * is close the minimal activity.  It inflates the `activity_hello_map.xml` layout file and
  * demonstrates how to initialize the `Map3DView` and get a `GoogleMap3D` reference.
  */
-public class HelloMapActivity extends Activity implements OnMap3DViewReadyCallback, OnMapReadyListener {
+public class HelloMapActivity extends AppCompatActivity implements OnMap3DViewReadyCallback, OnMapReadyListener {
     private final String TAG = this.getClass().getSimpleName();
     private Map3DView map3DView;
     private GoogleMap3D googleMap3D = null;
@@ -46,28 +49,33 @@ public class HelloMapActivity extends Activity implements OnMap3DViewReadyCallba
     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
+        WindowCompat.setDecorFitsSystemWindows(getWindow(), false);
+        enableImmersiveMode();
         setContentView(R.layout.activity_hello_map);
 
-        View rootView = findViewById(R.id.map_container);
-        ViewCompat.setOnApplyWindowInsetsListener(rootView, (view, insets) -> {
-            Insets statusBarInsets = insets.getInsets(WindowInsetsCompat.Type.statusBars());
-            Insets navigationBarInsets = insets.getInsets(WindowInsetsCompat.Type.navigationBars());
-
-            view.setPadding(
-                    view.getPaddingLeft(),
-                    view.getPaddingTop() + statusBarInsets.top,
-                    view.getPaddingRight(),
-                    view.getPaddingBottom() + navigationBarInsets.bottom
-            );
-
-            return WindowInsetsCompat.CONSUMED;
-        });
-
         map3DView = findViewById(R.id.map3dView);
         map3DView.onCreate(savedInstanceState);
         map3DView.getMap3DViewAsync(this);
     }
 
+    private void enableImmersiveMode() {
+        WindowInsetsControllerCompat insetsController =
+                WindowCompat.getInsetsController(getWindow(), getWindow().getDecorView());
+        if (insetsController != null) {
+            insetsController.setSystemBarsBehavior(
+                    WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE);
+            insetsController.hide(WindowInsetsCompat.Type.systemBars());
+        }
+    }
+
+    @Override
+    public void onWindowFocusChanged(boolean hasFocus) {
+        super.onWindowFocusChanged(hasFocus);
+        if (hasFocus) {
+            enableImmersiveMode();
+        }
+    }
+
     /**
      * Called when the [Map3DView] is ready to be used.
      *
@@ -104,6 +112,15 @@ private void initializeMap() {
         isInitialized = true;
         
         Log.i(TAG, "Initializing map position to Delicate Arch");
+
+        Map3DSettingsController.getShared().onSampleEntered(Map3DMode.HYBRID);
+        Map3DSettingsController.getShared().getSettings().applyTo(googleMap3D);
+        Map3DQuickSettingsButton quickSettings = findViewById(R.id.quick_settings_button);
+        if (quickSettings != null) {
+            quickSettings.setSettingsController(Map3DSettingsController.getShared());
+            quickSettings.setSampleDefaultMapMode(Map3DMode.HYBRID);
+            quickSettings.attachMap(googleMap3D);
+        }
         
         LatLngAltitude center = new LatLngAltitude(38.743502, -109.499374, 1467.0);
         Camera camera = new Camera(center, 349.6, 58.1, 0.0, 138.2);
@@ -119,7 +136,11 @@ public void onError(@NonNull Exception error) {
     @Override
     protected void onResume() {
         super.onResume();
+        enableImmersiveMode();
         map3DView.onResume();
+        if (googleMap3D != null) {
+            Map3DSettingsController.getShared().getSettings().applyTo(googleMap3D);
+        }
     }
 
     @Override
diff --git a/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/mapinteractions/MapInteractionsActivity.java b/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/mapinteractions/MapInteractionsActivity.java
index af144ddb..dd53c7f1 100644
--- a/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/mapinteractions/MapInteractionsActivity.java
+++ b/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/mapinteractions/MapInteractionsActivity.java
@@ -28,7 +28,6 @@
 import com.google.android.gms.maps3d.GoogleMap3D;
 import com.google.android.gms.maps3d.model.Camera;
 import com.google.android.gms.maps3d.model.LatLngAltitude;
-import com.google.android.gms.maps3d.model.Map3DMode;
 
 public class MapInteractionsActivity extends SampleBaseActivity {
 
@@ -90,8 +89,7 @@ public void run() {
   private void initializeMap(@NonNull GoogleMap3D googleMap3D) {
     if (isInitialized) return;
     isInitialized = true;
-
-    googleMap3D.setMapMode(Map3DMode.HYBRID);
+    super.onMapReady(googleMap3D);
 
     // Listeners for map clicks.
     googleMap3D.setMap3DClickListener((event) -> {
diff --git a/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/markers/MarkersActivity.java b/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/markers/MarkersActivity.java
index e49f12cb..98150fd0 100644
--- a/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/markers/MarkersActivity.java
+++ b/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/markers/MarkersActivity.java
@@ -91,6 +91,12 @@ public final Camera getBerlinCamera() {
     private boolean isTourActive = false;
     private boolean isInitialized = false;
 
+    @Override
+    @Map3DMode
+    protected int getDefaultMapMode() {
+        return Map3DMode.SATELLITE;
+    }
+
     @Override
     public final Camera getInitialCamera() {
         return toValidCamera(new Camera(
@@ -128,9 +134,9 @@ public void run() {
     private void initializeMap(GoogleMap3D googleMap3D) {
         if (isInitialized) return;
         isInitialized = true;
+        super.onMapReady(googleMap3D);
 
         googleMap3D.setCamera(getInitialCamera());
-        googleMap3D.setMapMode(Map3DMode.SATELLITE);
 
         Button flyBerlinButton = findViewById(R.id.fly_berlin_button);
         if (flyBerlinButton != null) {
diff --git a/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/models/ModelsActivity.java b/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/models/ModelsActivity.java
index a597f825..251c52f9 100644
--- a/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/models/ModelsActivity.java
+++ b/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/models/ModelsActivity.java
@@ -99,13 +99,17 @@ protected void onCreate(Bundle savedInstanceState) {
         stopButton.setVisibility(View.VISIBLE);
     }
 
+    @Override
+    @Map3DMode
+    protected int getDefaultMapMode() {
+        return Map3DMode.SATELLITE;
+    }
+
     @Override
     public void onMap3DViewReady(@NonNull GoogleMap3D googleMap3D) {
         super.onMap3DViewReady(googleMap3D);
         this.googleMap3D = googleMap3D;
 
-        googleMap3D.setMapMode(Map3DMode.SATELLITE);
-
         ModelOptions modelOptions = new ModelOptions();
         modelOptions.setId("plane_model");
         modelOptions.setPosition(new LatLngAltitude(
diff --git a/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/pathfollowing/PathFollowingActivity.java b/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/pathfollowing/PathFollowingActivity.java
index b83f9985..0de25655 100644
--- a/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/pathfollowing/PathFollowingActivity.java
+++ b/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/pathfollowing/PathFollowingActivity.java
@@ -32,6 +32,8 @@
 import androidx.appcompat.app.AppCompatActivity;
 import androidx.cardview.widget.CardView;
 import androidx.lifecycle.ViewModelProvider;
+import com.example.maps3d.common.Map3DQuickSettingsButton;
+import com.example.maps3d.common.Map3DSettingsController;
 import com.example.maps3d.common.PathData;
 import com.example.maps3d.common.PathEngine;
 import com.example.maps3d.common.PathFollowingViewModel;
@@ -45,6 +47,7 @@
 import com.google.android.gms.maps3d.model.AltitudeMode;
 import com.google.android.gms.maps3d.model.Camera;
 import com.google.android.gms.maps3d.model.LatLngAltitude;
+import com.google.android.gms.maps3d.model.Map3DMode;
 import com.google.android.gms.maps3d.model.Polyline;
 import com.google.android.gms.maps3d.model.PolylineOptions;
 import com.google.android.material.button.MaterialButton;
@@ -144,9 +147,24 @@ public void onMap3DViewReady(@NonNull GoogleMap3D googleMap3D) {
                 });
     }
 
+    @Override
+    public void onError(@NonNull Exception error) {
+        Log.e(TAG, "Error loading map", error);
+    }
+
     private void initializeMap() {
         if (isMapInitialized) return;
         isMapInitialized = true;
+        if (googleMap3D != null) {
+            Map3DSettingsController.getShared().onSampleEntered(Map3DMode.HYBRID);
+            Map3DSettingsController.getShared().getSettings().applyTo(googleMap3D);
+            Map3DQuickSettingsButton quickSettings = findViewById(R.id.quick_settings_button);
+            if (quickSettings != null) {
+                quickSettings.setSettingsController(Map3DSettingsController.getShared());
+                quickSettings.setSampleDefaultMapMode(Map3DMode.HYBRID);
+                quickSettings.attachMap(googleMap3D);
+            }
+        }
         resetPolylines();
     }
 
@@ -722,6 +740,9 @@ private void scheduleControlFade() {
     protected void onResume() {
         super.onResume();
         map3DView.onResume();
+        if (googleMap3D != null) {
+            Map3DSettingsController.getShared().getSettings().applyTo(googleMap3D);
+        }
     }
 
     @Override
diff --git a/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/polygons/PolygonsActivity.java b/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/polygons/PolygonsActivity.java
index b561097c..9764ca51 100644
--- a/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/polygons/PolygonsActivity.java
+++ b/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/polygons/PolygonsActivity.java
@@ -28,7 +28,6 @@
 import com.google.android.gms.maps3d.model.Camera;
 import com.google.android.gms.maps3d.model.Hole;
 import com.google.android.gms.maps3d.model.LatLngAltitude;
-import com.google.android.gms.maps3d.model.Map3DMode;
 import com.google.android.gms.maps3d.model.PolygonOptions;
 
 import java.util.Arrays;
@@ -153,9 +152,9 @@ public void run() {
     private void initializeMap(GoogleMap3D googleMap3D) {
         if (isInitialized) return;
         isInitialized = true;
+        super.onMapReady(googleMap3D);
 
         googleMap3D.setCamera(getInitialCamera());
-        googleMap3D.setMapMode(Map3DMode.HYBRID);
 
         initializePolygons(googleMap3D);
     }
diff --git a/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/polylines/PolylinesActivity.java b/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/polylines/PolylinesActivity.java
index 8fdb4dc3..d8d91c83 100644
--- a/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/polylines/PolylinesActivity.java
+++ b/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/polylines/PolylinesActivity.java
@@ -28,7 +28,6 @@
 import com.google.android.gms.maps3d.model.AltitudeMode;
 import com.google.android.gms.maps3d.model.Camera;
 import com.google.android.gms.maps3d.model.LatLngAltitude;
-import com.google.android.gms.maps3d.model.Map3DMode;
 import com.google.android.gms.maps3d.model.PolylineOptions;
 
 import java.util.ArrayList;
@@ -132,8 +131,8 @@ public void run() {
     private void initializeMap(@NonNull GoogleMap3D googleMap3D) {
         if (isInitialized) return;
         isInitialized = true;
+        super.onMapReady(googleMap3D);
 
-        googleMap3D.setMapMode(Map3DMode.HYBRID);
         googleMap3D.addPolyline(trailBackgroundPolylineOptions);
         com.google.android.gms.maps3d.model.Polyline foregroundPolyline = googleMap3D.addPolyline(trailForegroundPolylineOptions);
         foregroundPolyline.setClickListener(() -> showToast(getString(R.string.polyline_trail_clicked)));
diff --git a/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/popovers/PopoversActivity.java b/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/popovers/PopoversActivity.java
index 441a6466..446fe58e 100644
--- a/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/popovers/PopoversActivity.java
+++ b/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/popovers/PopoversActivity.java
@@ -85,12 +85,18 @@ public void run() {
     }, 2000);
   }
 
+  @Override
+  @Map3DMode
+  protected int getDefaultMapMode() {
+    return Map3DMode.SATELLITE;
+  }
+
   private void initializeMap(@NonNull GoogleMap3D googleMap3D) {
     if (isInitialized) return;
     isInitialized = true;
+    super.onMapReady(googleMap3D);
 
     googleMap3D.setCamera(getInitialCamera());
-    googleMap3D.setMapMode(Map3DMode.SATELLITE);
     setupPopover(googleMap3D);
   }
 
diff --git a/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/projection3d/Projection3DActivity.java b/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/projection3d/Projection3DActivity.java
index 0fa7ad88..7307a995 100644
--- a/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/projection3d/Projection3DActivity.java
+++ b/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/projection3d/Projection3DActivity.java
@@ -36,6 +36,7 @@
 import com.google.android.gms.maps3d.model.Camera;
 import com.google.android.gms.maps3d.model.FlyToOptions;
 import com.google.android.gms.maps3d.model.LatLngAltitude;
+import com.google.android.gms.maps3d.model.Map3DMode;
 import com.google.android.material.appbar.MaterialToolbar;
 import com.google.android.material.button.MaterialButton;
 
@@ -69,6 +70,12 @@ public String getTAG() {
         return "Projection3DActivity";
     }
 
+    @Override
+    @Map3DMode
+    protected int getDefaultMapMode() {
+        return Map3DMode.SATELLITE;
+    }
+
     @NonNull
     @Override
     public Camera getInitialCamera() {
diff --git a/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/roadmapmode/RoadmapModeActivity.java b/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/roadmapmode/RoadmapModeActivity.java
index e50eebf0..1bc302ef 100644
--- a/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/roadmapmode/RoadmapModeActivity.java
+++ b/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/roadmapmode/RoadmapModeActivity.java
@@ -31,6 +31,8 @@
 import androidx.annotation.Nullable;
 import androidx.cardview.widget.CardView;
 
+import com.example.maps3d.common.Map3DSettings;
+import com.example.maps3d.common.Map3DSettingsController;
 import com.example.maps3dcommon.R;
 import com.example.maps3djava.sampleactivity.SampleBaseActivity;
 import com.google.android.gms.maps.model.LatLng;
@@ -85,6 +87,7 @@ public class RoadmapModeActivity extends SampleBaseActivity {
   // --- State Variables ---
 
   private boolean isCollapsed = false;
+  private boolean isSyncingRadioGroup = false;
 
   // --- Handlers & Runnables ---
 
@@ -106,6 +109,12 @@ public String getTAG() {
     return "RoadmapModeActivity";
   }
 
+  @Override
+  @Map3DMode
+  protected int getDefaultMapMode() {
+    return Map3DMode.ROADMAP;
+  }
+
   @NonNull
   @Override
   public Camera getInitialCamera() {
@@ -176,15 +185,22 @@ private void initViews() {
 
     if (rgMapMode != null) {
       rgMapMode.setOnCheckedChangeListener((group, checkedId) -> {
-        if (googleMap3D == null) {
+        if (isSyncingRadioGroup) {
           return;
         }
+        int mode;
         if (checkedId == R.id.rb_roadmap) {
-          googleMap3D.setMapMode(Map3DMode.ROADMAP);
+          mode = Map3DMode.ROADMAP;
         } else if (checkedId == R.id.rb_hybrid) {
-          googleMap3D.setMapMode(Map3DMode.HYBRID);
+          mode = Map3DMode.HYBRID;
         } else if (checkedId == R.id.rb_satellite) {
-          googleMap3D.setMapMode(Map3DMode.SATELLITE);
+          mode = Map3DMode.SATELLITE;
+        } else {
+          return;
+        }
+        Map3DSettingsController.getShared().setMapMode(mode);
+        if (googleMap3D != null) {
+          Map3DSettingsController.getShared().getSettings().applyTo(googleMap3D);
         }
       });
     }
@@ -193,6 +209,29 @@ private void initViews() {
     fadeHandler.postDelayed(fadeOutRunnable, 3000L);
   }
 
+  @Override
+  protected void onQuickSettingsChanged(@NonNull Map3DSettings settings) {
+    if (rgMapMode == null) {
+      return;
+    }
+    int targetId;
+    int mapMode = settings.getMapMode();
+    if (mapMode == Map3DMode.ROADMAP) {
+      targetId = R.id.rb_roadmap;
+    } else if (mapMode == Map3DMode.HYBRID) {
+      targetId = R.id.rb_hybrid;
+    } else if (mapMode == Map3DMode.SATELLITE) {
+      targetId = R.id.rb_satellite;
+    } else {
+      return;
+    }
+    if (rgMapMode.getCheckedRadioButtonId() != targetId) {
+      isSyncingRadioGroup = true;
+      rgMapMode.check(targetId);
+      isSyncingRadioGroup = false;
+    }
+  }
+
   // --- UI Collapse / Expand Mechanics ---
 
   /**
@@ -248,13 +287,9 @@ public boolean dispatchTouchEvent(MotionEvent ev) {
   // --- 3D Map Setup ---
 
   @Override
-  public void onMap3DViewReady(@NonNull GoogleMap3D googleMap3D) {
-    super.onMap3DViewReady(googleMap3D);
-    googleMap3D.setOnMapReadyListener(sceneReadiness -> {
-      googleMap3D.setOnMapReadyListener(null);
-      googleMap3D.setMapMode(Map3DMode.ROADMAP);
-      googleMap3D.setCamera(getInitialCamera());
-    });
+  protected void onMapReady(@NonNull GoogleMap3D googleMap3D) {
+    super.onMapReady(googleMap3D);
+    googleMap3D.setCamera(getInitialCamera());
   }
 
   // --- Teardown ---
diff --git a/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/routes/RoutesActivity.java b/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/routes/RoutesActivity.java
index bf694e77..d1278e4e 100644
--- a/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/routes/RoutesActivity.java
+++ b/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/routes/RoutesActivity.java
@@ -380,10 +380,15 @@ private void togglePlayback(boolean play) {
 
   // --- Map Readiness & Route Rendering ---
 
+  @Override
+  @Map3DMode
+  protected int getDefaultMapMode() {
+    return Map3DMode.SATELLITE;
+  }
+
   @Override
   public void onMap3DViewReady(@NonNull GoogleMap3D googleMap3D) {
     super.onMap3DViewReady(googleMap3D);
-    googleMap3D.setMapMode(Map3DMode.SATELLITE);
 
     // Trigger async route fetch on executor thread
     loadAndRenderRouteAsync(googleMap3D);
diff --git a/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/sampleactivity/SampleBaseActivity.java b/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/sampleactivity/SampleBaseActivity.java
index 612d9d83..d129ac5b 100644
--- a/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/sampleactivity/SampleBaseActivity.java
+++ b/Maps3DSamples/ApiDemos/java-app/src/main/java/com/example/maps3djava/sampleactivity/SampleBaseActivity.java
@@ -24,6 +24,7 @@
 import android.os.Looper;
 import android.util.Log;
 import android.view.View;
+import android.view.ViewGroup;
 import android.widget.Toast;
 
 import androidx.annotation.CallSuper;
@@ -33,7 +34,12 @@
 import androidx.core.view.ViewCompat;
 import androidx.core.view.WindowCompat;
 import androidx.core.view.WindowInsetsCompat;
+import androidx.core.view.WindowInsetsControllerCompat;
 
+import com.example.maps3d.common.Map3DQuickSettingsButton;
+import com.example.maps3d.common.Map3DSettings;
+import com.example.maps3d.common.Map3DSettingsController;
+import com.example.maps3d.common.Map3DUiControls;
 import com.example.maps3dcommon.R;
 import com.google.android.gms.maps3d.GoogleMap3D;
 import com.google.android.gms.maps3d.Map3DView;
@@ -41,6 +47,7 @@
 import com.google.android.gms.maps3d.OnMap3DViewReadyCallback;
 import com.google.android.gms.maps3d.model.Camera;
 import com.google.android.gms.maps3d.model.FlyToOptions;
+import com.google.android.gms.maps3d.model.Map3DMode;
 import com.google.android.material.appbar.MaterialToolbar;
 import com.google.android.material.button.MaterialButton;
 
@@ -84,6 +91,65 @@ protected int getLayoutResId() {
 
     private OnCameraChangedListener cameraChangedListener;
 
+    private int lastStatusBarTop = 0;
+
+    private void applyStatusBarInsetsToMapControls(int statusBarTop, Map3DUiControls uiControls) {
+        if (statusBarTop > 0) {
+            lastStatusBarTop = statusBarTop;
+        }
+
+        Map3DQuickSettingsButton quickSettingsButton = findViewById(R.id.quick_settings_button);
+        if (quickSettingsButton != null) {
+            Map3DUiControls currentUi = uiControls != null ? uiControls : quickSettingsButton.getSettings().getUiControls();
+            quickSettingsButton.setStatusBarTopOffsetPx(lastStatusBarTop);
+            quickSettingsButton.updateTopMarginForUiControls(currentUi);
+        }
+    }
+
+    @Override
+    public void setContentView(int layoutResID) {
+        super.setContentView(layoutResID);
+        bindWindowInsetsAndMapHierarchy();
+    }
+
+    private void bindWindowInsetsAndMapHierarchy() {
+        View rootView = findViewById(R.id.map_container);
+        boolean hasOverlayAppBar = findViewById(R.id.app_bar_layout) != null;
+        if (!hasOverlayAppBar) {
+            lastStatusBarTop = 0;
+            Map3DQuickSettingsButton button = findViewById(R.id.quick_settings_button);
+            if (button != null) {
+                button.setStatusBarTopOffsetPx(0);
+                button.updateTopMarginForUiControls();
+            }
+            return;
+        }
+
+        if (rootView != null) {
+            ViewCompat.setOnApplyWindowInsetsListener(rootView, (v, windowInsets) -> {
+                Insets statusBarInsets = windowInsets.getInsets(WindowInsetsCompat.Type.statusBars());
+                Insets navInsets = windowInsets.getInsets(WindowInsetsCompat.Type.navigationBars());
+
+                View appBarLayout = findViewById(R.id.app_bar_layout);
+                if (appBarLayout != null) {
+                    appBarLayout.setPadding(0, statusBarInsets.top, 0, 0);
+                }
+                applyStatusBarInsetsToMapControls(statusBarInsets.top, null);
+
+                View controlScrollView = findViewById(R.id.control_scroll_view);
+                if (controlScrollView != null) {
+                    ViewGroup.MarginLayoutParams layoutParams = (ViewGroup.MarginLayoutParams) controlScrollView
+                            .getLayoutParams();
+                    int margin16dp = (int) (16 * getResources().getDisplayMetrics().density);
+                    layoutParams.bottomMargin = navInsets.bottom + margin16dp;
+                    controlScrollView.setLayoutParams(layoutParams);
+                }
+
+                return WindowInsetsCompat.CONSUMED;
+            });
+        }
+    }
+
     @CallSuper
     @Override
     protected void onCreate(Bundle savedInstanceState) {
@@ -91,6 +157,7 @@ protected void onCreate(Bundle savedInstanceState) {
 
         // This tells the system that the app will handle drawing behind the system bars.
         WindowCompat.setDecorFitsSystemWindows(getWindow(), false);
+        enableImmersiveMode();
 
         setContentView(getLayoutResId());
         View rootView = findViewById(R.id.map_container);
@@ -109,6 +176,8 @@ protected void onCreate(Bundle savedInstanceState) {
                 if (appBarLayout != null) {
                     appBarLayout.setPadding(0, statusBarInsets.top, 0, 0);
                 }
+                applyStatusBarInsetsToMapControls(statusBarInsets.top, null);
+
                 View controlScrollView = findViewById(R.id.control_scroll_view);
                 if (controlScrollView != null) {
                     android.view.ViewGroup.MarginLayoutParams layoutParams = (android.view.ViewGroup.MarginLayoutParams) controlScrollView
@@ -121,7 +190,6 @@ protected void onCreate(Bundle savedInstanceState) {
                 return WindowInsetsCompat.CONSUMED;
             });
         }
-
         map3DView = findViewById(R.id.map3dView);
         map3DView.onCreate(savedInstanceState);
         map3DView.getMap3DViewAsync(this);
@@ -145,11 +213,38 @@ protected void onCreate(Bundle savedInstanceState) {
         }
     }
 
+    /**
+     * Enables sticky immersive mode so the 3D map canvas occupies the entire display,
+     * hiding status and navigation bars while allowing transient reveal on edge swipes.
+     */
+    protected void enableImmersiveMode() {
+        WindowInsetsControllerCompat insetsController = WindowCompat.getInsetsController(getWindow(), getWindow().getDecorView());
+        if (insetsController != null) {
+            insetsController.setSystemBarsBehavior(WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE);
+            insetsController.hide(WindowInsetsCompat.Type.systemBars());
+        }
+    }
+
+    @Override
+    public void onWindowFocusChanged(boolean hasFocus) {
+        super.onWindowFocusChanged(hasFocus);
+        if (hasFocus) {
+            enableImmersiveMode();
+        }
+    }
+
     @CallSuper
     @Override
     protected void onResume() {
         super.onResume();
+        enableImmersiveMode();
         map3DView.onResume();
+        if (googleMap3D != null) {
+            Map3DSettings currentSettings = Map3DSettingsController.getShared().getSettings();
+            currentSettings.applyTo(googleMap3D);
+            onQuickSettingsChanged(currentSettings);
+            applyStatusBarInsetsToMapControls(lastStatusBarTop, currentSettings.getUiControls());
+        }
     }
 
     @CallSuper
@@ -184,12 +279,64 @@ protected void onSaveInstanceState(@NonNull Bundle outState) {
         map3DView.onSaveInstanceState(outState);
     }
 
+    /**
+     * Default Map Mode for this sample when the user has not explicitly overridden the mode in the
+     * current app session.
+     */
+    @Map3DMode
+    protected int getDefaultMapMode() {
+        return Map3DMode.HYBRID;
+    }
+
+    /**
+     * Hook invoked whenever Quick Settings change so subclasses with inline controls can stay in
+     * sync.
+     */
+    protected void onQuickSettingsChanged(@NonNull Map3DSettings settings) {}
+
+    private boolean isMapInitialized = false;
+
+    /**
+     * Called when the map is guaranteed ready and rendering has stabilized.
+     * Subclasses can override this to perform entity addition and map setup.
+     */
+    @CallSuper
+    protected void onMapReady(@NonNull GoogleMap3D googleMap3D) {
+        if (isMapInitialized) return;
+        isMapInitialized = true;
+        Log.d(getTAG(), "onMapReady called (guaranteed once)");
+
+        googleMap3D.setCamera(getInitialCamera());
+        Map3DSettingsController.getShared().onSampleEntered(getDefaultMapMode());
+        Map3DSettings initialSettings = Map3DSettingsController.getShared().getSettings();
+        initialSettings.applyTo(googleMap3D);
+        onQuickSettingsChanged(initialSettings);
+
+        Map3DQuickSettingsButton quickSettings = findViewById(R.id.quick_settings_button);
+        if (quickSettings != null) {
+            quickSettings.setSettingsController(Map3DSettingsController.getShared());
+            quickSettings.setSampleDefaultMapMode(getDefaultMapMode());
+            quickSettings.attachMap(googleMap3D);
+            quickSettings.setOnSettingsChangedListener(updatedSettings -> {
+                onQuickSettingsChanged(updatedSettings);
+                applyStatusBarInsetsToMapControls(lastStatusBarTop, updatedSettings.getUiControls());
+            });
+        }
+        applyStatusBarInsetsToMapControls(lastStatusBarTop, null);
+
+        // Re-apply settings and UI controls after viewport stabilizes
+        new Handler(Looper.getMainLooper()).postDelayed(() -> {
+            if (!isDestroyed() && !isFinishing() && this.googleMap3D != null) {
+                Map3DSettings currentSettings = Map3DSettingsController.getShared().getSettings();
+                currentSettings.applyTo(this.googleMap3D);
+                onQuickSettingsChanged(currentSettings);
+                applyStatusBarInsetsToMapControls(lastStatusBarTop, currentSettings.getUiControls());
+            }
+        }, 350L);
+    }
+
     /**
      * Called when the [Map3DView] is ready to be used.
-     * <p>
-     * This method is called after the [Map3DView] has been initialized and is ready to receive
-     * commands. It sets the internal [googleMap3D] reference and sets the initial camera
-     * position and orientation.
      *
      * @param googleMap3D The [GoogleMap3D] instance that is ready to be used.
      */
@@ -197,16 +344,13 @@ protected void onSaveInstanceState(@NonNull Bundle outState) {
     @Override
     public void onMap3DViewReady(GoogleMap3D googleMap3D) {
         this.googleMap3D = googleMap3D;
+        Log.d(getTAG(), "onMap3DViewReady called");
 
-        // Workaround: The Maps 3D SDK onMap3DViewReady callback fires when the map object
-        // is instantiated, but the internal native rendering pipeline and layout pass may briefly
-        // override initial programmatic camera positions. A short delay ensures the native map viewport
-        // has fully stabilized before applying the initial camera position.
-        new Handler(Looper.getMainLooper()).postDelayed(() -> {
-            if (!isDestroyed() && !isFinishing() && this.googleMap3D != null) {
-                this.googleMap3D.setCamera(getInitialCamera());
-            }
-        }, 350L);
+        // Wire up the standardized listener
+        googleMap3D.setOnMapReadyListener(map -> {
+            googleMap3D.setOnMapReadyListener(null);
+            onMapReady(googleMap3D);
+        });
 
         // Mark map view as steady when rendering stabilizes for automated visual tests
         googleMap3D.setOnMapSteadyListener(isSceneSteady -> {
@@ -215,11 +359,15 @@ public void onMap3DViewReady(GoogleMap3D googleMap3D) {
             }
         });
 
+        // Ensure onMapReady triggers even on delayed or reused fragments.
+        new Handler(Looper.getMainLooper()).postDelayed(() -> {
+            onMapReady(googleMap3D);
+        }, 2000L);
+
         // Initialize and set the camera changed listener
         cameraChangedListener = cameraPosition -> {
         };
         googleMap3D.setCameraChangedListener(cameraChangedListener);
-
     }
 
     @CallSuper
@@ -308,4 +456,4 @@ public boolean onKeyDown(int keyCode, android.view.KeyEvent event) {
 
         return super.onKeyDown(keyCode, event);
     }
-}
\ No newline at end of file
+}
diff --git a/Maps3DSamples/ApiDemos/kotlin-app/src/main/AndroidManifest.xml b/Maps3DSamples/ApiDemos/kotlin-app/src/main/AndroidManifest.xml
index 70304d81..256963c4 100644
--- a/Maps3DSamples/ApiDemos/kotlin-app/src/main/AndroidManifest.xml
+++ b/Maps3DSamples/ApiDemos/kotlin-app/src/main/AndroidManifest.xml
@@ -217,6 +217,13 @@
             android:exported="true"
             />
 
+        <activity
+            android:name=".uicontrols.UiControlsActivity"
+            android:theme="@style/Theme.Maps3DSamples"
+            android:label="@string/feature_title_ui_controls"
+            android:exported="true"
+            />
+
     </application>
 
 </manifest>
diff --git a/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/advancedcameraanimation/AdvancedCameraAnimationActivity.kt b/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/advancedcameraanimation/AdvancedCameraAnimationActivity.kt
index e49ec09f..41c543a5 100644
--- a/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/advancedcameraanimation/AdvancedCameraAnimationActivity.kt
+++ b/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/advancedcameraanimation/AdvancedCameraAnimationActivity.kt
@@ -48,6 +48,7 @@ import com.example.maps3dkotlin.sampleactivity.SampleBaseActivity
 import com.google.android.gms.maps3d.GoogleMap3D
 import com.google.android.gms.maps3d.model.Camera
 import com.google.android.gms.maps3d.model.FlyToOptions
+import com.google.android.gms.maps3d.model.Map3DMode
 import com.google.android.gms.maps3d.model.camera
 import com.google.android.gms.maps3d.model.flyToOptions
 import com.google.android.gms.maps3d.model.flyAroundOptions
@@ -77,6 +78,9 @@ import kotlin.coroutines.resume
 class AdvancedCameraAnimationActivity : SampleBaseActivity() {
     override val TAG: String = "AdvancedCameraAnimationActivity"
 
+    @Map3DMode
+    override val defaultMapMode: Int = Map3DMode.SATELLITE
+
     override val initialCamera: Camera = camera {
         center = latLngAltitude {
             latitude = TourData.AIRPLANE_FLIGHT_PATH.first().latitude
diff --git a/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/cameracontrols/CameraControlsActivity.kt b/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/cameracontrols/CameraControlsActivity.kt
index 60374835..4214e638 100644
--- a/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/cameracontrols/CameraControlsActivity.kt
+++ b/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/cameracontrols/CameraControlsActivity.kt
@@ -15,6 +15,7 @@
 package com.example.maps3dkotlin.cameracontrols
 
 import android.os.Bundle
+import android.view.View
 import android.widget.RadioGroup
 import android.widget.TextView
 import androidx.core.view.WindowCompat
@@ -38,6 +39,8 @@ import com.example.maps3dkotlin.cameracontrols.DataModel.nycCameraRestriction
 import com.example.maps3dkotlin.cameracontrols.DataModel.nycPolygonOptions
 import com.example.maps3dkotlin.cameracontrols.DataModel.EMPIRE_STATE_BUILDING_LATITUDE
 import com.example.maps3dkotlin.cameracontrols.DataModel.EMPIRE_STATE_BUILDING_LONGITUDE
+import com.example.maps3d.common.Map3DSettings
+import com.example.maps3d.common.Map3DSettingsController
 import com.example.maps3d.common.copy
 import com.example.maps3d.common.toCompassDirection
 import com.example.maps3d.common.toValidCamera
@@ -49,9 +52,13 @@ import com.google.android.material.slider.Slider
 class CameraControlsActivity : SampleBaseActivity(), OnMap3DViewReadyCallback {
     override val TAG = this::class.java.simpleName
 
+    @Map3DMode
+    override val defaultMapMode: Int = Map3DMode.SATELLITE
+
     private lateinit var cameraStateText: TextView
     private lateinit var rollSlider: Slider
     private lateinit var rollSliderLabel: TextView
+    private var isSyncingRadioGroup = false
 
     private var restrictionCubeFaces: MutableList<Polygon> = mutableListOf()
 
@@ -127,9 +134,15 @@ class CameraControlsActivity : SampleBaseActivity(), OnMap3DViewReadyCallback {
 
         // Set listener for RadioGroup
         findViewById<RadioGroup>(R.id.map_mode_radio_group).setOnCheckedChangeListener { _, checkedId ->
-            when (checkedId) {
-                R.id.map_mode_hybrid -> googleMap3D?.setMapMode(Map3DMode.HYBRID)
-                R.id.map_mode_satellite -> googleMap3D?.setMapMode(Map3DMode.SATELLITE)
+            if (isSyncingRadioGroup) return@setOnCheckedChangeListener
+            val mode = when (checkedId) {
+                R.id.map_mode_hybrid -> Map3DMode.HYBRID
+                R.id.map_mode_satellite -> Map3DMode.SATELLITE
+                else -> return@setOnCheckedChangeListener
+            }
+            Map3DSettingsController.shared.setMapMode(mode)
+            googleMap3D?.let { map ->
+                Map3DSettingsController.shared.settings.value.applyTo(map)
             }
         }
 
@@ -149,6 +162,24 @@ class CameraControlsActivity : SampleBaseActivity(), OnMap3DViewReadyCallback {
         }
     }
 
+    override fun onQuickSettingsChanged(settings: Map3DSettings) {
+        val group = findViewById<RadioGroup?>(R.id.map_mode_radio_group) ?: return
+        val targetId = when (settings.mapMode) {
+            Map3DMode.HYBRID -> R.id.map_mode_hybrid
+            Map3DMode.SATELLITE -> R.id.map_mode_satellite
+            else -> View.NO_ID
+        }
+        if (group.checkedRadioButtonId != targetId) {
+            isSyncingRadioGroup = true
+            if (targetId == View.NO_ID) {
+                group.clearCheck()
+            } else {
+                group.check(targetId)
+            }
+            isSyncingRadioGroup = false
+        }
+    }
+
     private fun updateRollSliderLabel(value: Float) {
         rollSliderLabel.text = getString(R.string.camera_roll_label_dynamic, value)
     }
diff --git a/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/datavisualization/DataVisualizationActivity.kt b/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/datavisualization/DataVisualizationActivity.kt
index 7b6b4200..899809b3 100644
--- a/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/datavisualization/DataVisualizationActivity.kt
+++ b/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/datavisualization/DataVisualizationActivity.kt
@@ -37,7 +37,6 @@ import com.google.android.gms.maps3d.GoogleMap3D
 import com.google.android.gms.maps3d.model.AltitudeMode
 import com.google.android.gms.maps3d.model.Camera
 import com.google.android.gms.maps3d.model.LatLngAltitude
-import com.google.android.gms.maps3d.model.Map3DMode
 import com.google.android.gms.maps3d.model.Polygon
 import com.google.android.gms.maps3d.model.camera
 import com.google.android.gms.maps3d.model.flyToOptions
@@ -210,7 +209,6 @@ class DataVisualizationActivity : SampleBaseActivity() {
 
   override fun onMapReady(googleMap3D: GoogleMap3D) {
     super.onMapReady(googleMap3D)
-    googleMap3D.setMapMode(Map3DMode.HYBRID)
     googleMap3D.flyCameraTo(
       flyToOptions {
         endCamera = initialCamera
diff --git a/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/fieldofview/FieldOfViewActivity.kt b/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/fieldofview/FieldOfViewActivity.kt
index bc86fa45..c10f4be7 100644
--- a/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/fieldofview/FieldOfViewActivity.kt
+++ b/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/fieldofview/FieldOfViewActivity.kt
@@ -32,6 +32,7 @@ import com.example.maps3dkotlin.sampleactivity.SampleBaseActivity
 import com.google.android.gms.maps.model.LatLng
 import com.google.android.gms.maps3d.GoogleMap3D
 import com.google.android.gms.maps3d.model.Camera
+import com.google.android.gms.maps3d.model.Map3DMode
 import com.google.android.gms.maps3d.model.camera
 import com.google.android.gms.maps3d.model.latLngAltitude
 import com.google.android.material.appbar.MaterialToolbar
@@ -69,6 +70,9 @@ class FieldOfViewActivity : SampleBaseActivity() {
 
   override val TAG = "FieldOfViewActivity"
 
+  @Map3DMode
+  override val defaultMapMode: Int = Map3DMode.SATELLITE
+
   override val initialCamera: Camera
     get() = camera {
       center = latLngAltitude {
diff --git a/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/hellomap/HelloMapActivity.kt b/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/hellomap/HelloMapActivity.kt
index cd179998..05886a66 100644
--- a/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/hellomap/HelloMapActivity.kt
+++ b/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/hellomap/HelloMapActivity.kt
@@ -14,19 +14,22 @@
 
 package com.example.maps3dkotlin.hellomap
 
-import android.app.Activity
 import android.os.Bundle
 import android.util.Log
-import android.view.View
-import androidx.core.view.ViewCompat
+import androidx.activity.enableEdgeToEdge
+import androidx.appcompat.app.AppCompatActivity
+import androidx.core.view.WindowCompat
 import androidx.core.view.WindowInsetsCompat
-import androidx.core.view.updatePadding
+import androidx.core.view.WindowInsetsControllerCompat
+import com.example.maps3d.common.Map3DQuickSettingsButton
+import com.example.maps3d.common.Map3DSettingsController
 import com.example.maps3dcommon.R
 import com.google.android.gms.maps3d.GoogleMap3D
 import com.google.android.gms.maps3d.Map3DView
 import com.google.android.gms.maps3d.OnMap3DViewReadyCallback
 import com.google.android.gms.maps3d.model.Camera
 import com.google.android.gms.maps3d.model.LatLngAltitude
+import com.google.android.gms.maps3d.model.Map3DMode
 
 /**
  * `HelloMapActivity` serves as a foundational example for integrating `Map3DView` into an
@@ -34,7 +37,7 @@ import com.google.android.gms.maps3d.model.LatLngAltitude
  * map, initializing the `Map3DView`, and obtaining a reference to the `GoogleMap3D` object
  * to interact with the map programmatically.
  */
-class HelloMapActivity : Activity(), OnMap3DViewReadyCallback {
+class HelloMapActivity : AppCompatActivity(), OnMap3DViewReadyCallback {
     // Using a companion object for the TAG is a common Kotlin pattern. It's static, final,
     // and accessible via the class name, making it a good practice for logging.
     companion object {
@@ -51,28 +54,10 @@ class HelloMapActivity : Activity(), OnMap3DViewReadyCallback {
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
+        enableEdgeToEdge()
+        enableImmersiveMode()
         setContentView(R.layout.activity_hello_map)
 
-        // The root view is identified once and then used for setting up window insets.
-        // This is a clean way to handle the view hierarchy.
-        val rootView = findViewById<View>(R.id.map_container)
-        ViewCompat.setOnApplyWindowInsetsListener(rootView) { view, insets ->
-            // We retrieve the insets for the status and navigation bars to adjust the padding.
-            // This ensures that the map content is not obscured by the system UI.
-            val statusBarInsets = insets.getInsets(WindowInsetsCompat.Type.statusBars())
-            val navigationBarInsets = insets.getInsets(WindowInsetsCompat.Type.navigationBars())
-
-            // The padding of the view is updated to account for the system bars.
-            // This is a more robust way to handle window insets than manual calculations.
-            view.updatePadding(
-                top = view.paddingTop + statusBarInsets.top,
-                bottom = view.paddingBottom + navigationBarInsets.bottom
-            )
-
-            // We consume the insets to prevent further processing by other views.
-            WindowInsetsCompat.CONSUMED
-        }
-
         // The Map3DView is initialized and its lifecycle is managed by forwarding the
         // activity's lifecycle events. This is a required step for the map to function correctly.
         map3DView = findViewById(R.id.map3dView)
@@ -80,6 +65,20 @@ class HelloMapActivity : Activity(), OnMap3DViewReadyCallback {
         map3DView.getMap3DViewAsync(this)
     }
 
+    private fun enableImmersiveMode() {
+        val insetsController = WindowCompat.getInsetsController(window, window.decorView)
+        insetsController.systemBarsBehavior =
+            WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
+        insetsController.hide(WindowInsetsCompat.Type.systemBars())
+    }
+
+    override fun onWindowFocusChanged(hasFocus: Boolean) {
+        super.onWindowFocusChanged(hasFocus)
+        if (hasFocus) {
+            enableImmersiveMode()
+        }
+    }
+
     /**
      * This callback is invoked when the `Map3DView` has been initialized and is ready for use.
      * At this point, the `GoogleMap3D` object is available, allowing for interaction with the
@@ -110,6 +109,14 @@ class HelloMapActivity : Activity(), OnMap3DViewReadyCallback {
 
         Log.i(TAG, "Initializing map position to Delicate Arch")
 
+        Map3DSettingsController.shared.onSampleEntered(Map3DMode.HYBRID)
+        Map3DSettingsController.shared.settings.value.applyTo(map)
+        findViewById<Map3DQuickSettingsButton?>(R.id.quick_settings_button)?.apply {
+            settingsController = Map3DSettingsController.shared
+            sampleDefaultMapMode = Map3DMode.HYBRID
+            attachMap(map)
+        }
+
         val center = LatLngAltitude(38.743502, -109.499374, 1467.0)
         val initialCamera = Camera(center, 349.6, 58.1, 0.0, 138.2)
 
@@ -128,7 +135,6 @@ class HelloMapActivity : Activity(), OnMap3DViewReadyCallback {
         // It's important to log errors to aid in debugging. In a production application,
         // you might also want to display a user-friendly message.
         Log.e(TAG, "Error loading map", error)
-        super.onError(error)
     }
 
     // The following methods are lifecycle callbacks that must be forwarded to the Map3DView.
@@ -138,7 +144,11 @@ class HelloMapActivity : Activity(), OnMap3DViewReadyCallback {
 
     override fun onResume() {
         super.onResume()
+        enableImmersiveMode()
         map3DView.onResume()
+        googleMap3D?.let { map ->
+            Map3DSettingsController.shared.settings.value.applyTo(map)
+        }
     }
 
     override fun onPause() {
diff --git a/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/mainactivity/MainActivity.kt b/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/mainactivity/MainActivity.kt
index ae8613ea..2be6b1c1 100644
--- a/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/mainactivity/MainActivity.kt
+++ b/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/mainactivity/MainActivity.kt
@@ -69,6 +69,7 @@ import com.example.maps3dkotlin.roadmapmode.RoadmapModeActivity
 import com.example.maps3dkotlin.fieldofview.FieldOfViewActivity
 import com.example.maps3dkotlin.projection3d.Projection3DActivity
 import com.example.maps3dkotlin.mapslocalization.MapsLocalizationActivity
+import com.example.maps3dkotlin.uicontrols.UiControlsActivity
 import com.example.maps3dkotlin.theme.Maps3DSamplesTheme
 import kotlinx.coroutines.launch
 
@@ -115,6 +116,7 @@ class MainActivity : ComponentActivity() {
         Sample(R.string.feature_title_data_visualization, DataVisualizationActivity::class.java),
         Sample(R.string.feature_title_cloud_styling, CloudStylingActivity::class.java),
         Sample(R.string.feature_title_roadmap_mode, RoadmapModeActivity::class.java),
+        Sample(R.string.feature_title_ui_controls, UiControlsActivity::class.java),
         Sample(R.string.feature_title_field_of_view, FieldOfViewActivity::class.java),
         Sample(R.string.feature_title_projection_3d, Projection3DActivity::class.java),
         Sample(R.string.feature_title_maps_localization, MapsLocalizationActivity::class.java),
diff --git a/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/mapinteractions/MapInteractionsActivity.kt b/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/mapinteractions/MapInteractionsActivity.kt
index 0eee3827..594e8f31 100644
--- a/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/mapinteractions/MapInteractionsActivity.kt
+++ b/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/mapinteractions/MapInteractionsActivity.kt
@@ -24,7 +24,6 @@ import androidx.lifecycle.lifecycleScope
 import com.example.maps3dcommon.R
 import com.example.maps3dkotlin.sampleactivity.SampleBaseActivity
 import com.google.android.gms.maps3d.GoogleMap3D
-import com.google.android.gms.maps3d.model.Map3DMode
 import com.google.android.gms.maps3d.model.camera
 import com.google.android.gms.maps3d.model.latLngAltitude
 import kotlinx.coroutines.launch
@@ -58,7 +57,6 @@ class MapInteractionsActivity : SampleBaseActivity() {
 
     override fun onMapReady(googleMap3D: GoogleMap3D) {
         super.onMapReady(googleMap3D)
-        googleMap3D.setMapMode(Map3DMode.HYBRID)
 
         // Listeners for map clicks. We use lifecycleScope to ensure coroutines are cancelled when the activity is destroyed.
         lifecycleScope.launch {
diff --git a/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/markers/MarkersActivity.kt b/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/markers/MarkersActivity.kt
index 39f1f8ec..a54fa375 100644
--- a/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/markers/MarkersActivity.kt
+++ b/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/markers/MarkersActivity.kt
@@ -100,9 +100,11 @@ class MarkersActivity : SampleBaseActivity() {
     // scene without digging into the logic of the activity.
     override val initialCamera = nycCamera
 
+    @Map3DMode
+    override val defaultMapMode: Int = Map3DMode.SATELLITE
+
     override fun onMapReady(googleMap3D: GoogleMap3D) {
         super.onMapReady(googleMap3D)
-        googleMap3D.setMapMode(Map3DMode.SATELLITE)
 
         findViewById<Button>(R.id.fly_berlin_button)?.apply {
             runOnUiThread {
diff --git a/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/models/ModelsActivity.kt b/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/models/ModelsActivity.kt
index e5d034c9..fe7e9a7d 100644
--- a/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/models/ModelsActivity.kt
+++ b/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/models/ModelsActivity.kt
@@ -98,10 +98,12 @@ class ModelsActivity : SampleBaseActivity() {
         }
     }
 
+    @Map3DMode
+    override val defaultMapMode: Int = Map3DMode.SATELLITE
+
     @OptIn(FlowPreview::class)
     override fun onMapReady(googleMap3D: GoogleMap3D) {
         super.onMapReady(googleMap3D)
-        googleMap3D.setMapMode(Map3DMode.SATELLITE)
 
         // Loading and adding models can be synonymous with network or disk I/O, so we do it on a background thread.
         lifecycleScope.launch(Dispatchers.Default) {
diff --git a/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/pathfollowing/PathFollowingActivity.kt b/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/pathfollowing/PathFollowingActivity.kt
index f7d8c13e..44e80960 100644
--- a/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/pathfollowing/PathFollowingActivity.kt
+++ b/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/pathfollowing/PathFollowingActivity.kt
@@ -34,6 +34,8 @@ import androidx.core.graphics.toColorInt
 import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.lifecycleScope
 import androidx.lifecycle.repeatOnLifecycle
+import com.example.maps3d.common.Map3DQuickSettingsButton
+import com.example.maps3d.common.Map3DSettingsController
 import com.example.maps3d.common.PathData
 import com.example.maps3d.common.PathEngine
 import com.example.maps3d.common.PathFollowingViewModel
@@ -47,6 +49,7 @@ import com.google.android.gms.maps3d.OnMap3DViewReadyCallback
 import com.google.android.gms.maps3d.model.AltitudeMode
 import com.google.android.gms.maps3d.model.Camera
 import com.google.android.gms.maps3d.model.LatLngAltitude
+import com.google.android.gms.maps3d.model.Map3DMode
 import com.google.android.gms.maps3d.model.Polyline
 import com.google.android.gms.maps3d.model.PolylineOptions
 import com.google.android.material.button.MaterialButton
@@ -143,11 +146,22 @@ class PathFollowingActivity : AppCompatActivity(), OnMap3DViewReadyCallback {
             runOnUiThread {
                 if (isMapInitialized) return@runOnUiThread
                 isMapInitialized = true
+                Map3DSettingsController.shared.onSampleEntered(Map3DMode.HYBRID)
+                Map3DSettingsController.shared.settings.value.applyTo(googleMap3D)
+                findViewById<Map3DQuickSettingsButton?>(R.id.quick_settings_button)?.apply {
+                    settingsController = Map3DSettingsController.shared
+                    sampleDefaultMapMode = Map3DMode.HYBRID
+                    attachMap(googleMap3D)
+                }
                 resetPolylines()
             }
         }
     }
 
+    override fun onError(error: Exception) {
+        Log.e(TAG, "Error loading map", error)
+    }
+
     private fun setupCustomGestureHandling() {
         gestureOverlay.setOnTouchListener(PathTouchHandler(this, viewModel))
     }
@@ -695,6 +709,9 @@ class PathFollowingActivity : AppCompatActivity(), OnMap3DViewReadyCallback {
     override fun onResume() {
         super.onResume()
         map3DView.onResume()
+        googleMap3D?.let { map ->
+            Map3DSettingsController.shared.settings.value.applyTo(map)
+        }
     }
 
     override fun onPause() {
diff --git a/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/polygons/PolygonsActivity.kt b/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/polygons/PolygonsActivity.kt
index f3430946..8bd59238 100644
--- a/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/polygons/PolygonsActivity.kt
+++ b/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/polygons/PolygonsActivity.kt
@@ -27,7 +27,6 @@ import com.google.android.gms.maps3d.GoogleMap3D
 import com.google.android.gms.maps3d.model.AltitudeMode
 import com.google.android.gms.maps3d.model.Camera
 import com.google.android.gms.maps3d.model.Hole
-import com.google.android.gms.maps3d.model.Map3DMode
 import com.google.android.gms.maps3d.model.Polygon
 import com.google.android.gms.maps3d.model.camera
 import com.google.android.gms.maps3d.model.flyToOptions
@@ -88,7 +87,6 @@ class PolygonsActivity : SampleBaseActivity() {
 
     override fun onMapReady(googleMap3D: GoogleMap3D) {
         super.onMapReady(googleMap3D)
-        googleMap3D.setMapMode(Map3DMode.HYBRID)
 
         // The camera is animated to the initial position.
         googleMap3D.flyCameraTo(
diff --git a/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/polylines/PolylinesActivity.kt b/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/polylines/PolylinesActivity.kt
index af0c6a95..9b4f111a 100644
--- a/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/polylines/PolylinesActivity.kt
+++ b/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/polylines/PolylinesActivity.kt
@@ -21,7 +21,6 @@ import androidx.lifecycle.lifecycleScope
 import com.example.maps3dkotlin.sampleactivity.SampleBaseActivity
 import com.google.android.gms.maps3d.GoogleMap3D
 import com.google.android.gms.maps3d.model.AltitudeMode
-import com.google.android.gms.maps3d.model.Map3DMode
 import com.google.android.gms.maps3d.model.Polyline
 import com.google.android.gms.maps3d.model.camera
 import com.google.android.gms.maps3d.model.latLngAltitude
@@ -87,7 +86,6 @@ class PolylinesActivity : SampleBaseActivity() {
 
     override fun onMapReady(googleMap3D: GoogleMap3D) {
         super.onMapReady(googleMap3D)
-        googleMap3D.setMapMode(Map3DMode.HYBRID)
         // Adding polylines can be a heavy operation (parsers), so we do it on a background thread.
         lifecycleScope.launch(Dispatchers.Default) {
             addPolylines(googleMap3D)
diff --git a/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/popovers/PopoversActivity.kt b/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/popovers/PopoversActivity.kt
index dcd02d7b..075b644d 100644
--- a/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/popovers/PopoversActivity.kt
+++ b/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/popovers/PopoversActivity.kt
@@ -58,9 +58,11 @@ class PopoversActivity : SampleBaseActivity() {
         range = 4075.0
     }
 
+    @Map3DMode
+    override val defaultMapMode: Int = Map3DMode.SATELLITE
+
     override fun onMapReady(googleMap3D: GoogleMap3D) {
         super.onMapReady(googleMap3D)
-        googleMap3D.setMapMode(Map3DMode.SATELLITE)
         setupPopover(googleMap3D)
     }
 
diff --git a/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/projection3d/Projection3DActivity.kt b/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/projection3d/Projection3DActivity.kt
index 23b074a5..9794af7b 100644
--- a/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/projection3d/Projection3DActivity.kt
+++ b/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/projection3d/Projection3DActivity.kt
@@ -29,6 +29,7 @@ import com.example.maps3dcommon.R
 import com.example.maps3dkotlin.sampleactivity.SampleBaseActivity
 import com.google.android.gms.maps3d.GoogleMap3D
 import com.google.android.gms.maps3d.model.Camera
+import com.google.android.gms.maps3d.model.Map3DMode
 import com.google.android.gms.maps3d.model.camera
 import com.google.android.gms.maps3d.model.flyToOptions
 import com.google.android.gms.maps3d.model.latLngAltitude
@@ -61,6 +62,9 @@ class Projection3DActivity : SampleBaseActivity() {
 
     override val TAG = "Projection3DActivity"
 
+    @Map3DMode
+    override val defaultMapMode: Int = Map3DMode.SATELLITE
+
     override val initialCamera: Camera
         get() = camera {
             center = latLngAltitude {
diff --git a/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/roadmapmode/RoadmapModeActivity.kt b/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/roadmapmode/RoadmapModeActivity.kt
index 01b9e5b3..8badb4f2 100644
--- a/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/roadmapmode/RoadmapModeActivity.kt
+++ b/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/roadmapmode/RoadmapModeActivity.kt
@@ -25,6 +25,8 @@ import android.view.View
 import android.view.ViewGroup
 import android.widget.RadioGroup
 import androidx.cardview.widget.CardView
+import com.example.maps3d.common.Map3DSettings
+import com.example.maps3d.common.Map3DSettingsController
 import com.example.maps3d.common.toValidCamera
 import com.example.maps3dcommon.R
 import com.example.maps3dkotlin.sampleactivity.SampleBaseActivity
@@ -67,6 +69,9 @@ class RoadmapModeActivity : SampleBaseActivity() {
 
   override val TAG = "RoadmapModeActivity"
 
+  @Map3DMode
+  override val defaultMapMode: Int = Map3DMode.ROADMAP
+
   override val initialCamera: Camera
     get() = camera {
       center = latLngAltitude {
@@ -91,6 +96,7 @@ class RoadmapModeActivity : SampleBaseActivity() {
   // --- State Variables ---
 
   private var isCollapsed = false
+  private var isSyncingRadioGroup = false
 
   // --- Handlers & Runnables ---
 
@@ -144,12 +150,16 @@ class RoadmapModeActivity : SampleBaseActivity() {
     }
 
     rgMapMode?.setOnCheckedChangeListener { _, checkedId ->
+      if (isSyncingRadioGroup) return@setOnCheckedChangeListener
+      val mode = when (checkedId) {
+        R.id.rb_roadmap -> Map3DMode.ROADMAP
+        R.id.rb_hybrid -> Map3DMode.HYBRID
+        R.id.rb_satellite -> Map3DMode.SATELLITE
+        else -> return@setOnCheckedChangeListener
+      }
+      Map3DSettingsController.shared.setMapMode(mode)
       googleMap3D?.let { map ->
-        when (checkedId) {
-          R.id.rb_roadmap -> map.setMapMode(Map3DMode.ROADMAP)
-          R.id.rb_hybrid -> map.setMapMode(Map3DMode.HYBRID)
-          R.id.rb_satellite -> map.setMapMode(Map3DMode.SATELLITE)
-        }
+        Map3DSettingsController.shared.settings.value.applyTo(map)
       }
     }
 
@@ -157,6 +167,21 @@ class RoadmapModeActivity : SampleBaseActivity() {
     fadeHandler.postDelayed(fadeOutRunnable, 3000L)
   }
 
+  override fun onQuickSettingsChanged(settings: Map3DSettings) {
+    val targetId = when (settings.mapMode) {
+      Map3DMode.ROADMAP -> R.id.rb_roadmap
+      Map3DMode.HYBRID -> R.id.rb_hybrid
+      Map3DMode.SATELLITE -> R.id.rb_satellite
+      else -> return
+    }
+    val group = rgMapMode ?: return
+    if (group.checkedRadioButtonId != targetId) {
+      isSyncingRadioGroup = true
+      group.check(targetId)
+      isSyncingRadioGroup = false
+    }
+  }
+
   // --- UI Collapse / Expand Mechanics ---
 
   /**
@@ -209,7 +234,6 @@ class RoadmapModeActivity : SampleBaseActivity() {
 
   override fun onMapReady(googleMap3D: GoogleMap3D) {
     super.onMapReady(googleMap3D)
-    googleMap3D.setMapMode(Map3DMode.ROADMAP)
     googleMap3D.setCamera(initialCamera)
   }
 
diff --git a/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/routes/RoutesActivity.kt b/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/routes/RoutesActivity.kt
index 82a6003c..a8b7cea6 100644
--- a/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/routes/RoutesActivity.kt
+++ b/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/routes/RoutesActivity.kt
@@ -341,9 +341,11 @@ class RoutesActivity : SampleBaseActivity() {
 
   // --- Map Readiness & Route Rendering ---
 
+  @Map3DMode
+  override val defaultMapMode: Int = Map3DMode.SATELLITE
+
   override fun onMapReady(googleMap3D: GoogleMap3D) {
     super.onMapReady(googleMap3D)
-    googleMap3D.setMapMode(Map3DMode.SATELLITE)
 
     lifecycleScope.launch(Dispatchers.Default) { loadAndRenderRoute(googleMap3D) }
   }
diff --git a/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/sampleactivity/SampleBaseActivity.kt b/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/sampleactivity/SampleBaseActivity.kt
index f887a8f1..a09f514a 100644
--- a/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/sampleactivity/SampleBaseActivity.kt
+++ b/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/sampleactivity/SampleBaseActivity.kt
@@ -20,17 +20,25 @@ import android.os.Looper
 import android.util.Log
 import android.view.KeyEvent
 import android.view.View
+import android.view.ViewGroup
 import androidx.activity.enableEdgeToEdge
 import androidx.annotation.CallSuper
 import androidx.annotation.LayoutRes
 import androidx.appcompat.app.AppCompatActivity
 import androidx.core.view.ViewCompat
+import androidx.core.view.WindowCompat
 import androidx.core.view.WindowInsetsCompat
+import androidx.core.view.WindowInsetsControllerCompat
 import androidx.core.view.updatePadding
 import androidx.lifecycle.lifecycleScope
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
 import com.example.maps3d.common.DEFAULT_CAMERA
+import com.example.maps3d.common.Map3DQuickSettingsButton
+import com.example.maps3d.common.Map3DSettings
+import com.example.maps3d.common.Map3DSettingsController
+import com.example.maps3d.common.Map3DUiControls
+import com.google.android.gms.maps3d.model.Map3DMode
 import com.example.maps3d.common.toCameraString
 import com.example.maps3d.common.toValidCamera
 import com.example.maps3d.common.toHeading
@@ -133,10 +141,65 @@ abstract class SampleBaseActivity : AppCompatActivity(), OnMap3DViewReadyCallbac
         }
     }
 
+    private var lastStatusBarTop: Int = 0
+
+    private fun applyStatusBarInsetsToMapControls(
+        statusBarTop: Int = lastStatusBarTop,
+        uiControls: Map3DUiControls? = null,
+    ) {
+        if (statusBarTop > 0) {
+            lastStatusBarTop = statusBarTop
+        }
+        // Keep the Quick Settings FAB directly below the active trailing controls
+        findViewById<Map3DQuickSettingsButton>(R.id.quick_settings_button)?.let { button ->
+            val currentUi = uiControls ?: button.getSettings().uiControls
+            button.statusBarTopOffsetPx = lastStatusBarTop
+            button.updateTopMarginForUiControls(currentUi)
+        }
+    }
+
+    override fun setContentView(layoutResID: Int) {
+        super.setContentView(layoutResID)
+        bindWindowInsetsAndMapHierarchy()
+    }
+
+    private fun bindWindowInsetsAndMapHierarchy() {
+        val rootView = findViewById<View?>(R.id.map_container)
+        val hasOverlayAppBar = findViewById<View?>(R.id.app_bar_layout) != null
+        if (!hasOverlayAppBar) {
+            lastStatusBarTop = 0
+            findViewById<Map3DQuickSettingsButton?>(R.id.quick_settings_button)?.let { button ->
+                button.statusBarTopOffsetPx = 0
+                button.updateTopMarginForUiControls()
+            }
+            return
+        }
+
+        if (rootView != null) {
+            ViewCompat.setOnApplyWindowInsetsListener(rootView) { _, insets ->
+                val statusBarInsets = insets.getInsets(WindowInsetsCompat.Type.statusBars())
+                val navInsets = insets.getInsets(WindowInsetsCompat.Type.navigationBars())
+
+                findViewById<View>(R.id.app_bar_layout)?.updatePadding(top = statusBarInsets.top)
+                applyStatusBarInsetsToMapControls(statusBarInsets.top)
+
+                findViewById<View>(R.id.control_scroll_view)?.let { scrollView ->
+                    val layoutParams = scrollView.layoutParams as ViewGroup.MarginLayoutParams
+                    val margin16dp = (16 * scrollView.resources.displayMetrics.density).toInt()
+                    layoutParams.bottomMargin = navInsets.bottom + margin16dp
+                    scrollView.layoutParams = layoutParams
+                }
+
+                WindowInsetsCompat.CONSUMED
+            }
+        }
+    }
+
     @CallSuper
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         enableEdgeToEdge()
+        enableImmersiveMode()
 
         setContentView(layoutResId)
         val rootView = findViewById<View>(R.id.map_container)
@@ -150,6 +213,7 @@ abstract class SampleBaseActivity : AppCompatActivity(), OnMap3DViewReadyCallbac
                 val navInsets = insets.getInsets(WindowInsetsCompat.Type.navigationBars())
 
                 findViewById<View>(R.id.app_bar_layout)?.updatePadding(top = statusBarInsets.top)
+                applyStatusBarInsetsToMapControls(statusBarInsets.top)
 
                 findViewById<View>(R.id.control_scroll_view)?.let { scrollView ->
                     val layoutParams = scrollView.layoutParams as android.view.ViewGroup.MarginLayoutParams
@@ -190,10 +254,35 @@ abstract class SampleBaseActivity : AppCompatActivity(), OnMap3DViewReadyCallbac
         }
     }
 
+    /**
+     * Enables sticky immersive mode so the 3D map canvas occupies the entire display,
+     * hiding status and navigation bars while allowing transient reveal on edge swipes.
+     */
+    protected fun enableImmersiveMode() {
+        val insetsController = WindowCompat.getInsetsController(window, window.decorView)
+        insetsController.systemBarsBehavior =
+            WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
+        insetsController.hide(WindowInsetsCompat.Type.systemBars())
+    }
+
+    override fun onWindowFocusChanged(hasFocus: Boolean) {
+        super.onWindowFocusChanged(hasFocus)
+        if (hasFocus) {
+            enableImmersiveMode()
+        }
+    }
+
     @CallSuper
     override fun onResume() {
         super.onResume()
+        enableImmersiveMode()
         map3DView.onResume()
+        googleMap3D?.let { map ->
+            val currentSettings = Map3DSettingsController.shared.settings.value
+            currentSettings.applyTo(map)
+            onQuickSettingsChanged(currentSettings)
+            applyStatusBarInsetsToMapControls(lastStatusBarTop, currentSettings.uiControls)
+        }
     }
 
     @CallSuper
@@ -221,6 +310,19 @@ abstract class SampleBaseActivity : AppCompatActivity(), OnMap3DViewReadyCallbac
         map3DView.onSaveInstanceState(outState)
     }
 
+    /**
+     * Default Map Mode for this sample when the user has not explicitly overridden the mode in the
+     * current app session.
+     */
+    @Map3DMode
+    protected open val defaultMapMode: Int = Map3DMode.HYBRID
+
+    /**
+     * Hook invoked whenever Quick Settings change so subclasses with inline controls can stay in
+     * sync.
+     */
+    protected open fun onQuickSettingsChanged(settings: Map3DSettings) {}
+
     /**
      * Called when the [Map3DView] is initialized and the map scene is ready.
      *
@@ -238,13 +340,36 @@ abstract class SampleBaseActivity : AppCompatActivity(), OnMap3DViewReadyCallbac
         if (isMapInitialized) return
         isMapInitialized = true
         Log.d(TAG, "onMapReady called (guaranteed once)")
+
+        googleMap3D.setCamera(initialCamera)
+        Map3DSettingsController.shared.onSampleEntered(defaultMapMode)
+        val initialSettings = Map3DSettingsController.shared.settings.value
+        initialSettings.applyTo(googleMap3D)
+        onQuickSettingsChanged(initialSettings)
+
+        findViewById<Map3DQuickSettingsButton?>(R.id.quick_settings_button)?.apply {
+            settingsController = Map3DSettingsController.shared
+            sampleDefaultMapMode = defaultMapMode
+            attachMap(googleMap3D)
+            setOnSettingsChangedListener { updatedSettings ->
+                onQuickSettingsChanged(updatedSettings)
+                applyStatusBarInsetsToMapControls(lastStatusBarTop, updatedSettings.uiControls)
+            }
+        }
+        applyStatusBarInsetsToMapControls()
+
         // Workaround: The Maps 3D SDK onMapReady callback fires when the map object
         // is instantiated, but the internal native rendering pipeline and layout pass may briefly
-        // override initial programmatic camera positions. A short delay ensures the native map viewport
-        // has fully stabilized before applying the initial camera position.
+        // override control hierarchies. A short delay ensures
+        // the native map viewport has fully stabilized before ensuring UI controls are present.
         Handler(Looper.getMainLooper()).postDelayed({
             if (!isDestroyed && !isFinishing) {
-                this.googleMap3D?.setCamera(initialCamera)
+                this.googleMap3D?.let { map ->
+                    val currentSettings = Map3DSettingsController.shared.settings.value
+                    currentSettings.applyTo(map)
+                    onQuickSettingsChanged(currentSettings)
+                    applyStatusBarInsetsToMapControls(lastStatusBarTop, currentSettings.uiControls)
+                }
             }
         }, 350L)
     }
@@ -278,7 +403,6 @@ abstract class SampleBaseActivity : AppCompatActivity(), OnMap3DViewReadyCallbac
     @CallSuper
     override fun onError(error: Exception) {
         Log.e(TAG, "Error loading map", error)
-        super.onError(error)
     }
 
     /**
diff --git a/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/theme/Theme.kt b/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/theme/Theme.kt
index 103413b9..6aff7894 100644
--- a/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/theme/Theme.kt
+++ b/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/theme/Theme.kt
@@ -22,7 +22,11 @@ import androidx.compose.material3.dynamicDarkColorScheme
 import androidx.compose.material3.dynamicLightColorScheme
 import androidx.compose.material3.lightColorScheme
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
 import androidx.compose.ui.platform.LocalContext
+import com.example.maps3d.common.Map3DColorScheme
+import com.example.maps3d.common.Map3DSettingsController
 
 private val DarkColorScheme = darkColorScheme(
     primary = Purple80,
@@ -53,13 +57,19 @@ fun Maps3DSamplesTheme(
     dynamicColor: Boolean = true,
     content: @Composable () -> Unit
 ) {
+    val sessionSettings by Map3DSettingsController.shared.settings.collectAsState()
+    val effectiveDarkTheme = when (sessionSettings.colorScheme) {
+        Map3DColorScheme.DARK -> true
+        Map3DColorScheme.LIGHT -> false
+        Map3DColorScheme.FOLLOW_SYSTEM -> darkTheme
+    }
     val colorScheme = when {
         dynamicColor && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S -> {
             val context = LocalContext.current
-            if (darkTheme) dynamicDarkColorScheme(context) else dynamicLightColorScheme(context)
+            if (effectiveDarkTheme) dynamicDarkColorScheme(context) else dynamicLightColorScheme(context)
         }
 
-        darkTheme -> DarkColorScheme
+        effectiveDarkTheme -> DarkColorScheme
         else -> LightColorScheme
     }
 
diff --git a/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/uicontrols/UiControlsActivity.kt b/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/uicontrols/UiControlsActivity.kt
new file mode 100644
index 00000000..5574d2ee
--- /dev/null
+++ b/Maps3DSamples/ApiDemos/kotlin-app/src/main/java/com/example/maps3dkotlin/uicontrols/UiControlsActivity.kt
@@ -0,0 +1,288 @@
+/*
+ * Copyright 2026 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.example.maps3dkotlin.uicontrols
+
+import android.os.Bundle
+import android.os.Handler
+import android.os.Looper
+import android.transition.TransitionManager
+import android.view.MotionEvent
+import android.view.View
+import android.view.ViewGroup
+import android.widget.RadioGroup
+import androidx.cardview.widget.CardView
+import com.example.maps3d.common.toValidCamera
+import com.example.maps3dcommon.R
+import com.example.maps3dkotlin.sampleactivity.SampleBaseActivity
+import com.google.android.gms.maps.model.LatLng
+import com.google.android.gms.maps3d.GoogleMap3D
+import com.google.android.gms.maps3d.UiControlSettings.ControlPlacement
+import com.google.android.gms.maps3d.model.Camera
+import com.google.android.gms.maps3d.model.CompassControl
+import com.google.android.gms.maps3d.UiControlSettings.ControlOrientation
+import com.google.android.gms.maps3d.model.Map3DControl
+import com.google.android.gms.maps3d.model.Map3DMode
+import com.google.android.gms.maps3d.model.PanHorizontalControl
+import com.google.android.gms.maps3d.model.PanVerticalControl
+import com.google.android.gms.maps3d.model.RotateControl
+import com.google.android.gms.maps3d.model.TiltControl
+import com.google.android.gms.maps3d.model.ZoomControl
+import com.google.android.gms.maps3d.model.camera
+import com.google.android.gms.maps3d.model.latLngAltitude
+import com.google.android.material.appbar.MaterialToolbar
+import com.google.android.material.button.MaterialButton
+import com.google.android.material.chip.Chip
+
+/**
+ * =================================================================================================
+ * Dedicated 3D Map UI Controls & Placement Demo (Kotlin Views)
+ * =================================================================================================
+ *
+ * Demonstrates configuring built-in 3D map UI control buttons (Zoom, Tilt, Rotate, Compass,
+ * PanVertical, PanHorizontal) and toggling their screen placement between
+ * [ControlPlacement.TRAILING] and [ControlPlacement.LEADING] using direct SDK API calls.
+ */
+class UiControlsActivity : SampleBaseActivity() {
+
+    override val TAG = "UiControlsActivity"
+
+    @Map3DMode
+    override val defaultMapMode: Int = Map3DMode.ROADMAP
+
+    override val initialCamera: Camera
+        get() = camera {
+            center = latLngAltitude {
+                latitude = SF_LOCATION.latitude
+                longitude = SF_LOCATION.longitude
+                altitude = 250.0
+            }
+            heading = 45.0
+            tilt = 65.0
+            roll = 0.0
+            range = 800.0
+        }.toValidCamera()
+
+    // --- UI Elements ---
+
+    private var controlsCard: CardView? = null
+    private var cardHeader: View? = null
+    private var cardContent: View? = null
+    private var btnCollapse: MaterialButton? = null
+    private var btnShowAll: MaterialButton? = null
+    private var btnHideAll: MaterialButton? = null
+    private var chipZoom: Chip? = null
+    private var chipTilt: Chip? = null
+    private var chipRotate: Chip? = null
+    private var chipCompass: Chip? = null
+    private var chipPanVertical: Chip? = null
+    private var chipPanHorizontal: Chip? = null
+    private var rgPlacement: RadioGroup? = null
+
+    // --- State Variables ---
+
+    private var isCollapsed = false
+    private var isSyncingUi = false
+
+    // --- Handlers & Runnables ---
+
+    private val fadeHandler = Handler(Looper.getMainLooper())
+    private val fadeOutRunnable = Runnable {
+        if (!isCollapsed) {
+            controlsCard?.animate()
+                ?.alpha(0.85f)
+                ?.setDuration(400)
+                ?.start()
+        }
+    }
+
+    // --- Lifecycle & Initialization ---
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+
+        // Hide base pill scroll view as this activity manages its own overlay card
+        findViewById<View>(R.id.control_scroll_view)?.visibility = View.GONE
+
+        // Inflate UI controls panel overlay into map container managed by SampleBaseActivity
+        findViewById<ViewGroup>(R.id.map_container)?.let { container ->
+            layoutInflater.inflate(R.layout.control_panel_ui_controls, container, true)
+        }
+
+        findViewById<MaterialToolbar>(R.id.top_bar)?.apply {
+            setTitle(R.string.feature_title_ui_controls)
+            setNavigationOnClickListener { finish() }
+        }
+
+        initViews()
+    }
+
+    private fun initViews() {
+        controlsCard = findViewById(R.id.control_panel)
+        cardHeader = findViewById(R.id.card_header)
+        cardContent = findViewById(R.id.card_content)
+        btnCollapse = findViewById(R.id.btn_collapse)
+        btnShowAll = findViewById(R.id.btn_show_all)
+        btnHideAll = findViewById(R.id.btn_hide_all)
+        chipZoom = findViewById(R.id.chip_zoom)
+        chipTilt = findViewById(R.id.chip_tilt)
+        chipRotate = findViewById(R.id.chip_rotate)
+        chipCompass = findViewById(R.id.chip_compass)
+        chipPanVertical = findViewById(R.id.chip_pan_vertical)
+        chipPanHorizontal = findViewById(R.id.chip_pan_horizontal)
+        rgPlacement = findViewById(R.id.rg_controls_placement)
+
+        btnCollapse?.setOnClickListener {
+            if (isCollapsed) expandControls() else collapseControls()
+        }
+
+        cardHeader?.setOnClickListener {
+            if (isCollapsed) expandControls() else collapseControls()
+        }
+
+        btnShowAll?.setOnClickListener {
+            setAllChips(true)
+            applyControlsToMap()
+        }
+
+        btnHideAll?.setOnClickListener {
+            setAllChips(false)
+            applyControlsToMap()
+        }
+
+        val chipListener = {
+            if (!isSyncingUi) {
+                applyControlsToMap()
+            }
+        }
+
+        chipZoom?.setOnCheckedChangeListener { _, _ -> chipListener() }
+        chipTilt?.setOnCheckedChangeListener { _, _ -> chipListener() }
+        chipRotate?.setOnCheckedChangeListener { _, _ -> chipListener() }
+        chipCompass?.setOnCheckedChangeListener { _, _ -> chipListener() }
+        chipPanVertical?.setOnCheckedChangeListener { _, _ -> chipListener() }
+        chipPanHorizontal?.setOnCheckedChangeListener { _, _ -> chipListener() }
+
+        rgPlacement?.setOnCheckedChangeListener { _, _ ->
+            if (!isSyncingUi) {
+                applyControlsToMap()
+            }
+        }
+
+        fadeHandler.postDelayed(fadeOutRunnable, 3000L)
+    }
+
+    private fun setAllChips(checked: Boolean) {
+        isSyncingUi = true
+        chipZoom?.isChecked = checked
+        chipTilt?.isChecked = checked
+        chipRotate?.isChecked = checked
+        chipCompass?.isChecked = checked
+        chipPanVertical?.isChecked = checked
+        chipPanHorizontal?.isChecked = checked
+        isSyncingUi = false
+    }
+
+    /**
+     * Applies the UI controls configuration directly to the [GoogleMap3D] instance using the SDK API.
+     */
+    private fun applyControlsToMap() {
+        val map = googleMap3D ?: return
+        val uiSettings = map.getUiControlSettings() ?: return
+
+        val primaryControls = mutableListOf<Map3DControl>()
+        if (chipZoom?.isChecked == true) primaryControls.add(ZoomControl(ControlOrientation.VERTICAL))
+        if (chipTilt?.isChecked == true) primaryControls.add(TiltControl(ControlOrientation.VERTICAL))
+        if (chipRotate?.isChecked == true) primaryControls.add(RotateControl(ControlOrientation.VERTICAL))
+
+        val secondaryControls = mutableListOf<Map3DControl>()
+        if (chipPanVertical?.isChecked == true) secondaryControls.add(PanVerticalControl(ControlOrientation.VERTICAL))
+        if (chipPanHorizontal?.isChecked == true) secondaryControls.add(PanHorizontalControl(ControlOrientation.VERTICAL))
+        if (chipCompass?.isChecked == true) secondaryControls.add(CompassControl())
+
+        val isLeading = rgPlacement?.checkedRadioButtonId == R.id.rb_placement_leading
+        val primaryPlacement = if (isLeading) ControlPlacement.LEADING else ControlPlacement.TRAILING
+        val secondaryPlacement = if (isLeading) ControlPlacement.TRAILING else ControlPlacement.LEADING
+
+        uiSettings.setUiControlsPlacement(primaryControls, primaryPlacement)
+        uiSettings.setUiControlsPlacement(secondaryControls, secondaryPlacement)
+    }
+
+    // --- UI Collapse / Expand Mechanics ---
+
+    private fun collapseControls() {
+        val card = controlsCard ?: return
+        val content = cardContent ?: return
+        isCollapsed = true
+        fadeHandler.removeCallbacks(fadeOutRunnable)
+        btnCollapse?.setIconResource(R.drawable.expand_less_24px)
+        btnCollapse?.contentDescription = getString(R.string.expand_controls)
+
+        TransitionManager.beginDelayedTransition(card)
+        content.visibility = View.GONE
+    }
+
+    private fun expandControls() {
+        val card = controlsCard ?: return
+        val content = cardContent ?: return
+        isCollapsed = false
+        btnCollapse?.setIconResource(R.drawable.expand_more_24px)
+        btnCollapse?.contentDescription = getString(R.string.collapse_controls)
+
+        TransitionManager.beginDelayedTransition(card)
+        content.visibility = View.VISIBLE
+
+        fadeHandler.removeCallbacks(fadeOutRunnable)
+        fadeHandler.postDelayed(fadeOutRunnable, 3000L)
+    }
+
+    override fun dispatchTouchEvent(ev: MotionEvent?): Boolean {
+        if (ev?.action == MotionEvent.ACTION_DOWN || ev?.action == MotionEvent.ACTION_MOVE) {
+            if (!isCollapsed) {
+                controlsCard?.animate()
+                    ?.alpha(1.0f)
+                    ?.setDuration(150)
+                    ?.start()
+                fadeHandler.removeCallbacks(fadeOutRunnable)
+                fadeHandler.postDelayed(fadeOutRunnable, 3000L)
+            }
+        }
+        return super.dispatchTouchEvent(ev)
+    }
+
+    // --- 3D Map Setup ---
+
+    override fun onQuickSettingsChanged(settings: com.example.maps3d.common.Map3DSettings) {
+        super.onQuickSettingsChanged(settings)
+        applyControlsToMap()
+    }
+
+    override fun onMapReady(googleMap3D: GoogleMap3D) {
+        super.onMapReady(googleMap3D)
+        googleMap3D.setCamera(initialCamera)
+        applyControlsToMap()
+    }
+
+    override fun onDestroy() {
+        fadeHandler.removeCallbacks(fadeOutRunnable)
+        super.onDestroy()
+    }
+
+    companion object {
+        /** Focal landmark centered on the San Francisco Financial District. */
+        val SF_LOCATION = LatLng(37.7915, -122.4010)
+    }
+}
diff --git a/Maps3DSamples/ApiDemos/kotlin-app/src/test/java/com/example/maps3dkotlin/mainactivity/MainActivityTest.kt b/Maps3DSamples/ApiDemos/kotlin-app/src/test/java/com/example/maps3dkotlin/mainactivity/MainActivityTest.kt
index 5c540e64..ad041a0e 100644
--- a/Maps3DSamples/ApiDemos/kotlin-app/src/test/java/com/example/maps3dkotlin/mainactivity/MainActivityTest.kt
+++ b/Maps3DSamples/ApiDemos/kotlin-app/src/test/java/com/example/maps3dkotlin/mainactivity/MainActivityTest.kt
@@ -32,7 +32,7 @@ class MainActivityTest {
         field.isAccessible = true
         val samples = field.get(activity) as List<*>
 
-        assertThat(samples).hasSize(24)
+        assertThat(samples).hasSize(25)
 
         // Extract the activityClass from each Sample object
         val sampleClasses = samples.map {
@@ -46,5 +46,6 @@ class MainActivityTest {
         assertThat(sampleClasses).contains(com.example.maps3dkotlin.mapinteractions.MapInteractionsActivity::class.java)
         assertThat(sampleClasses).contains(com.example.maps3dkotlin.projection3d.Projection3DActivity::class.java)
         assertThat(sampleClasses).contains(com.example.maps3dkotlin.mapslocalization.MapsLocalizationActivity::class.java)
+        assertThat(sampleClasses).contains(com.example.maps3dkotlin.uicontrols.UiControlsActivity::class.java)
     }
 }
diff --git a/Maps3DSamples/ComposeDemos/app/build.gradle.kts b/Maps3DSamples/ComposeDemos/app/build.gradle.kts
index ea7d984b..982c65df 100644
--- a/Maps3DSamples/ComposeDemos/app/build.gradle.kts
+++ b/Maps3DSamples/ComposeDemos/app/build.gradle.kts
@@ -85,6 +85,10 @@ android {
     }
 }
 
+composeCompiler {
+    stabilityConfigurationFiles.add(rootProject.layout.projectDirectory.file("compose_stability.conf"))
+}
+
 dependencies {
     coreLibraryDesugaring(libs.desugar.jdk.libs)
 
diff --git a/Maps3DSamples/ComposeDemos/app/src/main/AndroidManifest.xml b/Maps3DSamples/ComposeDemos/app/src/main/AndroidManifest.xml
index e22af608..801fe7e3 100644
--- a/Maps3DSamples/ComposeDemos/app/src/main/AndroidManifest.xml
+++ b/Maps3DSamples/ComposeDemos/app/src/main/AndroidManifest.xml
@@ -63,6 +63,7 @@
         <activity android:name=".datavisualization.DataVisualizationActivity" android:exported="true" android:label="Data Visualization" />
         <activity android:name=".cloudstyling.CloudStylingActivity" android:exported="true" android:label="Cloud Map Styling" />
         <activity android:name=".roadmapmode.RoadmapModeActivity" android:exported="true" android:label="Roadmap Mode" />
+        <activity android:name=".uicontrols.UiControlsActivity" android:exported="true" android:label="UI Controls" />
         <activity android:name=".fieldofview.FieldOfViewActivity" android:exported="true" android:label="Field Of View" />
         <activity android:name=".mapslocalization.MapsLocalizationActivity" android:exported="true" android:label="Maps Localization" />
 
diff --git a/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/MainActivity.kt b/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/MainActivity.kt
index a6dc6679..ce993d8d 100644
--- a/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/MainActivity.kt
+++ b/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/MainActivity.kt
@@ -59,13 +59,15 @@ import com.example.composedemos.polylines.PolylinesActivity
 import com.example.composedemos.popovers.PopoversActivity
 import com.example.composedemos.roadmapmode.RoadmapModeActivity
 import com.example.composedemos.routes.RoutesActivity
+import com.example.composedemos.uicontrols.UiControlsActivity
+import com.example.maps3d.common.Map3DSessionTheme
 
 class MainActivity : ComponentActivity() {
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         enableEdgeToEdge()
         setContent {
-            MaterialTheme {
+            Map3DSessionTheme {
                 Surface(
                     modifier = Modifier.fillMaxSize(),
                     color = MaterialTheme.colorScheme.background,
@@ -203,6 +205,11 @@ fun CatalogScreen() {
                 context.startActivity(Intent(context, RoadmapModeActivity::class.java))
             }
         }
+        item {
+            SampleItem("UI Controls") {
+                context.startActivity(Intent(context, UiControlsActivity::class.java))
+            }
+        }
         item {
             SampleItem("Field Of View") {
                 context.startActivity(Intent(context, FieldOfViewActivity::class.java))
diff --git a/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/advancedcameraanimation/AdvancedCameraAnimationActivity.kt b/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/advancedcameraanimation/AdvancedCameraAnimationActivity.kt
index 1c9ccc9d..9722537e 100644
--- a/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/advancedcameraanimation/AdvancedCameraAnimationActivity.kt
+++ b/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/advancedcameraanimation/AdvancedCameraAnimationActivity.kt
@@ -41,6 +41,7 @@ import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.heightIn
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.statusBarsPadding
 import androidx.compose.foundation.layout.width
 import androidx.compose.foundation.rememberScrollState
 import androidx.compose.foundation.shape.RoundedCornerShape
@@ -91,17 +92,21 @@ import com.example.maps3d.common.AdvancedCameraAnimationViewModel
 import com.example.maps3d.common.AnimationApproach
 import com.example.maps3d.common.CameraKeyframe
 import com.example.maps3d.common.EntityPose
+import com.example.maps3d.common.Map3DQuickSettingsWidget
+import com.example.maps3d.common.Map3DSessionTheme
 import com.example.maps3d.common.SimpleFlyToMode
 import com.example.maps3d.common.StationaryCameraTracker
 import com.example.maps3d.common.TourData
 import com.example.maps3d.common.TrajectoryFlightAnimator
 import com.example.maps3d.common.WorldState
 import com.example.maps3d.common.awaitCameraUpdate
+import com.example.maps3d.common.rememberMap3DSessionSettings
 import com.example.maps3d.common.toCameraUpdate
 import com.google.android.gms.maps3d.GoogleMap3D
 import com.google.android.gms.maps3d.model.AltitudeMode
 import com.google.android.gms.maps3d.model.Camera
 import com.google.android.gms.maps3d.model.LatLngAltitude
+import com.google.android.gms.maps3d.model.Map3DMode
 import com.google.android.gms.maps3d.model.camera
 import com.google.android.gms.maps3d.model.flyAroundOptions
 import com.google.android.gms.maps3d.model.flyToOptions
@@ -123,7 +128,7 @@ class AdvancedCameraAnimationActivity : ComponentActivity() {
         super.onCreate(savedInstanceState)
         enableEdgeToEdge()
         setContent {
-            MaterialTheme {
+            Map3DSessionTheme {
                 Scaffold(modifier = Modifier.fillMaxSize()) { innerPadding ->
                     Box(modifier = Modifier.fillMaxSize().padding(innerPadding)) {
                         AdvancedCameraAnimationScreen()
@@ -140,6 +145,7 @@ fun AdvancedCameraAnimationScreen(
 ) {
     val state by viewModel.worldState.collectAsStateWithLifecycle()
     var googleMap3D by remember { mutableStateOf<GoogleMap3D?>(null) }
+    val settings by rememberMap3DSessionSettings(defaultMapMode = Map3DMode.SATELLITE)
 
     val initialCamera = remember {
         camera {
@@ -317,6 +323,7 @@ fun AdvancedCameraAnimationScreen(
         GoogleMap3D(
             modifier = Modifier.fillMaxSize(),
             camera = currentCamera,
+            mapMode = settings.mapMode,
             models = models,
             onMapReady = { map ->
                 googleMap3D = map
@@ -340,6 +347,15 @@ fun AdvancedCameraAnimationScreen(
                 .align(Alignment.BottomCenter)
                 .padding(12.dp),
         )
+
+        Map3DQuickSettingsWidget(
+            modifier = Modifier
+                .align(Alignment.TopEnd)
+                .statusBarsPadding()
+                .padding(top = 8.dp, end = 8.dp),
+            sampleDefaultMapMode = Map3DMode.SATELLITE,
+            googleMap3D = googleMap3D,
+        )
     }
 }
 
diff --git a/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/cameracontrols/CameraControlsActivity.kt b/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/cameracontrols/CameraControlsActivity.kt
index 6d21c639..049516c5 100644
--- a/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/cameracontrols/CameraControlsActivity.kt
+++ b/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/cameracontrols/CameraControlsActivity.kt
@@ -49,7 +49,6 @@ import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableFloatStateOf
-import androidx.compose.runtime.mutableIntStateOf
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.setValue
@@ -70,7 +69,11 @@ import com.example.composedemos.cameracontrols.DataModel.EMPIRE_STATE_BUILDING_L
 import com.example.composedemos.cameracontrols.DataModel.EMPIRE_STATE_BUILDING_LONGITUDE
 import com.example.composedemos.cameracontrols.DataModel.nycCameraRestriction
 import com.example.composedemos.cameracontrols.DataModel.nycPolygonConfigs
+import com.example.maps3d.common.Map3DQuickSettingsWidget
+import com.example.maps3d.common.Map3DSessionTheme
+import com.example.maps3d.common.Map3DSettingsController
 import com.example.maps3d.common.copy
+import com.example.maps3d.common.rememberMap3DSessionSettings
 import com.example.maps3d.common.toCompassDirection
 import com.example.maps3d.common.toValidCamera
 import com.example.maps3d.common.wrapIn
@@ -99,7 +102,7 @@ class CameraControlsActivity : ComponentActivity() {
             WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
 
         setContent {
-            MaterialTheme {
+            Map3DSessionTheme {
                 Surface(
                     modifier = Modifier.fillMaxSize(),
                     color = MaterialTheme.colorScheme.background,
@@ -117,6 +120,7 @@ fun CameraControlsScreen() {
     var isMapSteady by remember { mutableStateOf(false) }
     var hasTriggeredInitialFlyTo by remember { mutableStateOf(false) }
     var googleMap3D by remember { mutableStateOf<GoogleMap3D?>(null) }
+    val settings by rememberMap3DSessionSettings(defaultMapMode = Map3DMode.SATELLITE)
 
     val initialCamera = remember {
         camera {
@@ -133,7 +137,7 @@ fun CameraControlsScreen() {
 
     var showRestriction by remember { mutableStateOf(false) }
     var isCameraRestricted by remember { mutableStateOf(false) }
-    var selectedMapMode by remember { mutableIntStateOf(Map3DMode.SATELLITE) }
+    val selectedMapMode = settings.mapMode
     var rollValue by remember { mutableFloatStateOf(0.0f) }
     var telemetryCamera by remember { mutableStateOf(initialCamera) }
 
@@ -320,7 +324,9 @@ fun CameraControlsScreen() {
                                 .weight(1f)
                                 .selectable(
                                     selected = (selectedMapMode == modeValue),
-                                    onClick = { selectedMapMode = modeValue },
+                                    onClick = {
+                                        Map3DSettingsController.shared.setMapMode(modeValue)
+                                    },
                                     role = Role.RadioButton,
                                 )
                                 .padding(vertical = 4.dp),
@@ -393,6 +399,16 @@ fun CameraControlsScreen() {
                 )
             }
         }
+
+        // 4. Quick Settings Overlay
+        Map3DQuickSettingsWidget(
+            modifier = Modifier
+                .align(Alignment.TopEnd)
+                .statusBarsPadding()
+                .padding(top = 8.dp, end = 8.dp),
+            sampleDefaultMapMode = Map3DMode.SATELLITE,
+            googleMap3D = googleMap3D,
+        )
     }
 }
 
diff --git a/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/camerarestrictions/CameraRestrictionsActivity.kt b/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/camerarestrictions/CameraRestrictionsActivity.kt
index b81264d3..99424c91 100644
--- a/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/camerarestrictions/CameraRestrictionsActivity.kt
+++ b/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/camerarestrictions/CameraRestrictionsActivity.kt
@@ -43,6 +43,11 @@ import androidx.compose.ui.unit.dp
 import androidx.core.view.WindowCompat
 import androidx.core.view.WindowInsetsCompat
 import androidx.core.view.WindowInsetsControllerCompat
+import com.example.maps3d.common.Map3DQuickSettingsWidget
+import com.example.maps3d.common.Map3DSessionTheme
+import com.example.maps3d.common.rememberMap3DSessionSettings
+import com.google.android.gms.maps3d.GoogleMap3D
+import com.google.android.gms.maps3d.model.Map3DMode
 import com.google.android.gms.maps3d.model.camera
 import com.google.android.gms.maps3d.model.cameraRestriction
 import com.google.android.gms.maps3d.model.latLngAltitude
@@ -56,11 +61,11 @@ class CameraRestrictionsActivity : ComponentActivity() {
 
         // Hide system tray (immersive mode)
         val windowInsetsController = WindowCompat.getInsetsController(window, window.decorView)
-        windowInsetsController.hide(androidx.core.view.WindowInsetsCompat.Type.systemBars())
+        windowInsetsController.hide(WindowInsetsCompat.Type.systemBars())
         windowInsetsController.systemBarsBehavior = WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
 
         setContent {
-            MaterialTheme {
+            Map3DSessionTheme {
                 Surface(
                     modifier = Modifier.fillMaxSize(),
                     color = MaterialTheme.colorScheme.background,
@@ -75,6 +80,8 @@ class CameraRestrictionsActivity : ComponentActivity() {
 @Composable
 fun CameraRestrictionsScreen() {
     var isMapSteady by remember { mutableStateOf(false) }
+    var googleMap3D by remember { mutableStateOf<GoogleMap3D?>(null) }
+    val settings by rememberMap3DSessionSettings(defaultMapMode = Map3DMode.HYBRID)
 
     // Camera centered on Space Needle
     val spaceNeedleCamera = remember {
@@ -122,8 +129,12 @@ fun CameraRestrictionsScreen() {
         // 1. Map fills the entire screen with camera restriction
         GoogleMap3D(
             camera = spaceNeedleCamera,
+            mapMode = settings.mapMode,
             cameraRestriction = seattleRestriction,
             modifier = Modifier.fillMaxSize(),
+            onMapReady = { map ->
+                googleMap3D = map
+            },
             onMapSteady = {
                 isMapSteady = true
             },
@@ -157,5 +168,15 @@ fun CameraRestrictionsScreen() {
                 style = MaterialTheme.typography.bodyMedium,
             )
         }
+
+        // 4. Quick Settings Overlay
+        Map3DQuickSettingsWidget(
+            modifier = Modifier
+                .align(Alignment.TopEnd)
+                .statusBarsPadding()
+                .padding(top = 8.dp, end = 8.dp),
+            sampleDefaultMapMode = Map3DMode.HYBRID,
+            googleMap3D = googleMap3D,
+        )
     }
 }
diff --git a/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/cloudstyling/CloudStylingActivity.kt b/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/cloudstyling/CloudStylingActivity.kt
index b5172a08..1f2e2260 100644
--- a/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/cloudstyling/CloudStylingActivity.kt
+++ b/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/cloudstyling/CloudStylingActivity.kt
@@ -53,6 +53,8 @@ import androidx.compose.ui.semantics.Role
 import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.text.intl.Locale
 import androidx.compose.ui.unit.dp
+import com.example.maps3d.common.Map3DQuickSettingsWidget
+import com.example.maps3d.common.rememberMap3DSessionSettings
 import com.example.maps3d.common.toValidCamera
 import com.example.maps3dcommon.R
 import com.google.android.gms.maps.model.LatLng
@@ -86,6 +88,7 @@ class CloudStylingActivity : ComponentActivity() {
 
 @Composable
 fun CloudStylingScreen() {
+    val sessionSettings by rememberMap3DSessionSettings(defaultMapMode = Map3DMode.ROADMAP)
     val currentLocale = Locale.current
     var selectedMapMode by remember { mutableIntStateOf(Map3DMode.ROADMAP) }
 
diff --git a/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/datavisualization/DataVisualizationActivity.kt b/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/datavisualization/DataVisualizationActivity.kt
index 19b32770..efe503a0 100644
--- a/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/datavisualization/DataVisualizationActivity.kt
+++ b/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/datavisualization/DataVisualizationActivity.kt
@@ -55,6 +55,9 @@ import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.unit.dp
 import androidx.core.view.WindowCompat
 import androidx.core.view.WindowInsetsControllerCompat
+import com.example.maps3d.common.Map3DQuickSettingsWidget
+import com.example.maps3d.common.Map3DSessionTheme
+import com.example.maps3d.common.rememberMap3DSessionSettings
 import com.google.android.gms.maps.model.LatLng
 import com.google.android.gms.maps3d.GoogleMap3D
 import com.google.android.gms.maps3d.model.AltitudeMode
@@ -81,7 +84,7 @@ class DataVisualizationActivity : ComponentActivity() {
         windowInsetsController.systemBarsBehavior = WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
 
         setContent {
-            MaterialTheme {
+            Map3DSessionTheme {
                 Surface(
                     modifier = Modifier.fillMaxSize(),
                     color = MaterialTheme.colorScheme.background,
@@ -98,6 +101,7 @@ fun DataVisualizationScreen() {
     val context = LocalContext.current
     var isMapSteady by remember { mutableStateOf(false) }
     var googleMap3DInstance by remember { mutableStateOf<GoogleMap3D?>(null) }
+    val settings by rememberMap3DSessionSettings(defaultMapMode = Map3DMode.HYBRID)
     var currentFloodElevation by remember { mutableDoubleStateOf(10.0) }
     var isSimulating by remember { mutableStateOf(false) }
     var activePolygon by remember { mutableStateOf<Polygon?>(null) }
@@ -176,11 +180,10 @@ fun DataVisualizationScreen() {
     ) {
         GoogleMap3D(
             camera = initialCamera,
-            mapMode = Map3DMode.HYBRID,
+            mapMode = settings.mapMode,
             modifier = Modifier.fillMaxSize(),
             onMapReady = { map ->
                 googleMap3DInstance = map
-                map.setMapMode(Map3DMode.HYBRID)
                 map.flyCameraTo(
                     flyToOptions {
                         endCamera = initialCamera
@@ -275,6 +278,16 @@ fun DataVisualizationScreen() {
                 }
             }
         }
+
+        // Quick Settings Overlay
+        Map3DQuickSettingsWidget(
+            modifier = Modifier
+                .align(Alignment.TopEnd)
+                .statusBarsPadding()
+                .padding(top = 8.dp, end = 8.dp),
+            sampleDefaultMapMode = Map3DMode.HYBRID,
+            googleMap3D = googleMap3DInstance,
+        )
     }
 }
 
diff --git a/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/fieldofview/FieldOfViewActivity.kt b/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/fieldofview/FieldOfViewActivity.kt
index e5033938..854d153f 100644
--- a/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/fieldofview/FieldOfViewActivity.kt
+++ b/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/fieldofview/FieldOfViewActivity.kt
@@ -29,6 +29,7 @@ import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.statusBarsPadding
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material3.Button
 import androidx.compose.material3.ButtonDefaults
@@ -50,6 +51,9 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
+import com.example.maps3d.common.Map3DQuickSettingsWidget
+import com.example.maps3d.common.Map3DSessionTheme
+import com.example.maps3d.common.rememberMap3DSessionSettings
 import com.google.android.gms.maps.model.LatLng
 import com.google.android.gms.maps3d.model.Camera
 import com.google.android.gms.maps3d.model.Map3DMode
@@ -66,7 +70,7 @@ class FieldOfViewActivity : ComponentActivity() {
         super.onCreate(savedInstanceState)
         enableEdgeToEdge()
         setContent {
-            MaterialTheme {
+            Map3DSessionTheme {
                 Surface(
                     modifier = Modifier.fillMaxSize(),
                     color = MaterialTheme.colorScheme.background,
@@ -85,6 +89,7 @@ class FieldOfViewActivity : ComponentActivity() {
 @Composable
 fun FieldOfViewScreen() {
     var fovValue by remember { mutableFloatStateOf(45.0f) }
+    val settings by rememberMap3DSessionSettings(defaultMapMode = Map3DMode.SATELLITE)
 
     val initialCamera = remember {
         camera {
@@ -133,7 +138,7 @@ fun FieldOfViewScreen() {
     Box(modifier = Modifier.fillMaxSize()) {
         GoogleMap3D(
             camera = cameraState,
-            mapMode = Map3DMode.SATELLITE,
+            mapMode = settings.mapMode,
             onMapReady = { mapInstance = it },
             modifier = Modifier.fillMaxSize(),
         )
@@ -232,5 +237,14 @@ fun FieldOfViewScreen() {
                 }
             }
         }
+
+        Map3DQuickSettingsWidget(
+            modifier = Modifier
+                .align(Alignment.TopEnd)
+                .statusBarsPadding()
+                .padding(top = 8.dp, end = 8.dp),
+            sampleDefaultMapMode = Map3DMode.SATELLITE,
+            googleMap3D = mapInstance,
+        )
     }
 }
diff --git a/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/hellomap/HelloMapActivity.kt b/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/hellomap/HelloMapActivity.kt
index 45caf24a..91a4abe6 100644
--- a/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/hellomap/HelloMapActivity.kt
+++ b/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/hellomap/HelloMapActivity.kt
@@ -42,6 +42,11 @@ import androidx.compose.ui.unit.dp
 import androidx.core.view.WindowCompat
 import androidx.core.view.WindowInsetsCompat
 import androidx.core.view.WindowInsetsControllerCompat
+import com.example.maps3d.common.Map3DQuickSettingsWidget
+import com.example.maps3d.common.Map3DSessionTheme
+import com.example.maps3d.common.rememberMap3DSessionSettings
+import com.google.android.gms.maps3d.GoogleMap3D
+import com.google.android.gms.maps3d.model.Map3DMode
 import com.google.android.gms.maps3d.model.camera
 import com.google.android.gms.maps3d.model.latLngAltitude
 import com.google.maps.android.compose3d.GoogleMap3D
@@ -57,7 +62,7 @@ class HelloMapActivity : ComponentActivity() {
         windowInsetsController.systemBarsBehavior = WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
 
         setContent {
-            MaterialTheme {
+            Map3DSessionTheme {
                 Surface(
                     modifier = Modifier.fillMaxSize(),
                     color = MaterialTheme.colorScheme.background,
@@ -72,6 +77,8 @@ class HelloMapActivity : ComponentActivity() {
 @Composable
 fun HelloMapScreen() {
     var isMapSteady by remember { mutableStateOf(false) }
+    var googleMap3D by remember { mutableStateOf<GoogleMap3D?>(null) }
+    val settings by rememberMap3DSessionSettings(defaultMapMode = Map3DMode.HYBRID)
 
     val delicateArchCamera = remember {
         camera {
@@ -96,7 +103,11 @@ fun HelloMapScreen() {
         // 1. Map fills the entire screen
         GoogleMap3D(
             camera = delicateArchCamera,
+            mapMode = settings.mapMode,
             modifier = Modifier.fillMaxSize(),
+            onMapReady = { map ->
+                googleMap3D = map
+            },
             onMapSteady = {
                 isMapSteady = true
             },
@@ -118,5 +129,15 @@ fun HelloMapScreen() {
                 color = MaterialTheme.colorScheme.onSurface,
             )
         }
+
+        // 3. Quick Settings Overlay
+        Map3DQuickSettingsWidget(
+            modifier = Modifier
+                .align(Alignment.TopEnd)
+                .statusBarsPadding()
+                .padding(top = 8.dp, end = 8.dp),
+            sampleDefaultMapMode = Map3DMode.HYBRID,
+            googleMap3D = googleMap3D,
+        )
     }
 }
diff --git a/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/mapinteractions/MapInteractionsActivity.kt b/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/mapinteractions/MapInteractionsActivity.kt
index 7692af3e..fc6a4208 100644
--- a/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/mapinteractions/MapInteractionsActivity.kt
+++ b/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/mapinteractions/MapInteractionsActivity.kt
@@ -42,6 +42,11 @@ import androidx.compose.ui.semantics.semantics
 import androidx.compose.ui.unit.dp
 import androidx.core.view.WindowCompat
 import androidx.core.view.WindowInsetsControllerCompat
+import com.example.maps3d.common.Map3DQuickSettingsWidget
+import com.example.maps3d.common.Map3DSessionTheme
+import com.example.maps3d.common.rememberMap3DSessionSettings
+import com.google.android.gms.maps3d.GoogleMap3D
+import com.google.android.gms.maps3d.model.Map3DMode
 import com.google.android.gms.maps3d.model.camera
 import com.google.android.gms.maps3d.model.latLngAltitude
 import com.google.maps.android.compose3d.GoogleMap3D
@@ -57,7 +62,7 @@ class MapInteractionsActivity : ComponentActivity() {
         windowInsetsController.systemBarsBehavior = WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
 
         setContent {
-            MaterialTheme {
+            Map3DSessionTheme {
                 Surface(
                     modifier = Modifier.fillMaxSize(),
                     color = MaterialTheme.colorScheme.background,
@@ -72,6 +77,8 @@ class MapInteractionsActivity : ComponentActivity() {
 @Composable
 fun MapInteractionsScreen() {
     var isMapSteady by remember { mutableStateOf(false) }
+    var googleMap3D by remember { mutableStateOf<GoogleMap3D?>(null) }
+    val settings by rememberMap3DSessionSettings(defaultMapMode = Map3DMode.HYBRID)
     var clickedInfo by remember { mutableStateOf("Click on the map to see details") }
 
     // Calibrated camera centered around Colorado State Capitol
@@ -97,8 +104,10 @@ fun MapInteractionsScreen() {
         // 1. Map fills the entire screen
         GoogleMap3D(
             camera = calibratedCamera,
+            mapMode = settings.mapMode,
             modifier = Modifier.fillMaxSize(),
             onMapReady = { instance ->
+                googleMap3D = instance
                 instance.setMap3DClickListener { event ->
                     clickedInfo = if (event.placeId != null) {
                         "Clicked Place ID: ${event.placeId}"
@@ -143,5 +152,15 @@ fun MapInteractionsScreen() {
                 style = MaterialTheme.typography.bodyMedium,
             )
         }
+
+        // 4. Quick Settings Overlay
+        Map3DQuickSettingsWidget(
+            modifier = Modifier
+                .align(Alignment.TopEnd)
+                .statusBarsPadding()
+                .padding(top = 8.dp, end = 8.dp),
+            sampleDefaultMapMode = Map3DMode.HYBRID,
+            googleMap3D = googleMap3D,
+        )
     }
 }
diff --git a/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/markers/MarkersActivity.kt b/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/markers/MarkersActivity.kt
index d5b78c91..3e304b57 100644
--- a/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/markers/MarkersActivity.kt
+++ b/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/markers/MarkersActivity.kt
@@ -70,6 +70,9 @@ import androidx.core.view.WindowInsetsCompat
 import androidx.core.view.WindowInsetsControllerCompat
 import com.example.composedemos.markers.data.Monster
 import com.example.composedemos.markers.data.MonsterParser
+import com.example.maps3d.common.Map3DQuickSettingsWidget
+import com.example.maps3d.common.Map3DSessionTheme
+import com.example.maps3d.common.rememberMap3DSessionSettings
 import com.example.maps3d.common.toCameraString
 import com.example.maps3d.common.toValidCamera
 import com.google.android.gms.maps3d.GoogleMap3D
@@ -115,7 +118,7 @@ class MarkersActivity : ComponentActivity() {
             WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
 
         setContent {
-            MaterialTheme {
+            Map3DSessionTheme {
                 Surface(
                     modifier = Modifier.fillMaxSize(),
                     color = MaterialTheme.colorScheme.background,
@@ -143,6 +146,7 @@ fun MarkersScreen() {
     var isMapSteady by remember { mutableStateOf(false) }
     val mapSteadyFlow = remember { MutableStateFlow(false) }
     var googleMap3D by remember { mutableStateOf<GoogleMap3D?>(null) }
+    val settings by rememberMap3DSessionSettings(defaultMapMode = Map3DMode.SATELLITE)
     var popovers by remember { mutableStateOf(emptyList<PopoverConfig>()) }
     var isTouring by remember { mutableStateOf(false) }
     var showMonsterMenu by remember { mutableStateOf(false) }
@@ -470,7 +474,7 @@ fun MarkersScreen() {
         // 1. Map fills the entire screen
         GoogleMap3D(
             camera = nycCamera,
-            mapMode = Map3DMode.SATELLITE,
+            mapMode = settings.mapMode,
             markers = allMarkers,
             popovers = popovers,
             modifier = Modifier.fillMaxSize(),
@@ -695,6 +699,16 @@ fun MarkersScreen() {
                 }
             }
         }
+
+        // 4. Quick Settings Overlay
+        Map3DQuickSettingsWidget(
+            modifier = Modifier
+                .align(Alignment.TopEnd)
+                .statusBarsPadding()
+                .padding(top = 8.dp, end = 8.dp),
+            sampleDefaultMapMode = Map3DMode.SATELLITE,
+            googleMap3D = googleMap3D,
+        )
     }
 }
 
diff --git a/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/models/ModelsActivity.kt b/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/models/ModelsActivity.kt
index c4baf59f..c6c03d52 100644
--- a/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/models/ModelsActivity.kt
+++ b/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/models/ModelsActivity.kt
@@ -49,6 +49,9 @@ import androidx.compose.ui.unit.dp
 import androidx.core.view.WindowCompat
 import androidx.core.view.WindowInsetsCompat
 import androidx.core.view.WindowInsetsControllerCompat
+import com.example.maps3d.common.Map3DQuickSettingsWidget
+import com.example.maps3d.common.Map3DSessionTheme
+import com.example.maps3d.common.rememberMap3DSessionSettings
 import com.google.android.gms.maps3d.model.AltitudeMode
 import com.google.android.gms.maps3d.model.Map3DMode
 import com.google.android.gms.maps3d.model.camera
@@ -70,11 +73,11 @@ class ModelsActivity : ComponentActivity() {
 
         // Hide system tray (immersive mode)
         val windowInsetsController = WindowCompat.getInsetsController(window, window.decorView)
-        windowInsetsController.hide(androidx.core.view.WindowInsetsCompat.Type.systemBars())
+        windowInsetsController.hide(WindowInsetsCompat.Type.systemBars())
         windowInsetsController.systemBarsBehavior = WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
 
         setContent {
-            MaterialTheme {
+            Map3DSessionTheme {
                 Surface(
                     modifier = Modifier.fillMaxSize(),
                     color = MaterialTheme.colorScheme.background,
@@ -92,6 +95,7 @@ private fun ModelsScreen() {
     val context = LocalContext.current
     val coroutineScope = rememberCoroutineScope()
     var isMapSteady by remember { mutableStateOf(false) }
+    val settings by rememberMap3DSessionSettings(defaultMapMode = Map3DMode.SATELLITE)
 
     val initialCamera = remember {
         camera {
@@ -141,7 +145,7 @@ private fun ModelsScreen() {
         GoogleMap3D(
             camera = cameraState,
             models = models,
-            mapMode = Map3DMode.SATELLITE,
+            mapMode = settings.mapMode,
             modifier = Modifier.fillMaxSize(),
             onMapReady = { googleMap3D ->
                 mapInstance = googleMap3D
@@ -210,6 +214,16 @@ private fun ModelsScreen() {
         ) {
             Text(text = "Stop")
         }
+
+        // 4. Quick Settings Overlay
+        Map3DQuickSettingsWidget(
+            modifier = Modifier
+                .align(Alignment.TopEnd)
+                .statusBarsPadding()
+                .padding(top = 8.dp, end = 8.dp),
+            sampleDefaultMapMode = Map3DMode.SATELLITE,
+            googleMap3D = mapInstance,
+        )
     }
 }
 
diff --git a/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/pathfollowing/PathFollowingActivity.kt b/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/pathfollowing/PathFollowingActivity.kt
index b249887d..665781ba 100644
--- a/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/pathfollowing/PathFollowingActivity.kt
+++ b/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/pathfollowing/PathFollowingActivity.kt
@@ -42,6 +42,7 @@ import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.heightIn
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.statusBarsPadding
 import androidx.compose.foundation.layout.width
 import androidx.compose.foundation.rememberScrollState
 import androidx.compose.foundation.shape.RoundedCornerShape
@@ -94,10 +95,14 @@ import androidx.lifecycle.LifecycleEventObserver
 import androidx.lifecycle.compose.LocalLifecycleOwner
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import androidx.lifecycle.viewmodel.compose.viewModel
+import com.example.maps3d.common.Map3DQuickSettingsWidget
+import com.example.maps3d.common.Map3DSessionTheme
 import com.example.maps3d.common.PathData
 import com.example.maps3d.common.PathEngine
 import com.example.maps3d.common.PathFollowingViewModel
 import com.example.maps3d.common.PathPlaybackState
+import com.example.maps3d.common.rememberMap3DSessionSettings
+import com.google.android.gms.maps3d.GoogleMap3D
 import com.google.android.gms.maps3d.model.AltitudeMode
 import com.google.android.gms.maps3d.model.LatLngAltitude
 import com.google.android.gms.maps3d.model.Map3DMode
@@ -117,7 +122,7 @@ class PathFollowingActivity : ComponentActivity() {
         super.onCreate(savedInstanceState)
         enableEdgeToEdge()
         setContent {
-            MaterialTheme {
+            Map3DSessionTheme {
                 Scaffold(modifier = Modifier.fillMaxSize()) { innerPadding ->
                     Surface(
                         modifier = Modifier
@@ -147,6 +152,8 @@ enum class AltitudeModeOption(val label: String, val mode: Int) {
 @Composable
 fun PathFollowingScreen(viewModel: PathFollowingViewModel = viewModel()) {
     val state by viewModel.uiState.collectAsStateWithLifecycle()
+    var googleMap3D by remember { mutableStateOf<GoogleMap3D?>(null) }
+    val settings by rememberMap3DSessionSettings(defaultMapMode = Map3DMode.HYBRID)
     var showHelpDialog by remember { mutableStateOf(false) }
     var showAltitudeInfoDialog by remember { mutableStateOf(false) }
     var lastInteractionTime by remember { mutableStateOf(System.currentTimeMillis()) }
@@ -261,8 +268,11 @@ fun PathFollowingScreen(viewModel: PathFollowingViewModel = viewModel()) {
         GoogleMap3D(
             modifier = Modifier.fillMaxSize(),
             camera = dynamicCamera,
-            mapMode = Map3DMode.HYBRID,
+            mapMode = settings.mapMode,
             polylines = listOfNotNull(staticPolylineConfig, progressPolylineConfig),
+            onMapReady = { map ->
+                googleMap3D = map
+            },
         )
 
         // Custom Gesture Overlay replacing built-in map gestures
@@ -400,6 +410,15 @@ fun PathFollowingScreen(viewModel: PathFollowingViewModel = viewModel()) {
             },
         )
 
+        Map3DQuickSettingsWidget(
+            modifier = Modifier
+                .align(Alignment.TopEnd)
+                .statusBarsPadding()
+                .padding(top = 8.dp, end = 8.dp),
+            sampleDefaultMapMode = Map3DMode.HYBRID,
+            googleMap3D = googleMap3D,
+        )
+
         if (showHelpDialog) {
             AlertDialog(
                 onDismissRequest = { showHelpDialog = false },
diff --git a/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/placedetails/PlaceDetailsActivity.kt b/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/placedetails/PlaceDetailsActivity.kt
index 80b08ad8..eb8997b1 100644
--- a/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/placedetails/PlaceDetailsActivity.kt
+++ b/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/placedetails/PlaceDetailsActivity.kt
@@ -65,6 +65,10 @@ import androidx.fragment.app.commit
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewmodel.compose.viewModel
 import com.example.composedemos.R
+import com.example.maps3d.common.Map3DQuickSettingsWidget
+import com.example.maps3d.common.Map3DSessionTheme
+import com.example.maps3d.common.rememberMap3DSessionSettings
+import com.google.android.gms.maps3d.GoogleMap3D
 import com.google.android.gms.maps3d.model.Camera
 import com.google.android.gms.maps3d.model.Map3DMode
 import com.google.android.gms.maps3d.model.camera
@@ -180,7 +184,7 @@ class PlaceDetailsActivity : FragmentActivity() {
         windowInsetsController.systemBarsBehavior = WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
 
         setContent {
-            MaterialTheme {
+            Map3DSessionTheme {
                 Surface(
                     modifier = Modifier.fillMaxSize(),
                     color = MaterialTheme.colorScheme.background,
@@ -217,6 +221,8 @@ class PlaceDetailsActivity : FragmentActivity() {
         )
         val sheetPeekHeight = 120.dp
         val cameraState by viewModel.cameraState.collectAsState()
+        var googleMap3D by remember { mutableStateOf<GoogleMap3D?>(null) }
+        val settings by rememberMap3DSessionSettings(defaultMapMode = Map3DMode.HYBRID)
 
         // Dismiss the place details overlay if the user fully expands the bottom sheet
         LaunchedEffect(scaffoldState.bottomSheetState.currentValue) {
@@ -249,8 +255,11 @@ class PlaceDetailsActivity : FragmentActivity() {
                 Box(modifier = Modifier.fillMaxSize()) {
                     GoogleMap3D(
                         camera = cameraState,
-                        mapMode = Map3DMode.HYBRID,
+                        mapMode = settings.mapMode,
                         modifier = Modifier.fillMaxSize(),
+                        onMapReady = { map ->
+                            googleMap3D = map
+                        },
                         onPlaceClick = { placeId ->
                             Log.d(TAG, "Place clicked: placeId=$placeId")
                             viewModel.setSelectedPlaceId(placeId)
@@ -269,6 +278,15 @@ class PlaceDetailsActivity : FragmentActivity() {
                         .padding(bottom = sheetPeekHeight + 16.dp, start = 16.dp, end = 16.dp),
                 )
             }
+
+            Map3DQuickSettingsWidget(
+                modifier = Modifier
+                    .align(Alignment.TopEnd)
+                    .statusBarsPadding()
+                    .padding(top = 8.dp, end = 8.dp),
+                sampleDefaultMapMode = Map3DMode.HYBRID,
+                googleMap3D = googleMap3D,
+            )
         }
     }
 
diff --git a/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/polygons/PolygonsActivity.kt b/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/polygons/PolygonsActivity.kt
index ccd4d3b6..ab164119 100644
--- a/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/polygons/PolygonsActivity.kt
+++ b/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/polygons/PolygonsActivity.kt
@@ -56,7 +56,10 @@ import androidx.compose.ui.unit.dp
 import androidx.core.view.WindowCompat
 import androidx.core.view.WindowInsetsCompat
 import androidx.core.view.WindowInsetsControllerCompat
+import com.example.maps3d.common.Map3DQuickSettingsWidget
+import com.example.maps3d.common.Map3DSessionTheme
 import com.example.maps3d.common.miles
+import com.example.maps3d.common.rememberMap3DSessionSettings
 import com.example.maps3d.common.toCameraString
 import com.example.maps3d.common.toMeters
 import com.example.maps3d.common.toValidCamera
@@ -89,7 +92,7 @@ class PolygonsActivity : ComponentActivity() {
             WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
 
         setContent {
-            MaterialTheme {
+            Map3DSessionTheme {
                 Surface(
                     modifier = Modifier.fillMaxSize(),
                     color = MaterialTheme.colorScheme.background,
@@ -107,6 +110,7 @@ fun PolygonsScreen() {
     val scope = rememberCoroutineScope()
     var isMapSteady by remember { mutableStateOf(false) }
     var googleMap3D by remember { mutableStateOf<GoogleMap3D?>(null) }
+    val settings by rememberMap3DSessionSettings(defaultMapMode = Map3DMode.HYBRID)
 
     val museumAltitude = remember { 1.miles.toMeters }
 
@@ -270,7 +274,7 @@ fun PolygonsScreen() {
         // 1. Map fills the entire screen
         GoogleMap3D(
             camera = denverCamera,
-            mapMode = Map3DMode.HYBRID,
+            mapMode = settings.mapMode,
             polygons = listOf(zooPolygonConfig) + museumPolygons,
             modifier = Modifier.fillMaxSize(),
             onMapReady = { map ->
@@ -353,6 +357,16 @@ fun PolygonsScreen() {
                 }
             }
         }
+
+        // 4. Quick Settings Overlay
+        Map3DQuickSettingsWidget(
+            modifier = Modifier
+                .align(Alignment.TopEnd)
+                .statusBarsPadding()
+                .padding(top = 8.dp, end = 8.dp),
+            sampleDefaultMapMode = Map3DMode.HYBRID,
+            googleMap3D = googleMap3D,
+        )
     }
 }
 
diff --git a/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/polylines/PolylinesActivity.kt b/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/polylines/PolylinesActivity.kt
index cdbdc2c6..beae0799 100644
--- a/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/polylines/PolylinesActivity.kt
+++ b/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/polylines/PolylinesActivity.kt
@@ -38,6 +38,7 @@ import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.semantics.contentDescription
@@ -46,6 +47,10 @@ import androidx.compose.ui.unit.dp
 import androidx.core.view.WindowCompat
 import androidx.core.view.WindowInsetsCompat
 import androidx.core.view.WindowInsetsControllerCompat
+import com.example.maps3d.common.Map3DQuickSettingsWidget
+import com.example.maps3d.common.Map3DSessionTheme
+import com.example.maps3d.common.rememberMap3DSessionSettings
+import com.google.android.gms.maps3d.GoogleMap3D
 import com.google.android.gms.maps3d.model.AltitudeMode
 import com.google.android.gms.maps3d.model.Map3DMode
 import com.google.android.gms.maps3d.model.camera
@@ -65,7 +70,7 @@ class PolylinesActivity : ComponentActivity() {
         windowInsetsController.systemBarsBehavior = WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
 
         setContent {
-            MaterialTheme {
+            Map3DSessionTheme {
                 Surface(
                     modifier = Modifier.fillMaxSize(),
                     color = MaterialTheme.colorScheme.background,
@@ -82,6 +87,8 @@ fun PolylinesScreen() {
     val context = LocalContext.current
     val scope = rememberCoroutineScope()
     var isMapSteady by remember { mutableStateOf(false) }
+    var googleMap3D by remember { mutableStateOf<GoogleMap3D?>(null) }
+    val settings by rememberMap3DSessionSettings(defaultMapMode = Map3DMode.HYBRID)
 
     // Define the camera position centered around Mount Sanitas trailhead
     val boulderCamera = remember {
@@ -140,9 +147,12 @@ fun PolylinesScreen() {
         // 1. Map fills the entire screen
         GoogleMap3D(
             camera = boulderCamera,
-            mapMode = Map3DMode.HYBRID,
+            mapMode = settings.mapMode,
             polylines = listOf(polylineConfig),
             modifier = Modifier.fillMaxSize(),
+            onMapReady = { map ->
+                googleMap3D = map
+            },
             onMapSteady = {
                 isMapSteady = true
             },
@@ -162,5 +172,15 @@ fun PolylinesScreen() {
                 color = MaterialTheme.colorScheme.onSurface,
             )
         }
+
+        // 3. Quick Settings Overlay
+        Map3DQuickSettingsWidget(
+            modifier = Modifier
+                .align(Alignment.TopEnd)
+                .statusBarsPadding()
+                .padding(top = 8.dp, end = 8.dp),
+            sampleDefaultMapMode = Map3DMode.HYBRID,
+            googleMap3D = googleMap3D,
+        )
     }
 }
diff --git a/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/popovers/PopoversActivity.kt b/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/popovers/PopoversActivity.kt
index 0acd09e6..428173e4 100644
--- a/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/popovers/PopoversActivity.kt
+++ b/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/popovers/PopoversActivity.kt
@@ -58,6 +58,9 @@ import androidx.compose.ui.unit.sp
 import androidx.core.view.WindowCompat
 import androidx.core.view.WindowInsetsCompat
 import androidx.core.view.WindowInsetsControllerCompat
+import com.example.maps3d.common.Map3DQuickSettingsWidget
+import com.example.maps3d.common.Map3DSessionTheme
+import com.example.maps3d.common.rememberMap3DSessionSettings
 import com.example.maps3d.common.toCameraString
 import com.example.maps3d.common.toValidCamera
 import com.google.android.gms.maps3d.GoogleMap3D
@@ -94,7 +97,7 @@ class PopoversActivity : ComponentActivity() {
             WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
 
         setContent {
-            MaterialTheme {
+            Map3DSessionTheme {
                 Surface(
                     modifier = Modifier.fillMaxSize(),
                     color = MaterialTheme.colorScheme.background,
@@ -111,6 +114,7 @@ fun PopoversScreen() {
     val scope = rememberCoroutineScope()
     var isMapSteady by remember { mutableStateOf(false) }
     var googleMap3D by remember { mutableStateOf<GoogleMap3D?>(null) }
+    val settings by rememberMap3DSessionSettings(defaultMapMode = Map3DMode.SATELLITE)
     var popover by remember { mutableStateOf<Popover?>(null) }
     var popoverToggleCount by remember { mutableIntStateOf(0) }
 
@@ -202,7 +206,7 @@ fun PopoversScreen() {
             camera = initialCamera,
             markers = listOf(markerInGoldenGate),
             popovers = popovers,
-            mapMode = Map3DMode.SATELLITE,
+            mapMode = settings.mapMode,
             modifier = Modifier.fillMaxSize(),
             onMapReady = { map ->
                 googleMap3D = map
@@ -278,6 +282,16 @@ fun PopoversScreen() {
                 }
             }
         }
+
+        // 4. Quick Settings Overlay
+        Map3DQuickSettingsWidget(
+            modifier = Modifier
+                .align(Alignment.TopEnd)
+                .statusBarsPadding()
+                .padding(top = 8.dp, end = 8.dp),
+            sampleDefaultMapMode = Map3DMode.SATELLITE,
+            googleMap3D = googleMap3D,
+        )
     }
 }
 
diff --git a/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/roadmapmode/RoadmapModeActivity.kt b/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/roadmapmode/RoadmapModeActivity.kt
index d5829b06..128e54bf 100644
--- a/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/roadmapmode/RoadmapModeActivity.kt
+++ b/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/roadmapmode/RoadmapModeActivity.kt
@@ -29,6 +29,7 @@ import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.statusBarsPadding
 import androidx.compose.foundation.layout.width
 import androidx.compose.foundation.selection.selectable
 import androidx.compose.foundation.shape.RoundedCornerShape
@@ -40,7 +41,6 @@ import androidx.compose.material3.Surface
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableIntStateOf
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.setValue
@@ -49,7 +49,12 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.semantics.Role
 import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.unit.dp
+import com.example.maps3d.common.Map3DQuickSettingsWidget
+import com.example.maps3d.common.Map3DSessionTheme
+import com.example.maps3d.common.Map3DSettingsController
+import com.example.maps3d.common.rememberMap3DSessionSettings
 import com.google.android.gms.maps.model.LatLng
+import com.google.android.gms.maps3d.GoogleMap3D
 import com.google.android.gms.maps3d.model.Map3DMode
 import com.google.android.gms.maps3d.model.camera
 import com.google.android.gms.maps3d.model.latLngAltitude
@@ -61,7 +66,7 @@ class RoadmapModeActivity : ComponentActivity() {
         super.onCreate(savedInstanceState)
         enableEdgeToEdge()
         setContent {
-            MaterialTheme {
+            Map3DSessionTheme {
                 Surface(
                     modifier = Modifier.fillMaxSize(),
                     color = MaterialTheme.colorScheme.background,
@@ -80,7 +85,9 @@ class RoadmapModeActivity : ComponentActivity() {
 
 @Composable
 fun RoadmapModeScreen() {
-    var selectedMapMode by remember { mutableIntStateOf(Map3DMode.ROADMAP) }
+    var googleMap3D by remember { mutableStateOf<GoogleMap3D?>(null) }
+    val settings by rememberMap3DSessionSettings(defaultMapMode = Map3DMode.ROADMAP)
+    val selectedMapMode = settings.mapMode
 
     val initialLocation = RoadmapModeActivity.SF_LOCATION
     val currentCameraState by remember {
@@ -103,6 +110,9 @@ fun RoadmapModeScreen() {
             camera = currentCameraState,
             mapMode = selectedMapMode,
             modifier = Modifier.fillMaxSize(),
+            onMapReady = { map ->
+                googleMap3D = map
+            },
         )
 
         Card(
@@ -143,7 +153,9 @@ fun RoadmapModeScreen() {
                             modifier = Modifier
                                 .selectable(
                                     selected = (selectedMapMode == modeValue),
-                                    onClick = { selectedMapMode = modeValue },
+                                    onClick = {
+                                        Map3DSettingsController.shared.setMapMode(modeValue)
+                                    },
                                     role = Role.RadioButton,
                                 )
                                 .padding(vertical = 4.dp),
@@ -163,5 +175,14 @@ fun RoadmapModeScreen() {
                 }
             }
         }
+
+        Map3DQuickSettingsWidget(
+            modifier = Modifier
+                .align(Alignment.TopEnd)
+                .statusBarsPadding()
+                .padding(top = 8.dp, end = 8.dp),
+            sampleDefaultMapMode = Map3DMode.ROADMAP,
+            googleMap3D = googleMap3D,
+        )
     }
 }
diff --git a/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/routes/RoutesActivity.kt b/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/routes/RoutesActivity.kt
index 45134bc2..232724d6 100644
--- a/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/routes/RoutesActivity.kt
+++ b/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/routes/RoutesActivity.kt
@@ -95,7 +95,11 @@ import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import androidx.lifecycle.viewmodel.compose.viewModel
 import com.example.composedemos.BuildConfig
 import com.example.composedemos.R
+import com.example.maps3d.common.Map3DQuickSettingsWidget
+import com.example.maps3d.common.Map3DSessionTheme
+import com.example.maps3d.common.rememberMap3DSessionSettings
 import com.google.android.gms.maps.model.LatLng
+import com.google.android.gms.maps3d.GoogleMap3D
 import com.google.android.gms.maps3d.model.AltitudeMode
 import com.google.android.gms.maps3d.model.Camera
 import com.google.android.gms.maps3d.model.ImageView
@@ -163,7 +167,7 @@ class RoutesActivity : ComponentActivity() {
         windowInsetsController.systemBarsBehavior = WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
 
         setContent {
-            MaterialTheme {
+            Map3DSessionTheme {
                 Surface(
                     modifier = Modifier.fillMaxSize(),
                     color = MaterialTheme.colorScheme.background,
@@ -180,6 +184,8 @@ class RoutesActivity : ComponentActivity() {
 @Composable
 fun RouteSampleScreen(viewModel: RouteViewModel) {
     val uiState by viewModel.uiState.collectAsStateWithLifecycle()
+    var googleMap3D by remember { mutableStateOf<GoogleMap3D?>(null) }
+    val settings by rememberMap3DSessionSettings(defaultMapMode = Map3DMode.SATELLITE)
 
     val context = LocalContext.current
     val sharedPrefs = remember { context.getSharedPreferences("route_prefs", Context.MODE_PRIVATE) }
@@ -406,8 +412,11 @@ fun RouteSampleScreen(viewModel: RouteViewModel) {
             markers = currentMarkers,
             models = currentModels,
             polylines = polylines,
-            mapMode = Map3DMode.SATELLITE,
+            mapMode = settings.mapMode,
             modifier = Modifier.fillMaxSize(),
+            onMapReady = { map ->
+                googleMap3D = map
+            },
             onCameraChanged = { camera ->
                 cameraFlow.tryEmit(camera)
             },
@@ -419,7 +428,7 @@ fun RouteSampleScreen(viewModel: RouteViewModel) {
                 .fillMaxWidth()
                 .background(MaterialTheme.colorScheme.surface.copy(alpha = 0.75f))
                 .statusBarsPadding()
-                .padding(horizontal = 16.dp, vertical = 8.dp),
+                .padding(start = 16.dp, end = 64.dp, top = 8.dp, bottom = 8.dp),
         ) {
             Row(
                 modifier = Modifier.fillMaxWidth(),
@@ -498,6 +507,16 @@ fun RouteSampleScreen(viewModel: RouteViewModel) {
                 sharedPrefs.edit { putInt("warning_count", warningCount + 1) }
             })
         }
+
+        // Quick Settings Overlay
+        Map3DQuickSettingsWidget(
+            modifier = Modifier
+                .align(Alignment.TopEnd)
+                .statusBarsPadding()
+                .padding(top = 8.dp, end = 8.dp),
+            sampleDefaultMapMode = Map3DMode.SATELLITE,
+            googleMap3D = googleMap3D,
+        )
     }
 }
 
diff --git a/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/uicontrols/UiControlsActivity.kt b/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/uicontrols/UiControlsActivity.kt
new file mode 100644
index 00000000..2ba9fa00
--- /dev/null
+++ b/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/uicontrols/UiControlsActivity.kt
@@ -0,0 +1,392 @@
+/*
+ * Copyright 2026 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.example.composedemos.uicontrols
+
+import android.os.Bundle
+import androidx.activity.ComponentActivity
+import androidx.activity.compose.setContent
+import androidx.activity.enableEdgeToEdge
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.ExperimentalLayoutApi
+import androidx.compose.foundation.layout.FlowRow
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.statusBarsPadding
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.selection.selectable
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.Card
+import androidx.compose.material3.CardDefaults
+import androidx.compose.material3.FilterChip
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.RadioButton
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.semantics.Role
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.dp
+import androidx.core.view.WindowCompat
+import androidx.core.view.WindowInsetsCompat
+import androidx.core.view.WindowInsetsControllerCompat
+import com.example.maps3d.common.Map3DQuickSettingsWidget
+import com.example.maps3d.common.Map3DSessionTheme
+import com.example.maps3d.common.rememberMap3DSessionSettings
+import com.example.maps3dcommon.R
+import com.google.android.gms.maps.model.LatLng
+import com.google.android.gms.maps3d.GoogleMap3D
+import com.google.android.gms.maps3d.UiControlSettings.ControlOrientation
+import com.google.android.gms.maps3d.UiControlSettings.ControlPlacement
+import com.google.android.gms.maps3d.model.CompassControl
+import com.google.android.gms.maps3d.model.Map3DControl
+import com.google.android.gms.maps3d.model.Map3DMode
+import com.google.android.gms.maps3d.model.PanHorizontalControl
+import com.google.android.gms.maps3d.model.PanVerticalControl
+import com.google.android.gms.maps3d.model.RotateControl
+import com.google.android.gms.maps3d.model.TiltControl
+import com.google.android.gms.maps3d.model.ZoomControl
+import com.google.android.gms.maps3d.model.camera
+import com.google.android.gms.maps3d.model.latLngAltitude
+import com.google.maps.android.compose3d.GoogleMap3D
+
+class UiControlsActivity : ComponentActivity() {
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        enableEdgeToEdge()
+        enableImmersiveMode()
+        setContent {
+            Map3DSessionTheme {
+                Surface(
+                    modifier = Modifier.fillMaxSize(),
+                    color = MaterialTheme.colorScheme.background,
+                ) {
+                    UiControlsScreen()
+                }
+            }
+        }
+    }
+
+    override fun onResume() {
+        super.onResume()
+        enableImmersiveMode()
+    }
+
+    override fun onWindowFocusChanged(hasFocus: Boolean) {
+        super.onWindowFocusChanged(hasFocus)
+        if (hasFocus) {
+            enableImmersiveMode()
+        }
+    }
+
+    private fun enableImmersiveMode() {
+        val insetsController = WindowCompat.getInsetsController(window, window.decorView)
+        insetsController.systemBarsBehavior =
+            WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
+        insetsController.hide(WindowInsetsCompat.Type.systemBars())
+    }
+
+    companion object {
+        // San Francisco Financial District
+        val SF_LOCATION = LatLng(37.7915, -122.4010)
+    }
+}
+
+@OptIn(ExperimentalLayoutApi::class)
+@Composable
+fun UiControlsScreen() {
+    var googleMap3D by remember { mutableStateOf<GoogleMap3D?>(null) }
+    var isCollapsed by remember { mutableStateOf(false) }
+    val settings by rememberMap3DSessionSettings(defaultMapMode = Map3DMode.ROADMAP)
+
+    // Local state for UI controls showcase (directly controls SDK without polluting session settings)
+    var zoomEnabled by remember { mutableStateOf(true) }
+    var tiltEnabled by remember { mutableStateOf(true) }
+    var rotateEnabled by remember { mutableStateOf(true) }
+    var panVerticalEnabled by remember { mutableStateOf(true) }
+    var panHorizontalEnabled by remember { mutableStateOf(true) }
+    var compassEnabled by remember { mutableStateOf(true) }
+    var controlsPosition by remember { mutableIntStateOf(ControlPlacement.TRAILING) }
+
+    val initialLocation = UiControlsActivity.SF_LOCATION
+    val currentCameraState by remember {
+        mutableStateOf(
+            camera {
+                center = latLngAltitude {
+                    latitude = initialLocation.latitude
+                    longitude = initialLocation.longitude
+                    altitude = 250.0
+                }
+                heading = 45.0
+                tilt = 65.0
+                range = 800.0
+            },
+        )
+    }
+
+    // Apply UI controls directly to GoogleMap3D using SDK APIs
+    val mapKey = System.identityHashCode(googleMap3D)
+    LaunchedEffect(
+        mapKey,
+        settings,
+        zoomEnabled,
+        tiltEnabled,
+        rotateEnabled,
+        panVerticalEnabled,
+        panHorizontalEnabled,
+        compassEnabled,
+        controlsPosition,
+    ) {
+        val map = googleMap3D ?: return@LaunchedEffect
+        val uiSettings = map.getUiControlSettings() ?: return@LaunchedEffect
+
+        val primaryControls = mutableListOf<Map3DControl>()
+        if (zoomEnabled) primaryControls.add(ZoomControl(ControlOrientation.VERTICAL))
+        if (tiltEnabled) primaryControls.add(TiltControl(ControlOrientation.VERTICAL))
+        if (rotateEnabled) primaryControls.add(RotateControl(ControlOrientation.VERTICAL))
+
+        val secondaryControls = mutableListOf<Map3DControl>()
+        if (panVerticalEnabled) secondaryControls.add(PanVerticalControl(ControlOrientation.VERTICAL))
+        if (panHorizontalEnabled) secondaryControls.add(PanHorizontalControl(ControlOrientation.VERTICAL))
+        if (compassEnabled) secondaryControls.add(CompassControl())
+
+        val isLeading = controlsPosition == ControlPlacement.LEADING
+        val primaryPlacement = if (isLeading) ControlPlacement.LEADING else ControlPlacement.TRAILING
+        val secondaryPlacement = if (isLeading) ControlPlacement.TRAILING else ControlPlacement.LEADING
+
+        uiSettings.setUiControlsPlacement(primaryControls, primaryPlacement)
+        uiSettings.setUiControlsPlacement(secondaryControls, secondaryPlacement)
+    }
+
+    Box(modifier = Modifier.fillMaxSize()) {
+        GoogleMap3D(
+            camera = currentCameraState,
+            mapMode = settings.mapMode,
+            modifier = Modifier.fillMaxSize(),
+            onMapReady = { map ->
+                googleMap3D = map
+            },
+        )
+
+        Card(
+            modifier = Modifier
+                .align(Alignment.BottomCenter)
+                .fillMaxWidth()
+                .padding(12.dp),
+            shape = RoundedCornerShape(16.dp),
+            colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.surface),
+            elevation = CardDefaults.cardElevation(defaultElevation = 8.dp),
+        ) {
+            Column(
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .padding(horizontal = 16.dp, vertical = 8.dp),
+            ) {
+                Row(
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .clickable { isCollapsed = !isCollapsed },
+                    horizontalArrangement = Arrangement.SpaceBetween,
+                    verticalAlignment = Alignment.CenterVertically,
+                ) {
+                    Text(
+                        text = stringResource(R.string.ui_controls_panel_title),
+                        style = MaterialTheme.typography.titleSmall,
+                        fontWeight = FontWeight.Bold,
+                    )
+
+                    IconButton(onClick = { isCollapsed = !isCollapsed }) {
+                        Icon(
+                            painter = painterResource(
+                                id = if (isCollapsed) {
+                                    R.drawable.expand_less_24px
+                                } else {
+                                    R.drawable.expand_more_24px
+                                },
+                            ),
+                            contentDescription = stringResource(
+                                id = if (isCollapsed) {
+                                    R.string.expand_controls
+                                } else {
+                                    R.string.collapse_controls
+                                },
+                            ),
+                        )
+                    }
+                }
+
+                AnimatedVisibility(visible = !isCollapsed) {
+                    Column(
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .padding(bottom = 4.dp),
+                    ) {
+                        Row(
+                            modifier = Modifier.fillMaxWidth(),
+                            horizontalArrangement = Arrangement.SpaceBetween,
+                            verticalAlignment = Alignment.CenterVertically,
+                        ) {
+                            Text(
+                                text = stringResource(R.string.ui_controls_visibility_label),
+                                style = MaterialTheme.typography.labelMedium,
+                            )
+
+                            Row {
+                                TextButton(
+                                    onClick = {
+                                        zoomEnabled = true
+                                        tiltEnabled = true
+                                        rotateEnabled = true
+                                        panVerticalEnabled = true
+                                        panHorizontalEnabled = true
+                                        compassEnabled = true
+                                    },
+                                ) {
+                                    Text(text = stringResource(R.string.ui_controls_show_all))
+                                }
+
+                                TextButton(
+                                    onClick = {
+                                        zoomEnabled = false
+                                        tiltEnabled = false
+                                        rotateEnabled = false
+                                        panVerticalEnabled = false
+                                        panHorizontalEnabled = false
+                                        compassEnabled = false
+                                    },
+                                ) {
+                                    Text(text = stringResource(R.string.ui_controls_hide_all))
+                                }
+                            }
+                        }
+
+                        FlowRow(
+                            modifier = Modifier.fillMaxWidth(),
+                            horizontalArrangement = Arrangement.spacedBy(6.dp),
+                            verticalArrangement = Arrangement.spacedBy(2.dp),
+                        ) {
+                            FilterChip(
+                                selected = zoomEnabled,
+                                onClick = { zoomEnabled = !zoomEnabled },
+                                label = { Text(stringResource(R.string.ui_control_chip_zoom)) },
+                            )
+                            FilterChip(
+                                selected = tiltEnabled,
+                                onClick = { tiltEnabled = !tiltEnabled },
+                                label = { Text(stringResource(R.string.ui_control_chip_tilt)) },
+                            )
+                            FilterChip(
+                                selected = rotateEnabled,
+                                onClick = { rotateEnabled = !rotateEnabled },
+                                label = { Text(stringResource(R.string.ui_control_chip_rotate)) },
+                            )
+                            FilterChip(
+                                selected = panVerticalEnabled,
+                                onClick = { panVerticalEnabled = !panVerticalEnabled },
+                                label = { Text(stringResource(R.string.ui_control_chip_pan_vertical)) },
+                            )
+                            FilterChip(
+                                selected = panHorizontalEnabled,
+                                onClick = { panHorizontalEnabled = !panHorizontalEnabled },
+                                label = { Text(stringResource(R.string.ui_control_chip_pan_horizontal)) },
+                            )
+                            FilterChip(
+                                selected = compassEnabled,
+                                onClick = { compassEnabled = !compassEnabled },
+                                label = { Text(stringResource(R.string.ui_control_chip_compass)) },
+                            )
+                        }
+
+                        Spacer(modifier = Modifier.height(6.dp))
+
+                        Text(
+                            text = stringResource(R.string.ui_controls_placement_label),
+                            style = MaterialTheme.typography.labelMedium,
+                        )
+
+                        Row(
+                            modifier = Modifier.fillMaxWidth(),
+                            horizontalArrangement = Arrangement.SpaceBetween,
+                            verticalAlignment = Alignment.CenterVertically,
+                        ) {
+                            val placements = listOf(
+                                ControlPlacement.TRAILING to stringResource(R.string.ui_controls_placement_trailing),
+                                ControlPlacement.LEADING to stringResource(R.string.ui_controls_placement_leading),
+                            )
+
+                            placements.forEach { (positionValue, positionLabel) ->
+                                Row(
+                                    modifier = Modifier
+                                        .weight(1f)
+                                        .selectable(
+                                            selected = (controlsPosition == positionValue),
+                                            onClick = {
+                                                controlsPosition = positionValue
+                                            },
+                                            role = Role.RadioButton,
+                                        )
+                                        .padding(vertical = 4.dp),
+                                    verticalAlignment = Alignment.CenterVertically,
+                                ) {
+                                    RadioButton(
+                                        selected = (controlsPosition == positionValue),
+                                        onClick = null,
+                                    )
+                                    Spacer(modifier = Modifier.width(4.dp))
+                                    Text(
+                                        text = positionLabel,
+                                        style = MaterialTheme.typography.bodyMedium,
+                                    )
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        Map3DQuickSettingsWidget(
+            modifier = Modifier
+                .align(Alignment.TopEnd)
+                .statusBarsPadding()
+                .padding(top = 8.dp, end = 8.dp),
+            sampleDefaultMapMode = Map3DMode.ROADMAP,
+            googleMap3D = googleMap3D,
+        )
+    }
+}
diff --git a/compose_stability.conf b/compose_stability.conf
new file mode 100644
index 00000000..214ac3b3
--- /dev/null
+++ b/compose_stability.conf
@@ -0,0 +1,2 @@
+// Consider all Google Maps 3D SDK types stable for Jetpack Compose
+com.google.android.gms.maps3d.**
diff --git a/maps3d-compose-demo/src/main/java/com/example/maps3dcomposedemo/CameraAnimationsActivity.kt b/maps3d-compose-demo/src/main/java/com/example/maps3dcomposedemo/CameraAnimationsActivity.kt
index 1da9a13d..64a53fe0 100644
--- a/maps3d-compose-demo/src/main/java/com/example/maps3dcomposedemo/CameraAnimationsActivity.kt
+++ b/maps3d-compose-demo/src/main/java/com/example/maps3dcomposedemo/CameraAnimationsActivity.kt
@@ -176,16 +176,15 @@ fun CameraAnimationsScreen() {
 }
 
 // Helper extensions
-suspend fun com.google.android.gms.maps3d.GoogleMap3D.awaitCameraAnimation() =
-    suspendCancellableCoroutine { continuation ->
-        setCameraAnimationEndListener {
-            setCameraAnimationEndListener(null) // Cleanup
-            if (continuation.isActive) {
-                continuation.resume(Unit)
-            }
+suspend fun com.google.android.gms.maps3d.GoogleMap3D.awaitCameraAnimation() = suspendCancellableCoroutine { continuation ->
+    setCameraAnimationEndListener {
+        setCameraAnimationEndListener(null) // Cleanup
+        if (continuation.isActive) {
+            continuation.resume(Unit)
         }
+    }
 
-        continuation.invokeOnCancellation {
-            setCameraAnimationEndListener(null)
-        }
+    continuation.invokeOnCancellation {
+        setCameraAnimationEndListener(null)
     }
+}
diff --git a/maps3d-compose-demo/src/main/java/com/example/maps3dcomposedemo/MainActivity.kt b/maps3d-compose-demo/src/main/java/com/example/maps3dcomposedemo/MainActivity.kt
index 96f6af59..6474826d 100644
--- a/maps3d-compose-demo/src/main/java/com/example/maps3dcomposedemo/MainActivity.kt
+++ b/maps3d-compose-demo/src/main/java/com/example/maps3dcomposedemo/MainActivity.kt
@@ -59,9 +59,11 @@ class MainActivity : ComponentActivity() {
 @Composable
 fun CatalogScreen() {
     val context = LocalContext.current
-    LazyColumn(modifier = Modifier
-        .fillMaxSize()
-        .safeDrawingPadding()) {
+    LazyColumn(
+        modifier = Modifier
+            .fillMaxSize()
+            .safeDrawingPadding(),
+    ) {
         item {
             Text(
                 text = stringResource(R.string.catalog_title),
diff --git a/maps3d-compose/build.gradle.kts b/maps3d-compose/build.gradle.kts
index e73a7a05..25131655 100644
--- a/maps3d-compose/build.gradle.kts
+++ b/maps3d-compose/build.gradle.kts
@@ -59,6 +59,10 @@ android {
     }
 }
 
+composeCompiler {
+    stabilityConfigurationFiles.add(rootProject.layout.projectDirectory.file("compose_stability.conf"))
+}
+
 dependencies {
     implementation(libs.androidx.core.ktx)
     implementation(libs.androidx.lifecycle.runtime.ktx)
diff --git a/maps3d-compose/src/main/java/com/google/maps/android/compose3d/GoogleMap3D.kt b/maps3d-compose/src/main/java/com/google/maps/android/compose3d/GoogleMap3D.kt
index 530bff0f..4687b56d 100644
--- a/maps3d-compose/src/main/java/com/google/maps/android/compose3d/GoogleMap3D.kt
+++ b/maps3d-compose/src/main/java/com/google/maps/android/compose3d/GoogleMap3D.kt
@@ -119,7 +119,7 @@ fun GoogleMap3D(
     val currentOnMapClick by rememberUpdatedState(onMapClick)
     val currentOnPlaceClick by rememberUpdatedState(onPlaceClick)
 
-    DisposableEffect(lifecycleOwner, map3DViewState.value) {
+    DisposableEffect(lifecycleOwner, map3DViewState.value != null) {
         val map3dView = map3DViewState.value ?: return@DisposableEffect onDispose {}
         var isViewResumed = false
         val observer = LifecycleEventObserver { _, event ->
diff --git a/maps3d-compose/src/main/java/com/google/maps/android/compose3d/utils/CameraUpdate.kt b/maps3d-compose/src/main/java/com/google/maps/android/compose3d/utils/CameraUpdate.kt
index adc56ee6..00998765 100644
--- a/maps3d-compose/src/main/java/com/google/maps/android/compose3d/utils/CameraUpdate.kt
+++ b/maps3d-compose/src/main/java/com/google/maps/android/compose3d/utils/CameraUpdate.kt
@@ -63,8 +63,7 @@ sealed class CameraUpdate {
 
 fun FlyToOptions.toCameraUpdate(): CameraUpdate = CameraUpdate.FlyTo(this.toValidFlyToOptions())
 
-fun FlyAroundOptions.toCameraUpdate(): CameraUpdate =
-    CameraUpdate.FlyAround(this.toValidFlyAroundOptions())
+fun FlyAroundOptions.toCameraUpdate(): CameraUpdate = CameraUpdate.FlyAround(this.toValidFlyAroundOptions())
 
 fun FlyToOptions.toValidFlyToOptions(): FlyToOptions = this.copy(
     endCamera = this.endCamera.toValidCamera(),
diff --git a/maps3d-compose/src/main/java/com/google/maps/android/compose3d/utils/Units.kt b/maps3d-compose/src/main/java/com/google/maps/android/compose3d/utils/Units.kt
index 00a478bf..6a114f5b 100644
--- a/maps3d-compose/src/main/java/com/google/maps/android/compose3d/utils/Units.kt
+++ b/maps3d-compose/src/main/java/com/google/maps/android/compose3d/utils/Units.kt
@@ -145,8 +145,7 @@ object ImperialUnitsConverter : UnitsConverter() {
         ValueWithUnitsTemplate(meters.toMiles, R.string.in_miles)
     }
 
-    override fun toElevationUnits(meters: Meters): ValueWithUnitsTemplate =
-        ValueWithUnitsTemplate(meters.toFeet, R.string.in_feet)
+    override fun toElevationUnits(meters: Meters): ValueWithUnitsTemplate = ValueWithUnitsTemplate(meters.toFeet, R.string.in_feet)
 }
 
 /** Class to render measurements in metric units. */
@@ -159,8 +158,7 @@ object MetricUnitsConverter : UnitsConverter() {
         ValueWithUnitsTemplate(meters.toKilometers, R.string.in_kilometers)
     }
 
-    override fun toElevationUnits(meters: Meters): ValueWithUnitsTemplate =
-        ValueWithUnitsTemplate(meters.toMeters, R.string.in_meters)
+    override fun toElevationUnits(meters: Meters): ValueWithUnitsTemplate = ValueWithUnitsTemplate(meters.toMeters, R.string.in_meters)
 }
 
 /** A composition local that provides a [UnitsConverter] instance. */
diff --git a/maps3d-compose/src/main/java/com/google/maps/android/compose3d/utils/Utilities.kt b/maps3d-compose/src/main/java/com/google/maps/android/compose3d/utils/Utilities.kt
index 1f887fbb..ea7c987a 100644
--- a/maps3d-compose/src/main/java/com/google/maps/android/compose3d/utils/Utilities.kt
+++ b/maps3d-compose/src/main/java/com/google/maps/android/compose3d/utils/Utilities.kt
@@ -157,8 +157,7 @@ fun LatLngAltitude.toValidLocation(): LatLngAltitude {
  * @receiver The Number? to convert.
  * @return The heading value as a Double within [0.0, 360.0).
  */
-fun Number?.toHeading(): Double =
-    this?.toDouble()?.wrapIn(headingRange.start, headingRange.endInclusive) ?: DEFAULT_HEADING
+fun Number?.toHeading(): Double = this?.toDouble()?.wrapIn(headingRange.start, headingRange.endInclusive) ?: DEFAULT_HEADING
 
 /**
  * Converts a Number? to a valid tilt value (0.0 to 90.0).
diff --git a/snippets/common/src/main/res/layout/activity_map.xml b/snippets/common/src/main/res/layout/activity_map.xml
index e463be6f..7692bf6d 100644
--- a/snippets/common/src/main/res/layout/activity_map.xml
+++ b/snippets/common/src/main/res/layout/activity_map.xml
@@ -17,13 +17,15 @@
 
 <FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:app="http://schemas.android.com/apk/res-auto"
+    xmlns:map3d="http://schemas.android.com/apk/res-auto"
     android:layout_width="match_parent"
     android:layout_height="match_parent">
 
     <com.google.android.gms.maps3d.Map3DView
         android:id="@+id/map"
         android:layout_width="match_parent"
-        android:layout_height="match_parent" />
+        android:layout_height="match_parent"
+        map3d:mapMode="hybrid" />
 
 
 
diff --git a/snippets/java-app/src/main/java/com/example/snippets/java/MapActivity.java b/snippets/java-app/src/main/java/com/example/snippets/java/MapActivity.java
index 56c330a6..f4ed8eb2 100644
--- a/snippets/java-app/src/main/java/com/example/snippets/java/MapActivity.java
+++ b/snippets/java-app/src/main/java/com/example/snippets/java/MapActivity.java
@@ -24,6 +24,9 @@
 import androidx.activity.EdgeToEdge;
 import androidx.annotation.NonNull;
 import androidx.appcompat.app.AppCompatActivity;
+import androidx.core.view.WindowCompat;
+import androidx.core.view.WindowInsetsCompat;
+import androidx.core.view.WindowInsetsControllerCompat;
 import com.example.snippets.common.R;
 import com.google.android.gms.maps3d.GoogleMap3D;
 import com.google.android.gms.maps3d.Map3DView;
@@ -48,6 +51,7 @@ public class MapActivity extends AppCompatActivity {
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         EdgeToEdge.enable(this);
+        enableImmersiveMode();
         setContentView(R.layout.activity_map);
         map3DView = findViewById(R.id.map);
         map3DView.onCreate(savedInstanceState);
@@ -215,6 +219,24 @@ protected void runSnippet() {
         }
     }
 
+    private void enableImmersiveMode() {
+        WindowInsetsControllerCompat insetsController =
+                WindowCompat.getInsetsController(getWindow(), getWindow().getDecorView());
+        if (insetsController != null) {
+            insetsController.setSystemBarsBehavior(
+                    WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE);
+            insetsController.hide(WindowInsetsCompat.Type.systemBars());
+        }
+    }
+
+    @Override
+    public void onWindowFocusChanged(boolean hasFocus) {
+        super.onWindowFocusChanged(hasFocus);
+        if (hasFocus) {
+            enableImmersiveMode();
+        }
+    }
+
     @Override
     protected void onStart() {
         super.onStart();
@@ -224,6 +246,7 @@ protected void onStart() {
     @Override
     protected void onResume() {
         super.onResume();
+        enableImmersiveMode();
         if (map3DView != null) map3DView.onResume();
     }
 
diff --git a/snippets/java-app/src/main/java/com/example/snippets/java/SnippetRegistry.java b/snippets/java-app/src/main/java/com/example/snippets/java/SnippetRegistry.java
index db72ee40..34ffe3c0 100644
--- a/snippets/java-app/src/main/java/com/example/snippets/java/SnippetRegistry.java
+++ b/snippets/java-app/src/main/java/com/example/snippets/java/SnippetRegistry.java
@@ -19,7 +19,15 @@
 import android.content.Context;
 import com.example.snippets.java.annotations.SnippetGroup;
 import com.example.snippets.java.annotations.SnippetItem;
-import com.example.snippets.java.snippets.*;
+import com.example.snippets.java.snippets.CameraControlSnippets;
+import com.example.snippets.java.snippets.MapInitSnippets;
+import com.example.snippets.java.snippets.MapLocalizationSnippets;
+import com.example.snippets.java.snippets.MarkerSnippets;
+import com.example.snippets.java.snippets.ModelSnippets;
+import com.example.snippets.java.snippets.PlaceSnippets;
+import com.example.snippets.java.snippets.PolygonSnippets;
+import com.example.snippets.java.snippets.PolylineSnippets;
+import com.example.snippets.java.snippets.PopoverSnippets;
 import com.google.android.gms.maps3d.Popover;
 import com.google.android.gms.maps3d.model.Marker;
 import com.google.android.gms.maps3d.model.Model;
diff --git a/snippets/java-app/src/main/java/com/example/snippets/java/TrackedMap3D.java b/snippets/java-app/src/main/java/com/example/snippets/java/TrackedMap3D.java
index 5a8a8a80..f7722f43 100644
--- a/snippets/java-app/src/main/java/com/example/snippets/java/TrackedMap3D.java
+++ b/snippets/java-app/src/main/java/com/example/snippets/java/TrackedMap3D.java
@@ -22,6 +22,7 @@
 import com.google.android.gms.maps3d.OnMapReadyListener;
 import com.google.android.gms.maps3d.OnMapSteadyListener;
 import com.google.android.gms.maps3d.Popover;
+import com.google.android.gms.maps3d.UiControlSettings;
 import com.google.android.gms.maps3d.model.Camera;
 import com.google.android.gms.maps3d.model.CameraRestriction;
 import com.google.android.gms.maps3d.model.FlyAroundOptions;
@@ -127,4 +128,12 @@ public CameraRestriction getCameraRestriction() {
     public void setLocale(LocaleOptions options) {
         delegate.setLocale(options);
     }
+
+    public UiControlSettings getUiControlSettings() {
+        UiControlSettings settings = delegate.getUiControlSettings();
+        if (settings != null && !items.contains(settings)) {
+            items.add(settings);
+        }
+        return settings;
+    }
 }
diff --git a/snippets/java-app/src/main/java/com/example/snippets/java/snippets/MapInitSnippets.java b/snippets/java-app/src/main/java/com/example/snippets/java/snippets/MapInitSnippets.java
index a06d47ed..a9c8831d 100644
--- a/snippets/java-app/src/main/java/com/example/snippets/java/snippets/MapInitSnippets.java
+++ b/snippets/java-app/src/main/java/com/example/snippets/java/snippets/MapInitSnippets.java
@@ -25,13 +25,13 @@
 import com.example.snippets.java.annotations.SnippetGroup;
 import com.example.snippets.java.annotations.SnippetItem;
 import com.google.android.gms.maps3d.GoogleMap3D;
-import com.google.android.gms.maps3d.Map3DInitConfig;
 import com.google.android.gms.maps3d.Map3DView;
 import com.google.android.gms.maps3d.OnMap3DViewReadyCallback;
 import com.google.android.gms.maps3d.OnMapReadyListener;
 import com.google.android.gms.maps3d.OnMapSteadyListener;
 import com.google.android.gms.maps3d.model.Camera;
 import com.google.android.gms.maps3d.model.LatLngAltitude;
+import com.google.android.gms.maps3d.model.Map3DMode;
 
 @SnippetGroup(
         title = "Map Initialization",
@@ -44,7 +44,7 @@ public class MapInitSnippets {
     @SuppressWarnings("unused")
     public void basicMap3D(Context context) {
         // [START maps_android_3d_init_basic_java]
-        Map3DView map3DView = new Map3DView(context, Map3DInitConfig.create());
+        Map3DView map3DView = new Map3DView(context, Map3DMode.HYBRID);
 
         // Get the map asynchronously
         map3DView.getMap3DViewAsync(
diff --git a/snippets/kotlin-app/src/main/java/com/example/snippets/kotlin/MapActivity.kt b/snippets/kotlin-app/src/main/java/com/example/snippets/kotlin/MapActivity.kt
index 55780874..b42719d5 100644
--- a/snippets/kotlin-app/src/main/java/com/example/snippets/kotlin/MapActivity.kt
+++ b/snippets/kotlin-app/src/main/java/com/example/snippets/kotlin/MapActivity.kt
@@ -21,6 +21,8 @@ import android.util.Log
 import android.widget.Toast
 import androidx.appcompat.app.AppCompatActivity
 import androidx.core.view.WindowCompat
+import androidx.core.view.WindowInsetsCompat
+import androidx.core.view.WindowInsetsControllerCompat
 import androidx.lifecycle.lifecycleScope
 import com.example.snippets.common.R
 import com.google.android.gms.maps3d.GoogleMap3D
@@ -46,6 +48,7 @@ class MapActivity : AppCompatActivity() {
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         WindowCompat.setDecorFitsSystemWindows(window, false)
+        enableImmersiveMode()
         setContentView(R.layout.activity_map)
 
         map3DView = findViewById(R.id.map)
@@ -152,6 +155,20 @@ class MapActivity : AppCompatActivity() {
         })
     }
 
+    private fun enableImmersiveMode() {
+        val insetsController = WindowCompat.getInsetsController(window, window.decorView)
+        insetsController.systemBarsBehavior =
+            WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
+        insetsController.hide(WindowInsetsCompat.Type.systemBars())
+    }
+
+    override fun onWindowFocusChanged(hasFocus: Boolean) {
+        super.onWindowFocusChanged(hasFocus)
+        if (hasFocus) {
+            enableImmersiveMode()
+        }
+    }
+
     override fun onStart() {
         super.onStart()
         map3DView.onStart()
@@ -159,6 +176,7 @@ class MapActivity : AppCompatActivity() {
 
     override fun onResume() {
         super.onResume()
+        enableImmersiveMode()
         map3DView.onResume()
     }
 
diff --git a/snippets/kotlin-app/src/main/java/com/example/snippets/kotlin/SnippetRegistry.kt b/snippets/kotlin-app/src/main/java/com/example/snippets/kotlin/SnippetRegistry.kt
index acaf89a1..d94aa48b 100644
--- a/snippets/kotlin-app/src/main/java/com/example/snippets/kotlin/SnippetRegistry.kt
+++ b/snippets/kotlin-app/src/main/java/com/example/snippets/kotlin/SnippetRegistry.kt
@@ -28,8 +28,11 @@ import com.example.snippets.kotlin.snippets.PlaceSnippets
 import com.example.snippets.kotlin.snippets.PolygonSnippets
 import com.example.snippets.kotlin.snippets.PolylineSnippets
 import com.example.snippets.kotlin.snippets.PopoverSnippets
+import com.example.snippets.kotlin.snippets.UiControlSnippets
 import com.google.android.gms.maps3d.GoogleMap3D
 import com.google.android.gms.maps3d.Popover
+import com.google.android.gms.maps3d.UiControlSettings
+import com.google.android.gms.maps3d.UiControlSettings.ControlPlacement
 import com.google.android.gms.maps3d.model.Marker
 import com.google.android.gms.maps3d.model.Model
 import com.google.android.gms.maps3d.model.Polygon
@@ -57,10 +60,21 @@ object SnippetRegistry {
             try {
                 when (item) {
                     is Marker -> item.remove()
+
                     is Polyline -> item.remove()
+
                     is Polygon -> item.remove()
+
                     is Model -> item.remove()
+
                     is Popover -> item.remove()
+
+                    is UiControlSettings -> {
+                        item.setUiControlsPlacement(emptyList(), ControlPlacement.TRAILING)
+                        item.setUiControlsPlacement(emptyList(), ControlPlacement.LEADING)
+                        item.setUiControlsPlacement(emptyList(), ControlPlacement.TOP)
+                        item.setUiControlsPlacement(emptyList(), ControlPlacement.BOTTOM)
+                    }
                 }
             } catch (e: Exception) {
                 // Ignore failures to avoid crashing if already cleanup or invalid
@@ -73,6 +87,7 @@ object SnippetRegistry {
         MapInitSnippets::class.java,
         MapLocalizationSnippets::class.java,
         CameraControlSnippets::class.java,
+        UiControlSnippets::class.java,
         MarkerSnippets::class.java,
         PolygonSnippets::class.java,
         PolylineSnippets::class.java,
diff --git a/snippets/kotlin-app/src/main/java/com/example/snippets/kotlin/TrackedMap3D.kt b/snippets/kotlin-app/src/main/java/com/example/snippets/kotlin/TrackedMap3D.kt
index 720b0332..37f463a3 100644
--- a/snippets/kotlin-app/src/main/java/com/example/snippets/kotlin/TrackedMap3D.kt
+++ b/snippets/kotlin-app/src/main/java/com/example/snippets/kotlin/TrackedMap3D.kt
@@ -6,6 +6,7 @@ import com.google.android.gms.maps3d.OnMap3DClickListener
 import com.google.android.gms.maps3d.OnMapReadyListener
 import com.google.android.gms.maps3d.OnMapSteadyListener
 import com.google.android.gms.maps3d.Popover
+import com.google.android.gms.maps3d.UiControlSettings
 import com.google.android.gms.maps3d.model.Camera
 import com.google.android.gms.maps3d.model.CameraRestriction
 import com.google.android.gms.maps3d.model.FlyAroundOptions
@@ -70,4 +71,10 @@ class TrackedMap3D(val delegate: GoogleMap3D, private val items: MutableList<Any
     fun setCameraRestriction(restriction: CameraRestriction?) = delegate.setCameraRestriction(restriction)
     fun getCameraRestriction() = delegate.getCameraRestriction()
     fun setLocale(options: LocaleOptions) = delegate.setLocale(options)
+
+    fun getUiControlSettings(): UiControlSettings? {
+        val settings = delegate.getUiControlSettings()
+        if (settings != null && settings !in items) items.add(settings)
+        return settings
+    }
 }
diff --git a/snippets/kotlin-app/src/main/java/com/example/snippets/kotlin/snippets/MapInitSnippets.kt b/snippets/kotlin-app/src/main/java/com/example/snippets/kotlin/snippets/MapInitSnippets.kt
index a4abb95b..81e84cd0 100644
--- a/snippets/kotlin-app/src/main/java/com/example/snippets/kotlin/snippets/MapInitSnippets.kt
+++ b/snippets/kotlin-app/src/main/java/com/example/snippets/kotlin/snippets/MapInitSnippets.kt
@@ -28,9 +28,9 @@ import androidx.compose.ui.viewinterop.AndroidView
 import com.example.snippets.kotlin.annotations.SnippetGroup
 import com.example.snippets.kotlin.annotations.SnippetItem
 import com.google.android.gms.maps3d.GoogleMap3D
-import com.google.android.gms.maps3d.Map3DInitConfig
 import com.google.android.gms.maps3d.Map3DView
 import com.google.android.gms.maps3d.OnMap3DViewReadyCallback
+import com.google.android.gms.maps3d.model.Map3DMode
 import com.google.android.gms.maps3d.model.camera
 import com.google.android.gms.maps3d.model.latLngAltitude
 
@@ -57,7 +57,7 @@ class MapInitSnippets {
         AndroidView(
             modifier = Modifier.fillMaxSize(),
             factory = { context ->
-                Map3DView(context, Map3DInitConfig.create()).apply {
+                Map3DView(context, Map3DMode.HYBRID).apply {
                     getMap3DViewAsync(object : OnMap3DViewReadyCallback {
                         override fun onMap3DViewReady(googleMap3D: GoogleMap3D) {
                             val camera = camera {
diff --git a/snippets/kotlin-app/src/main/java/com/example/snippets/kotlin/snippets/UiControlSnippets.kt b/snippets/kotlin-app/src/main/java/com/example/snippets/kotlin/snippets/UiControlSnippets.kt
new file mode 100644
index 00000000..4e6eaeb8
--- /dev/null
+++ b/snippets/kotlin-app/src/main/java/com/example/snippets/kotlin/snippets/UiControlSnippets.kt
@@ -0,0 +1,195 @@
+/*
+ * Copyright 2026 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.example.snippets.kotlin.snippets
+
+import com.example.snippets.kotlin.TrackedMap3D
+import com.example.snippets.kotlin.annotations.SnippetGroup
+import com.example.snippets.kotlin.annotations.SnippetItem
+import com.google.android.gms.maps3d.UiControlSettings.ControlOrientation
+import com.google.android.gms.maps3d.UiControlSettings.ControlPlacement
+import com.google.android.gms.maps3d.model.CompassControl
+import com.google.android.gms.maps3d.model.PanHorizontalControl
+import com.google.android.gms.maps3d.model.PanVerticalControl
+import com.google.android.gms.maps3d.model.RotateControl
+import com.google.android.gms.maps3d.model.Spacer
+import com.google.android.gms.maps3d.model.TiltControl
+import com.google.android.gms.maps3d.model.ZoomControl
+import com.google.android.gms.maps3d.model.camera
+import com.google.android.gms.maps3d.model.flyToOptions
+import com.google.android.gms.maps3d.model.latLngAltitude
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import kotlin.time.Duration.Companion.seconds
+
+/**
+ * Snippets demonstrating built-in 3D map UI control buttons and placement configuration.
+ */
+@SnippetGroup(
+    title = "UI Controls",
+    description = "Snippets demonstrating built-in 3D map camera UI controls and screen placement.",
+)
+class UiControlSnippets(
+    private val map: TrackedMap3D,
+    private val lifecycleScope: CoroutineScope,
+) {
+
+    /**
+     * Configures the built-in 3D camera UI controls on the trailing and leading edges of the map.
+     */
+    @Suppress("unused")
+    @SnippetItem(
+        title = "1. Configure UI Controls Placement",
+        description = "Configures Zoom, Tilt, and Rotate controls on the trailing edge and Pan and Compass controls on the leading edge.",
+    )
+    fun configureUiControlsPlacement() {
+        focusSampleScene()
+        // [START maps_android_3d_ui_controls_placement_kt]
+        map.getUiControlSettings()?.let { uiSettings ->
+            val trailingControls = listOf(
+                ZoomControl(ControlOrientation.VERTICAL),
+                TiltControl(ControlOrientation.VERTICAL),
+                RotateControl(ControlOrientation.VERTICAL),
+            )
+            uiSettings.setUiControlsPlacement(trailingControls, ControlPlacement.TRAILING)
+
+            val leadingControls = listOf(
+                PanVerticalControl(ControlOrientation.VERTICAL),
+                PanHorizontalControl(ControlOrientation.VERTICAL),
+                CompassControl(),
+            )
+            uiSettings.setUiControlsPlacement(leadingControls, ControlPlacement.LEADING)
+        }
+        // [END maps_android_3d_ui_controls_placement_kt]
+    }
+
+    /**
+     * Swaps the main camera controls to the leading edge and secondary pan/compass controls to the trailing edge.
+     */
+    @Suppress("unused")
+    @SnippetItem(
+        title = "2. Swap Leading & Trailing Edges",
+        description = "Moves main camera controls (Zoom, Tilt, Rotate) to the leading edge and Pan/Compass controls to the trailing edge.",
+    )
+    fun swapUiControlsEdges() {
+        focusSampleScene()
+        // [START maps_android_3d_ui_controls_swap_edges_kt]
+        map.getUiControlSettings()?.let { uiSettings ->
+            val leadingControls = listOf(
+                ZoomControl(ControlOrientation.VERTICAL),
+                TiltControl(ControlOrientation.VERTICAL),
+                RotateControl(ControlOrientation.VERTICAL),
+            )
+            uiSettings.setUiControlsPlacement(leadingControls, ControlPlacement.LEADING)
+
+            val trailingControls = listOf(
+                PanVerticalControl(ControlOrientation.VERTICAL),
+                PanHorizontalControl(ControlOrientation.VERTICAL),
+                CompassControl(),
+            )
+            uiSettings.setUiControlsPlacement(trailingControls, ControlPlacement.TRAILING)
+        }
+        // [END maps_android_3d_ui_controls_swap_edges_kt]
+    }
+
+    /**
+     * Configures horizontal UI controls with spacers along the top and bottom screen edges.
+     */
+    @Suppress("unused")
+    @SnippetItem(
+        title = "3. Horizontal & Top/Bottom Controls",
+        description = "Configures horizontal control orientation with Spacers along the top and bottom edges of the map.",
+    )
+    fun configureHorizontalTopBottomControls() {
+        focusSampleScene()
+        // [START maps_android_3d_ui_controls_orientation_kt]
+        map.getUiControlSettings()?.let { uiSettings ->
+            val topControls = listOf(
+                CompassControl(),
+                Spacer(),
+                RotateControl(ControlOrientation.HORIZONTAL),
+                TiltControl(ControlOrientation.HORIZONTAL),
+            )
+            uiSettings.setUiControlsPlacement(topControls, ControlPlacement.TOP)
+
+            val bottomControls = listOf(
+                ZoomControl(ControlOrientation.HORIZONTAL),
+                Spacer(),
+                PanHorizontalControl(ControlOrientation.HORIZONTAL),
+                PanVerticalControl(ControlOrientation.HORIZONTAL),
+            )
+            uiSettings.setUiControlsPlacement(bottomControls, ControlPlacement.BOTTOM)
+        }
+        // [END maps_android_3d_ui_controls_orientation_kt]
+    }
+
+    /**
+     * Hides all built-in 3D camera UI controls by passing an empty list to each placement edge.
+     */
+    @Suppress("unused")
+    @SnippetItem(
+        title = "4. Hide UI Controls",
+        description = "Displays UI controls briefly and then hides all controls across every screen edge using an empty list.",
+    )
+    fun hideUiControls() {
+        focusSampleScene()
+        // [START_EXCLUDE]
+        map.getUiControlSettings()?.let { uiSettings ->
+            uiSettings.setUiControlsPlacement(
+                listOf(ZoomControl(null), TiltControl(null), RotateControl(null)),
+                ControlPlacement.TRAILING,
+            )
+            uiSettings.setUiControlsPlacement(
+                listOf(PanVerticalControl(null), PanHorizontalControl(null), CompassControl()),
+                ControlPlacement.LEADING,
+            )
+        }
+        // [END_EXCLUDE]
+
+        lifecycleScope.launch {
+            // [START_EXCLUDE]
+            delay(2.seconds)
+            // [END_EXCLUDE]
+            // [START maps_android_3d_ui_controls_hide_kt]
+            map.getUiControlSettings()?.let { uiSettings ->
+                uiSettings.setUiControlsPlacement(emptyList(), ControlPlacement.TRAILING)
+                uiSettings.setUiControlsPlacement(emptyList(), ControlPlacement.LEADING)
+                uiSettings.setUiControlsPlacement(emptyList(), ControlPlacement.TOP)
+                uiSettings.setUiControlsPlacement(emptyList(), ControlPlacement.BOTTOM)
+            }
+            // [END maps_android_3d_ui_controls_hide_kt]
+        }
+    }
+
+    private fun focusSampleScene() {
+        map.flyCameraTo(
+            flyToOptions {
+                endCamera = camera {
+                    center = latLngAltitude {
+                        latitude = 37.8199
+                        longitude = -122.4783
+                        altitude = 0.0
+                    }
+                    heading = 330.0
+                    tilt = 55.0
+                    range = 1500.0
+                }
+                durationInMillis = 1500
+            },
+        )
+    }
+}