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
new file mode 100644
index 00000000..2d9a0c2d
--- /dev/null
+++ b/Maps3DSamples/ApiDemos/common/src/main/res/layout/activity_path_following.xml
@@ -0,0 +1,209 @@
+<?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.coordinatorlayout.widget.CoordinatorLayout
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    android:layout_width="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"
+        />
+
+
+
+    <!-- Bottom Control Panel Card -->
+    <androidx.cardview.widget.CardView
+        android:id="@+id/controls_card"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:layout_gravity="bottom"
+        android:layout_margin="12dp"
+        app:cardCornerRadius="16dp"
+        app:cardElevation="8dp"
+        >
+
+        <ScrollView
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:maxHeight="320dp"
+            >
+
+            <LinearLayout
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:orientation="vertical"
+                android:padding="12dp"
+                >
+
+                <!-- Environment Selection Header -->
+                <TextView
+                    style="@style/TextAppearance.Material3.LabelLarge"
+                    android:layout_width="wrap_content"
+                    android:layout_height="wrap_content"
+                    android:text="Path Environment:"
+                    android:textStyle="bold"
+                    />
+
+                <RadioGroup
+                    android:id="@+id/rg_environment"
+                    android:layout_width="match_parent"
+                    android:layout_height="wrap_content"
+                    android:orientation="horizontal"
+                    android:layout_marginTop="2dp"
+                    >
+
+                    <RadioButton
+                        android:id="@+id/rb_urban"
+                        android:layout_width="0dp"
+                        android:layout_height="wrap_content"
+                        android:layout_weight="1"
+                        android:checked="true"
+                        android:text="Urban"
+                        />
+
+                    <RadioButton
+                        android:id="@+id/rb_rural"
+                        android:layout_width="0dp"
+                        android:layout_height="wrap_content"
+                        android:layout_weight="1"
+                        android:text="Rural"
+                        />
+                </RadioGroup>
+
+                <!-- Play / Pause and Progress Row -->
+                <LinearLayout
+                    android:layout_width="match_parent"
+                    android:layout_height="wrap_content"
+                    android:orientation="horizontal"
+                    android:gravity="center_vertical"
+                    android:layout_marginTop="4dp"
+                    >
+
+                    <com.google.android.material.button.MaterialButton
+                        android:id="@+id/btn_play_pause"
+                        style="@style/Widget.Material3.Button.IconButton.Filled"
+                        android:layout_width="44dp"
+                        android:layout_height="44dp"
+                        app:icon="@drawable/play_arrow_24px"
+                        />
+
+                    <com.google.android.material.slider.Slider
+                        android:id="@+id/progress_slider"
+                        android:layout_width="0dp"
+                        android:layout_height="wrap_content"
+                        android:layout_weight="1"
+                        android:valueFrom="0.0"
+                        android:valueTo="1.0"
+                        android:value="0.0"
+                        />
+                </LinearLayout>
+
+                <!-- Camera Parameter Sliders -->
+                <TextView
+                    android:id="@+id/range_slider_label"
+                    style="@style/TextAppearance.Material3.LabelMedium"
+                    android:layout_width="wrap_content"
+                    android:layout_height="wrap_content"
+                    android:layout_marginTop="4dp"
+                    android:text="Camera Range: 300m"
+                    />
+
+                <com.google.android.material.slider.Slider
+                    android:id="@+id/range_slider"
+                    android:layout_width="match_parent"
+                    android:layout_height="wrap_content"
+                    android:valueFrom="50.0"
+                    android:valueTo="1000.0"
+                    android:value="300.0"
+                    />
+
+                <TextView
+                    android:id="@+id/altitude_slider_label"
+                    style="@style/TextAppearance.Material3.LabelMedium"
+                    android:layout_width="wrap_content"
+                    android:layout_height="wrap_content"
+                    android:text="Ground Altitude: 20m"
+                    />
+
+                <com.google.android.material.slider.Slider
+                    android:id="@+id/altitude_slider"
+                    android:layout_width="match_parent"
+                    android:layout_height="wrap_content"
+                    android:valueFrom="5.0"
+                    android:valueTo="200.0"
+                    android:value="20.0"
+                    />
+
+                <TextView
+                    android:id="@+id/heading_slider_label"
+                    style="@style/TextAppearance.Material3.LabelMedium"
+                    android:layout_width="wrap_content"
+                    android:layout_height="wrap_content"
+                    android:text="Heading Offset: 0°"
+                    />
+
+                <com.google.android.material.slider.Slider
+                    android:id="@+id/heading_slider"
+                    android:layout_width="match_parent"
+                    android:layout_height="wrap_content"
+                    android:valueFrom="-180.0"
+                    android:valueTo="180.0"
+                    android:value="0.0"
+                    />
+
+                <TextView
+                    android:id="@+id/tilt_slider_label"
+                    style="@style/TextAppearance.Material3.LabelMedium"
+                    android:layout_width="wrap_content"
+                    android:layout_height="wrap_content"
+                    android:text="Camera Tilt: 70°"
+                    />
+
+                <com.google.android.material.slider.Slider
+                    android:id="@+id/tilt_slider"
+                    android:layout_width="match_parent"
+                    android:layout_height="wrap_content"
+                    android:valueFrom="0.0"
+                    android:valueTo="85.0"
+                    android:value="70.0"
+                    />
+
+                <TextView
+                    android:id="@+id/speed_slider_label"
+                    style="@style/TextAppearance.Material3.LabelMedium"
+                    android:layout_width="wrap_content"
+                    android:layout_height="wrap_content"
+                    android:text="Follow Speed: 30 m/s"
+                    />
+
+                <com.google.android.material.slider.Slider
+                    android:id="@+id/speed_slider"
+                    android:layout_width="match_parent"
+                    android:layout_height="wrap_content"
+                    android:valueFrom="5.0"
+                    android:valueTo="100.0"
+                    android:value="30.0"
+                    />
+            </LinearLayout>
+        </ScrollView>
+    </androidx.cardview.widget.CardView>
+</androidx.coordinatorlayout.widget.CoordinatorLayout>
diff --git a/Maps3DSamples/ApiDemos/common/src/main/res/layout/control_panel_advanced_animation.xml b/Maps3DSamples/ApiDemos/common/src/main/res/layout/control_panel_advanced_animation.xml
new file mode 100644
index 00000000..d0a40acc
--- /dev/null
+++ b/Maps3DSamples/ApiDemos/common/src/main/res/layout/control_panel_advanced_animation.xml
@@ -0,0 +1,111 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+ Copyright 2025 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:layout_margin="12dp"
+        android:orientation="vertical"
+        >
+
+        <TextView
+            style="@style/TextAppearance.Material3.LabelLarge"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="Select Animation Approach:"
+            android:textStyle="bold"
+            />
+
+        <RadioGroup
+            android:id="@+id/rg_approach"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:orientation="vertical"
+            android:layout_marginTop="4dp"
+            >
+
+            <RadioButton
+                android:id="@+id/rb_simple_flyto"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:text="1. SDK Simple flyTo (Native Transition)"
+                />
+
+            <RadioButton
+                android:id="@+id/rb_keyframe_tour"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:text="2. Keyframe Queue (Multi-step Camera Tour)"
+                />
+
+            <RadioButton
+                android:id="@+id/rb_dispatcher_loop"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:checked="true"
+                android:text="3. Frame Dispatcher (Chase Cam + 3D Airplane)"
+                />
+
+            <RadioButton
+                android:id="@+id/rb_orbit_spin"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:text="4. 360° Orbit Spin (Continuous Orbital Camera)"
+                />
+        </RadioGroup>
+
+        <LinearLayout
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:orientation="horizontal"
+            android:gravity="end"
+            android:layout_marginTop="8dp"
+            >
+
+            <Button
+                android:id="@+id/btn_reset"
+                style="@style/Widget.Material3.Button.OutlinedButton"
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                android:text="Reset"
+                android:layout_marginEnd="8dp"
+                />
+
+            <Button
+                android:id="@+id/btn_play_pause"
+                style="@style/Widget.Material3.Button"
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                android:text="Play"
+                />
+        </LinearLayout>
+
+    </LinearLayout>
+</androidx.cardview.widget.CardView>
diff --git a/Maps3DSamples/ApiDemos/common/src/main/res/layout/control_panel_data_visualization.xml b/Maps3DSamples/ApiDemos/common/src/main/res/layout/control_panel_data_visualization.xml
new file mode 100644
index 00000000..ad9d35c0
--- /dev/null
+++ b/Maps3DSamples/ApiDemos/common/src/main/res/layout/control_panel_data_visualization.xml
@@ -0,0 +1,110 @@
+<?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:layout_margin="12dp"
+        android:orientation="vertical"
+        >
+
+        <LinearLayout
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:orientation="horizontal"
+            android:gravity="center_vertical"
+            >
+
+            <TextView
+                android:id="@+id/tv_flood_depth_label"
+                style="@style/TextAppearance.Material3.LabelLarge"
+                android:layout_width="0dp"
+                android:layout_height="wrap_content"
+                android:layout_weight="1"
+                android:text="Flood Elevation: +10.0 m (32.8 ft)"
+                android:textStyle="bold"
+                />
+
+            <TextView
+                android:id="@+id/tv_flood_risk_badge"
+                style="@style/TextAppearance.Material3.LabelSmall"
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                android:background="#25FF0000"
+                android:paddingStart="8dp"
+                android:paddingEnd="8dp"
+                android:paddingTop="2dp"
+                android:paddingBottom="2dp"
+                android:text="🚨 Flood Hazard (+10m)"
+                android:textColor="#FFCC0000"
+                android:textStyle="bold"
+                />
+        </LinearLayout>
+
+        <com.google.android.material.slider.Slider
+            android:id="@+id/flood_slider"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:layout_marginTop="2dp"
+            android:valueFrom="0.0"
+            android:valueTo="100.0"
+            android:value="10.0"
+            android:stepSize="0.1"
+            />
+
+        <LinearLayout
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:orientation="horizontal"
+            android:gravity="center_vertical"
+            android:layout_marginTop="4dp"
+            >
+
+            <TextView
+                style="@style/TextAppearance.Material3.LabelMedium"
+                android:layout_width="0dp"
+                android:layout_height="wrap_content"
+                android:layout_weight="1"
+                android:text="Continuous Tide Simulation:"
+                android:textStyle="bold"
+                />
+
+            <com.google.android.material.button.MaterialButton
+                android:id="@+id/btn_animate_flood"
+                style="@style/Widget.Material3.Button.TonalButton"
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                android:text="▶ Start Simulation"
+                android:textSize="12sp"
+                />
+        </LinearLayout>
+
+    </LinearLayout>
+</androidx.cardview.widget.CardView>
diff --git a/Maps3DSamples/ApiDemos/common/src/main/res/layout/control_panel_field_of_view.xml b/Maps3DSamples/ApiDemos/common/src/main/res/layout/control_panel_field_of_view.xml
new file mode 100644
index 00000000..67695a75
--- /dev/null
+++ b/Maps3DSamples/ApiDemos/common/src/main/res/layout/control_panel_field_of_view.xml
@@ -0,0 +1,126 @@
+<?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:layout_margin="12dp"
+        android:orientation="vertical"
+        >
+
+        <TextView
+            android:id="@+id/fov_slider_label"
+            style="@style/TextAppearance.Material3.LabelLarge"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="Field of View: 45°"
+            android:textStyle="bold"
+            />
+
+        <com.google.android.material.slider.Slider
+            android:id="@+id/fov_slider"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:layout_marginTop="4dp"
+            android:valueFrom="15.0"
+            android:valueTo="120.0"
+            android:value="45.0"
+            />
+
+        <TextView
+            style="@style/TextAppearance.Material3.LabelMedium"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:layout_marginTop="4dp"
+            android:text="FOV Presets:"
+            android:textStyle="bold"
+            />
+
+        <LinearLayout
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:orientation="horizontal"
+            android:layout_marginTop="4dp"
+            >
+
+            <Button
+                android:id="@+id/btn_fov_telephoto"
+                style="@style/Widget.Material3.Button.OutlinedButton"
+                android:layout_width="0dp"
+                android:layout_height="wrap_content"
+                android:layout_weight="1"
+                android:text="20° Tele"
+                android:textSize="10sp"
+                android:paddingStart="2dp"
+                android:paddingEnd="2dp"
+                />
+
+            <Button
+                android:id="@+id/btn_fov_standard"
+                style="@style/Widget.Material3.Button.OutlinedButton"
+                android:layout_width="0dp"
+                android:layout_height="wrap_content"
+                android:layout_weight="1"
+                android:layout_marginStart="2dp"
+                android:layout_marginEnd="2dp"
+                android:text="45° Standard"
+                android:textSize="10sp"
+                android:paddingStart="2dp"
+                android:paddingEnd="2dp"
+                />
+
+            <Button
+                android:id="@+id/btn_fov_wide"
+                style="@style/Widget.Material3.Button.OutlinedButton"
+                android:layout_width="0dp"
+                android:layout_height="wrap_content"
+                android:layout_weight="1"
+                android:layout_marginEnd="2dp"
+                android:text="90° Wide"
+                android:textSize="10sp"
+                android:paddingStart="2dp"
+                android:paddingEnd="2dp"
+                />
+
+            <Button
+                android:id="@+id/btn_fov_ultrawide"
+                style="@style/Widget.Material3.Button.OutlinedButton"
+                android:layout_width="0dp"
+                android:layout_height="wrap_content"
+                android:layout_weight="1"
+                android:text="120° Ultra"
+                android:textSize="10sp"
+                android:paddingStart="2dp"
+                android:paddingEnd="2dp"
+                />
+        </LinearLayout>
+
+    </LinearLayout>
+</androidx.cardview.widget.CardView>
diff --git a/Maps3DSamples/ApiDemos/common/src/main/res/layout/control_panel_roadmap_mode.xml b/Maps3DSamples/ApiDemos/common/src/main/res/layout/control_panel_roadmap_mode.xml
new file mode 100644
index 00000000..ec83a2bd
--- /dev/null
+++ b/Maps3DSamples/ApiDemos/common/src/main/res/layout/control_panel_roadmap_mode.xml
@@ -0,0 +1,82 @@
+<?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:layout_margin="12dp"
+        android:orientation="vertical"
+        >
+
+        <TextView
+            style="@style/TextAppearance.Material3.LabelLarge"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="@string/map_mode"
+            android:textStyle="bold"
+            />
+
+        <RadioGroup
+            android:id="@+id/rg_map_mode"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:orientation="horizontal"
+            android:gravity="center_vertical"
+            android:layout_marginTop="8dp"
+            >
+
+            <RadioButton
+                android:id="@+id/rb_roadmap"
+                android:layout_width="0dp"
+                android:layout_weight="1"
+                android:layout_height="wrap_content"
+                android:checked="true"
+                android:text="@string/roadmap"
+                />
+
+            <RadioButton
+                android:id="@+id/rb_hybrid"
+                android:layout_width="0dp"
+                android:layout_weight="1"
+                android:layout_height="wrap_content"
+                android:text="@string/hybrid"
+                />
+
+            <RadioButton
+                android:id="@+id/rb_satellite"
+                android:layout_width="0dp"
+                android:layout_weight="1"
+                android:layout_height="wrap_content"
+                android:text="@string/satellite"
+                />
+        </RadioGroup>
+
+    </LinearLayout>
+</androidx.cardview.widget.CardView>
diff --git a/Maps3DSamples/ApiDemos/common/src/main/res/values/strings.xml b/Maps3DSamples/ApiDemos/common/src/main/res/values/strings.xml
index c8c730dc..41293504 100644
--- a/Maps3DSamples/ApiDemos/common/src/main/res/values/strings.xml
+++ b/Maps3DSamples/ApiDemos/common/src/main/res/values/strings.xml
@@ -74,7 +74,6 @@
     <string name="snapshot_camera">Snapshot</string>
     <string name="stop_camera">Stop camera animations</string>
 
-
     <!--
     Distance in feet, formatted to 0 decimal places.
     For example, 1234.56 feet will be formatted as "1,235 ft".
@@ -127,4 +126,8 @@
     <string name="vehicle_speed_format">Vehicle Speed: %1$dm/s</string>
     <string name="camera_yaw_offset_format">Camera Yaw Offset: %1$d°</string>
     <string name="routes_offline_fallback">Offline: Using local Oahu fallback route</string>
+    <string name="map_mode">Map Mode</string>
+    <string name="roadmap">Roadmap</string>
+    <string name="hybrid">Hybrid</string>
+    <string name="satellite">Satellite</string>
 </resources>
diff --git a/Maps3DSamples/ApiDemos/java-app/src/androidTest/java/com/example/maps3djava/AdvancedCameraAnimationVisualTest.java b/Maps3DSamples/ApiDemos/java-app/src/androidTest/java/com/example/maps3djava/AdvancedCameraAnimationVisualTest.java
new file mode 100644
index 00000000..25b5c70c
--- /dev/null
+++ b/Maps3DSamples/ApiDemos/java-app/src/androidTest/java/com/example/maps3djava/AdvancedCameraAnimationVisualTest.java
@@ -0,0 +1,79 @@
+/*
+ * 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.maps3djava;
+
+import static org.junit.Assert.assertTrue;
+
+import android.content.Intent;
+import android.graphics.Bitmap;
+
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import androidx.test.uiautomator.By;
+import androidx.test.uiautomator.Until;
+
+import com.example.maps3djava.advancedcameraanimation.AdvancedCameraAnimationActivity;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+/**
+ * A premium visual regression test for the View-based Java Advanced Camera Animation sample.
+ *
+ * Demonstrates robust programmatic testing of 3D camera animations and glTF models by launching the Java-based
+ * [AdvancedCameraAnimationActivity], waiting for 3D map tiles, the 3D airplane glTF model, and camera tour approaches
+ * to render, capturing a screenshot of the active map scene, and verifying visual correctness using the Gemini API.
+ */
+@RunWith(AndroidJUnit4.class)
+public class AdvancedCameraAnimationVisualTest extends BaseVisualTest {
+
+    @Test
+    public void verifyAdvancedCameraAnimationRenders() {
+        // Launch AdvancedCameraAnimationActivity
+        Intent intent = new Intent(context, AdvancedCameraAnimationActivity.class);
+        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+        context.startActivity(intent);
+
+        // Wait for the activity to be displayed in the foreground
+        uiDevice.wait(Until.hasObject(By.pkg(context.getPackageName()).depth(0)), 10000);
+
+        // Wait for map tiles to load, 3D airplane model to stream, and camera flight animation to settle
+        waitForMapRendering(15);
+
+        // Capture high-resolution screenshot of the active 3D map scene
+        Bitmap screenshotBitmap = captureScreenshot("advanced_camera_animation_screenshot.png");
+
+        // Define the verification prompt for the visual testing agent
+        String prompt = "Please act as a UI tester and analyze this screenshot.\n" +
+                "1. Confirm that a 3D map view is visible over San Francisco (Golden Gate Bridge / Bay area).\n" +
+                "2. Confirm that a 3D AIRPLANE MODEL or aerial flight path object is visible in 3D space.\n" +
+                "3. Confirm that the animation approach control card (with radio options for Simple flyTo, Keyframe Tour, Frame Dispatcher, 360 Orbit Spin, and Play/Reset buttons) is visible at the bottom of the screen.\n" +
+                "\n" +
+                "If and ONLY IF you can clearly see the 3D map scene, 3D airplane flight tour, and bottom animation approach selector card, reply with \"PASSED\".\n" +
+                "If you cannot see the 3D map scene or control card, reply with \"FAILED: 3D map scene or control card not visible\".\n" +
+                "Report what you see in detail.";
+
+        // Analyze the image using Gemini (using blocking wrapper)
+        String geminiResponse = helper.analyzeImageBlocking(screenshotBitmap, prompt, geminiApiKey);
+        System.out.println("Gemini's analysis: " + geminiResponse);
+
+        // Assert on Gemini's response
+        assertTrue(
+            "Visual verification failed. Gemini response: " + geminiResponse,
+            geminiResponse != null && geminiResponse.toUpperCase().contains("PASSED")
+        );
+    }
+}
diff --git a/Maps3DSamples/ApiDemos/java-app/src/androidTest/java/com/example/maps3djava/BaseVisualTest.java b/Maps3DSamples/ApiDemos/java-app/src/androidTest/java/com/example/maps3djava/BaseVisualTest.java
index 60f54cce..16757a45 100644
--- a/Maps3DSamples/ApiDemos/java-app/src/androidTest/java/com/example/maps3djava/BaseVisualTest.java
+++ b/Maps3DSamples/ApiDemos/java-app/src/androidTest/java/com/example/maps3djava/BaseVisualTest.java
@@ -93,12 +93,10 @@ protected Bitmap captureScreenshot() {
      * @param timeoutSeconds The maximum time to wait in seconds.
      */
     protected void waitForMapRendering(long timeoutSeconds) {
-        // Fallback to sleep since View-based samples do not set "MapSteady" content description.
-        System.out.println("Sleeping for " + timeoutSeconds + " seconds to allow map to render...");
-        try {
-            Thread.sleep(timeoutSeconds * 1000);
-        } catch (InterruptedException e) {
-            Thread.currentThread().interrupt();
+        android.util.Log.i("BaseVisualTest", "Waiting up to " + timeoutSeconds + "s for map to become steady...");
+        boolean steady = uiDevice.wait(Until.hasObject(By.desc("MapSteady")), timeoutSeconds * 1000);
+        if (!steady) {
+            android.util.Log.w("BaseVisualTest", "Map did not report MapSteady within " + timeoutSeconds + "s; proceeding with capture.");
         }
     }
 
diff --git a/Maps3DSamples/ApiDemos/java-app/src/androidTest/java/com/example/maps3djava/DataVisualizationVisualTest.java b/Maps3DSamples/ApiDemos/java-app/src/androidTest/java/com/example/maps3djava/DataVisualizationVisualTest.java
new file mode 100644
index 00000000..a2f00a72
--- /dev/null
+++ b/Maps3DSamples/ApiDemos/java-app/src/androidTest/java/com/example/maps3djava/DataVisualizationVisualTest.java
@@ -0,0 +1,80 @@
+/*
+ * 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.maps3djava;
+
+import static org.junit.Assert.assertTrue;
+
+import android.content.Intent;
+import android.graphics.Bitmap;
+
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import androidx.test.uiautomator.By;
+import androidx.test.uiautomator.Until;
+
+import com.example.maps3djava.datavisualization.DataVisualizationActivity;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+/**
+ * A premium visual regression test for the View-based Java 3D Data Visualization sample.
+ *
+ * Demonstrates robust programmatic testing of dynamic 3D extruded volume polygons by launching the Java-based
+ * [DataVisualizationActivity], waiting for 3D map tiles, the extruded flood volume polygon over the San Francisco
+ * waterfront, and control panel widgets to render, capturing a screenshot of the active map scene, and verifying visual
+ * correctness using the Gemini API.
+ */
+@RunWith(AndroidJUnit4.class)
+public class DataVisualizationVisualTest extends BaseVisualTest {
+
+    @Test
+    public void verifyDataVisualizationRenders() {
+        // Launch DataVisualizationActivity
+        Intent intent = new Intent(context, DataVisualizationActivity.class);
+        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+        context.startActivity(intent);
+
+        // Wait for the activity to be displayed in the foreground
+        uiDevice.wait(Until.hasObject(By.pkg(context.getPackageName()).depth(0)), 10000);
+
+        // Wait for map tiles to load, 3D flood polygon to extrude, and UI controls to settle
+        waitForMapRendering(15);
+
+        // Capture high-resolution screenshot of the active 3D map scene
+        Bitmap screenshotBitmap = captureScreenshot("data_visualization_screenshot.png");
+
+        // Define the verification prompt for the visual testing agent
+        String prompt = "Please act as a UI tester and analyze this screenshot.\n" +
+                "1. Confirm that a 3D map view is visible over the San Francisco waterfront.\n" +
+                "2. Confirm that an EXTRUDED 3D POLYGON or volumetric polygon shape (red tinted flood water zone) is clearly visible on top of the 3D terrain/map.\n" +
+                "3. Confirm that the Data Visualization control card (showing Flood Elevation label, Risk Badge status, elevation slider, and Start/Stop Simulation button) is visible at the bottom of the screen.\n" +
+                "\n" +
+                "If and ONLY IF you can clearly see the 3D map view with the extruded red flood polygon and bottom simulation control panel, reply with \"PASSED\".\n" +
+                "If you cannot see the extruded flood polygon or control panel, reply with \"FAILED: Extruded flood polygon or control panel not visible\".\n" +
+                "Report what you see in detail.";
+
+        // Analyze the image using Gemini (using blocking wrapper)
+        String geminiResponse = helper.analyzeImageBlocking(screenshotBitmap, prompt, geminiApiKey);
+        System.out.println("Gemini's analysis: " + geminiResponse);
+
+        // Assert on Gemini's response
+        assertTrue(
+            "Visual verification failed. Gemini response: " + geminiResponse,
+            geminiResponse != null && geminiResponse.toUpperCase().contains("PASSED")
+        );
+    }
+}
diff --git a/Maps3DSamples/ApiDemos/java-app/src/androidTest/java/com/example/maps3djava/FieldOfViewVisualTest.java b/Maps3DSamples/ApiDemos/java-app/src/androidTest/java/com/example/maps3djava/FieldOfViewVisualTest.java
new file mode 100644
index 00000000..77f4d16c
--- /dev/null
+++ b/Maps3DSamples/ApiDemos/java-app/src/androidTest/java/com/example/maps3djava/FieldOfViewVisualTest.java
@@ -0,0 +1,80 @@
+/*
+ * 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.maps3djava;
+
+import static org.junit.Assert.assertTrue;
+
+import android.content.Intent;
+import android.graphics.Bitmap;
+
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import androidx.test.uiautomator.By;
+import androidx.test.uiautomator.Until;
+
+import com.example.maps3djava.fieldofview.FieldOfViewActivity;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+/**
+ * A premium visual regression test for the View-based Java Field of View (FOV) sample.
+ *
+ * Demonstrates robust programmatic testing of optical dolly-zoom camera controls by launching the Java-based
+ * [FieldOfViewActivity], waiting for 3D map tiles over the San Francisco Financial District, perspective dolly-zoom
+ * camera controls, and quick FOV preset buttons to load, capturing a screenshot of the active map scene, and verifying
+ * visual correctness using the Gemini API.
+ */
+@RunWith(AndroidJUnit4.class)
+public class FieldOfViewVisualTest extends BaseVisualTest {
+
+    @Test
+    public void verifyFieldOfViewRenders() {
+        // Launch FieldOfViewActivity
+        Intent intent = new Intent(context, FieldOfViewActivity.class);
+        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+        context.startActivity(intent);
+
+        // Wait for the activity to be displayed in the foreground
+        uiDevice.wait(Until.hasObject(By.pkg(context.getPackageName()).depth(0)), 10000);
+
+        // Wait for map tiles to render and optical dolly zoom view to settle
+        waitForMapRendering(15);
+
+        // Capture high-resolution screenshot of the active 3D map scene
+        Bitmap screenshotBitmap = captureScreenshot("field_of_view_screenshot.png");
+
+        // Define the verification prompt for the visual testing agent
+        String prompt = "Please act as a UI tester and analyze this screenshot.\n" +
+                "1. Confirm that a 3D map view is visible over the San Francisco Financial District area.\n" +
+                "2. Confirm that the Field of View perspective control card (with FOV angle slider and instant preset buttons: 20° Telephoto, 45° Standard, 90° Wide, 120° Ultra-Wide) is visible at the bottom of the screen.\n" +
+                "3. Confirm that the visual text label showing the current FOV angle (e.g. \"Field of View: 45°\") is visible on the card.\n" +
+                "\n" +
+                "If and ONLY IF you can clearly see the 3D map view and bottom Field of View control card with presets and slider, reply with \"PASSED\".\n" +
+                "If you cannot see the 3D map scene or FOV control card, reply with \"FAILED: 3D map scene or FOV controls not visible\".\n" +
+                "Report what you see in detail.";
+
+        // Analyze the image using Gemini (using blocking wrapper)
+        String geminiResponse = helper.analyzeImageBlocking(screenshotBitmap, prompt, geminiApiKey);
+        System.out.println("Gemini's analysis: " + geminiResponse);
+
+        // Assert on Gemini's response
+        assertTrue(
+            "Visual verification failed. Gemini response: " + geminiResponse,
+            geminiResponse != null && geminiResponse.toUpperCase().contains("PASSED")
+        );
+    }
+}
diff --git a/Maps3DSamples/ApiDemos/java-app/src/androidTest/java/com/example/maps3djava/PathFollowingVisualTest.java b/Maps3DSamples/ApiDemos/java-app/src/androidTest/java/com/example/maps3djava/PathFollowingVisualTest.java
new file mode 100644
index 00000000..2fabd18b
--- /dev/null
+++ b/Maps3DSamples/ApiDemos/java-app/src/androidTest/java/com/example/maps3djava/PathFollowingVisualTest.java
@@ -0,0 +1,79 @@
+/*
+ * 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.maps3djava;
+
+import static org.junit.Assert.assertTrue;
+
+import android.content.Intent;
+import android.graphics.Bitmap;
+
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import androidx.test.uiautomator.By;
+import androidx.test.uiautomator.Until;
+
+import com.example.maps3djava.pathfollowing.PathFollowingActivity;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+/**
+ * A premium visual regression test for the View-based Java Path Following sample.
+ * Demonstrates robust programmatic testing of ground-level route navigation by launching the Java-based
+ * [PathFollowingActivity], waiting for 3D map tiles and path coordinates to render, allowing the Handler-driven
+ * play loop to animate the camera along the route, capturing a screenshot of the active map scene, and verifying
+ * visual correctness using the Gemini API.
+ */
+@RunWith(AndroidJUnit4.class)
+public class PathFollowingVisualTest extends BaseVisualTest {
+
+    @Test
+    public void verifyPathFollowingRenders() {
+        // Launch PathFollowingActivity
+        Intent intent = new Intent(context, PathFollowingActivity.class);
+        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+        context.startActivity(intent);
+
+        // Wait for the activity to be displayed in the foreground
+        uiDevice.wait(Until.hasObject(By.pkg(context.getPackageName()).depth(0)), 10000);
+
+        // Wait for map tiles to load, ground polyline to render, and initial animation to settle
+        waitForMapRendering(15);
+
+        // Capture high-resolution screenshot of the active 3D map scene
+        Bitmap screenshotBitmap = captureScreenshot("path_following_screenshot.png");
+
+        // Define the verification prompt for the visual testing agent
+        String prompt = "Please act as a UI tester and analyze this screenshot.\n" +
+                "1. Confirm that a 3D map view is visible.\n" +
+                "2. Confirm that a BLUE POLYLINE (line) is clearly visible on the map, representing the route path.\n" +
+                "3. Confirm that interactive camera control sliders (Range, Altitude, Heading, Tilt, Speed) and an Urban/Rural selector panel are visible at the bottom of the screen.\n" +
+                "\n" +
+                "If and ONLY IF you can clearly see the 3D map view with the blue route polyline and bottom control card, reply with \"PASSED\".\n" +
+                "If you cannot see the blue route polyline or control panel, reply with \"FAILED: Blue path polyline or UI controls not visible\".\n" +
+                "Report what you see in detail.";
+
+        // Analyze the image using Gemini (using blocking wrapper)
+        String geminiResponse = helper.analyzeImageBlocking(screenshotBitmap, prompt, geminiApiKey);
+        System.out.println("Gemini's analysis: " + geminiResponse);
+
+        // Assert on Gemini's response
+        assertTrue(
+            "Visual verification failed. Gemini response: " + geminiResponse,
+            geminiResponse != null && geminiResponse.toUpperCase().contains("PASSED")
+        );
+    }
+}
diff --git a/Maps3DSamples/ApiDemos/java-app/src/androidTest/java/com/example/maps3djava/RoadmapModeVisualTest.java b/Maps3DSamples/ApiDemos/java-app/src/androidTest/java/com/example/maps3djava/RoadmapModeVisualTest.java
new file mode 100644
index 00000000..a42602ef
--- /dev/null
+++ b/Maps3DSamples/ApiDemos/java-app/src/androidTest/java/com/example/maps3djava/RoadmapModeVisualTest.java
@@ -0,0 +1,84 @@
+/*
+ * 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.maps3djava;
+
+import static org.junit.Assert.assertTrue;
+
+import android.content.Intent;
+import android.graphics.Bitmap;
+
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import androidx.test.uiautomator.By;
+import androidx.test.uiautomator.Until;
+
+import com.example.maps3djava.roadmapmode.RoadmapModeActivity;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+/**
+ * A premium visual regression test for the View-based Java 3D Roadmap Mode sample.
+
+ * Demonstrates robust programmatic testing of 3D vector map modes by launching the Java-based
+ * [RoadmapModeActivity], waiting for 3D vector roadmap tiles and street networks to initialize,
+ * capturing a screenshot of the active map scene, and verifying visual correctness using the Gemini
+ * API.
+ */
+@RunWith(AndroidJUnit4.class)
+public class RoadmapModeVisualTest extends BaseVisualTest {
+
+  @Test
+  public void verifyRoadmapModeRenders() {
+    // Launch RoadmapModeActivity
+    Intent intent = new Intent(context, RoadmapModeActivity.class);
+    intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+    context.startActivity(intent);
+
+    // Wait for the activity to be displayed in the foreground
+    uiDevice.wait(Until.hasObject(By.pkg(context.getPackageName()).depth(0)), 10000);
+
+    // Wait for map tiles to render and 3D vector buildings/streets to settle
+    waitForMapRendering(15);
+
+    // Capture high-resolution screenshot of the active 3D map scene
+    Bitmap screenshotBitmap = captureScreenshot("roadmap_mode_screenshot.png");
+
+    // Define the verification prompt for the visual testing agent
+    String prompt = "Please act as a UI tester and analyze this screenshot.\n" +
+        "1. Confirm that a 3D map view is visible over San Francisco.\n" +
+        "2. Confirm that the map is rendered in 3D ROADMAP / VECTOR mode (showing street network layouts, road labels, and/or vector 3D building blocks rather than raw satellite imagery only).\n"
+        +
+        "3. Confirm that the Map Mode radio selection card (with Roadmap, Hybrid, and Satellite options) is visible at the bottom of the screen.\n"
+        +
+        "\n" +
+        "If and ONLY IF you can clearly see the 3D Roadmap map scene and bottom Map Mode selection card, reply with \"PASSED\".\n"
+        +
+        "If you cannot see the 3D map scene or control card, reply with \"FAILED: 3D Roadmap scene or Map Mode controls not visible\".\n"
+        +
+        "Report what you see in detail.";
+
+    // Analyze the image using Gemini (using blocking wrapper)
+    String geminiResponse = helper.analyzeImageBlocking(screenshotBitmap, prompt, geminiApiKey);
+    System.out.println("Gemini's analysis: " + geminiResponse);
+
+    // Assert on Gemini's response
+    assertTrue(
+        "Visual verification failed. Gemini response: " + geminiResponse,
+        geminiResponse != null && geminiResponse.toUpperCase().contains("PASSED")
+    );
+  }
+}
diff --git a/Maps3DSamples/ApiDemos/java-app/src/androidTest/java/com/example/maps3djava/RoutesVisualTest.java b/Maps3DSamples/ApiDemos/java-app/src/androidTest/java/com/example/maps3djava/RoutesVisualTest.java
index 77922fdc..4614d0aa 100644
--- a/Maps3DSamples/ApiDemos/java-app/src/androidTest/java/com/example/maps3djava/RoutesVisualTest.java
+++ b/Maps3DSamples/ApiDemos/java-app/src/androidTest/java/com/example/maps3djava/RoutesVisualTest.java
@@ -51,13 +51,8 @@ public void verifyRoutesRenders() {
         // Wait for the activity to be displayed in the foreground
         uiDevice.wait(Until.hasObject(By.pkg(context.getPackageName()).depth(0)), 10000);
 
-        // Wait 15 seconds for map tiles to load, route coordinates to fetch, and the vehicle model to start animating
-        System.out.println("Waiting 15 seconds for map rendering and vehicle animation...");
-        try {
-            Thread.sleep(15000);
-        } catch (InterruptedException e) {
-            e.printStackTrace();
-        }
+        // Wait for map tiles to load, route coordinates to fetch, and the vehicle model to start animating
+        waitForMapRendering(15);
 
         // Capture high-resolution screenshot of the active 3D map scene
         Bitmap screenshotBitmap = captureScreenshot("routes_screenshot.png");
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 fa422f98..2c174042 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
@@ -1,5 +1,5 @@
 /*
- * Copyright 2026 Google LLC
+ * Copyright 2025 Google LLC
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,15 +16,573 @@
 
 package com.example.maps3djava.advancedcameraanimation;
 
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.Looper;
+import android.view.ViewGroup;
+import android.widget.Button;
+import android.widget.RadioGroup;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.example.maps3d.common.PositionAndHeading;
+import com.example.maps3d.common.RouteEngine;
 import com.example.maps3dcommon.R;
-import com.example.maps3djava.common.BaseSkeletonActivity;
+import com.example.maps3djava.sampleactivity.SampleBaseActivity;
+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.FlyToOptions;
+import com.google.android.gms.maps3d.model.LatLngAltitude;
+import com.google.android.gms.maps3d.model.Model;
+import com.google.android.gms.maps3d.model.ModelOptions;
+import com.google.android.gms.maps3d.model.Orientation;
+import com.google.android.gms.maps3d.model.Vector3D;
+import com.google.android.material.appbar.MaterialToolbar;
+import com.google.maps.android.SphericalUtil;
+import java.util.Arrays;
+import java.util.List;
 
-/**
- * Skeleton activity for AdvancedCameraAnimationActivity.
- */
-public class AdvancedCameraAnimationActivity extends BaseSkeletonActivity {
-    @Override
-    protected int getTitleResId() {
-        return R.string.feature_title_advanced_camera_animation;
+public class AdvancedCameraAnimationActivity extends SampleBaseActivity {
+
+  public enum AnimationApproach {
+    SIMPLE_FLY_TO,
+    KEYFRAME_TOUR,
+    DISPATCHER_FRAME_LOOP,
+    ORBIT_360_SPIN
+  }
+
+  public abstract static class Keyframe {
+
+    public final String title;
+    public final String description;
+
+    public Keyframe(String title, String description) {
+      this.title = title;
+      this.description = description;
+    }
+  }
+
+  public static class KeyframeFlyTo extends Keyframe {
+
+    public final LatLng targetCenter;
+    public final double targetAltitude;
+    public final double targetHeading;
+    public final double targetTilt;
+    public final double targetRange;
+    public final long durationMs;
+
+    public KeyframeFlyTo(String title, String description, LatLng targetCenter,
+        double targetAltitude, double targetHeading, double targetTilt, double targetRange,
+        long durationMs) {
+      super(title, description);
+      this.targetCenter = targetCenter;
+      this.targetAltitude = targetAltitude;
+      this.targetHeading = targetHeading;
+      this.targetTilt = targetTilt;
+      this.targetRange = targetRange;
+      this.durationMs = durationMs;
+    }
+  }
+
+  public static class KeyframeDwell extends Keyframe {
+
+    public final long durationMs;
+
+    public KeyframeDwell(String title, String description, long durationMs) {
+      super(title, description);
+      this.durationMs = durationMs;
     }
+  }
+
+  public static class KeyframeOrbit extends Keyframe {
+
+    public final LatLng center;
+    public final double altitude;
+    public final double range;
+    public final double tilt;
+    public final double startHeading;
+    public final double endHeading;
+    public final long durationMs;
+
+    public KeyframeOrbit(String title, String description, LatLng center, double altitude,
+        double range, double tilt, double startHeading, double endHeading, long durationMs) {
+      super(title, description);
+      this.center = center;
+      this.altitude = altitude;
+      this.range = range;
+      this.tilt = tilt;
+      this.startHeading = startHeading;
+      this.endHeading = endHeading;
+      this.durationMs = durationMs;
+    }
+  }
+
+  private static final String MODEL_ID = "airplane_model";
+  private static final String PLANE_URL = "https://storage.googleapis.com/gmp-maps-demos/p3d-map/assets/Airplane.glb";
+
+  private Model airplaneModel;
+  private int currentStepIndex = 0;
+  private boolean isPlaying = false;
+  private AnimationApproach selectedApproach = AnimationApproach.DISPATCHER_FRAME_LOOP;
+
+  private Button btnPlayPause;
+
+  private final Handler handler = new Handler(Looper.getMainLooper());
+  private Runnable animationRunnable = null;
+
+  // 15 Fine-Grained Waypoints on the direct route from Golden Gate Bridge to Coit Tower
+  public static final List<LatLng> AIRPLANE_FLIGHT_PATH = Arrays.asList(
+      new LatLng(37.8199, -122.4783), // 1. Golden Gate Bridge (Source)
+      new LatLng(37.8188, -122.4735), // 2. Fort Point / Presidio Overlook
+      new LatLng(37.8175, -122.4685), // 3. Crissy Field West
+      new LatLng(37.8160, -122.4635), // 4. Crissy Field East
+      new LatLng(37.8145, -122.4585), // 5. Marina Green West
+      new LatLng(37.8130, -122.4530), // 6. Marina District Center
+      new LatLng(37.8115, -122.4475), // 7. Fort Mason West
+      new LatLng(37.8100, -122.4420), // 8. Fort Mason Heights
+      new LatLng(37.8085, -122.4365), // 9. Aquatic Park Cove
+      new LatLng(37.8070, -122.4310), // 10. Fisherman's Wharf West
+      new LatLng(37.8058, -122.4250), // 11. Fisherman's Wharf Center
+      new LatLng(37.8048, -122.4195), // 12. Pier 39 Promenade
+      new LatLng(37.8038, -122.4140), // 13. Embarcadero North
+      new LatLng(37.8030, -122.4090), // 14. Telegraph Hill Slopes
+      new LatLng(37.8024, -122.4058)  // 15. Coit Tower (Destination)
+  );
+
+  public static final List<Keyframe> SAN_FRANCISCO_TOUR = Arrays.asList(
+      new KeyframeFlyTo("1. Golden Gate Flight", "3D Airplane flight over Golden Gate Bridge",
+          new LatLng(37.8199, -122.4783), 200.0, 105.0, 65.0, 600.0, 2500L),
+      new KeyframeDwell("2. Mid-Air Observation", "Dwell pause observing 3D airplane", 1500L),
+      new KeyframeOrbit("3. Golden Gate 360° Orbit",
+          "360° orbital camera spin around flying airplane", new LatLng(37.8199, -122.4783), 200.0,
+          600.0, 65.0, 105.0, 465.0, 4000L),
+      new KeyframeFlyTo("4. Transit to Coit Tower", "Airplane flight to Coit Tower Landmark",
+          new LatLng(37.8024, -122.4058), 200.0, 105.0, 65.0, 600.0, 3000L)
+  );
+
+  private double[] cumulativeDistances;
+
+  @Override
+  protected void onCreate(@Nullable Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+
+    // Inflate control panel overlay into the map container managed by SampleBaseActivity
+    ViewGroup container = findViewById(R.id.map_container);
+    if (container != null) {
+      getLayoutInflater().inflate(R.layout.control_panel_advanced_animation, container, true);
+    }
+
+    MaterialToolbar topBar = findViewById(R.id.top_bar);
+    if (topBar != null) {
+      topBar.setTitle("Advanced Camera Animation");
+      topBar.setNavigationOnClickListener(v -> finish());
+    }
+
+    RadioGroup rgApproach = findViewById(R.id.rg_approach);
+    if (rgApproach != null) {
+      rgApproach.setOnCheckedChangeListener((group, checkedId) -> {
+        if (checkedId == R.id.rb_simple_flyto) {
+          selectedApproach = AnimationApproach.SIMPLE_FLY_TO;
+        } else if (checkedId == R.id.rb_keyframe_tour) {
+          selectedApproach = AnimationApproach.KEYFRAME_TOUR;
+        } else if (checkedId == R.id.rb_orbit_spin) {
+          selectedApproach = AnimationApproach.ORBIT_360_SPIN;
+        } else {
+          selectedApproach = AnimationApproach.DISPATCHER_FRAME_LOOP;
+        }
+        resetAndRestartTour();
+      });
+    }
+
+    Button btnReset = findViewById(R.id.btn_reset);
+    if (btnReset != null) {
+      btnReset.setOnClickListener(v -> resetAndRestartTour());
+    }
+
+    btnPlayPause = findViewById(R.id.btn_play_pause);
+    if (btnPlayPause != null) {
+      btnPlayPause.setOnClickListener(v -> {
+        if (isPlaying) {
+          stopTour();
+        } else {
+          startSelectedApproach();
+        }
+      });
+    }
+  }
+
+  private void updatePlayPauseButtonState() {
+    if (btnPlayPause != null) {
+      btnPlayPause.setText(isPlaying ? "Pause" : "Play");
+    }
+  }
+
+  @NonNull
+  @Override
+  public Camera getInitialCamera() {
+    LatLng startLoc = AIRPLANE_FLIGHT_PATH.get(0);
+    double initialHeading = SphericalUtil.computeHeading(startLoc, AIRPLANE_FLIGHT_PATH.get(1));
+    return new Camera(
+        new LatLngAltitude(startLoc.latitude, startLoc.longitude, 200.0),
+        normalizeHeading(initialHeading),
+        65.0,
+        0.0,
+        600.0
+    );
+  }
+
+  @NonNull
+  @Override
+  public String getTAG() {
+    return "AdvancedCameraAnimation";
+  }
+
+  @Override
+  public void onMap3DViewReady(@NonNull GoogleMap3D googleMap3D) {
+    super.onMap3DViewReady(googleMap3D);
+
+    cumulativeDistances = RouteEngine.calculateCumulativeDistances(AIRPLANE_FLIGHT_PATH);
+
+    LatLng startLoc = AIRPLANE_FLIGHT_PATH.get(0);
+    double initialHeading = SphericalUtil.computeHeading(startLoc, AIRPLANE_FLIGHT_PATH.get(1));
+    updateAirplaneModel(startLoc, initialHeading + 180.0);
+
+    // Auto-start smooth flight animation after 1 second delay
+    handler.postDelayed(this::startSelectedApproach, 1000L);
+  }
+
+  private void updateAirplaneModel(LatLng position, double planeHeadingDeg) {
+    if (googleMap3D != null) {
+      ModelOptions modelOptions = new ModelOptions();
+      modelOptions.setId(MODEL_ID);
+      modelOptions.setPosition(new LatLngAltitude(position.latitude, position.longitude, 200.0));
+      modelOptions.setUrl(PLANE_URL);
+      modelOptions.setAltitudeMode(AltitudeMode.ABSOLUTE);
+      modelOptions.setScale(new Vector3D(0.08, 0.08, 0.08));
+      modelOptions.setOrientation(new Orientation(normalizeHeading(planeHeadingDeg), -90.0, 0.0));
+
+      airplaneModel = googleMap3D.addModel(modelOptions);
+    }
+  }
+
+  private void startSelectedApproach() {
+    stopTour();
+    if (selectedApproach == AnimationApproach.SIMPLE_FLY_TO) {
+      runSimpleFlyTo();
+    } else if (selectedApproach == AnimationApproach.KEYFRAME_TOUR) {
+      startOrResumeTour();
+    } else if (selectedApproach == AnimationApproach.DISPATCHER_FRAME_LOOP) {
+      runFrameDispatcherLoop();
+    } else if (selectedApproach == AnimationApproach.ORBIT_360_SPIN) {
+      run360OrbitSpin();
+    }
+  }
+
+  private void runSimpleFlyTo() {
+    stopTour();
+    isPlaying = true;
+    updatePlayPauseButtonState();
+
+    LatLng target = AIRPLANE_FLIGHT_PATH.get(AIRPLANE_FLIGHT_PATH.size() - 1);
+    double heading = SphericalUtil.computeHeading(
+        AIRPLANE_FLIGHT_PATH.get(AIRPLANE_FLIGHT_PATH.size() - 2), target);
+    updateAirplaneModel(target, heading + 180.0);
+
+    Camera targetCam = new Camera(
+        new LatLngAltitude(target.latitude, target.longitude, 200.0),
+        normalizeHeading(heading),
+        65.0,
+        0.0,
+        600.0
+    );
+    googleMap3D.flyCameraTo(new FlyToOptions(targetCam, 1500L));
+    isPlaying = false;
+    updatePlayPauseButtonState();
+  }
+
+  /**
+   * Executes multi-step keyframe queue tour stage by stage in Java.
+   */
+  private void startOrResumeTour() {
+    stopTour();
+    isPlaying = true;
+    updatePlayPauseButtonState();
+    currentStepIndex = 0;
+    executeNextKeyframeStep();
+  }
+
+  private void executeNextKeyframeStep() {
+    if (!isPlaying || currentStepIndex >= SAN_FRANCISCO_TOUR.size()) {
+      isPlaying = false;
+      updatePlayPauseButtonState();
+      return;
+    }
+
+    Keyframe step = SAN_FRANCISCO_TOUR.get(currentStepIndex);
+
+    if (step instanceof KeyframeFlyTo) {
+      KeyframeFlyTo flyToStep = (KeyframeFlyTo) step;
+      updateAirplaneModel(flyToStep.targetCenter, flyToStep.targetHeading + 180.0);
+      Camera targetCam = new Camera(
+          new LatLngAltitude(flyToStep.targetCenter.latitude, flyToStep.targetCenter.longitude,
+              flyToStep.targetAltitude),
+          normalizeHeading(flyToStep.targetHeading),
+          flyToStep.targetTilt,
+          0.0,
+          flyToStep.targetRange
+      );
+      if (googleMap3D != null) {
+        googleMap3D.flyCameraTo(new FlyToOptions(targetCam, flyToStep.durationMs));
+      }
+      handler.postDelayed(() -> {
+        currentStepIndex++;
+        executeNextKeyframeStep();
+      }, flyToStep.durationMs);
+
+    } else if (step instanceof KeyframeDwell) {
+      KeyframeDwell dwellStep = (KeyframeDwell) step;
+      handler.postDelayed(() -> {
+        currentStepIndex++;
+        executeNextKeyframeStep();
+      }, dwellStep.durationMs);
+
+    } else if (step instanceof KeyframeOrbit) {
+      KeyframeOrbit orbitStep = (KeyframeOrbit) step;
+      final long frameMs = 16L;
+      final long totalFrames = Math.max(1, orbitStep.durationMs / frameMs);
+
+      animationRunnable = new Runnable() {
+        private long currentFrame = 0;
+
+        @Override
+        public void run() {
+            if (!isPlaying) {
+                return;
+            }
+
+          double t = (double) currentFrame / totalFrames;
+          double orbitHeading = interpolateAngle(orbitStep.startHeading, orbitStep.endHeading, t);
+
+          updateAirplaneModel(orbitStep.center, orbitHeading + 180.0);
+
+          Camera updatedCam = new Camera(
+              new LatLngAltitude(orbitStep.center.latitude, orbitStep.center.longitude,
+                  orbitStep.altitude),
+              normalizeHeading(orbitHeading),
+              orbitStep.tilt,
+              0.0,
+              orbitStep.range
+          );
+          if (googleMap3D != null) {
+            googleMap3D.setCamera(updatedCam);
+          }
+
+          currentFrame++;
+          if (currentFrame <= totalFrames) {
+            handler.postDelayed(this, frameMs);
+          } else {
+            currentStepIndex++;
+            executeNextKeyframeStep();
+          }
+        }
+      };
+      handler.post(animationRunnable);
+    }
+  }
+
+  /**
+   * Frame Dispatcher Animation Loop. High-speed flight animation (400 m/s) stopping cleanly at
+   * destination.
+   */
+  private void runFrameDispatcherLoop() {
+    stopTour();
+    isPlaying = true;
+    updatePlayPauseButtonState();
+
+    final double totalDistance = Math.max(1.0, cumulativeDistances[cumulativeDistances.length - 1]);
+    final double flightSpeedMps = 400.0;
+
+    animationRunnable = new Runnable() {
+      private double elapsedDistance = 0.0;
+      private long lastTime = System.currentTimeMillis();
+
+      @Override
+      public void run() {
+          if (!isPlaying) {
+              return;
+          }
+
+        long now = System.currentTimeMillis();
+        double dt = (now - lastTime) / 1000.0;
+        lastTime = now;
+
+        elapsedDistance += flightSpeedMps * dt;
+
+        // Stop cleanly at destination
+        if (elapsedDistance >= totalDistance) {
+          elapsedDistance = totalDistance;
+          PositionAndHeading posAndHeading = RouteEngine.calculatePositionAndHeading(
+              AIRPLANE_FLIGHT_PATH,
+              cumulativeDistances,
+              elapsedDistance,
+              30.0
+          );
+          double planeHeading = posAndHeading.getHeading() + 180.0;
+          updateAirplaneModel(posAndHeading.getPosition(), planeHeading);
+
+          Camera finalCam = new Camera(
+              new LatLngAltitude(posAndHeading.getPosition().latitude,
+                  posAndHeading.getPosition().longitude, 200.0),
+              normalizeHeading(posAndHeading.getHeading()),
+              65.0,
+              0.0,
+              600.0
+          );
+          if (googleMap3D != null) {
+            googleMap3D.setCamera(finalCam);
+          }
+          isPlaying = false;
+          updatePlayPauseButtonState();
+          return;
+        }
+
+        PositionAndHeading posAndHeading = RouteEngine.calculatePositionAndHeading(
+            AIRPLANE_FLIGHT_PATH,
+            cumulativeDistances,
+            elapsedDistance,
+            30.0
+        );
+
+        double planeHeading = posAndHeading.getHeading() + 180.0;
+        updateAirplaneModel(posAndHeading.getPosition(), planeHeading);
+
+        Camera updatedCam = new Camera(
+            new LatLngAltitude(posAndHeading.getPosition().latitude,
+                posAndHeading.getPosition().longitude, 200.0),
+            normalizeHeading(posAndHeading.getHeading()),
+            65.0,
+            0.0,
+            600.0
+        );
+
+        if (googleMap3D != null) {
+          googleMap3D.setCamera(updatedCam);
+        }
+
+        handler.postDelayed(this, 16L);
+      }
+    };
+    handler.post(animationRunnable);
+  }
+
+  /**
+   * Option 4: Continuous 360-degree orbital camera spin around landmark.
+   */
+  private void run360OrbitSpin() {
+    stopTour();
+    isPlaying = true;
+    updatePlayPauseButtonState();
+
+    final LatLng targetCenter = AIRPLANE_FLIGHT_PATH.get(0);
+    updateAirplaneModel(targetCenter, 105.0 + 180.0);
+
+    final long frameMs = 16L;
+    final long totalMs = 6000L;
+    final long totalFrames = Math.max(1, totalMs / frameMs);
+    final double startHeading = 105.0;
+
+    animationRunnable = new Runnable() {
+      private long currentFrame = 0;
+
+      @Override
+      public void run() {
+          if (!isPlaying) {
+              return;
+          }
+
+        double t = (double) currentFrame / totalFrames;
+        double headingDeg = (startHeading + t * 360.0) % 360.0;
+
+        Camera currentCam = new Camera(
+            new LatLngAltitude(targetCenter.latitude, targetCenter.longitude, 200.0),
+            normalizeHeading(headingDeg),
+            65.0,
+            0.0,
+            600.0
+        );
+        if (googleMap3D != null) {
+          googleMap3D.setCamera(currentCam);
+        }
+
+        currentFrame++;
+        if (currentFrame <= totalFrames) {
+          handler.postDelayed(this, frameMs);
+        } else {
+          isPlaying = false;
+          updatePlayPauseButtonState();
+        }
+      }
+    };
+    handler.post(animationRunnable);
+  }
+
+  private void stopTour() {
+    isPlaying = false;
+    updatePlayPauseButtonState();
+    if (animationRunnable != null) {
+      handler.removeCallbacks(animationRunnable);
+      animationRunnable = null;
+    }
+    if (googleMap3D != null) {
+      googleMap3D.stopCameraAnimation();
+    }
+  }
+
+  /**
+   * Resets the camera and airplane model to the initial start location and restarts animation.
+   */
+  public void resetAndRestartTour() {
+    stopTour();
+    currentStepIndex = 0;
+
+    LatLng startLoc = AIRPLANE_FLIGHT_PATH.get(0);
+    double initialHeading = SphericalUtil.computeHeading(startLoc, AIRPLANE_FLIGHT_PATH.get(1));
+    updateAirplaneModel(startLoc, initialHeading + 180.0);
+
+    Camera resetCam = new Camera(
+        new LatLngAltitude(startLoc.latitude, startLoc.longitude, 200.0),
+        normalizeHeading(initialHeading),
+        65.0,
+        0.0,
+        600.0
+    );
+    if (googleMap3D != null) {
+      googleMap3D.setCamera(resetCam);
+    }
+
+    handler.postDelayed(this::startSelectedApproach, 300L);
+  }
+
+  private static double normalizeHeading(double headingDeg) {
+    double normalized = headingDeg % 360.0;
+    return normalized < 0.0 ? normalized + 360.0 : normalized;
+  }
+
+  private static double interpolateAngle(double start, double end, double fraction) {
+    double diff = (end - start) % 360.0;
+      if (diff > 180.0) {
+          diff -= 360.0;
+      }
+      if (diff < -180.0) {
+          diff += 360.0;
+      }
+    return (start + diff * fraction + 360.0) % 360.0;
+  }
+
+  @Override
+  protected void onPause() {
+    super.onPause();
+    stopTour();
+  }
 }
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 08e793cc..8f3578d3 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
@@ -16,15 +16,266 @@
 
 package com.example.maps3djava.datavisualization;
 
+import static com.example.maps3d.common.UtilitiesKt.toValidCamera;
+
+import android.graphics.Color;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.Looper;
+import android.view.ViewGroup;
+import android.widget.Button;
+import android.widget.TextView;
+import android.widget.Toast;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
 import com.example.maps3dcommon.R;
-import com.example.maps3djava.common.BaseSkeletonActivity;
+import com.example.maps3djava.sampleactivity.SampleBaseActivity;
+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.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;
+import com.google.android.material.slider.Slider;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Locale;
 
 /**
- * Skeleton activity for DataVisualizationActivity.
+ * Showcases dynamic 3D volume extrusion in Google Maps 3D SDK (Java) by simulating elevated flood
+ * tides.
  */
-public class DataVisualizationActivity extends BaseSkeletonActivity {
-    @Override
-    protected int getTitleResId() {
-        return R.string.feature_title_data_visualization;
+public class DataVisualizationActivity extends SampleBaseActivity {
+
+  public static final LatLng SF_FLOOD_CENTER = new LatLng(37.8025, -122.4030);
+  private static final String POLYGON_ID = "flood_zone_polygon";
+
+  public static final List<double[]> floodZoneCoords = Arrays.asList(
+      new double[]{37.805156, -122.403256},
+      new double[]{37.803370, -122.401287},
+      new double[]{37.799222, -122.405080},
+      new double[]{37.797500, -122.408000},
+      new double[]{37.801000, -122.411000},
+      new double[]{37.805156, -122.403256}
+  );
+
+  private final int waterFillColor = Color.argb(140, 230, 40, 40);
+  private final int waterStrokeColor = Color.argb(255, 180, 0, 0);
+  private final double waterStrokeWidth = 2.5;
+
+  private TextView floodDepthLabel;
+  private TextView floodRiskBadge;
+  private Slider floodSlider;
+  private Button btnAnimateFlood;
+
+  private Polygon floodPolygon = null;
+  private double currentFloodElevation = 10.0;
+
+  private final Handler simulationHandler = new Handler(Looper.getMainLooper());
+  private Runnable simulationRunnable;
+  private boolean isSimulating = false;
+
+  @NonNull
+  @Override
+  public String getTAG() {
+    return "DataVisualizationActivity";
+  }
+
+  @NonNull
+  @Override
+  public Camera getInitialCamera() {
+    return toValidCamera(new Camera(
+        new LatLngAltitude(SF_FLOOD_CENTER.latitude, SF_FLOOD_CENTER.longitude, 120.0),
+        35.0,
+        64.0,
+        0.0,
+        1200.0
+    ));
+  }
+
+  @Override
+  protected void onCreate(@Nullable Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+
+    ViewGroup container = findViewById(R.id.map_container);
+    if (container != null) {
+      getLayoutInflater().inflate(R.layout.control_panel_data_visualization, container, true);
+    }
+
+    MaterialToolbar topBar = findViewById(R.id.top_bar);
+    if (topBar != null) {
+      topBar.setTitle(R.string.feature_title_data_visualization);
+      topBar.setNavigationOnClickListener(v -> finish());
+    }
+
+    floodDepthLabel = findViewById(R.id.tv_flood_depth_label);
+    floodRiskBadge = findViewById(R.id.tv_flood_risk_badge);
+    floodSlider = findViewById(R.id.flood_slider);
+    btnAnimateFlood = findViewById(R.id.btn_animate_flood);
+
+    if (floodSlider != null) {
+      floodSlider.addOnChangeListener((slider, value, fromUser) -> {
+        if (fromUser) {
+          stopSimulation();
+        }
+        updateFloodElevation(value);
+      });
+    }
+
+    if (btnAnimateFlood != null) {
+      btnAnimateFlood.setOnClickListener(v -> {
+        if (isSimulating) {
+          stopSimulation();
+        } else {
+          startSimulation();
+        }
+      });
     }
+  }
+
+  @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));
+    });
+  }
+
+  public void updateFloodElevation(double currentFloodHeightMeters) {
+    currentFloodElevation = currentFloodHeightMeters;
+
+    runOnUiThread(() -> {
+      double feet = currentFloodHeightMeters * 3.28084;
+      if (floodDepthLabel != null) {
+        floodDepthLabel.setText(
+            String.format(Locale.US, "Flood Elevation: +%.1f m (%.1f ft)", currentFloodHeightMeters,
+                feet));
+      }
+
+      if (floodRiskBadge != null) {
+        if (currentFloodHeightMeters <= 2.0) {
+          floodRiskBadge.setText("🌊 Baseline Tide");
+          floodRiskBadge.setTextColor(Color.parseColor("#008800"));
+          floodRiskBadge.setBackgroundColor(Color.parseColor("#2000AA00"));
+        } else if (currentFloodHeightMeters <= 8.0) {
+          floodRiskBadge.setText("⚠️ Minor Inundation");
+          floodRiskBadge.setTextColor(Color.parseColor("#BB7700"));
+          floodRiskBadge.setBackgroundColor(Color.parseColor("#20FFAA00"));
+        } else if (currentFloodHeightMeters <= 20.0) {
+          floodRiskBadge.setText("🌊 Moderate Flooding");
+          floodRiskBadge.setTextColor(Color.parseColor("#0077CC"));
+          floodRiskBadge.setBackgroundColor(Color.parseColor("#200088FF"));
+        } else if (currentFloodHeightMeters <= 35.0) {
+          floodRiskBadge.setText("🚨 Storm Surge (Cat 3)");
+          floodRiskBadge.setTextColor(Color.parseColor("#DD4400"));
+          floodRiskBadge.setBackgroundColor(Color.parseColor("#25FF5500"));
+        } else {
+          floodRiskBadge.setText("⛔ Extreme Inundation");
+          floodRiskBadge.setTextColor(Color.parseColor("#CC0000"));
+          floodRiskBadge.setBackgroundColor(Color.parseColor("#25FF0000"));
+        }
+      }
+
+        if (googleMap3D == null) {
+            return;
+        }
+
+      List<LatLngAltitude> path = new ArrayList<>();
+      for (double[] coord : floodZoneCoords) {
+        path.add(new LatLngAltitude(coord[0], coord[1], currentFloodHeightMeters));
+      }
+
+      PolygonOptions options = new PolygonOptions();
+      options.setId(POLYGON_ID);
+      options.setPath(path);
+      options.setFillColor(waterFillColor);
+      options.setStrokeColor(waterStrokeColor);
+      options.setStrokeWidth(waterStrokeWidth);
+      options.setAltitudeMode(AltitudeMode.ABSOLUTE);
+      options.setExtruded(true);
+      options.setDrawsOccludedSegments(true);
+      options.setGeodesic(false);
+
+      floodPolygon = googleMap3D.addPolygon(options);
+      if (floodPolygon != null) {
+        floodPolygon.setClickListener(() -> runOnUiThread(() -> Toast.makeText(
+            DataVisualizationActivity.this,
+            String.format(Locale.US, "San Francisco Waterfront - Water Level: +%.1f m",
+                currentFloodElevation),
+            Toast.LENGTH_SHORT
+        ).show()));
+      }
+    });
+  }
+
+  private void startSimulation() {
+    double maxVal = floodSlider != null ? floodSlider.getValueTo() : 100.0;
+    double minVal = floodSlider != null ? floodSlider.getValueFrom() : 0.0;
+    if (currentFloodElevation >= maxVal) {
+      if (floodSlider != null) {
+        floodSlider.setValue((float) minVal);
+      }
+      updateFloodElevation(minVal);
+    }
+
+    isSimulating = true;
+    if (btnAnimateFlood != null) {
+      btnAnimateFlood.setText("⏹ Stop Simulation");
+    }
+
+    simulationRunnable = new Runnable() {
+      @Override
+      public void run() {
+          if (!isSimulating) {
+              return;
+          }
+
+        double currentMax = floodSlider != null ? floodSlider.getValueTo() : 100.0;
+        double newElevation = currentFloodElevation + 0.2;
+        newElevation = Math.round(newElevation * 10.0) / 10.0;
+        if (floodSlider != null) {
+          floodSlider.setValue((float) newElevation);
+        } else {
+          updateFloodElevation(newElevation);
+        }
+        if (newElevation >= currentMax) {
+          stopSimulation();
+          return;
+        }
+
+        simulationHandler.postDelayed(this, 20);
+      }
+    };
+    simulationHandler.post(simulationRunnable);
+  }
+
+  private void stopSimulation() {
+    isSimulating = false;
+    if (simulationRunnable != null) {
+      simulationHandler.removeCallbacks(simulationRunnable);
+      simulationRunnable = null;
+    }
+    if (btnAnimateFlood != null) {
+      btnAnimateFlood.setText("▶ Start Simulation");
+    }
+  }
+
+  @Override
+  protected void onDestroy() {
+    stopSimulation();
+    super.onDestroy();
+  }
 }
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 47496a2a..2d5c352e 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
@@ -16,15 +16,138 @@
 
 package com.example.maps3djava.fieldofview;
 
+import android.os.Bundle;
+import android.view.ViewGroup;
+import android.widget.Button;
+import android.widget.TextView;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.example.maps3d.common.UtilitiesKt;
 import com.example.maps3dcommon.R;
-import com.example.maps3djava.common.BaseSkeletonActivity;
+import com.example.maps3djava.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.LatLngAltitude;
+import com.google.android.material.appbar.MaterialToolbar;
+import com.google.android.material.slider.Slider;
 
 /**
- * Skeleton activity for FieldOfViewActivity.
+ * Showcases Field of View (FOV) perspective scaling in Google Maps 3D SDK (Java implementation).
+ *
+ * Features:
+ * - Interactive FOV slider and quick presets preserving current active map location smoothly.
+ * - Robust toValidCamera validation preventing out-of-range heading/tilt crash during manual map rotation.
  */
-public class FieldOfViewActivity extends BaseSkeletonActivity {
+public class FieldOfViewActivity extends SampleBaseActivity {
+
+    public static final LatLng SF_FINANCIAL_DISTRICT = new LatLng(37.7952, -122.4028);
+
+    private TextView fovSliderLabel;
+    private Slider fovSlider;
+    private double currentFov = 45.0;
+
+    @NonNull
+    @Override
+    public String getTAG() {
+        return "FieldOfViewActivity";
+    }
+
+    @NonNull
+    @Override
+    public Camera getInitialCamera() {
+        return UtilitiesKt.toValidCamera(new Camera(
+                new LatLngAltitude(SF_FINANCIAL_DISTRICT.latitude, SF_FINANCIAL_DISTRICT.longitude, 150.0),
+                45.0,
+                65.0,
+                0.0,
+                800.0
+        ));
+    }
+
+    @Override
+    protected void onCreate(@Nullable Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        // Inflate FOV control panel overlay into map container managed by SampleBaseActivity
+        ViewGroup container = findViewById(R.id.map_container);
+        if (container != null) {
+            getLayoutInflater().inflate(R.layout.control_panel_field_of_view, container, true);
+        }
+
+        MaterialToolbar topBar = findViewById(R.id.top_bar);
+        if (topBar != null) {
+            topBar.setTitle("Field of View (FOV)");
+            topBar.setNavigationOnClickListener(v -> finish());
+        }
+
+        fovSliderLabel = findViewById(R.id.fov_slider_label);
+        fovSlider = findViewById(R.id.fov_slider);
+
+        if (fovSlider != null) {
+            fovSlider.addOnChangeListener((slider, value, fromUser) -> updateFov(value));
+        }
+
+        Button btnTele = findViewById(R.id.btn_fov_telephoto);
+        if (btnTele != null) {
+            btnTele.setOnClickListener(v -> { if (fovSlider != null) fovSlider.setValue(20.0f); });
+        }
+
+        Button btnStd = findViewById(R.id.btn_fov_standard);
+        if (btnStd != null) {
+            btnStd.setOnClickListener(v -> { if (fovSlider != null) fovSlider.setValue(45.0f); });
+        }
+
+        Button btnWide = findViewById(R.id.btn_fov_wide);
+        if (btnWide != null) {
+            btnWide.setOnClickListener(v -> { if (fovSlider != null) fovSlider.setValue(90.0f); });
+        }
+
+        Button btnUltra = findViewById(R.id.btn_fov_ultrawide);
+        if (btnUltra != null) {
+            btnUltra.setOnClickListener(v -> { if (fovSlider != null) fovSlider.setValue(120.0f); });
+        }
+    }
+
     @Override
-    protected int getTitleResId() {
-        return R.string.feature_title_field_of_view;
+    public void onMap3DViewReady(@NonNull GoogleMap3D googleMap3D) {
+        super.onMap3DViewReady(googleMap3D);
+        googleMap3D.setOnMapReadyListener(sceneReadiness -> {
+            googleMap3D.setOnMapReadyListener(null);
+            runOnUiThread(() -> updateFov((float) currentFov));
+        });
+    }
+
+    private void updateFov(float fovAngle) {
+        currentFov = fovAngle;
+        runOnUiThread(() -> {
+            if (fovSliderLabel != null) {
+                fovSliderLabel.setText("Field of View: " + (int) fovAngle + "°");
+            }
+        });
+
+        if (googleMap3D != null) {
+            Camera liveCam = googleMap3D.getCamera() != null ? UtilitiesKt.toValidCamera(googleMap3D.getCamera()) : null;
+            Camera currCam = (liveCam != null && (Math.abs(liveCam.getCenter().getLatitude()) > 0.001 || Math.abs(liveCam.getCenter().getLongitude()) > 0.001))
+                    ? liveCam
+                    : getInitialCamera();
+            double baseFovRad = Math.toRadians(45.0 / 2.0);
+            double targetFovRad = Math.toRadians(fovAngle / 2.0);
+
+            double targetRange = 800.0 * Math.tan(baseFovRad) / Math.tan(targetFovRad);
+            if (targetRange < 150.0) targetRange = 150.0;
+            if (targetRange > 3000.0) targetRange = 3000.0;
+
+            Camera updatedCam = UtilitiesKt.toValidCamera(new Camera(
+                    currCam.getCenter(),
+                    currCam.getHeading(),
+                    currCam.getTilt(),
+                    currCam.getRoll(),
+                    targetRange
+            ));
+            googleMap3D.setCamera(updatedCam);
+        }
     }
 }
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 51fe5942..c0551815 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
@@ -16,15 +16,422 @@
 
 package com.example.maps3djava.pathfollowing;
 
+import static com.example.maps3d.common.UtilitiesKt.toHeading;
+
+import android.graphics.Color;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.Looper;
+import android.widget.RadioGroup;
+import android.widget.TextView;
+import androidx.annotation.NonNull;
+import androidx.appcompat.app.AppCompatActivity;
+import androidx.core.view.WindowCompat;
 import com.example.maps3dcommon.R;
-import com.example.maps3djava.common.BaseSkeletonActivity;
+import com.google.android.gms.maps.model.LatLng;
+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.AltitudeMode;
+import com.google.android.gms.maps3d.model.Camera;
+import com.google.android.gms.maps3d.model.LatLngAltitude;
+import com.google.android.gms.maps3d.model.Polyline;
+import com.google.android.gms.maps3d.model.PolylineOptions;
+import com.google.android.material.button.MaterialButton;
+import com.google.android.material.slider.Slider;
+import com.google.maps.android.SphericalUtil;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
 
 /**
- * Skeleton activity for PathFollowingActivity.
+ * Advanced sample demonstrating ground-level path following in Java.
+ *
+ * Features: - Urban vs Rural ground-level paths - Real-time camera controls via sliders: Range,
+ * Ground Altitude, Heading Offset, Tilt, Follow Speed - Smooth Handler-based frame animation along
+ * the route
  */
-public class PathFollowingActivity extends BaseSkeletonActivity {
-    @Override
-    protected int getTitleResId() {
-        return R.string.feature_title_path_following;
+public class PathFollowingActivity extends AppCompatActivity implements OnMap3DViewReadyCallback {
+
+  private Map3DView map3DView;
+  private GoogleMap3D googleMap3D;
+
+  // Urban Path (New York City - Central Park Block Circuit)
+  public static final List<LatLng> URBAN_PATH = Arrays.asList(
+      new LatLng(40.7783119, -73.9627630),
+      new LatLng(40.7776355, -73.9611664),
+      new LatLng(40.7770011, -73.9616294),
+      new LatLng(40.7776743, -73.9632228),
+      new LatLng(40.7783119, -73.9627630)
+  );
+
+  // Rural Path
+  public static final List<LatLng> RURAL_PATH = Arrays.asList(
+      new LatLng(37.254529, -122.380897),
+      new LatLng(37.255065, -122.381627),
+      new LatLng(37.257540, -122.383720),
+      new LatLng(37.261200, -122.383950),
+      new LatLng(37.264780, -122.388210),
+      new LatLng(37.268520, -122.392450),
+      new LatLng(37.272110, -122.397640),
+      new LatLng(37.276430, -122.401120),
+      new LatLng(37.280850, -122.403560),
+      new LatLng(37.286018, -122.405072),
+      new LatLng(37.291040, -122.404210),
+      new LatLng(37.295800, -122.401980),
+      new LatLng(37.300120, -122.399540),
+      new LatLng(37.304550, -122.397210),
+      new LatLng(37.309200, -122.395100),
+      new LatLng(37.313450, -122.392840),
+      new LatLng(37.317200, -122.390510),
+      new LatLng(37.320850, -122.388740),
+      new LatLng(37.323540, -122.387600),
+      new LatLng(37.325269, -122.386728)
+  );
+
+  // View Bindings
+  private RadioGroup rgEnvironment;
+  private MaterialButton btnPlayPause;
+  private Slider progressSlider;
+  private Slider rangeSlider;
+  private TextView rangeSliderLabel;
+  private Slider altitudeSlider;
+  private TextView altitudeSliderLabel;
+  private Slider headingSlider;
+  private TextView headingSliderLabel;
+  private Slider tiltSlider;
+  private TextView tiltSliderLabel;
+  private Slider speedSlider;
+  private TextView speedSliderLabel;
+
+  // Control parameters
+  private double cameraRange = 300.0;
+  private double groundAltitude = 20.0;
+  private double headingOffset = 0.0;
+  private double cameraTilt = 70.0;
+  private double followSpeedMps = 30.0;
+
+  // Path state
+  private List<LatLng> currentPath = URBAN_PATH;
+  private double[] cumulativeDistances = new double[0];
+  private double totalDistance = 0.0;
+  private double elapsedDistance = 0.0;
+  private boolean isPlaying = false;
+  private boolean isUserScrubbing = false;
+
+  private Polyline pathPolyline = null;
+  private final Handler handler = new Handler(Looper.getMainLooper());
+  private Runnable animationRunnable;
+
+  @Override
+  protected void onCreate(Bundle savedInstanceState) {
+    WindowCompat.setDecorFitsSystemWindows(getWindow(), false);
+    super.onCreate(savedInstanceState);
+    setContentView(R.layout.activity_path_following);
+
+    map3DView = findViewById(R.id.map3dView);
+    map3DView.onCreate(savedInstanceState);
+    map3DView.getMap3DViewAsync(this);
+
+    initViews();
+    loadPathData(URBAN_PATH);
+  }
+
+  @Override
+  protected void onResume() {
+    super.onResume();
+    map3DView.onResume();
+  }
+
+  @Override
+  protected void onPause() {
+    super.onPause();
+    map3DView.onPause();
+    pauseAnimation();
+  }
+
+  @Override
+  protected void onDestroy() {
+    super.onDestroy();
+    pauseAnimation();
+    if (pathPolyline != null) {
+      pathPolyline.remove();
+      pathPolyline = null;
+    }
+    map3DView.onDestroy();
+  }
+
+  @Override
+  public void onLowMemory() {
+    super.onLowMemory();
+    map3DView.onLowMemory();
+  }
+
+  @Override
+  protected void onSaveInstanceState(@NonNull Bundle outState) {
+    super.onSaveInstanceState(outState);
+    map3DView.onSaveInstanceState(outState);
+  }
+
+  private void initViews() {
+    rgEnvironment = findViewById(R.id.rg_environment);
+    btnPlayPause = findViewById(R.id.btn_play_pause);
+    progressSlider = findViewById(R.id.progress_slider);
+
+    rangeSlider = findViewById(R.id.range_slider);
+    rangeSliderLabel = findViewById(R.id.range_slider_label);
+    altitudeSlider = findViewById(R.id.altitude_slider);
+    altitudeSliderLabel = findViewById(R.id.altitude_slider_label);
+    headingSlider = findViewById(R.id.heading_slider);
+    headingSliderLabel = findViewById(R.id.heading_slider_label);
+    tiltSlider = findViewById(R.id.tilt_slider);
+    tiltSliderLabel = findViewById(R.id.tilt_slider_label);
+    speedSlider = findViewById(R.id.speed_slider);
+    speedSliderLabel = findViewById(R.id.speed_slider_label);
+
+    // Radio group environment selection
+    rgEnvironment.setOnCheckedChangeListener((group, checkedId) -> {
+      if (checkedId == R.id.rb_urban) {
+        altitudeSlider.setValueTo(200.0f);
+        switchEnvironment(URBAN_PATH);
+      } else if (checkedId == R.id.rb_rural) {
+        altitudeSlider.setValueTo(2000.0f);
+        switchEnvironment(RURAL_PATH);
+      }
+    });
+
+    // Play/Pause button
+    btnPlayPause.setOnClickListener(v -> {
+      if (isPlaying) {
+        pauseAnimation();
+      } else {
+        startAnimation();
+      }
+    });
+
+    // Progress slider scrubbing
+    progressSlider.addOnChangeListener((slider, value, fromUser) -> {
+      if (fromUser) {
+        isUserScrubbing = true;
+        elapsedDistance = totalDistance * value;
+        updateCameraPositionForDistance(elapsedDistance);
+      }
+    });
+    progressSlider.addOnSliderTouchListener(new Slider.OnSliderTouchListener() {
+      @Override
+      public void onStartTrackingTouch(@NonNull Slider slider) {
+        isUserScrubbing = true;
+      }
+
+      @Override
+      public void onStopTrackingTouch(@NonNull Slider slider) {
+        isUserScrubbing = false;
+      }
+    });
+
+    // Sliders listeners
+    rangeSlider.addOnChangeListener((slider, value, fromUser) -> {
+      cameraRange = value;
+      rangeSliderLabel.setText(String.format("Camera Range: %dm", (int) cameraRange));
+      updateCameraPositionForDistance(elapsedDistance);
+    });
+
+    altitudeSlider.addOnChangeListener((slider, value, fromUser) -> {
+      groundAltitude = value;
+      altitudeSliderLabel.setText(String.format("Ground Altitude: %dm", (int) groundAltitude));
+      updateCameraPositionForDistance(elapsedDistance);
+    });
+
+    headingSlider.addOnChangeListener((slider, value, fromUser) -> {
+      headingOffset = value;
+      headingSliderLabel.setText(String.format("Heading Offset: %d°", (int) headingOffset));
+      updateCameraPositionForDistance(elapsedDistance);
+    });
+
+    tiltSlider.addOnChangeListener((slider, value, fromUser) -> {
+      cameraTilt = value;
+      tiltSliderLabel.setText(String.format("Camera Tilt: %d°", (int) cameraTilt));
+      updateCameraPositionForDistance(elapsedDistance);
+    });
+
+    speedSlider.addOnChangeListener((slider, value, fromUser) -> {
+      followSpeedMps = value;
+      speedSliderLabel.setText(String.format("Follow Speed: %d m/s", (int) followSpeedMps));
+    });
+  }
+
+  @Override
+  public void onMap3DViewReady(@NonNull GoogleMap3D googleMap3D) {
+    this.googleMap3D = googleMap3D;
+    googleMap3D.setOnMapReadyListener((map) -> {
+      googleMap3D.setOnMapReadyListener(null);
+      drawPathPolyline();
+      updateCameraPositionForDistance(0.0);
+    });
+  }
+
+  private Double currentHeading = null;
+
+  private void switchEnvironment(List<LatLng> path) {
+    pauseAnimation();
+    currentHeading = null;
+    elapsedDistance = 0.0;
+    progressSlider.setValue(0f);
+
+    if (path.equals(RURAL_PATH)) {
+      cameraRange = 450.0;
+      groundAltitude = 40.0;
+      cameraTilt = 75.0;
+      rangeSlider.setValue(450f);
+      altitudeSlider.setValue(40f);
+      tiltSlider.setValue(75f);
+      rangeSliderLabel.setText("Camera Range: 450m");
+      altitudeSliderLabel.setText("Ground Altitude: 40m");
+      tiltSliderLabel.setText("Camera Tilt: 75°");
+    } else {
+      cameraRange = 300.0;
+      groundAltitude = 20.0;
+      cameraTilt = 70.0;
+      rangeSlider.setValue(300f);
+      altitudeSlider.setValue(20f);
+      tiltSlider.setValue(70f);
+      rangeSliderLabel.setText("Camera Range: 300m");
+      altitudeSliderLabel.setText("Ground Altitude: 20m");
+      tiltSliderLabel.setText("Camera Tilt: 70°");
+    }
+
+    loadPathData(path);
+    drawPathPolyline();
+    updateCameraPositionForDistance(0.0);
+  }
+
+  private void loadPathData(List<LatLng> path) {
+    currentPath = path;
+    cumulativeDistances = new double[path.size()];
+    totalDistance = 0.0;
+    cumulativeDistances[0] = 0.0;
+    for (int i = 1; i < path.size(); i++) {
+      double dist = SphericalUtil.computeDistanceBetween(path.get(i - 1), path.get(i));
+      totalDistance += dist;
+      cumulativeDistances[i] = totalDistance;
+    }
+  }
+
+  private void drawPathPolyline() {
+    if (googleMap3D == null) {
+      return;
+    }
+    if (pathPolyline != null) {
+      pathPolyline.remove();
+    }
+
+    List<LatLngAltitude> vertices = new ArrayList<>();
+    for (LatLng latLng : currentPath) {
+      vertices.add(new LatLngAltitude(latLng.latitude, latLng.longitude, 5.0));
+    }
+
+    PolylineOptions polyOptions = new PolylineOptions();
+    polyOptions.setPath(vertices);
+    polyOptions.setStrokeColor(Color.parseColor("#4285F4"));
+    polyOptions.setStrokeWidth(10.0);
+    polyOptions.setAltitudeMode(AltitudeMode.RELATIVE_TO_GROUND);
+
+    pathPolyline = googleMap3D.addPolyline(polyOptions);
+  }
+
+  private void startAnimation() {
+    if (isPlaying) {
+      return;
+    }
+    isPlaying = true;
+    btnPlayPause.setIconResource(R.drawable.pause_24px);
+
+    final long frameDurationMs = 16L;
+    animationRunnable = new Runnable() {
+      @Override
+      public void run() {
+        if (!isPlaying) {
+          return;
+        }
+
+        double stepDistance = followSpeedMps * (frameDurationMs / 1000.0);
+        elapsedDistance += stepDistance;
+
+        if (elapsedDistance >= totalDistance) {
+          elapsedDistance = 0.0;
+        }
+
+        if (!isUserScrubbing && totalDistance > 0) {
+          float progress = (float) (elapsedDistance / totalDistance);
+          if (progress >= 0f && progress <= 1f) {
+            progressSlider.setValue(progress);
+          }
+        }
+
+        updateCameraPositionForDistance(elapsedDistance);
+        handler.postDelayed(this, frameDurationMs);
+      }
+    };
+
+    handler.post(animationRunnable);
+  }
+
+  private void pauseAnimation() {
+    isPlaying = false;
+    btnPlayPause.setIconResource(R.drawable.play_arrow_24px);
+    if (animationRunnable != null) {
+      handler.removeCallbacks(animationRunnable);
+      animationRunnable = null;
+    }
+  }
+
+  private void updateCameraPositionForDistance(double dist) {
+    if (googleMap3D == null || currentPath.isEmpty()) {
+      return;
+    }
+
+    int index = 0;
+    while (index < cumulativeDistances.length - 1 && cumulativeDistances[index + 1] < dist) {
+      index++;
+    }
+
+    LatLng p1 = currentPath.get(index);
+    LatLng p2 = (index < currentPath.size() - 1) ? currentPath.get(index + 1) : p1;
+
+    double segStartDist = cumulativeDistances[index];
+    double segEndDist =
+        (index < cumulativeDistances.length - 1) ? cumulativeDistances[index + 1] : totalDistance;
+    double segLen = segEndDist - segStartDist;
+
+    double fraction =
+        (segLen > 0) ? Math.max(0.0, Math.min(1.0, (dist - segStartDist) / segLen)) : 0.0;
+    LatLng currentLatLng = SphericalUtil.interpolate(p1, p2, fraction);
+    double bearing = SphericalUtil.computeHeading(p1, p2);
+
+    double targetHeadingRaw = toHeading(bearing + headingOffset);
+    double targetHeading;
+    if (currentHeading == null || isUserScrubbing || !isPlaying) {
+      targetHeading = targetHeadingRaw;
+    } else {
+      double diff = (targetHeadingRaw - currentHeading) % 360.0;
+      if (diff > 180.0) {
+        diff -= 360.0;
+      }
+      if (diff < -180.0) {
+        diff += 360.0;
+      }
+      targetHeading = toHeading(currentHeading + diff * 0.12);
     }
+    currentHeading = targetHeading;
+
+    Camera newCamera = new Camera(
+        new LatLngAltitude(currentLatLng.latitude, currentLatLng.longitude, groundAltitude),
+        targetHeading,
+        cameraTilt,
+        0.0,
+        cameraRange
+    );
+
+    googleMap3D.setCamera(newCamera);
+  }
 }
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 aba4d625..76dc8340 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
@@ -16,15 +16,89 @@
 
 package com.example.maps3djava.roadmapmode;
 
+import android.os.Bundle;
+import android.view.ViewGroup;
+import android.widget.RadioGroup;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
 import com.example.maps3dcommon.R;
-import com.example.maps3djava.common.BaseSkeletonActivity;
+import com.example.maps3djava.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.LatLngAltitude;
+import com.google.android.gms.maps3d.model.Map3DMode;
+import com.google.android.material.appbar.MaterialToolbar;
 
 /**
- * Skeleton activity for RoadmapModeActivity.
+ * Showcases 3D Roadmap mode in Google Maps 3D SDK (Java implementation).
+ * Features: - Switching between ROADMAP, HYBRID, and SATELLITE 3D render modes focused on San
+ * Francisco.
  */
-public class RoadmapModeActivity extends BaseSkeletonActivity {
-    @Override
-    protected int getTitleResId() {
-        return R.string.feature_title_roadmap_mode;
+public class RoadmapModeActivity extends SampleBaseActivity {
+
+  public static final LatLng SF_LOCATION = new LatLng(37.7915, -122.4010);
+
+  @NonNull
+  @Override
+  public String getTAG() {
+    return "RoadmapModeActivity";
+  }
+
+  @NonNull
+  @Override
+  public Camera getInitialCamera() {
+    return new Camera(
+        new LatLngAltitude(SF_LOCATION.latitude, SF_LOCATION.longitude, 250.0),
+        45.0,
+        65.0,
+        0.0,
+        800.0
+    );
+  }
+
+  @Override
+  protected void onCreate(@Nullable Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+
+    // Inflate roadmap control panel overlay into map container managed by SampleBaseActivity
+    ViewGroup container = findViewById(R.id.map_container);
+    if (container != null) {
+      getLayoutInflater().inflate(R.layout.control_panel_roadmap_mode, container, true);
     }
+
+    MaterialToolbar topBar = findViewById(R.id.top_bar);
+    if (topBar != null) {
+      topBar.setTitle("3D Roadmap Mode");
+      topBar.setNavigationOnClickListener(v -> finish());
+    }
+
+    RadioGroup rgMapMode = findViewById(R.id.rg_map_mode);
+    if (rgMapMode != null) {
+      rgMapMode.setOnCheckedChangeListener((group, checkedId) -> {
+        if (googleMap3D != null) {
+          if (checkedId == R.id.rb_roadmap) {
+            googleMap3D.setMapMode(Map3DMode.ROADMAP);
+          } else if (checkedId == R.id.rb_hybrid) {
+            googleMap3D.setMapMode(Map3DMode.HYBRID);
+          } else if (checkedId == R.id.rb_satellite) {
+            googleMap3D.setMapMode(Map3DMode.SATELLITE);
+          }
+        }
+      });
+    }
+  }
+
+  @Override
+  public void onMap3DViewReady(@NonNull GoogleMap3D googleMap3D) {
+    super.onMap3DViewReady(googleMap3D);
+    googleMap3D.setOnMapReadyListener((map) -> {
+      googleMap3D.setOnMapReadyListener(null);
+      googleMap3D.setMapMode(Map3DMode.ROADMAP);
+      googleMap3D.setCamera(getInitialCamera());
+    });
+
+  }
 }
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 d3439f90..7bf24ea6 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
@@ -184,6 +184,13 @@ public void onMap3DViewReady(GoogleMap3D googleMap3D) {
 
         googleMap3D.setCamera(getInitialCamera());
 
+        // Mark map view as steady when rendering stabilizes for automated visual tests
+        googleMap3D.setOnMapSteadyListener(isSceneSteady -> {
+            if (isSceneSteady && map3DView != null) {
+                map3DView.setContentDescription("MapSteady");
+            }
+        });
+
         // Initialize and set the camera changed listener
         cameraChangedListener = cameraPosition -> {
         };
diff --git a/Maps3DSamples/ApiDemos/kotlin-app/src/androidTest/java/com/example/maps3dkotlin/AdvancedCameraAnimationVisualTest.kt b/Maps3DSamples/ApiDemos/kotlin-app/src/androidTest/java/com/example/maps3dkotlin/AdvancedCameraAnimationVisualTest.kt
new file mode 100644
index 00000000..4f07b77d
--- /dev/null
+++ b/Maps3DSamples/ApiDemos/kotlin-app/src/androidTest/java/com/example/maps3dkotlin/AdvancedCameraAnimationVisualTest.kt
@@ -0,0 +1,82 @@
+/*
+ * 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
+
+import android.content.Intent
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.uiautomator.By
+import androidx.test.uiautomator.Until
+import com.example.maps3dkotlin.advancedcameraanimation.AdvancedCameraAnimationActivity
+import kotlin.time.Duration.Companion.milliseconds
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.runBlocking
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+
+/**
+ * A premium visual regression test for the View-based Kotlin Advanced Camera Animation sample.
+ *
+ * This test automates launching the [AdvancedCameraAnimationActivity], waiting for 3D map tiles, the 3D airplane
+ * glTF model, and automated camera approach tours (Golden Gate Bridge to Coit Tower corridor) to render, capturing a
+ * screenshot of the live rendering scene, and verifying visual correctness using the Gemini API.
+ */
+@RunWith(AndroidJUnit4::class)
+class AdvancedCameraAnimationVisualTest : BaseVisualTest() {
+
+  @Test
+  fun verifyAdvancedCameraAnimationRenders() {
+    runBlocking {
+      // Launch AdvancedCameraAnimationActivity
+      val intent = Intent(context, AdvancedCameraAnimationActivity::class.java).apply {
+        addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+      }
+      context.startActivity(intent)
+
+      // Wait for the activity to be displayed in the foreground
+      uiDevice.wait(Until.hasObject(By.pkg(context.packageName).depth(0)), 10000)
+
+      // Wait for map tiles to load, 3D airplane model to stream, and camera flight animation to settle
+      waitForMapRendering(15)
+
+      // Capture high-resolution screenshot of the active 3D map scene
+      val screenshotBitmap = captureScreenshot("advanced_camera_animation_screenshot.png")
+
+      // Define the verification prompt for the visual testing agent
+      val prompt = """
+                Please act as a UI tester and analyze this screenshot.
+                1. Confirm that a 3D map view is visible over San Francisco (Golden Gate Bridge / Bay area).
+                2. Confirm that a 3D AIRPLANE MODEL or aerial flight path object is visible in 3D space.
+                3. Confirm that the animation approach control card (with radio options for Simple flyTo, Keyframe Tour, Frame Dispatcher, 360 Orbit Spin, and Play/Reset buttons) is visible at the bottom of the screen.
+
+                If and ONLY IF you can clearly see the 3D map scene, 3D airplane flight tour, and bottom animation approach selector card, reply with "PASSED".
+                If you cannot see the 3D map scene or control card, reply with "FAILED: 3D map scene or control card not visible".
+                Report what you see in detail.
+            """.trimIndent()
+
+      // Analyze the image using Gemini
+      val geminiResponse = helper.analyzeImage(screenshotBitmap, prompt, geminiApiKey)
+      println("Gemini's analysis: ${'$'}geminiResponse")
+
+      // Assert on Gemini's response
+      assertTrue(
+        "Visual verification failed. Gemini response: ${'$'}geminiResponse",
+        geminiResponse?.contains("PASSED", ignoreCase = true) == true
+      )
+    }
+  }
+}
diff --git a/Maps3DSamples/ApiDemos/kotlin-app/src/androidTest/java/com/example/maps3dkotlin/BaseVisualTest.kt b/Maps3DSamples/ApiDemos/kotlin-app/src/androidTest/java/com/example/maps3dkotlin/BaseVisualTest.kt
index 14186703..d62d635f 100644
--- a/Maps3DSamples/ApiDemos/kotlin-app/src/androidTest/java/com/example/maps3dkotlin/BaseVisualTest.kt
+++ b/Maps3DSamples/ApiDemos/kotlin-app/src/androidTest/java/com/example/maps3dkotlin/BaseVisualTest.kt
@@ -74,12 +74,10 @@ abstract class BaseVisualTest {
      * @param timeoutSeconds The maximum time to wait in seconds.
      */
     protected fun waitForMapRendering(timeoutSeconds: Long = 30) {
-        // Fallback to sleep since View-based samples do not set "MapSteady" content description.
-        println("Sleeping for $timeoutSeconds seconds to allow map to render...")
-        try {
-            Thread.sleep(timeoutSeconds * 1000)
-        } catch (e: InterruptedException) {
-            Thread.currentThread().interrupt()
+        android.util.Log.i("BaseVisualTest", "Waiting up to ${timeoutSeconds}s for map to become steady...")
+        val steady = uiDevice.wait(Until.hasObject(By.desc("MapSteady")), timeoutSeconds * 1000)
+        if (!steady) {
+            android.util.Log.w("BaseVisualTest", "Map did not report MapSteady within ${timeoutSeconds}s; proceeding with capture.")
         }
     }
 }
diff --git a/Maps3DSamples/ApiDemos/kotlin-app/src/androidTest/java/com/example/maps3dkotlin/DataVisualizationVisualTest.kt b/Maps3DSamples/ApiDemos/kotlin-app/src/androidTest/java/com/example/maps3dkotlin/DataVisualizationVisualTest.kt
new file mode 100644
index 00000000..de37bc5f
--- /dev/null
+++ b/Maps3DSamples/ApiDemos/kotlin-app/src/androidTest/java/com/example/maps3dkotlin/DataVisualizationVisualTest.kt
@@ -0,0 +1,82 @@
+/*
+ * 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
+
+import android.content.Intent
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.uiautomator.By
+import androidx.test.uiautomator.Until
+import com.example.maps3dkotlin.datavisualization.DataVisualizationActivity
+import kotlin.time.Duration.Companion.milliseconds
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.runBlocking
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+
+/**
+ * A premium visual regression test for the View-based Kotlin 3D Data Visualization sample.
+ *
+ * This test automates launching the [DataVisualizationActivity], waiting for 3D map tiles, dynamic 3D extruded polygon
+ * flood volumes over the San Francisco Waterfront, and control panel widgets to render, capturing a screenshot of the
+ * live rendering scene, and verifying visual correctness using the Gemini API.
+ */
+@RunWith(AndroidJUnit4::class)
+class DataVisualizationVisualTest : BaseVisualTest() {
+
+  @Test
+  fun verifyDataVisualizationRenders() {
+    runBlocking {
+      // Launch DataVisualizationActivity
+      val intent = Intent(context, DataVisualizationActivity::class.java).apply {
+        addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+      }
+      context.startActivity(intent)
+
+      // Wait for the activity to be displayed in the foreground
+      uiDevice.wait(Until.hasObject(By.pkg(context.packageName).depth(0)), 10000)
+
+      // Wait for map tiles to load, 3D flood polygon to extrude, and UI controls to settle
+      waitForMapRendering(15)
+
+      // Capture high-resolution screenshot of the active 3D map scene
+      val screenshotBitmap = captureScreenshot("data_visualization_screenshot.png")
+
+      // Define the verification prompt for the visual testing agent
+      val prompt = """
+                Please act as a UI tester and analyze this screenshot.
+                1. Confirm that a 3D map view is visible over the San Francisco waterfront.
+                2. Confirm that an EXTRUDED 3D POLYGON or volumetric polygon shape (red tinted flood water zone) is clearly visible on top of the 3D terrain/map.
+                3. Confirm that the Data Visualization control card (showing Flood Elevation label, Risk Badge status, elevation slider, and Start/Stop Simulation button) is visible at the bottom of the screen.
+
+                If and ONLY IF you can clearly see the 3D map view with the extruded red flood polygon and bottom simulation control panel, reply with "PASSED".
+                If you cannot see the extruded flood polygon or control panel, reply with "FAILED: Extruded flood polygon or control panel not visible".
+                Report what you see in detail.
+            """.trimIndent()
+
+      // Analyze the image using Gemini
+      val geminiResponse = helper.analyzeImage(screenshotBitmap, prompt, geminiApiKey)
+      println("Gemini's analysis: ${'$'}geminiResponse")
+
+      // Assert on Gemini's response
+      assertTrue(
+        "Visual verification failed. Gemini response: ${'$'}geminiResponse",
+        geminiResponse?.contains("PASSED", ignoreCase = true) == true
+      )
+    }
+  }
+}
diff --git a/Maps3DSamples/ApiDemos/kotlin-app/src/androidTest/java/com/example/maps3dkotlin/FieldOfViewVisualTest.kt b/Maps3DSamples/ApiDemos/kotlin-app/src/androidTest/java/com/example/maps3dkotlin/FieldOfViewVisualTest.kt
new file mode 100644
index 00000000..727c72e5
--- /dev/null
+++ b/Maps3DSamples/ApiDemos/kotlin-app/src/androidTest/java/com/example/maps3dkotlin/FieldOfViewVisualTest.kt
@@ -0,0 +1,82 @@
+/*
+ * 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
+
+import android.content.Intent
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.uiautomator.By
+import androidx.test.uiautomator.Until
+import com.example.maps3dkotlin.fieldofview.FieldOfViewActivity
+import kotlin.time.Duration.Companion.milliseconds
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.runBlocking
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+
+/**
+ * A premium visual regression test for the View-based Kotlin Field of View (FOV) sample.
+ *
+ * This test automates launching the [FieldOfViewActivity], waiting for 3D map tiles over the San Francisco Financial
+ * District, perspective dolly-zoom camera controls, and quick FOV preset buttons to load, capturing a screenshot of the
+ * live rendering scene, and verifying visual correctness using the Gemini API.
+ */
+@RunWith(AndroidJUnit4::class)
+class FieldOfViewVisualTest : BaseVisualTest() {
+
+  @Test
+  fun verifyFieldOfViewRenders() {
+    runBlocking {
+      // Launch FieldOfViewActivity
+      val intent = Intent(context, FieldOfViewActivity::class.java).apply {
+        addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+      }
+      context.startActivity(intent)
+
+      // Wait for the activity to be displayed in the foreground
+      uiDevice.wait(Until.hasObject(By.pkg(context.packageName).depth(0)), 10000)
+
+      // Wait for map tiles to render and optical dolly zoom view to settle
+      waitForMapRendering(15)
+
+      // Capture high-resolution screenshot of the active 3D map scene
+      val screenshotBitmap = captureScreenshot("field_of_view_screenshot.png")
+
+      // Define the verification prompt for the visual testing agent
+      val prompt = """
+                Please act as a UI tester and analyze this screenshot.
+                1. Confirm that a 3D map view is visible over the San Francisco Financial District area.
+                2. Confirm that the Field of View perspective control card (with FOV angle slider and instant preset buttons: 20° Telephoto, 45° Standard, 90° Wide, 120° Ultra-Wide) is visible at the bottom of the screen.
+                3. Confirm that the visual text label showing the current FOV angle (e.g. "Field of View: 45°") is visible on the card.
+
+                If and ONLY IF you can clearly see the 3D map view and bottom Field of View control card with presets and slider, reply with "PASSED".
+                If you cannot see the 3D map scene or FOV control card, reply with "FAILED: 3D map scene or FOV controls not visible".
+                Report what you see in detail.
+            """.trimIndent()
+
+      // Analyze the image using Gemini
+      val geminiResponse = helper.analyzeImage(screenshotBitmap, prompt, geminiApiKey)
+      println("Gemini's analysis: ${'$'}geminiResponse")
+
+      // Assert on Gemini's response
+      assertTrue(
+        "Visual verification failed. Gemini response: ${'$'}geminiResponse",
+        geminiResponse?.contains("PASSED", ignoreCase = true) == true
+      )
+    }
+  }
+}
diff --git a/Maps3DSamples/ApiDemos/kotlin-app/src/androidTest/java/com/example/maps3dkotlin/PathFollowingVisualTest.kt b/Maps3DSamples/ApiDemos/kotlin-app/src/androidTest/java/com/example/maps3dkotlin/PathFollowingVisualTest.kt
new file mode 100644
index 00000000..3b239bc7
--- /dev/null
+++ b/Maps3DSamples/ApiDemos/kotlin-app/src/androidTest/java/com/example/maps3dkotlin/PathFollowingVisualTest.kt
@@ -0,0 +1,82 @@
+/*
+ * 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
+
+import android.content.Intent
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.uiautomator.By
+import androidx.test.uiautomator.Until
+import com.example.maps3dkotlin.pathfollowing.PathFollowingActivity
+import kotlin.time.Duration.Companion.milliseconds
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.runBlocking
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+
+/**
+ * A premium visual regression test for the View-based Kotlin Path Following sample.
+ *
+ * This test automates launching the [PathFollowingActivity], waiting for the 3D map scene, polyline route,
+ * and ground-level camera navigation engine to initialize, capturing a screenshot of the live rendering scene,
+ * and verifying visual correctness using the Gemini API.
+ */
+@RunWith(AndroidJUnit4::class)
+class PathFollowingVisualTest : BaseVisualTest() {
+
+  @Test
+  fun verifyPathFollowingRenders() {
+    runBlocking {
+      // Launch PathFollowingActivity
+      val intent = Intent(context, PathFollowingActivity::class.java).apply {
+        addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+      }
+      context.startActivity(intent)
+
+      // Wait for the activity to be displayed in the foreground
+      uiDevice.wait(Until.hasObject(By.pkg(context.packageName).depth(0)), 10000)
+
+      // Wait for map tiles to load, ground polyline to render, and path animation to initialize
+      waitForMapRendering(15)
+
+      // Capture high-resolution screenshot of the active 3D map scene
+      val screenshotBitmap = captureScreenshot("path_following_screenshot.png")
+
+      // Define the verification prompt for the visual testing agent
+      val prompt = """
+                Please act as a UI tester and analyze this screenshot.
+                1. Confirm that a 3D map view is visible.
+                2. Confirm that a BLUE POLYLINE (line) is clearly visible on the map, representing the navigation path.
+                3. Confirm that interactive camera control sliders (Range, Altitude, Heading, Tilt, Speed) and an Urban/Rural selector panel are visible at the bottom of the screen.
+
+                If and ONLY IF you can clearly see the 3D map view with the blue route polyline and bottom control card, reply with "PASSED".
+                If you cannot see the blue route polyline or control panel, reply with "FAILED: Blue path polyline or UI controls not visible".
+                Report what you see in detail.
+            """.trimIndent()
+
+      // Analyze the image using Gemini
+      val geminiResponse = helper.analyzeImage(screenshotBitmap, prompt, geminiApiKey)
+      println("Gemini's analysis: ${'$'}geminiResponse")
+
+      // Assert on Gemini's response
+      assertTrue(
+        "Visual verification failed. Gemini response: ${'$'}geminiResponse",
+        geminiResponse?.contains("PASSED", ignoreCase = true) == true
+      )
+    }
+  }
+}
diff --git a/Maps3DSamples/ApiDemos/kotlin-app/src/androidTest/java/com/example/maps3dkotlin/RoadmapModeVisualTest.kt b/Maps3DSamples/ApiDemos/kotlin-app/src/androidTest/java/com/example/maps3dkotlin/RoadmapModeVisualTest.kt
new file mode 100644
index 00000000..4c026e1b
--- /dev/null
+++ b/Maps3DSamples/ApiDemos/kotlin-app/src/androidTest/java/com/example/maps3dkotlin/RoadmapModeVisualTest.kt
@@ -0,0 +1,82 @@
+/*
+ * 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
+
+import android.content.Intent
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.uiautomator.By
+import androidx.test.uiautomator.Until
+import com.example.maps3dkotlin.roadmapmode.RoadmapModeActivity
+import kotlin.time.Duration.Companion.milliseconds
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.runBlocking
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+
+/**
+ * A premium visual regression test for the View-based Kotlin 3D Roadmap Mode sample.
+ *
+ * This test automates launching the [RoadmapModeActivity], waiting for 3D Vector Roadmap tiles (featuring 3D building
+ * geometry and road network overlays in San Francisco) to initialize and settle, capturing a screenshot of the live
+ * rendering scene, and verifying visual correctness using the Gemini API.
+ */
+@RunWith(AndroidJUnit4::class)
+class RoadmapModeVisualTest : BaseVisualTest() {
+
+  @Test
+  fun verifyRoadmapModeRenders() {
+    runBlocking {
+      // Launch RoadmapModeActivity
+      val intent = Intent(context, RoadmapModeActivity::class.java).apply {
+        addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+      }
+      context.startActivity(intent)
+
+      // Wait for the activity to be displayed in the foreground
+      uiDevice.wait(Until.hasObject(By.pkg(context.packageName).depth(0)), 10000)
+
+      // Wait for map tiles to render and 3D vector buildings/streets to settle
+      waitForMapRendering(15)
+
+      // Capture high-resolution screenshot of the active 3D map scene
+      val screenshotBitmap = captureScreenshot("roadmap_mode_screenshot.png")
+
+      // Define the verification prompt for the visual testing agent
+      val prompt = """
+                Please act as a UI tester and analyze this screenshot.
+                1. Confirm that a 3D map view is visible over San Francisco.
+                2. Confirm that the map is rendered in 3D ROADMAP / VECTOR mode (showing street network layouts, road labels, and/or vector 3D building blocks rather than raw satellite imagery only).
+                3. Confirm that the Map Mode radio selection card (with Roadmap, Hybrid, and Satellite options) is visible at the bottom of the screen.
+
+                If and ONLY IF you can clearly see the 3D Roadmap map scene and bottom Map Mode selection card, reply with "PASSED".
+                If you cannot see the 3D map scene or control card, reply with "FAILED: 3D Roadmap scene or Map Mode controls not visible".
+                Report what you see in detail.
+            """.trimIndent()
+
+      // Analyze the image using Gemini
+      val geminiResponse = helper.analyzeImage(screenshotBitmap, prompt, geminiApiKey)
+      println("Gemini's analysis: ${'$'}geminiResponse")
+
+      // Assert on Gemini's response
+      assertTrue(
+        "Visual verification failed. Gemini response: ${'$'}geminiResponse",
+        geminiResponse?.contains("PASSED", ignoreCase = true) == true
+      )
+    }
+  }
+}
diff --git a/Maps3DSamples/ApiDemos/kotlin-app/src/androidTest/java/com/example/maps3dkotlin/RoutesVisualTest.kt b/Maps3DSamples/ApiDemos/kotlin-app/src/androidTest/java/com/example/maps3dkotlin/RoutesVisualTest.kt
index 532dc90c..3a7a3b95 100644
--- a/Maps3DSamples/ApiDemos/kotlin-app/src/androidTest/java/com/example/maps3dkotlin/RoutesVisualTest.kt
+++ b/Maps3DSamples/ApiDemos/kotlin-app/src/androidTest/java/com/example/maps3dkotlin/RoutesVisualTest.kt
@@ -49,9 +49,8 @@ class RoutesVisualTest : BaseVisualTest() {
             // Wait for the activity to be displayed in the foreground
             uiDevice.wait(Until.hasObject(By.pkg(context.packageName).depth(0)), 10000)
 
-            // Wait 15 seconds for map tiles to load, route coordinates to fetch, and the vehicle model to start animating
-            println("Waiting 15 seconds for map rendering and vehicle animation...")
-            delay(15000)
+            // Wait for map tiles to load, route coordinates to fetch, and the vehicle model to start animating
+            waitForMapRendering(15)
 
             // Capture high-resolution screenshot of the active 3D map scene
             val screenshotBitmap = captureScreenshot("routes_screenshot.png")
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 25ea9e9e..c1ef67fe 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
@@ -16,14 +16,539 @@
 
 package com.example.maps3dkotlin.advancedcameraanimation
 
+import android.os.Bundle
+import android.view.ViewGroup
+import android.widget.Button
+import android.widget.RadioGroup
+import androidx.lifecycle.lifecycleScope
+import com.example.maps3d.common.RouteEngine
 import com.example.maps3dcommon.R
-import com.example.maps3dkotlin.common.BaseSkeletonActivity
+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.AltitudeMode
+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.Model
+import com.google.android.gms.maps3d.model.ModelOptions
+import com.google.android.gms.maps3d.model.Orientation
+import com.google.android.gms.maps3d.model.Vector3D
+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.maps.android.SphericalUtil
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.isActive
+import kotlinx.coroutines.launch
+import kotlin.time.Duration.Companion.milliseconds
 
-/**
- * Skeleton activity for AdvancedCameraAnimationActivity.
- */
-class AdvancedCameraAnimationActivity : BaseSkeletonActivity() {
-    override fun getTitleResId(): Int {
-        return R.string.feature_title_advanced_camera_animation
+enum class AnimationApproach {
+    SIMPLE_FLY_TO,
+    KEYFRAME_TOUR,
+    DISPATCHER_FRAME_LOOP,
+    ORBIT_360_SPIN
+}
+
+sealed interface CameraKeyframe {
+    val stepTitle: String
+    val stepDescription: String
+
+    data class FlyTo(
+        override val stepTitle: String,
+        override val stepDescription: String,
+        val targetCenter: LatLng,
+        val targetAltitude: Double,
+        val targetHeading: Double,
+        val targetTilt: Double,
+        val targetRange: Double,
+        val durationMs: Long = 2500L
+    ) : CameraKeyframe
+
+    data class DwellPause(
+        override val stepTitle: String,
+        override val stepDescription: String,
+        val durationMs: Long = 1500L
+    ) : CameraKeyframe
+
+    data class OrbitAround(
+        override val stepTitle: String,
+        override val stepDescription: String,
+        val center: LatLng,
+        val altitude: Double,
+        val range: Double,
+        val tilt: Double,
+        val startHeading: Double,
+        val endHeading: Double,
+        val durationMs: Long = 4000L
+    ) : CameraKeyframe
+}
+
+class AdvancedCameraAnimationActivity : SampleBaseActivity() {
+
+    override val TAG = "AdvancedCameraAnimation"
+
+    override val initialCamera: Camera
+        get() {
+            val firstLoc = AIRPLANE_FLIGHT_PATH.first()
+            val initialHeading = SphericalUtil.computeHeading(firstLoc, AIRPLANE_FLIGHT_PATH[1])
+            return camera {
+                center = latLngAltitude {
+                    latitude = firstLoc.latitude
+                    longitude = firstLoc.longitude
+                    altitude = 200.0
+                }
+                heading = normalizeHeading(initialHeading)
+                tilt = 65.0
+                range = 600.0
+            }
+        }
+
+    private var airplaneModel: Model? = null
+    private var currentStepIndex = 0
+    private var isPlaying = false
+    private var tourJob: Job? = null
+    private var restartJob: Job? = null
+    private var selectedApproach = AnimationApproach.DISPATCHER_FRAME_LOOP
+
+    private var btnPlayPause: Button? = null
+
+    private val cumulativeDistances by lazy {
+        RouteEngine.calculateCumulativeDistances(AIRPLANE_FLIGHT_PATH)
+    }
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+
+        // Inflate control panel overlay into the map container managed by SampleBaseActivity
+        findViewById<ViewGroup>(R.id.map_container)?.let { container ->
+            layoutInflater.inflate(R.layout.control_panel_advanced_animation, container, true)
+        }
+
+        findViewById<MaterialToolbar>(R.id.top_bar)?.apply {
+            title = "Advanced Camera Animation"
+            setNavigationOnClickListener { finish() }
+        }
+
+        findViewById<RadioGroup>(R.id.rg_approach)?.setOnCheckedChangeListener { _, checkedId ->
+            selectedApproach = when (checkedId) {
+                R.id.rb_simple_flyto -> AnimationApproach.SIMPLE_FLY_TO
+                R.id.rb_keyframe_tour -> AnimationApproach.KEYFRAME_TOUR
+                R.id.rb_orbit_spin -> AnimationApproach.ORBIT_360_SPIN
+                else -> AnimationApproach.DISPATCHER_FRAME_LOOP
+            }
+            resetAndRestartTour()
+        }
+
+        findViewById<Button>(R.id.btn_reset)?.setOnClickListener {
+            resetAndRestartTour()
+        }
+
+        btnPlayPause = findViewById(R.id.btn_play_pause)
+        btnPlayPause?.setOnClickListener {
+            if (isPlaying) {
+                stopTour()
+            } else {
+                startSelectedApproach()
+            }
+        }
+    }
+
+    private fun updatePlayPauseButtonState() {
+        btnPlayPause?.text = if (isPlaying) "Pause" else "Play"
+    }
+
+    override fun onMap3DViewReady(googleMap3D: GoogleMap3D) {
+        super.onMap3DViewReady(googleMap3D)
+
+        // Instantiate 3D Airplane Model on map at initial start position
+        val startLoc = AIRPLANE_FLIGHT_PATH.first()
+        val initialHeading = SphericalUtil.computeHeading(startLoc, AIRPLANE_FLIGHT_PATH[1])
+        updateAirplaneModel(startLoc, initialHeading + 180.0)
+
+        // Auto-start smooth flight animation after 1 second delay
+        restartJob = lifecycleScope.launch {
+            delay(1000L.milliseconds)
+            startSelectedApproach()
+        }
+    }
+
+    /**
+     * Updates the 3D Airplane Model's position and orientation on the map.
+     * Note: Calling `map.addModel(opts)` continuously with the same `id` string
+     * is the recommended approach for dynamically updating a model's location.
+     *
+     * Remote URLs: Models should be hosted and loaded via external URL.
+     */
+    private fun updateAirplaneModel(targetLatLng: LatLng, planeHeadingDeg: Double) {
+        googleMap3D?.let { map ->
+            val opts = ModelOptions().apply {
+                id = MODEL_ID
+                position = LatLngAltitude(targetLatLng.latitude, targetLatLng.longitude, 200.0)
+                altitudeMode = AltitudeMode.ABSOLUTE
+                orientation = Orientation(normalizeHeading(planeHeadingDeg), -90.0, 0.0)
+                url = PLANE_URL
+                scale = Vector3D(0.08, 0.08, 0.08)
+            }
+            airplaneModel = map.addModel(opts)
+        }
+    }
+
+    private fun startSelectedApproach() {
+        stopTour()
+        when (selectedApproach) {
+            AnimationApproach.SIMPLE_FLY_TO -> runSimpleFlyTo()
+            AnimationApproach.KEYFRAME_TOUR -> startOrResumeTour()
+            AnimationApproach.DISPATCHER_FRAME_LOOP -> runFrameDispatcherLoop()
+            AnimationApproach.ORBIT_360_SPIN -> run360OrbitSpin()
+        }
+    }
+
+    private fun runSimpleFlyTo() {
+        stopTour()
+        isPlaying = true
+        updatePlayPauseButtonState()
+
+        val targetLoc = AIRPLANE_FLIGHT_PATH.last()
+        val flightHeading = SphericalUtil.computeHeading(AIRPLANE_FLIGHT_PATH[AIRPLANE_FLIGHT_PATH.size - 2], targetLoc)
+        updateAirplaneModel(targetLoc, flightHeading + 180.0)
+
+        val targetCam = camera {
+            center = latLngAltitude {
+                latitude = targetLoc.latitude
+                longitude = targetLoc.longitude
+                altitude = 200.0
+            }
+            heading = normalizeHeading(flightHeading)
+            tilt = 65.0
+            range = 600.0
+        }
+        googleMap3D?.flyCameraTo(FlyToOptions(targetCam, 1500L))
+        isPlaying = false
+        updatePlayPauseButtonState()
+    }
+
+    /**
+     * Executes multi-step keyframe queue tour smoothly stage by stage.
+     */
+    private fun startOrResumeTour() {
+        stopTour()
+        isPlaying = true
+        updatePlayPauseButtonState()
+        currentStepIndex = 0
+
+        tourJob = lifecycleScope.launch(Dispatchers.Main) {
+            val frameDurationMs = 16L
+
+            while (currentStepIndex < SAN_FRANCISCO_TOUR.size && isActive && isPlaying) {
+                val step = SAN_FRANCISCO_TOUR[currentStepIndex]
+
+                when (step) {
+                    is CameraKeyframe.FlyTo -> {
+                        val targetCam = camera {
+                            center = latLngAltitude {
+                                latitude = step.targetCenter.latitude
+                                longitude = step.targetCenter.longitude
+                                altitude = step.targetAltitude
+                            }
+                            heading = normalizeHeading(step.targetHeading)
+                            tilt = step.targetTilt
+                            range = step.targetRange
+                        }
+                        updateAirplaneModel(step.targetCenter, step.targetHeading + 180.0)
+                        googleMap3D?.flyCameraTo(FlyToOptions(targetCam, step.durationMs))
+                        delay(step.durationMs.milliseconds)
+                    }
+
+                    is CameraKeyframe.DwellPause -> {
+                        delay(step.durationMs.milliseconds)
+                    }
+
+                    is CameraKeyframe.OrbitAround -> {
+                        val totalFrames = (step.durationMs / frameDurationMs).coerceAtLeast(1)
+                        for (frame in 0..totalFrames) {
+                            if (!isActive || !isPlaying) break
+                            val t = frame.toDouble() / totalFrames
+                            val orbitHeading = interpolateAngle(step.startHeading, step.endHeading, t)
+
+                            val updatedCam = camera {
+                                center = latLngAltitude {
+                                    latitude = step.center.latitude
+                                    longitude = step.center.longitude
+                                    altitude = step.altitude
+                                }
+                                heading = normalizeHeading(orbitHeading)
+                                tilt = step.tilt
+                                range = step.range
+                            }
+
+                            updateAirplaneModel(step.center, orbitHeading + 180.0)
+                            googleMap3D?.setCamera(updatedCam)
+                            delay(frameDurationMs.milliseconds)
+                        }
+                    }
+                }
+
+                if (!isActive || !isPlaying) break
+
+                if (currentStepIndex < SAN_FRANCISCO_TOUR.size - 1) {
+                    currentStepIndex++
+                } else {
+                    isPlaying = false
+                    updatePlayPauseButtonState()
+                    break
+                }
+            }
+        }
+    }
+
+    /**
+     * Frame Dispatcher Animation Loop.
+     * High-speed flight animation (400 m/s) stopping cleanly at destination.
+     * 
+     * For the most visually uniform cinematic sweeping motion, we recommend using
+     * `Choreographer.FrameCallback` to sync our delta-time interpolation directly 
+     * to the hardware display frames.
+     */
+    private fun runFrameDispatcherLoop() {
+        stopTour()
+        isPlaying = true
+        updatePlayPauseButtonState()
+
+        val totalDistance = cumulativeDistances.last().coerceAtLeast(1.0)
+        val flightSpeedMps = 400.0 // Fast 400 m/s high-speed flight
+
+        val frameCallback = object : android.view.Choreographer.FrameCallback {
+            private var lastTimeNanos = 0L
+            private var elapsedDistance = 0.0
+
+            override fun doFrame(frameTimeNanos: Long) {
+                if (!isPlaying) return
+
+                if (lastTimeNanos == 0L) {
+                    lastTimeNanos = frameTimeNanos
+                    android.view.Choreographer.getInstance().postFrameCallback(this)
+                    return
+                }
+
+                val dt = (frameTimeNanos - lastTimeNanos) / 1_000_000_000.0
+                lastTimeNanos = frameTimeNanos
+
+                elapsedDistance += flightSpeedMps * dt
+
+                if (elapsedDistance >= totalDistance) {
+                    elapsedDistance = totalDistance
+                    val posAndHeading = RouteEngine.calculatePositionAndHeading(
+                        AIRPLANE_FLIGHT_PATH,
+                        cumulativeDistances,
+                        elapsedDistance,
+                        30.0
+                    )
+                    val planeHeading = posAndHeading.heading.toDouble() + 180.0
+                    updateAirplaneModel(posAndHeading.position, planeHeading)
+
+                    val finalCam = camera {
+                        center = latLngAltitude {
+                            latitude = posAndHeading.position.latitude
+                            longitude = posAndHeading.position.longitude
+                            altitude = 200.0
+                        }
+                        heading = normalizeHeading(posAndHeading.heading.toDouble())
+                        tilt = 65.0
+                        range = 600.0
+                    }
+                    googleMap3D?.setCamera(finalCam)
+                    isPlaying = false
+                    updatePlayPauseButtonState()
+                    return
+                }
+
+                val posAndHeading = RouteEngine.calculatePositionAndHeading(
+                    AIRPLANE_FLIGHT_PATH,
+                    cumulativeDistances,
+                    elapsedDistance,
+                    30.0
+                )
+
+                val planeHeading = posAndHeading.heading.toDouble() + 180.0
+                updateAirplaneModel(posAndHeading.position, planeHeading)
+
+                val updatedCam = camera {
+                    center = latLngAltitude {
+                        latitude = posAndHeading.position.latitude
+                        longitude = posAndHeading.position.longitude
+                        altitude = 200.0
+                    }
+                    heading = normalizeHeading(posAndHeading.heading.toDouble())
+                    tilt = 65.0
+                    range = 600.0
+                }
+                googleMap3D?.setCamera(updatedCam)
+
+                android.view.Choreographer.getInstance().postFrameCallback(this)
+            }
+        }
+        android.view.Choreographer.getInstance().postFrameCallback(frameCallback)
+    }
+
+    /**
+     * Option 4: Continuous 360-degree orbital camera spin around landmark.
+     */
+    private fun run360OrbitSpin() {
+        stopTour()
+        isPlaying = true
+        updatePlayPauseButtonState()
+
+        val targetCenter = AIRPLANE_FLIGHT_PATH.first()
+        updateAirplaneModel(targetCenter, 105.0 + 180.0)
+
+        tourJob = lifecycleScope.launch(Dispatchers.Main) {
+            val frameDurationMs = 16L
+            val totalMs = 6000L // 6 second smooth 360° spin
+            val totalFrames = (totalMs / frameDurationMs).coerceAtLeast(1)
+            val startHeading = 105.0
+
+            for (frame in 0..totalFrames) {
+                if (!isActive || !isPlaying) break
+                val t = frame.toDouble() / totalFrames
+                val headingDeg = (startHeading + t * 360.0) % 360.0
+
+                val currentCam = camera {
+                    center = latLngAltitude {
+                        latitude = targetCenter.latitude
+                        longitude = targetCenter.longitude
+                        altitude = 200.0
+                    }
+                    heading = normalizeHeading(headingDeg)
+                    tilt = 65.0
+                    range = 600.0
+                }
+                googleMap3D?.setCamera(currentCam)
+                delay(frameDurationMs.milliseconds)
+            }
+            isPlaying = false
+            updatePlayPauseButtonState()
+        }
+    }
+
+    private fun stopTour() {
+        isPlaying = false
+        updatePlayPauseButtonState()
+        restartJob?.cancel()
+        restartJob = null
+        tourJob?.cancel()
+        tourJob = null
+        googleMap3D?.stopCameraAnimation()
+    }
+
+    /**
+     * Resets the camera and airplane model to the initial start location and restarts animation.
+     */
+    fun resetAndRestartTour() {
+        stopTour()
+        currentStepIndex = 0
+
+        val startLoc = AIRPLANE_FLIGHT_PATH.first()
+        val initialHeading = SphericalUtil.computeHeading(startLoc, AIRPLANE_FLIGHT_PATH[1])
+        updateAirplaneModel(startLoc, initialHeading + 180.0)
+
+        val resetCam = camera {
+            center = latLngAltitude {
+                latitude = startLoc.latitude
+                longitude = startLoc.longitude
+                altitude = 200.0
+            }
+            heading = normalizeHeading(initialHeading)
+            tilt = 65.0
+            range = 600.0
+        }
+        googleMap3D?.setCamera(resetCam)
+
+        restartJob = lifecycleScope.launch {
+            delay(300.milliseconds)
+            startSelectedApproach()
+        }
+    }
+
+    override fun onPause() {
+        super.onPause()
+        stopTour()
+    }
+
+    companion object {
+        private const val MODEL_ID = "airplane_model"
+        private const val PLANE_URL = "https://storage.googleapis.com/gmp-maps-demos/p3d-map/assets/Airplane.glb"
+
+        val SAN_FRANCISCO_TOUR = listOf(
+            CameraKeyframe.FlyTo(
+                stepTitle = "1. Golden Gate Bridge Flight",
+                stepDescription = "3D Airplane flight over Golden Gate Bridge",
+                targetCenter = LatLng(37.8199, -122.4783),
+                targetAltitude = 200.0,
+                targetHeading = 105.0,
+                targetTilt = 65.0,
+                targetRange = 600.0,
+                durationMs = 2500L
+            ),
+            CameraKeyframe.DwellPause(
+                stepTitle = "2. Mid-Air Observation",
+                stepDescription = "Dwell pause observing 3D airplane over Golden Gate",
+                durationMs = 1500L
+            ),
+            CameraKeyframe.OrbitAround(
+                stepTitle = "3. Golden Gate 360° Orbit",
+                stepDescription = "360° orbital camera spin around flying airplane",
+                center = LatLng(37.8199, -122.4783),
+                altitude = 200.0,
+                range = 600.0,
+                tilt = 65.0,
+                startHeading = 105.0,
+                endHeading = 465.0,
+                durationMs = 4000L
+            ),
+            CameraKeyframe.FlyTo(
+                stepTitle = "4. Transit to Coit Tower",
+                stepDescription = "Airplane flight to Coit Tower Landmark",
+                targetCenter = LatLng(37.8024, -122.4058),
+                targetAltitude = 200.0,
+                targetHeading = 105.0,
+                targetTilt = 65.0,
+                targetRange = 600.0,
+                durationMs = 3000L
+            )
+        )
+
+        // 15 Fine-Grained Waypoints on the direct route from Golden Gate Bridge to Coit Tower
+        val AIRPLANE_FLIGHT_PATH = listOf(
+            LatLng(37.8199, -122.4783), // 1. Golden Gate Bridge (Source)
+            LatLng(37.8188, -122.4735), // 2. Fort Point / Presidio Overlook
+            LatLng(37.8175, -122.4685), // 3. Crissy Field West
+            LatLng(37.8160, -122.4635), // 4. Crissy Field East
+            LatLng(37.8145, -122.4585), // 5. Marina Green West
+            LatLng(37.8130, -122.4530), // 6. Marina District Center
+            LatLng(37.8115, -122.4475), // 7. Fort Mason West
+            LatLng(37.8100, -122.4420), // 8. Fort Mason Heights
+            LatLng(37.8085, -122.4365), // 9. Aquatic Park Cove
+            LatLng(37.8070, -122.4310), // 10. Fisherman's Wharf West
+            LatLng(37.8058, -122.4250), // 11. Fisherman's Wharf Center
+            LatLng(37.8048, -122.4195), // 12. Pier 39 Promenade
+            LatLng(37.8038, -122.4140), // 13. Embarcadero North
+            LatLng(37.8030, -122.4090), // 14. Telegraph Hill Slopes
+            LatLng(37.8024, -122.4058)  // 15. Coit Tower (Destination)
+        )
+
+        private fun normalizeHeading(headingDeg: Double): Double {
+            val normalized = headingDeg % 360.0
+            return if (normalized < 0.0) normalized + 360.0 else normalized
+        }
+
+        private fun interpolateAngle(start: Double, end: Double, fraction: Double): Double {
+            var diff = (end - start) % 360.0
+            if (diff > 180.0) diff -= 360.0
+            if (diff < -180.0) diff += 360.0
+            return (start + diff * fraction + 360.0) % 360.0
+        }
     }
 }
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 02c9de6c..168e7900 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
@@ -1,5 +1,5 @@
 /*
- * Copyright 2025 Google LLC
+ * 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.
@@ -16,14 +16,240 @@
 
 package com.example.maps3dkotlin.datavisualization
 
+import android.graphics.Color
+import android.os.Bundle
+import android.view.ViewGroup
+import android.widget.Button
+import android.widget.TextView
+import android.widget.Toast
+import androidx.lifecycle.lifecycleScope
+import com.example.maps3d.common.toValidCamera
 import com.example.maps3dcommon.R
-import com.example.maps3dkotlin.common.BaseSkeletonActivity
+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.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
+import com.google.android.gms.maps3d.model.latLngAltitude
+import com.google.android.gms.maps3d.model.polygonOptions
+import com.google.android.material.appbar.MaterialToolbar
+import com.google.android.material.slider.Slider
+import kotlin.time.Duration.Companion.milliseconds
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.isActive
+import kotlinx.coroutines.launch
 
 /**
- * Skeleton activity for DataVisualizationActivity.
+ * Showcases dynamic 3D volume extrusion in Google Maps 3D SDK by simulating elevated flood tides.
  */
-class DataVisualizationActivity : BaseSkeletonActivity() {
-    override fun getTitleResId(): Int {
-        return R.string.feature_title_data_visualization
+class DataVisualizationActivity : SampleBaseActivity() {
+
+  override val TAG = "DataVisualizationActivity"
+
+  override val initialCamera: Camera = camera {
+    center = latLngAltitude {
+      latitude = SF_FLOOD_CENTER.latitude
+      longitude = SF_FLOOD_CENTER.longitude
+      altitude = 120.0
+    }
+    heading = 35.0
+    tilt = 64.0
+    range = 1200.0
+  }.toValidCamera()
+
+  private lateinit var floodDepthLabel: TextView
+  private lateinit var floodRiskBadge: TextView
+  private lateinit var floodSlider: Slider
+  private lateinit var btnAnimateFlood: Button
+
+  private var floodPolygon: Polygon? = null
+  private var currentFloodElevation = 10.0
+  private var simulationJob: Job? = null
+
+  private val waterFillColor = Color.argb(140, 230, 40, 40)
+  private val waterStrokeColor = Color.argb(255, 180, 0, 0)
+  private val waterStrokeWidth = 2.5
+
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+
+    findViewById<ViewGroup>(R.id.map_container)?.let { container ->
+      layoutInflater.inflate(R.layout.control_panel_data_visualization, container, true)
+    }
+
+    findViewById<MaterialToolbar>(R.id.top_bar)?.apply {
+      title = getString(R.string.feature_title_data_visualization)
+      setNavigationOnClickListener { finish() }
+    }
+
+    floodDepthLabel = findViewById(R.id.tv_flood_depth_label)
+    floodRiskBadge = findViewById(R.id.tv_flood_risk_badge)
+    floodSlider = findViewById(R.id.flood_slider)
+    btnAnimateFlood = findViewById(R.id.btn_animate_flood)
+
+    floodSlider.addOnChangeListener { _, value, fromUser ->
+      if (fromUser) {
+        stopSimulation()
+      }
+      updateFloodElevation(value.toDouble())
+    }
+
+    btnAnimateFlood.setOnClickListener {
+      if (simulationJob != null) {
+        stopSimulation()
+      } else {
+        startSimulation()
+      }
+    }
+  }
+
+  override fun onMapReady(googleMap3D: GoogleMap3D) {
+    super.onMapReady(googleMap3D)
+    googleMap3D.setMapMode(Map3DMode.HYBRID)
+    googleMap3D.flyCameraTo(
+      flyToOptions {
+        endCamera = initialCamera
+        durationInMillis = 1200
+      }
+    )
+    lifecycleScope.launch(Dispatchers.Main) {
+      updateFloodElevation(currentFloodElevation)
+    }
+  }
+
+  fun updateFloodElevation(currentFloodHeightMeters: Double) {
+    currentFloodElevation = currentFloodHeightMeters
+
+    runOnUiThread {
+      val feet = currentFloodHeightMeters * 3.28084
+      floodDepthLabel.text =
+        String.format("Flood Elevation: +%.1f m (%.1f ft)", currentFloodHeightMeters, feet)
+
+      when {
+        currentFloodHeightMeters <= 2.0 -> {
+          floodRiskBadge.text = "🌊 Baseline Tide"
+          floodRiskBadge.setTextColor(Color.parseColor("#008800"))
+          floodRiskBadge.setBackgroundColor(Color.parseColor("#2000AA00"))
+        }
+
+        currentFloodHeightMeters <= 8.0 -> {
+          floodRiskBadge.text = "⚠️ Minor Inundation"
+          floodRiskBadge.setTextColor(Color.parseColor("#BB7700"))
+          floodRiskBadge.setBackgroundColor(Color.parseColor("#20FFAA00"))
+        }
+
+        currentFloodHeightMeters <= 20.0 -> {
+          floodRiskBadge.text = "🌊 Moderate Flooding"
+          floodRiskBadge.setTextColor(Color.parseColor("#0077CC"))
+          floodRiskBadge.setBackgroundColor(Color.parseColor("#200088FF"))
+        }
+
+        currentFloodHeightMeters <= 35.0 -> {
+          floodRiskBadge.text = "🚨 Storm Surge (Cat 3)"
+          floodRiskBadge.setTextColor(Color.parseColor("#DD4400"))
+          floodRiskBadge.setBackgroundColor(Color.parseColor("#25FF5500"))
+        }
+
+        else -> {
+          floodRiskBadge.text = "⛔ Extreme Inundation"
+          floodRiskBadge.setTextColor(Color.parseColor("#CC0000"))
+          floodRiskBadge.setBackgroundColor(Color.parseColor("#25FF0000"))
+        }
+      }
+
+      val map = googleMap3D ?: return@runOnUiThread
+
+      val path: List<LatLngAltitude> = floodZoneCoords.map { coord ->
+        latLngAltitude {
+          latitude = coord.first
+          longitude = coord.second
+          altitude = currentFloodHeightMeters
+        }
+      }
+
+      val options = polygonOptions {
+        id = POLYGON_ID
+        this.path = path
+        fillColor = waterFillColor
+        strokeColor = waterStrokeColor
+        strokeWidth = waterStrokeWidth
+        altitudeMode = AltitudeMode.ABSOLUTE
+        extruded = true
+        drawsOccludedSegments = true
+        geodesic = false
+      }
+
+      floodPolygon = map.addPolygon(options)?.apply {
+        setClickListener {
+          runOnUiThread {
+            Toast.makeText(
+              this@DataVisualizationActivity,
+              String.format(
+                "San Francisco Waterfront - Water Level: +%.1f m",
+                currentFloodElevation
+              ),
+              Toast.LENGTH_SHORT
+            ).show()
+          }
+        }
+      }
     }
+  }
+
+  private fun startSimulation() {
+    val maxVal = floodSlider.valueTo.toDouble()
+    val minVal = floodSlider.valueFrom.toDouble()
+    if (currentFloodElevation >= maxVal) {
+      floodSlider.value = minVal.toFloat()
+      updateFloodElevation(minVal)
+    }
+
+    btnAnimateFlood.text = "⏹ Stop Simulation"
+    simulationJob = lifecycleScope.launch {
+      while (isActive) {
+        val currentMax = floodSlider.valueTo.toDouble()
+        var newElevation = currentFloodElevation + 0.2
+        newElevation = Math.round(newElevation * 10.0) / 10.0
+        floodSlider.value = newElevation.toFloat()
+        if (newElevation >= currentMax) {
+          stopSimulation()
+          break
+        }
+        delay(20.milliseconds)
+      }
+    }
+  }
+
+  private fun stopSimulation() {
+    simulationJob?.cancel()
+    simulationJob = null
+    btnAnimateFlood.text = "▶ Start Simulation"
+  }
+
+  override fun onDestroy() {
+    stopSimulation()
+    super.onDestroy()
+  }
+
+  companion object {
+    private const val POLYGON_ID = "flood_zone_polygon"
+
+    val SF_FLOOD_CENTER = LatLng(37.8025, -122.4030)
+
+    val floodZoneCoords = listOf(
+      Pair(37.805156, -122.403256),
+      Pair(37.803370, -122.401287),
+      Pair(37.799222, -122.405080),
+      Pair(37.797500, -122.408000),
+      Pair(37.801000, -122.411000),
+      Pair(37.805156, -122.403256)
+    )
+  }
 }
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 a22a1671..4b1c4268 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
@@ -16,14 +16,135 @@
 
 package com.example.maps3dkotlin.fieldofview
 
+import android.os.Bundle
+import android.view.ViewGroup
+import android.widget.Button
+import android.widget.TextView
+import androidx.lifecycle.lifecycleScope
+import com.example.maps3d.common.toValidCamera
 import com.example.maps3dcommon.R
-import com.example.maps3dkotlin.common.BaseSkeletonActivity
+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.camera
+import com.google.android.gms.maps3d.model.latLngAltitude
+import com.google.android.material.appbar.MaterialToolbar
+import com.google.android.material.slider.Slider
+import kotlin.math.tan
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
 
 /**
- * Skeleton activity for FieldOfViewActivity.
+ * Showcases Field of View (FOV) perspective scaling in Google Maps 3D SDK.
+ *
+ * Features:
+ * - Dynamic camera Field of View (FOV) perspective slider (15° to 120°).
+ * - Instant FOV preset buttons (20° Telephoto, 45° Standard, 90° Wide, 120° Ultra-Wide).
+ * - Safe camera validation preventing out-of-range heading/tilt crash during manual map rotation.
  */
-class FieldOfViewActivity : BaseSkeletonActivity() {
-    override fun getTitleResId(): Int {
-        return R.string.feature_title_field_of_view
+class FieldOfViewActivity : SampleBaseActivity() {
+
+  override val TAG = "FieldOfViewActivity"
+
+  override val initialCamera: Camera
+    get() = camera {
+      center = latLngAltitude {
+        latitude = SF_FINANCIAL_DISTRICT.latitude
+        longitude = SF_FINANCIAL_DISTRICT.longitude
+        altitude = 150.0
+      }
+      heading = 45.0
+      tilt = 65.0
+      range = 800.0
+    }.toValidCamera()
+
+  private lateinit var fovSliderLabel: TextView
+  private lateinit var fovSlider: Slider
+
+  private var currentFov = 45.0
+
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+
+    // Inflate FOV control panel overlay into map container managed by SampleBaseActivity
+    findViewById<ViewGroup>(R.id.map_container)?.let { container ->
+      layoutInflater.inflate(R.layout.control_panel_field_of_view, container, true)
+    }
+
+    findViewById<MaterialToolbar>(R.id.top_bar)?.apply {
+      title = "Field of View (FOV)"
+      setNavigationOnClickListener { finish() }
+    }
+
+    fovSliderLabel = findViewById(R.id.fov_slider_label)
+    fovSlider = findViewById(R.id.fov_slider)
+
+    fovSlider.addOnChangeListener { _, value, _ ->
+      updateFov(value.toDouble())
+    }
+
+    findViewById<Button>(R.id.btn_fov_telephoto)?.setOnClickListener {
+      fovSlider.value = 20.0f
+    }
+
+    findViewById<Button>(R.id.btn_fov_standard)?.setOnClickListener {
+      fovSlider.value = 45.0f
+    }
+
+    findViewById<Button>(R.id.btn_fov_wide)?.setOnClickListener {
+      fovSlider.value = 90.0f
+    }
+
+    findViewById<Button>(R.id.btn_fov_ultrawide)?.setOnClickListener {
+      fovSlider.value = 120.0f
+    }
+  }
+
+  override fun onMapReady(googleMap3D: GoogleMap3D) {
+    super.onMapReady(googleMap3D)
+    lifecycleScope.launch(Dispatchers.Main) {
+      updateFov(currentFov)
     }
+  }
+
+  private fun updateFov(fovAngle: Double) {
+    currentFov = fovAngle
+    runOnUiThread {
+      fovSliderLabel.text = "Field of View: ${fovAngle.toInt()}°"
+    }
+
+    googleMap3D?.let { map ->
+      val liveCam = map.getCamera()?.toValidCamera()
+      val currCam =
+        if (liveCam != null && (kotlin.math.abs(liveCam.center.latitude) > 0.001 || kotlin.math.abs(
+            liveCam.center.longitude
+          ) > 0.001)
+        ) {
+          liveCam
+        } else {
+          initialCamera
+        }
+
+      // Deterministic optical dolly zoom perspective range (baseline 800m at 45° FOV)
+      val baseFovRad = Math.toRadians(45.0 / 2.0)
+      val targetFovRad = Math.toRadians(fovAngle / 2.0)
+      val targetRange = (800.0 * tan(baseFovRad) / tan(targetFovRad)).coerceIn(150.0, 3000.0)
+
+      val updatedCam = camera {
+        center = currCam.center
+        heading = currCam.heading
+        tilt = currCam.tilt
+        roll = currCam.roll
+        range = targetRange
+      }.toValidCamera()
+
+      map.setCamera(updatedCam)
+    }
+  }
+
+  companion object {
+    // San Francisco Financial District / Transamerica Pyramid area
+    val SF_FINANCIAL_DISTRICT = LatLng(37.7952, -122.4028)
+  }
 }
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 4e8984d0..cd179998 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
@@ -96,7 +96,7 @@ class HelloMapActivity : Activity(), OnMap3DViewReadyCallback {
             initializeMap()
         }
 
-        // Workaround for bug where onMapReady is not called on reused instances.
+        // Ensure onMapReady triggers even on delayed or reused fragments.
         // Call initialization after a short delay.
         android.os.Handler(android.os.Looper.getMainLooper()).postDelayed({
             initializeMap()
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 f46591e5..957d0921 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
@@ -1,5 +1,5 @@
 /*
- * Copyright 2025 Google LLC
+ * 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.
@@ -16,14 +16,434 @@
 
 package com.example.maps3dkotlin.pathfollowing
 
+import android.graphics.Color
+import android.os.Bundle
+import android.widget.RadioGroup
+import android.widget.TextView
+import androidx.appcompat.app.AppCompatActivity
+import androidx.core.view.WindowCompat
+import androidx.lifecycle.lifecycleScope
+import com.example.maps3d.common.toHeading
 import com.example.maps3dcommon.R
-import com.example.maps3dkotlin.common.BaseSkeletonActivity
+import com.google.android.gms.maps.model.LatLng
+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.AltitudeMode
+import com.google.android.gms.maps3d.model.Polyline
+import com.google.android.gms.maps3d.model.camera
+import com.google.android.gms.maps3d.model.latLngAltitude
+import com.google.android.gms.maps3d.model.polylineOptions
+import com.google.android.material.button.MaterialButton
+import com.google.android.material.slider.Slider
+import com.google.maps.android.SphericalUtil
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import android.view.Choreographer
+import android.view.MotionEvent
+import androidx.cardview.widget.CardView
 
 /**
- * Skeleton activity for PathFollowingActivity.
+ * Advanced sample demonstrating ground-level path following in Kotlin.
+ *
+ * Features:
+ * - Urban vs Rural ground-level paths
+ * - Real-time camera controls via sliders: Range, Ground Altitude, Heading Offset, Tilt, Follow Speed
+ * - Smooth frame-by-frame animation along the route
  */
-class PathFollowingActivity : BaseSkeletonActivity() {
-    override fun getTitleResId(): Int {
-        return R.string.feature_title_path_following
+class PathFollowingActivity : AppCompatActivity(), OnMap3DViewReadyCallback {
+
+  private lateinit var map3DView: Map3DView
+  private var googleMap3D: GoogleMap3D? = null
+
+  // View Bindings
+  private lateinit var rgEnvironment: RadioGroup
+  private lateinit var btnPlayPause: MaterialButton
+  private lateinit var progressSlider: Slider
+  private lateinit var rangeSlider: Slider
+  private lateinit var rangeSliderLabel: TextView
+  private lateinit var altitudeSlider: Slider
+  private lateinit var altitudeSliderLabel: TextView
+  private lateinit var headingSlider: Slider
+  private lateinit var headingSliderLabel: TextView
+  private lateinit var tiltSlider: Slider
+  private lateinit var tiltSliderLabel: TextView
+  private lateinit var speedSlider: Slider
+  private lateinit var speedSliderLabel: TextView
+
+  private var controlsCard: CardView? = null
+  private var fadeOutJob: Job? = null
+
+  override fun dispatchTouchEvent(ev: MotionEvent): Boolean {
+    if (ev.action == MotionEvent.ACTION_DOWN || ev.action == MotionEvent.ACTION_MOVE) {
+      controlsCard?.let { card ->
+        card.animate().alpha(1.0f).setDuration(150).start()
+        fadeOutJob?.cancel()
+        fadeOutJob = lifecycleScope.launch {
+          delay(3000L)
+          card.animate().alpha(0.2f).setDuration(500).start()
+        }
+      }
+    }
+    return super.dispatchTouchEvent(ev)
+  }
+
+
+  // Control parameters
+  private var cameraRange = 300.0
+  private var groundAltitude = 20.0
+  private var headingOffset = 0.0
+  private var cameraTilt = 70.0
+  private var followSpeedMps = 30.0
+
+  // Path state
+  private var currentPath: List<LatLng> = URBAN_PATH
+  private var cumulativeDistances: DoubleArray = doubleArrayOf()
+  private var totalDistance: Double = 0.0
+  private var elapsedDistance: Double = 0.0
+  private var isPlaying = false
+  private var isUserScrubbing = false
+
+  private var pathPolyline: Polyline? = null
+  private var animationJob: Job? = null
+
+  override fun onCreate(savedInstanceState: Bundle?) {
+    WindowCompat.setDecorFitsSystemWindows(window, false)
+    super.onCreate(savedInstanceState)
+    setContentView(R.layout.activity_path_following)
+
+    map3DView = findViewById(R.id.map3dView)
+    map3DView.onCreate(savedInstanceState)
+    map3DView.getMap3DViewAsync(this)
+
+    initViews()
+    loadPathData(URBAN_PATH)
+  }
+
+  override fun onResume() {
+    super.onResume()
+    map3DView.onResume()
+  }
+
+  override fun onPause() {
+    super.onPause()
+    map3DView.onPause()
+    pauseAnimation()
+  }
+
+  override fun onDestroy() {
+    super.onDestroy()
+    pauseAnimation()
+    pathPolyline?.remove()
+    pathPolyline = null
+    map3DView.onDestroy()
+  }
+
+  override fun onLowMemory() {
+    super.onLowMemory()
+    map3DView.onLowMemory()
+  }
+
+  override fun onSaveInstanceState(outState: Bundle) {
+    super.onSaveInstanceState(outState)
+    map3DView.onSaveInstanceState(outState)
+  }
+
+  override fun onMap3DViewReady(googleMap3D: GoogleMap3D) {
+    this.googleMap3D = googleMap3D
+    googleMap3D.setOnMapReadyListener {
+      googleMap3D.setOnMapReadyListener(null)
+      drawPathPolyline()
+      updateCameraPositionForDistance(0.0)
     }
+  }
+
+  private fun initViews() {
+    controlsCard = findViewById(R.id.controls_card)
+    fadeOutJob = lifecycleScope.launch {
+      delay(3000L)
+      controlsCard?.animate()?.alpha(0.2f)?.setDuration(500)?.start()
+    }
+
+    rgEnvironment = findViewById(R.id.rg_environment)
+    btnPlayPause = findViewById(R.id.btn_play_pause)
+    progressSlider = findViewById(R.id.progress_slider)
+
+    rangeSlider = findViewById(R.id.range_slider)
+    rangeSliderLabel = findViewById(R.id.range_slider_label)
+    altitudeSlider = findViewById(R.id.altitude_slider)
+    altitudeSliderLabel = findViewById(R.id.altitude_slider_label)
+    headingSlider = findViewById(R.id.heading_slider)
+    headingSliderLabel = findViewById(R.id.heading_slider_label)
+    tiltSlider = findViewById(R.id.tilt_slider)
+    tiltSliderLabel = findViewById(R.id.tilt_slider_label)
+    speedSlider = findViewById(R.id.speed_slider)
+    speedSliderLabel = findViewById(R.id.speed_slider_label)
+
+    // Radio group environment listener
+    rgEnvironment.setOnCheckedChangeListener { _, checkedId ->
+      when (checkedId) {
+        R.id.rb_urban -> {
+          altitudeSlider.valueTo = 200.0f
+          switchEnvironment(URBAN_PATH)
+        }
+
+        R.id.rb_rural -> {
+          altitudeSlider.valueTo = 2000.0f
+          switchEnvironment(RURAL_PATH)
+        }
+      }
+    }
+
+    // Play/Pause button
+    btnPlayPause.setOnClickListener {
+      if (isPlaying) {
+        pauseAnimation()
+      } else {
+        startAnimation()
+      }
+    }
+
+    // Progress slider scrubbing
+    progressSlider.addOnChangeListener { _, value, fromUser ->
+      if (fromUser) {
+        isUserScrubbing = true
+        elapsedDistance = totalDistance * value.toDouble()
+        updateCameraPositionForDistance(elapsedDistance)
+      }
+    }
+    progressSlider.addOnSliderTouchListener(object : Slider.OnSliderTouchListener {
+      override fun onStartTrackingTouch(slider: Slider) {
+        isUserScrubbing = true
+      }
+
+      override fun onStopTrackingTouch(slider: Slider) {
+        isUserScrubbing = false
+      }
+    })
+
+    // Slider listeners for interactive camera inputs
+    rangeSlider.addOnChangeListener { _, value, _ ->
+      cameraRange = value.toDouble()
+      rangeSliderLabel.text = "Camera Range: ${cameraRange.toInt()}m"
+      updateCameraPositionForDistance(elapsedDistance)
+    }
+
+    altitudeSlider.addOnChangeListener { _, value, _ ->
+      groundAltitude = value.toDouble()
+      altitudeSliderLabel.text = "Ground Altitude: ${groundAltitude.toInt()}m"
+      updateCameraPositionForDistance(elapsedDistance)
+    }
+
+    headingSlider.addOnChangeListener { _, value, _ ->
+      headingOffset = value.toDouble()
+      headingSliderLabel.text = "Heading Offset: ${headingOffset.toInt()}°"
+      updateCameraPositionForDistance(elapsedDistance)
+    }
+
+    tiltSlider.addOnChangeListener { _, value, _ ->
+      cameraTilt = value.toDouble()
+      tiltSliderLabel.text = "Camera Tilt: ${cameraTilt.toInt()}°"
+      updateCameraPositionForDistance(elapsedDistance)
+    }
+
+    speedSlider.addOnChangeListener { _, value, _ ->
+      followSpeedMps = value.toDouble()
+      speedSliderLabel.text = "Follow Speed: ${followSpeedMps.toInt()} m/s"
+    }
+  }
+
+
+  private fun switchEnvironment(path: List<LatLng>) {
+    pauseAnimation()
+    currentHeading = null
+    elapsedDistance = 0.0
+    progressSlider.value = 0f
+
+    if (path == RURAL_PATH) {
+      cameraRange = 450.0
+      groundAltitude = 40.0
+      cameraTilt = 75.0
+      rangeSlider.value = 450f
+      altitudeSlider.value = 40f
+      tiltSlider.value = 75f
+      rangeSliderLabel.text = "Camera Range: 450m"
+      altitudeSliderLabel.text = "Ground Altitude: 40m"
+      tiltSliderLabel.text = "Camera Tilt: 75°"
+    } else {
+      cameraRange = 300.0
+      groundAltitude = 20.0
+      cameraTilt = 70.0
+      rangeSlider.value = 300f
+      altitudeSlider.value = 20f
+      tiltSlider.value = 70f
+      rangeSliderLabel.text = "Camera Range: 300m"
+      altitudeSliderLabel.text = "Ground Altitude: 20m"
+      tiltSliderLabel.text = "Camera Tilt: 70°"
+    }
+
+    loadPathData(path)
+    drawPathPolyline()
+    updateCameraPositionForDistance(0.0)
+  }
+
+  private fun loadPathData(path: List<LatLng>) {
+    currentPath = path
+    cumulativeDistances = DoubleArray(path.size)
+    totalDistance = 0.0
+    cumulativeDistances[0] = 0.0
+    for (i in 1 until path.size) {
+      val dist = SphericalUtil.computeDistanceBetween(path[i - 1], path[i])
+      totalDistance += dist
+      cumulativeDistances[i] = totalDistance
+    }
+  }
+
+  private fun drawPathPolyline() {
+    val map = googleMap3D ?: return
+    pathPolyline?.remove()
+    val polyOptions = polylineOptions {
+      strokeColor = Color.parseColor("#4285F4")
+      strokeWidth = 10.0
+      altitudeMode = AltitudeMode.RELATIVE_TO_GROUND
+      path = currentPath.map { latLng ->
+        latLngAltitude {
+          latitude = latLng.latitude
+          longitude = latLng.longitude
+          altitude = 5.0
+        }
+      }
+    }
+    pathPolyline = map.addPolyline(polyOptions)
+  }
+
+  private fun startAnimation() {
+    if (isPlaying) return
+    isPlaying = true
+    btnPlayPause.setIconResource(R.drawable.pause_24px)
+
+    val frameCallback = object : Choreographer.FrameCallback {
+      private var lastTimeNanos = 0L
+
+      override fun doFrame(frameTimeNanos: Long) {
+        if (!isPlaying) return
+
+        if (lastTimeNanos == 0L) {
+          lastTimeNanos = frameTimeNanos
+          Choreographer.getInstance().postFrameCallback(this)
+          return
+        }
+
+        val dt = (frameTimeNanos - lastTimeNanos) / 1_000_000_000.0
+        lastTimeNanos = frameTimeNanos
+
+        val stepDistance = followSpeedMps * dt
+        elapsedDistance += stepDistance
+
+        if (elapsedDistance >= totalDistance) {
+          elapsedDistance = 0.0
+        }
+
+        if (!isUserScrubbing) {
+          progressSlider.value = (elapsedDistance / totalDistance).toFloat().coerceIn(0f, 1f)
+        }
+        updateCameraPositionForDistance(elapsedDistance)
+
+        Choreographer.getInstance().postFrameCallback(this)
+      }
+    }
+    Choreographer.getInstance().postFrameCallback(frameCallback)
+  }
+
+  private fun pauseAnimation() {
+    isPlaying = false
+    btnPlayPause.setIconResource(R.drawable.play_arrow_24px)
+    animationJob?.cancel()
+    animationJob = null
+  }
+
+  private var currentHeading: Double? = null
+
+  private fun updateCameraPositionForDistance(dist: Double) {
+    val map = googleMap3D ?: return
+    if (currentPath.isEmpty()) return
+
+    var index = 0
+    while (index < cumulativeDistances.size - 1 && cumulativeDistances[index + 1] < dist) {
+      index++
+    }
+
+    val p1 = currentPath[index]
+    val p2 = if (index < currentPath.size - 1) currentPath[index + 1] else p1
+
+    val segStartDist = cumulativeDistances[index]
+    val segEndDist =
+      if (index < cumulativeDistances.size - 1) cumulativeDistances[index + 1] else totalDistance
+    val segLen = segEndDist - segStartDist
+
+    val fraction = if (segLen > 0) ((dist - segStartDist) / segLen).coerceIn(0.0, 1.0) else 0.0
+    val currentLatLng = SphericalUtil.interpolate(p1, p2, fraction)
+    val bearing = SphericalUtil.computeHeading(p1, p2)
+
+    val targetHeadingRaw = (bearing + headingOffset).toHeading()
+    val targetHeading = if (currentHeading == null || isUserScrubbing || !isPlaying) {
+      targetHeadingRaw
+    } else {
+      var diff = (targetHeadingRaw - currentHeading!!) % 360.0
+      if (diff > 180.0) diff -= 360.0
+      if (diff < -180.0) diff += 360.0
+      (currentHeading!! + diff * 0.12).toHeading()
+    }
+    currentHeading = targetHeading
+
+    val newCamera = camera {
+      center = latLngAltitude {
+        latitude = currentLatLng.latitude
+        longitude = currentLatLng.longitude
+        altitude = groundAltitude
+      }
+      heading = targetHeading
+      tilt = cameraTilt
+      range = cameraRange
+    }
+
+    map.setCamera(newCamera)
+  }
+
+  companion object {
+    // Urban Path (New York City - Central Park Block Circuit)
+    val URBAN_PATH = listOf(
+      LatLng(40.7783119, -73.9627630),
+      LatLng(40.7776355, -73.9611664),
+      LatLng(40.7770011, -73.9616294),
+      LatLng(40.7776743, -73.9632228),
+      LatLng(40.7783119, -73.9627630)
+    )
+
+    // Rural Path
+    val RURAL_PATH = listOf(
+      LatLng(37.254529, -122.380897),
+      LatLng(37.255065, -122.381627),
+      LatLng(37.257540, -122.383720),
+      LatLng(37.261200, -122.383950),
+      LatLng(37.264780, -122.388210),
+      LatLng(37.268520, -122.392450),
+      LatLng(37.272110, -122.397640),
+      LatLng(37.276430, -122.401120),
+      LatLng(37.280850, -122.403560),
+      LatLng(37.286018, -122.405072),
+      LatLng(37.291040, -122.404210),
+      LatLng(37.295800, -122.401980),
+      LatLng(37.300120, -122.399540),
+      LatLng(37.304550, -122.397210),
+      LatLng(37.309200, -122.395100),
+      LatLng(37.313450, -122.392840),
+      LatLng(37.317200, -122.390510),
+      LatLng(37.320850, -122.388740),
+      LatLng(37.323540, -122.387600),
+      LatLng(37.325269, -122.386728)
+    )
+  }
 }
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 1d3d9467..acf45c21 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
@@ -16,14 +16,74 @@
 
 package com.example.maps3dkotlin.roadmapmode
 
+import android.os.Bundle
+import android.view.ViewGroup
+import android.widget.RadioGroup
 import com.example.maps3dcommon.R
-import com.example.maps3dkotlin.common.BaseSkeletonActivity
+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
 
 /**
- * Skeleton activity for RoadmapModeActivity.
+ * Showcases 3D Roadmap mode in Google Maps 3D SDK focused on San Francisco.
+ *
+ * Features:
+ * - Switching between ROADMAP (Vector 3D Buildings & Street Layout), HYBRID, and SATELLITE modes.
  */
-class RoadmapModeActivity : BaseSkeletonActivity() {
-    override fun getTitleResId(): Int {
-        return R.string.feature_title_roadmap_mode
+class RoadmapModeActivity : SampleBaseActivity() {
+
+    override val TAG = "RoadmapModeActivity"
+
+    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
+        }
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+
+        // Inflate roadmap control panel overlay into map container managed by SampleBaseActivity
+        findViewById<ViewGroup>(R.id.map_container)?.let { container ->
+            layoutInflater.inflate(R.layout.control_panel_roadmap_mode, container, true)
+        }
+
+        findViewById<MaterialToolbar>(R.id.top_bar)?.apply {
+            title = "3D Roadmap Mode"
+            setNavigationOnClickListener { finish() }
+        }
+
+        findViewById<RadioGroup>(R.id.rg_map_mode)?.setOnCheckedChangeListener { _, checkedId ->
+            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)
+                }
+            }
+        }
+    }
+
+    override fun onMapReady(googleMap3D: GoogleMap3D) {
+        super.onMapReady(googleMap3D)
+        googleMap3D.setMapMode(Map3DMode.ROADMAP)
+        googleMap3D.setCamera(initialCamera)
+    }
+
+    companion object {
+        // San Francisco Financial District
+        val SF_LOCATION = LatLng(37.7915, -122.4010)
     }
 }
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 564fe032..e0de7631 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
@@ -241,7 +241,14 @@ abstract class SampleBaseActivity : AppCompatActivity(), OnMap3DViewReadyCallbac
             onMapReady(googleMap3D)
         }
 
-        // Workaround for bug where onMapReady is not called on reused instances.
+        // Mark map view as steady when rendering stabilizes for automated visual tests
+        googleMap3D.setOnMapSteadyListener { isSceneSteady ->
+            if (isSceneSteady) {
+                map3DView.contentDescription = "MapSteady"
+            }
+        }
+
+        // Ensure onMapReady triggers even on delayed or reused fragments.
         lifecycleScope.launch {
             delay(2000)
             onMapReady(googleMap3D)
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 d0461f0f..5e475d91 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
@@ -36,9 +36,6 @@ import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.unit.dp
-import androidx.core.view.WindowCompat
-import androidx.core.view.WindowInsetsCompat
-import androidx.core.view.WindowInsetsControllerCompat
 import com.example.composedemos.advancedcameraanimation.AdvancedCameraAnimationActivity
 import com.example.composedemos.animatingmodels.AnimatingModelsActivity
 import com.example.composedemos.cameracontrols.CameraControlsActivity
@@ -82,7 +79,11 @@ class MainActivity : ComponentActivity() {
 @Composable
 fun CatalogScreen() {
     val context = LocalContext.current
-    LazyColumn(modifier = Modifier.fillMaxSize().safeDrawingPadding()) {
+    LazyColumn(
+        modifier = Modifier
+            .fillMaxSize()
+            .safeDrawingPadding(),
+    ) {
         item {
             Text(
                 text = "Compose Demos Catalog",
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 06b0d19a..7c2e5564 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
@@ -1,5 +1,5 @@
 /*
- * Copyright 2026 Google LLC
+ * Copyright 2025 Google LLC
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,20 +17,106 @@
 package com.example.composedemos.advancedcameraanimation
 
 import android.os.Bundle
+import android.os.SystemClock
 import androidx.activity.ComponentActivity
 import androidx.activity.compose.setContent
 import androidx.activity.enableEdgeToEdge
+import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+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.width
+import androidx.compose.foundation.selection.selectable
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.Button
+import androidx.compose.material3.Card
+import androidx.compose.material3.CardDefaults
 import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.Scaffold
+import androidx.compose.material3.OutlinedButton
+import androidx.compose.material3.RadioButton
+import androidx.compose.material3.Surface
 import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
+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.rememberCoroutineScope
+import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
-import androidx.core.view.WindowCompat
-import androidx.core.view.WindowInsetsCompat
-import androidx.core.view.WindowInsetsControllerCompat
+import androidx.compose.ui.platform.LocalLifecycleOwner
+import androidx.compose.ui.semantics.Role
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.dp
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleEventObserver
+import com.example.composedemos.routes.RouteEngine
+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.FlyToOptions
+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.SphericalUtil
+import com.google.maps.android.compose3d.GoogleMap3D
+import com.google.maps.android.compose3d.ModelConfig
+import com.google.maps.android.compose3d.ModelScale
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.isActive
+import kotlinx.coroutines.launch
+import kotlin.time.Duration.Companion.milliseconds
+
+enum class AnimationApproach(val title: String) {
+    SIMPLE_FLY_TO("1. SDK Simple flyTo (Native Transition)"),
+    KEYFRAME_TOUR("2. Keyframe Queue (Multi-step Camera Tour)"),
+    DISPATCHER_FRAME_LOOP("3. Frame Dispatcher (Chase Cam + 3D Airplane)"),
+    ORBIT_360_SPIN("4. 360° Orbit Spin (Continuous Orbital Camera)"),
+}
+
+sealed interface CameraKeyframe {
+    val stepTitle: String
+    val stepDescription: String
+
+    data class FlyTo(
+        override val stepTitle: String,
+        override val stepDescription: String,
+        val targetCenter: LatLng,
+        val targetAltitude: Double,
+        val targetHeading: Double,
+        val targetTilt: Double,
+        val targetRange: Double,
+        val durationMs: Long = 2500L,
+    ) : CameraKeyframe
+
+    data class DwellPause(
+        override val stepTitle: String,
+        override val stepDescription: String,
+        val durationMs: Long = 1500L,
+    ) : CameraKeyframe
+
+    data class OrbitAround(
+        override val stepTitle: String,
+        override val stepDescription: String,
+        val center: LatLng,
+        val altitude: Double,
+        val range: Double,
+        val tilt: Double,
+        val startHeading: Double,
+        val endHeading: Double,
+        val durationMs: Long = 4000L,
+    ) : CameraKeyframe
+}
 
 class AdvancedCameraAnimationActivity : ComponentActivity() {
     override fun onCreate(savedInstanceState: Bundle?) {
@@ -38,20 +124,540 @@ class AdvancedCameraAnimationActivity : ComponentActivity() {
         enableEdgeToEdge()
         setContent {
             MaterialTheme {
-                Scaffold(modifier = Modifier.fillMaxSize()) { innerPadding ->
-                    Box(
-                        modifier = Modifier
-                            .fillMaxSize()
-                            .padding(innerPadding),
-                        contentAlignment = Alignment.Center,
+                Surface(
+                    modifier = Modifier.fillMaxSize(),
+                    color = MaterialTheme.colorScheme.background,
+                ) {
+                    AdvancedCameraAnimationScreen()
+                }
+            }
+        }
+    }
+
+    companion object {
+        val SAN_FRANCISCO_TOUR = listOf(
+            CameraKeyframe.FlyTo(
+                stepTitle = "1. Golden Gate Bridge Flight",
+                stepDescription = "3D Airplane flight over Golden Gate Bridge",
+                targetCenter = LatLng(37.8199, -122.4783),
+                targetAltitude = 200.0,
+                targetHeading = 105.0,
+                targetTilt = 65.0,
+                targetRange = 600.0,
+                durationMs = 2500L,
+            ),
+            CameraKeyframe.DwellPause(
+                stepTitle = "2. Mid-Air Observation",
+                stepDescription = "Dwell pause observing 3D airplane over Golden Gate",
+                durationMs = 1500L,
+            ),
+            CameraKeyframe.OrbitAround(
+                stepTitle = "3. Golden Gate 360° Orbit",
+                stepDescription = "360° orbital camera spin around flying airplane",
+                center = LatLng(37.8199, -122.4783),
+                altitude = 200.0,
+                range = 600.0,
+                tilt = 65.0,
+                startHeading = 105.0,
+                endHeading = 465.0,
+                durationMs = 4000L,
+            ),
+            CameraKeyframe.FlyTo(
+                stepTitle = "4. Transit to Coit Tower",
+                stepDescription = "Airplane flight to Coit Tower Landmark",
+                targetCenter = LatLng(37.8024, -122.4058),
+                targetAltitude = 200.0,
+                targetHeading = 105.0,
+                targetTilt = 65.0,
+                targetRange = 600.0,
+                durationMs = 3000L,
+            ),
+        )
+
+        // 15 Fine-Grained Waypoints on the direct route from Golden Gate Bridge to Coit Tower
+        val AIRPLANE_FLIGHT_PATH = listOf(
+            LatLng(37.8199, -122.4783), // 1. Golden Gate Bridge (Source)
+            LatLng(37.8188, -122.4735), // 2. Fort Point / Presidio Overlook
+            LatLng(37.8175, -122.4685), // 3. Crissy Field West
+            LatLng(37.8160, -122.4635), // 4. Crissy Field East
+            LatLng(37.8145, -122.4585), // 5. Marina Green West
+            LatLng(37.8130, -122.4530), // 6. Marina District Center
+            LatLng(37.8115, -122.4475), // 7. Fort Mason West
+            LatLng(37.8100, -122.4420), // 8. Fort Mason Heights
+            LatLng(37.8085, -122.4365), // 9. Aquatic Park Cove
+            LatLng(37.8070, -122.4310), // 10. Fisherman's Wharf West
+            LatLng(37.8058, -122.4250), // 11. Fisherman's Wharf Center
+            LatLng(37.8048, -122.4195), // 12. Pier 39 Promenade
+            LatLng(37.8038, -122.4140), // 13. Embarcadero North
+            LatLng(37.8030, -122.4090), // 14. Telegraph Hill Slopes
+            LatLng(37.8024, -122.4058), // 15. Coit Tower (Destination)
+        )
+    }
+}
+
+@Composable
+fun AdvancedCameraAnimationScreen() {
+    val tourSequence = AdvancedCameraAnimationActivity.SAN_FRANCISCO_TOUR
+    val flightPath = AdvancedCameraAnimationActivity.AIRPLANE_FLIGHT_PATH
+    val scope = rememberCoroutineScope()
+
+    var mapInstance by remember { mutableStateOf<GoogleMap3D?>(null) }
+    var selectedApproach by remember { mutableStateOf(AnimationApproach.DISPATCHER_FRAME_LOOP) }
+
+    val initialStep = tourSequence.first() as CameraKeyframe.FlyTo
+    var currentCameraState by remember {
+        mutableStateOf(
+            camera {
+                center = latLngAltitude {
+                    latitude = initialStep.targetCenter.latitude
+                    longitude = initialStep.targetCenter.longitude
+                    altitude = initialStep.targetAltitude
+                }
+                heading = 105.0
+                tilt = initialStep.targetTilt
+                range = initialStep.targetRange
+            },
+        )
+    }
+
+    var planePosition by remember {
+        mutableStateOf(
+            latLngAltitude {
+                latitude = flightPath.first().latitude
+                longitude = flightPath.first().longitude
+                altitude = 200.0
+            },
+        )
+    }
+    var planeHeading by remember {
+        val rawH = SphericalUtil.computeHeading(flightPath.first(), flightPath[1])
+        mutableStateOf(normalizeHeading(rawH + 180.0))
+    }
+
+    val activeModels = remember(planePosition, planeHeading) {
+        listOf(
+            ModelConfig(
+                key = "airplane_model",
+                position = planePosition,
+                url = "https://storage.googleapis.com/gmp-maps-demos/p3d-map/assets/Airplane.glb",
+                altitudeMode = AltitudeMode.ABSOLUTE,
+                scale = ModelScale.Uniform(0.08f),
+                heading = planeHeading,
+                tilt = -90.0,
+                roll = 0.0,
+            ),
+        )
+    }
+
+    var currentStepIndex by remember { mutableIntStateOf(0) }
+    var isPlaying by remember { mutableStateOf(false) }
+    var tourJob by remember { mutableStateOf<Job?>(null) }
+    var restartJob by remember { mutableStateOf<Job?>(null) }
+
+    val cumulativeDistances: DoubleArray = remember(flightPath) {
+        RouteEngine.calculateCumulativeDistances(flightPath)
+    }
+
+    val lifecycleOwner = LocalLifecycleOwner.current
+    DisposableEffect(lifecycleOwner) {
+        val observer = LifecycleEventObserver { _, event ->
+            if (event == Lifecycle.Event.ON_PAUSE || event == Lifecycle.Event.ON_STOP) {
+                isPlaying = false
+                tourJob?.cancel()
+                tourJob = null
+                restartJob?.cancel()
+                restartJob = null
+                mapInstance?.stopCameraAnimation()
+            }
+        }
+        lifecycleOwner.lifecycle.addObserver(observer)
+        onDispose {
+            lifecycleOwner.lifecycle.removeObserver(observer)
+            tourJob?.cancel()
+            restartJob?.cancel()
+            mapInstance?.stopCameraAnimation()
+        }
+    }
+
+    fun stopTour() {
+        isPlaying = false
+        tourJob?.cancel()
+        tourJob = null
+        restartJob?.cancel()
+        restartJob = null
+        mapInstance?.stopCameraAnimation()
+    }
+
+    fun runSimpleFlyTo() {
+        stopTour()
+        isPlaying = true
+
+        val targetLoc = flightPath.last()
+        val flightHeading = SphericalUtil.computeHeading(flightPath[flightPath.size - 2], targetLoc)
+        planePosition = latLngAltitude {
+            latitude = targetLoc.latitude
+            longitude = targetLoc.longitude
+            altitude = 200.0
+        }
+        planeHeading = normalizeHeading(flightHeading + 180.0)
+
+        val targetCam = camera {
+            center = latLngAltitude {
+                latitude = targetLoc.latitude
+                longitude = targetLoc.longitude
+                altitude = 200.0
+            }
+            heading = normalizeHeading(flightHeading)
+            tilt = 65.0
+            range = 600.0
+        }
+        mapInstance?.flyCameraTo(FlyToOptions(targetCam, 1500L))
+        isPlaying = false
+    }
+
+    fun runKeyframeTour() {
+        stopTour()
+        isPlaying = true
+        currentStepIndex = 0
+
+        tourJob = scope.launch(Dispatchers.Main) {
+            val frameDurationMs = 16L
+            while (currentStepIndex < tourSequence.size && isActive && isPlaying) {
+                val step = tourSequence[currentStepIndex]
+                when (step) {
+                    is CameraKeyframe.FlyTo -> {
+                        val targetCam = camera {
+                            center = latLngAltitude {
+                                latitude = step.targetCenter.latitude
+                                longitude = step.targetCenter.longitude
+                                altitude = step.targetAltitude
+                            }
+                            heading = normalizeHeading(step.targetHeading)
+                            tilt = step.targetTilt
+                            range = step.targetRange
+                        }
+                        planePosition = latLngAltitude {
+                            latitude = step.targetCenter.latitude
+                            longitude = step.targetCenter.longitude
+                            altitude = 200.0
+                        }
+                        planeHeading = normalizeHeading(step.targetHeading + 180.0)
+                        mapInstance?.flyCameraTo(FlyToOptions(targetCam, step.durationMs))
+                        delay(step.durationMs.milliseconds)
+                    }
+
+                    is CameraKeyframe.DwellPause -> {
+                        delay(step.durationMs.milliseconds)
+                    }
+
+                    is CameraKeyframe.OrbitAround -> {
+                        val totalMs = step.durationMs
+                        val startTimeMs = SystemClock.uptimeMillis()
+                        while (isActive && isPlaying) {
+                            val elapsedMs = SystemClock.uptimeMillis() - startTimeMs
+                            if (elapsedMs > totalMs) break
+
+                            val t = (elapsedMs.toDouble() / totalMs).coerceIn(0.0, 1.0)
+                            val orbitHeading = interpolateAngle(step.startHeading, step.endHeading, t)
+
+                            val updatedCam = camera {
+                                center = latLngAltitude {
+                                    latitude = step.center.latitude
+                                    longitude = step.center.longitude
+                                    altitude = step.altitude
+                                }
+                                heading = normalizeHeading(orbitHeading)
+                                tilt = step.tilt
+                                range = step.range
+                            }
+
+                            planePosition = latLngAltitude {
+                                latitude = step.center.latitude
+                                longitude = step.center.longitude
+                                altitude = 200.0
+                            }
+                            planeHeading = normalizeHeading(orbitHeading + 180.0)
+                            currentCameraState = updatedCam
+                            delay(16L) // Keeps dispatch rhythm steady
+                        }
+                    }
+                }
+
+                if (!isActive || !isPlaying) break
+
+                if (currentStepIndex < tourSequence.size - 1) {
+                    currentStepIndex++
+                } else {
+                    isPlaying = false
+                    break
+                }
+            }
+        }
+    }
+
+    fun runFrameDispatcherLoop() {
+        stopTour()
+        isPlaying = true
+
+        tourJob = scope.launch(Dispatchers.Main) {
+            val totalDistance = cumulativeDistances.last().coerceAtLeast(1.0)
+            val flightSpeedMps = 400.0
+            var elapsedDistance = 0.0
+            var lastTime = System.currentTimeMillis()
+
+            while (isPlaying && isActive) {
+                val now = System.currentTimeMillis()
+                val dt = (now - lastTime) / 1000.0
+                lastTime = now
+
+                elapsedDistance += flightSpeedMps * dt
+
+                if (elapsedDistance >= totalDistance) {
+                    elapsedDistance = totalDistance
+                    val posAndHeading = RouteEngine.calculatePositionAndHeading(
+                        flightPath,
+                        cumulativeDistances,
+                        elapsedDistance,
+                        30.0,
+                    )
+                    val planeH = posAndHeading.heading.toDouble() + 180.0
+                    planePosition = latLngAltitude {
+                        latitude = posAndHeading.position.latitude
+                        longitude = posAndHeading.position.longitude
+                        altitude = 200.0
+                    }
+                    planeHeading = normalizeHeading(planeH)
+                    currentCameraState = camera {
+                        center = latLngAltitude {
+                            latitude = posAndHeading.position.latitude
+                            longitude = posAndHeading.position.longitude
+                            altitude = 200.0
+                        }
+                        heading = normalizeHeading(posAndHeading.heading.toDouble())
+                        tilt = 65.0
+                        range = 600.0
+                    }
+                    isPlaying = false
+                    break
+                }
+
+                val posAndHeading = RouteEngine.calculatePositionAndHeading(
+                    flightPath,
+                    cumulativeDistances,
+                    elapsedDistance,
+                    30.0,
+                )
+                val planeH = posAndHeading.heading.toDouble() + 180.0
+                planePosition = latLngAltitude {
+                    latitude = posAndHeading.position.latitude
+                    longitude = posAndHeading.position.longitude
+                    altitude = 200.0
+                }
+                planeHeading = normalizeHeading(planeH)
+
+                currentCameraState = camera {
+                    center = latLngAltitude {
+                        latitude = posAndHeading.position.latitude
+                        longitude = posAndHeading.position.longitude
+                        altitude = 200.0
+                    }
+                    heading = normalizeHeading(posAndHeading.heading.toDouble())
+                    tilt = 65.0
+                    range = 600.0
+                }
+                delay(16.milliseconds)
+            }
+        }
+    }
+
+    fun run360OrbitSpin() {
+        stopTour()
+        isPlaying = true
+
+        val targetCenter = flightPath.first()
+        planePosition = latLngAltitude {
+            latitude = targetCenter.latitude
+            longitude = targetCenter.longitude
+            altitude = 200.0
+        }
+        planeHeading = normalizeHeading(105.0 + 180.0)
+
+        tourJob = scope.launch(Dispatchers.Main) {
+            val totalMs = 6000L
+            val startHeading = 105.0
+            val startTimeMs = SystemClock.uptimeMillis()
+
+            while (isActive && isPlaying) {
+                val elapsedMs = SystemClock.uptimeMillis() - startTimeMs
+                if (elapsedMs > totalMs) break
+
+                val t = (elapsedMs.toDouble() / totalMs).coerceIn(0.0, 1.0)
+                val headingDeg = (startHeading + t * 360.0) % 360.0
+
+                currentCameraState = camera {
+                    center = latLngAltitude {
+                        latitude = targetCenter.latitude
+                        longitude = targetCenter.longitude
+                        altitude = 200.0
+                    }
+                    heading = normalizeHeading(headingDeg)
+                    tilt = 65.0
+                    range = 600.0
+                }
+                delay(16.milliseconds)
+            }
+            isPlaying = false
+        }
+    }
+
+    fun startSelectedApproach() {
+        stopTour()
+        when (selectedApproach) {
+            AnimationApproach.SIMPLE_FLY_TO -> runSimpleFlyTo()
+            AnimationApproach.KEYFRAME_TOUR -> runKeyframeTour()
+            AnimationApproach.DISPATCHER_FRAME_LOOP -> runFrameDispatcherLoop()
+            AnimationApproach.ORBIT_360_SPIN -> run360OrbitSpin()
+        }
+    }
+
+    // Auto-start initial animation once after map loads
+    LaunchedEffect(Unit) {
+        delay(1000.milliseconds)
+        startSelectedApproach()
+    }
+
+    fun resetTour() {
+        stopTour()
+        restartJob?.cancel()
+        currentStepIndex = 0
+
+        val p1 = flightPath.first()
+        val p2 = flightPath[1]
+        val rawH = SphericalUtil.computeHeading(p1, p2)
+        planePosition = latLngAltitude {
+            latitude = p1.latitude
+            longitude = p1.longitude
+            altitude = 200.0
+        }
+        planeHeading = normalizeHeading(rawH + 180.0)
+
+        val firstStep = tourSequence.first() as CameraKeyframe.FlyTo
+        currentCameraState = camera {
+            center = latLngAltitude {
+                latitude = firstStep.targetCenter.latitude
+                longitude = firstStep.targetCenter.longitude
+                altitude = firstStep.targetAltitude
+            }
+            heading = normalizeHeading(rawH)
+            tilt = firstStep.targetTilt
+            range = firstStep.targetRange
+        }
+
+        restartJob = scope.launch {
+            delay(300.milliseconds)
+            startSelectedApproach()
+        }
+    }
+
+    Box(modifier = Modifier.fillMaxSize()) {
+        GoogleMap3D(
+            camera = currentCameraState,
+            models = activeModels,
+            mapMode = Map3DMode.SATELLITE,
+            onMapReady = { mapInstance = it },
+            modifier = Modifier.fillMaxSize(),
+        )
+
+        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(12.dp),
+            ) {
+                Text(
+                    text = "Select Animation Approach:",
+                    style = MaterialTheme.typography.labelLarge,
+                    fontWeight = FontWeight.Bold,
+                )
+
+                Spacer(modifier = Modifier.height(4.dp))
+
+                Column(modifier = Modifier.fillMaxWidth()) {
+                    AnimationApproach.entries.forEach { approach ->
+                        Row(
+                            modifier = Modifier
+                                .fillMaxWidth()
+                                .selectable(
+                                    selected = (selectedApproach == approach),
+                                    onClick = {
+                                        selectedApproach = approach
+                                        resetTour()
+                                    },
+                                    role = Role.RadioButton,
+                                )
+                                .padding(vertical = 2.dp),
+                            verticalAlignment = Alignment.CenterVertically,
+                        ) {
+                            RadioButton(
+                                selected = (selectedApproach == approach),
+                                onClick = null,
+                            )
+                            Spacer(modifier = Modifier.width(8.dp))
+                            Text(
+                                text = approach.title,
+                                style = MaterialTheme.typography.bodyMedium,
+                            )
+                        }
+                    }
+                }
+
+                Spacer(modifier = Modifier.height(8.dp))
+
+                Row(
+                    modifier = Modifier.fillMaxWidth(),
+                    horizontalArrangement = Arrangement.End,
+                    verticalAlignment = Alignment.CenterVertically,
+                ) {
+                    OutlinedButton(
+                        onClick = { resetTour() },
+                        modifier = Modifier.padding(end = 8.dp),
                     ) {
-                        Text(
-                            text = "TODO: Advanced Camera Animation sample will be implemented here.",
-                            style = MaterialTheme.typography.headlineSmall,
-                        )
+                        Text("Reset")
+                    }
+
+                    Button(
+                        onClick = {
+                            if (isPlaying) {
+                                stopTour()
+                            } else {
+                                startSelectedApproach()
+                            }
+                        },
+                    ) {
+                        Text(if (isPlaying) "Pause" else "Play")
                     }
                 }
             }
         }
     }
 }
+
+private fun normalizeHeading(headingDeg: Double): Double {
+    val normalized = headingDeg % 360.0
+    return if (normalized < 0.0) normalized + 360.0 else normalized
+}
+
+private fun interpolateAngle(start: Double, end: Double, fraction: Double): Double {
+    var diff = (end - start) % 360.0
+    if (diff > 180.0) diff -= 360.0
+    if (diff < -180.0) diff += 360.0
+    return (start + diff * fraction + 360.0) % 360.0
+}
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 175e67f7..19b32770 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
@@ -17,41 +17,276 @@
 package com.example.composedemos.datavisualization
 
 import android.os.Bundle
+import android.widget.Toast
 import androidx.activity.ComponentActivity
 import androidx.activity.compose.setContent
 import androidx.activity.enableEdgeToEdge
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
 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.Card
+import androidx.compose.material3.CardDefaults
 import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Slider
+import androidx.compose.material3.Surface
 import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableDoubleStateOf
+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.graphics.Color
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.semantics
+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.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.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
+import com.google.android.gms.maps3d.model.latLngAltitude
+import com.google.android.gms.maps3d.model.polygonOptions
+import com.google.maps.android.compose3d.GoogleMap3D
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.isActive
+import kotlin.time.Duration.Companion.milliseconds
+import android.graphics.Color as AndroidColor
 
 class DataVisualizationActivity : ComponentActivity() {
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         enableEdgeToEdge()
+
+        val windowInsetsController = WindowCompat.getInsetsController(window, window.decorView)
+        windowInsetsController.hide(androidx.core.view.WindowInsetsCompat.Type.systemBars())
+        windowInsetsController.systemBarsBehavior = WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
+
         setContent {
             MaterialTheme {
-                Scaffold(modifier = Modifier.fillMaxSize()) { innerPadding ->
-                    Box(
-                        modifier = Modifier
-                            .fillMaxSize()
-                            .padding(innerPadding),
-                        contentAlignment = Alignment.Center,
+                Surface(
+                    modifier = Modifier.fillMaxSize(),
+                    color = MaterialTheme.colorScheme.background,
+                ) {
+                    DataVisualizationScreen()
+                }
+            }
+        }
+    }
+}
+
+@Composable
+fun DataVisualizationScreen() {
+    val context = LocalContext.current
+    var isMapSteady by remember { mutableStateOf(false) }
+    var googleMap3DInstance by remember { mutableStateOf<GoogleMap3D?>(null) }
+    var currentFloodElevation by remember { mutableDoubleStateOf(10.0) }
+    var isSimulating by remember { mutableStateOf(false) }
+    var activePolygon by remember { mutableStateOf<Polygon?>(null) }
+
+    val initialCamera: Camera = remember {
+        camera {
+            center = latLngAltitude {
+                latitude = SF_FLOOD_CENTER.latitude
+                longitude = SF_FLOOD_CENTER.longitude
+                altitude = 120.0
+            }
+            heading = 35.0
+            tilt = 64.0
+            range = 1200.0
+        }
+    }
+
+    // Coroutine loop for auto flood simulation animation
+    LaunchedEffect(isSimulating) {
+        if (isSimulating) {
+            if (currentFloodElevation >= 50.0) {
+                currentFloodElevation = 0.0
+            }
+            while (isActive && isSimulating) {
+                var newElevation = currentFloodElevation + 0.2
+                newElevation = Math.round(newElevation * 10.0) / 10.0
+                if (newElevation >= 50.0) {
+                    currentFloodElevation = 50.0
+                    isSimulating = false
+                    break
+                }
+                currentFloodElevation = newElevation
+                delay(20.milliseconds)
+            }
+        }
+    }
+
+    // Synchronize 3D extruded flood polygon whenever flood elevation or map instance updates
+    LaunchedEffect(currentFloodElevation, googleMap3DInstance) {
+        val map = googleMap3DInstance ?: return@LaunchedEffect
+        val path = floodZoneCoords.map { (lat, lng) ->
+            latLngAltitude {
+                latitude = lat
+                longitude = lng
+                altitude = currentFloodElevation
+            }
+        }
+
+        val options = polygonOptions {
+            id = POLYGON_ID
+            this.path = path
+            fillColor = AndroidColor.argb(140, 230, 40, 40)
+            strokeColor = AndroidColor.argb(255, 180, 0, 0)
+            strokeWidth = 2.5
+            altitudeMode = AltitudeMode.ABSOLUTE
+            extruded = true
+            drawsOccludedSegments = true
+            geodesic = false
+        }
+
+        activePolygon = map.addPolygon(options).apply {
+            setClickListener {
+                Toast.makeText(
+                    context,
+                    String.format("San Francisco Waterfront - Water Level: +%.1f m", currentFloodElevation),
+                    Toast.LENGTH_SHORT,
+                ).show()
+            }
+        }
+    }
+
+    Box(
+        modifier = Modifier
+            .fillMaxSize()
+            .semantics { contentDescription = if (isMapSteady) "MapSteady" else "MapLoading" },
+    ) {
+        GoogleMap3D(
+            camera = initialCamera,
+            mapMode = Map3DMode.HYBRID,
+            modifier = Modifier.fillMaxSize(),
+            onMapReady = { map ->
+                googleMap3DInstance = map
+                map.setMapMode(Map3DMode.HYBRID)
+                map.flyCameraTo(
+                    flyToOptions {
+                        endCamera = initialCamera
+                        durationInMillis = 1200
+                    },
+                )
+            },
+            onMapSteady = {
+                isMapSteady = true
+            },
+        )
+
+        // Translucent Top Bar
+        Box(
+            modifier = Modifier
+                .fillMaxWidth()
+                .background(MaterialTheme.colorScheme.surface.copy(alpha = 0.75f))
+                .statusBarsPadding()
+                .padding(horizontal = 16.dp, vertical = 8.dp),
+        ) {
+            Text(
+                text = "Data Visualization (Flood Fill)",
+                style = MaterialTheme.typography.titleMedium,
+                color = MaterialTheme.colorScheme.onSurface,
+            )
+        }
+
+        // Bottom Interactive Control Panel
+        Card(
+            modifier = Modifier
+                .fillMaxWidth()
+                .align(Alignment.BottomCenter)
+                .padding(12.dp),
+            shape = RoundedCornerShape(16.dp),
+            elevation = CardDefaults.cardElevation(defaultElevation = 8.dp),
+            colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.surface),
+        ) {
+            Column(
+                modifier = Modifier.padding(16.dp),
+                verticalArrangement = Arrangement.spacedBy(8.dp),
+            ) {
+                val feet = currentFloodElevation * 3.28084
+                Text(
+                    text = String.format("Flood Elevation: +%.1f m (%.1f ft)", currentFloodElevation, feet),
+                    style = MaterialTheme.typography.titleSmall,
+                    fontWeight = FontWeight.Bold,
+                )
+
+                val (badgeText, badgeColor, badgeBg) = when {
+                    currentFloodElevation <= 2.0 -> Triple("🌊 Baseline Tide", Color(0xFF008800), Color(0x2000AA00))
+                    currentFloodElevation <= 8.0 -> Triple("⚠️ Minor Inundation", Color(0xFFBB7700), Color(0x20FFAA00))
+                    currentFloodElevation <= 20.0 -> Triple("🌊 Moderate Flooding", Color(0xFF0077CC), Color(0x200088FF))
+                    currentFloodElevation <= 35.0 -> Triple("🚨 Storm Surge (Cat 3)", Color(0xFFDD4400), Color(0x25FF5500))
+                    else -> Triple("⛔ Extreme Inundation", Color(0xFFCC0000), Color(0x25FF0000))
+                }
+
+                Surface(
+                    shape = RoundedCornerShape(8.dp),
+                    color = badgeBg,
+                ) {
+                    Text(
+                        text = badgeText,
+                        color = badgeColor,
+                        style = MaterialTheme.typography.labelMedium,
+                        fontWeight = FontWeight.SemiBold,
+                        modifier = Modifier.padding(horizontal = 8.dp, vertical = 4.dp),
+                    )
+                }
+
+                Row(
+                    modifier = Modifier.fillMaxWidth(),
+                    verticalAlignment = Alignment.CenterVertically,
+                    horizontalArrangement = Arrangement.spacedBy(12.dp),
+                ) {
+                    Slider(
+                        value = currentFloodElevation.toFloat(),
+                        onValueChange = {
+                            isSimulating = false
+                            currentFloodElevation = it.toDouble()
+                        },
+                        valueRange = 0f..50f,
+                        modifier = Modifier.weight(1f),
+                    )
+
+                    Button(
+                        onClick = {
+                            isSimulating = !isSimulating
+                        },
                     ) {
-                        Text(
-                            text = "TODO: Data Visualization sample will be implemented here.",
-                            style = MaterialTheme.typography.headlineSmall,
-                        )
+                        Text(if (isSimulating) "⏹ Stop" else "▶ Simulate")
                     }
                 }
             }
         }
     }
 }
+
+private const val POLYGON_ID = "flood_zone_polygon"
+
+private val SF_FLOOD_CENTER = LatLng(37.8025, -122.4030)
+
+private val floodZoneCoords = listOf(
+    Pair(37.805156, -122.403256),
+    Pair(37.803370, -122.401287),
+    Pair(37.799222, -122.405080),
+    Pair(37.797500, -122.408000),
+    Pair(37.801000, -122.411000),
+    Pair(37.805156, -122.403256),
+)
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 7eb586f9..e5033938 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
@@ -20,35 +20,214 @@ import android.os.Bundle
 import androidx.activity.ComponentActivity
 import androidx.activity.compose.setContent
 import androidx.activity.enableEdgeToEdge
+import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+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.shape.RoundedCornerShape
+import androidx.compose.material3.Button
+import androidx.compose.material3.ButtonDefaults
+import androidx.compose.material3.Card
+import androidx.compose.material3.CardDefaults
 import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.Scaffold
+import androidx.compose.material3.OutlinedButton
+import androidx.compose.material3.Slider
+import androidx.compose.material3.Surface
 import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableFloatStateOf
+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.core.view.WindowCompat
-import androidx.core.view.WindowInsetsCompat
-import androidx.core.view.WindowInsetsControllerCompat
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import com.google.android.gms.maps.model.LatLng
+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.maps.android.compose3d.GoogleMap3D
+import com.google.maps.android.compose3d.utils.toValidCamera
+import kotlin.math.abs
+import kotlin.math.tan
 
 class FieldOfViewActivity : ComponentActivity() {
+
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         enableEdgeToEdge()
         setContent {
             MaterialTheme {
-                Scaffold(modifier = Modifier.fillMaxSize()) { innerPadding ->
-                    Box(
-                        modifier = Modifier
-                            .fillMaxSize()
-                            .padding(innerPadding),
-                        contentAlignment = Alignment.Center,
-                    ) {
-                        Text(
-                            text = "TODO: Field Of View sample will be implemented here.",
-                            style = MaterialTheme.typography.headlineSmall,
-                        )
+                Surface(
+                    modifier = Modifier.fillMaxSize(),
+                    color = MaterialTheme.colorScheme.background,
+                ) {
+                    FieldOfViewScreen()
+                }
+            }
+        }
+    }
+
+    companion object {
+        val SF_FINANCIAL_DISTRICT = LatLng(37.7952, -122.4028)
+    }
+}
+
+@Composable
+fun FieldOfViewScreen() {
+    var fovValue by remember { mutableFloatStateOf(45.0f) }
+
+    val initialCamera = remember {
+        camera {
+            center = latLngAltitude {
+                latitude = FieldOfViewActivity.SF_FINANCIAL_DISTRICT.latitude
+                longitude = FieldOfViewActivity.SF_FINANCIAL_DISTRICT.longitude
+                altitude = 150.0
+            }
+            heading = 45.0
+            tilt = 65.0
+            range = 800.0
+        }.toValidCamera()
+    }
+
+    var cameraState by remember { mutableStateOf(initialCamera) }
+    var mapInstance by remember { mutableStateOf<com.google.android.gms.maps3d.GoogleMap3D?>(null) }
+
+    fun updateCameraFov(newFov: Float) {
+        fovValue = newFov
+
+        val activeMap = mapInstance
+        val liveCam = activeMap?.getCamera()?.toValidCamera()
+
+        val refCam: Camera = if (liveCam != null && (abs(liveCam.center.latitude) > 0.001 || abs(liveCam.center.longitude) > 0.001)) {
+            liveCam
+        } else {
+            cameraState
+        }
+
+        val baseFovRad = Math.toRadians(45.0 / 2.0)
+        val targetFovRad = Math.toRadians(newFov.toDouble() / 2.0)
+        val targetRange = (800.0 * tan(baseFovRad) / tan(targetFovRad)).coerceIn(150.0, 3000.0)
+
+        val updatedCam = camera {
+            center = refCam.center
+            heading = refCam.heading
+            tilt = refCam.tilt
+            roll = refCam.roll
+            range = targetRange
+        }.toValidCamera()
+
+        cameraState = updatedCam
+        activeMap?.setCamera(updatedCam)
+    }
+
+    Box(modifier = Modifier.fillMaxSize()) {
+        GoogleMap3D(
+            camera = cameraState,
+            mapMode = Map3DMode.SATELLITE,
+            onMapReady = { mapInstance = it },
+            modifier = Modifier.fillMaxSize(),
+        )
+
+        Card(
+            modifier = Modifier
+                .align(Alignment.BottomCenter)
+                .fillMaxWidth()
+                .padding(16.dp),
+            shape = RoundedCornerShape(16.dp),
+            colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.surface),
+            elevation = CardDefaults.cardElevation(defaultElevation = 8.dp),
+        ) {
+            Column(
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .padding(16.dp),
+            ) {
+                Text(
+                    text = "Field of View: ${fovValue.toInt()}°",
+                    style = MaterialTheme.typography.titleMedium,
+                    fontWeight = FontWeight.Bold,
+                    color = MaterialTheme.colorScheme.onSurface,
+                )
+
+                Spacer(modifier = Modifier.height(4.dp))
+
+                Slider(
+                    value = fovValue,
+                    onValueChange = { updateCameraFov(it) },
+                    valueRange = 15.0f..120.0f,
+                    modifier = Modifier.fillMaxWidth(),
+                )
+
+                Spacer(modifier = Modifier.height(8.dp))
+
+                Text(
+                    text = "FOV Presets:",
+                    style = MaterialTheme.typography.labelLarge,
+                    fontWeight = FontWeight.SemiBold,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                )
+
+                Spacer(modifier = Modifier.height(8.dp))
+
+                Row(
+                    modifier = Modifier.fillMaxWidth(),
+                    horizontalArrangement = Arrangement.spacedBy(6.dp),
+                ) {
+                    val presets = listOf(
+                        20.0f to "20° Tele",
+                        45.0f to "45° Standard",
+                        90.0f to "90° Wide",
+                        120.0f to "120° Ultra",
+                    )
+
+                    presets.forEach { (presetFov, label) ->
+                        val isSelected = abs(fovValue - presetFov) < 1.0f
+
+                        if (isSelected) {
+                            Button(
+                                onClick = { updateCameraFov(presetFov) },
+                                modifier = Modifier.weight(1f),
+                                shape = RoundedCornerShape(12.dp),
+                                colors = ButtonDefaults.buttonColors(
+                                    containerColor = MaterialTheme.colorScheme.primary,
+                                    contentColor = MaterialTheme.colorScheme.onPrimary,
+                                ),
+                                contentPadding = ButtonDefaults.ContentPadding,
+                            ) {
+                                Text(
+                                    text = label,
+                                    fontSize = 11.sp,
+                                    fontWeight = FontWeight.Bold,
+                                    maxLines = 1,
+                                )
+                            }
+                        } else {
+                            OutlinedButton(
+                                onClick = { updateCameraFov(presetFov) },
+                                modifier = Modifier.weight(1f),
+                                shape = RoundedCornerShape(12.dp),
+                                colors = ButtonDefaults.outlinedButtonColors(
+                                    contentColor = MaterialTheme.colorScheme.primary,
+                                ),
+                                contentPadding = ButtonDefaults.ContentPadding,
+                            ) {
+                                Text(
+                                    text = label,
+                                    fontSize = 11.sp,
+                                    maxLines = 1,
+                                )
+                            }
+                        }
                     }
                 }
             }
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 2d9e4825..1d2c09da 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
@@ -16,41 +16,490 @@
 
 package com.example.composedemos.pathfollowing
 
+import android.graphics.Color
 import android.os.Bundle
+import android.view.MotionEvent
 import androidx.activity.ComponentActivity
 import androidx.activity.compose.setContent
 import androidx.activity.enableEdgeToEdge
+import androidx.compose.animation.core.animateFloatAsState
+import androidx.compose.animation.core.tween
+import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.heightIn
 import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.selection.selectable
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Pause
+import androidx.compose.material.icons.filled.PlayArrow
+import androidx.compose.material3.Card
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
 import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.Scaffold
+import androidx.compose.material3.RadioButton
+import androidx.compose.material3.Slider
+import androidx.compose.material3.Surface
 import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableDoubleStateOf
+import androidx.compose.runtime.mutableFloatStateOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.runtime.withFrameNanos
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.alpha
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.semantics.Role
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.unit.dp
 import androidx.core.view.WindowCompat
 import androidx.core.view.WindowInsetsCompat
 import androidx.core.view.WindowInsetsControllerCompat
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleEventObserver
+import androidx.lifecycle.compose.LocalLifecycleOwner
+import com.google.android.gms.maps.model.LatLng
+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.maps.android.SphericalUtil
+import com.google.maps.android.compose3d.GoogleMap3D
+import com.google.maps.android.compose3d.PolylineConfig
+import kotlinx.coroutines.delay
 
 class PathFollowingActivity : ComponentActivity() {
+    val touchEventFlow = kotlinx.coroutines.flow.MutableSharedFlow<Unit>(extraBufferCapacity = 1)
+
+    override fun dispatchTouchEvent(ev: MotionEvent): Boolean {
+        if (ev.action == MotionEvent.ACTION_DOWN || ev.action == MotionEvent.ACTION_MOVE) {
+            touchEventFlow.tryEmit(Unit)
+        }
+        return super.dispatchTouchEvent(ev)
+    }
+
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         enableEdgeToEdge()
+
+        val windowInsetsController = WindowCompat.getInsetsController(window, window.decorView)
+        windowInsetsController.hide(WindowInsetsCompat.Type.systemBars())
+        windowInsetsController.systemBarsBehavior =
+            WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
+
         setContent {
             MaterialTheme {
-                Scaffold(modifier = Modifier.fillMaxSize()) { innerPadding ->
-                    Box(
-                        modifier = Modifier
-                            .fillMaxSize()
-                            .padding(innerPadding),
-                        contentAlignment = Alignment.Center,
+                Surface(
+                    modifier = Modifier.fillMaxSize(),
+                    color = MaterialTheme.colorScheme.background,
+                ) {
+                    PathFollowingScreen()
+                }
+            }
+        }
+    }
+
+    companion object {
+        // Urban Path (New York City - Central Park Block Circuit)
+        val URBAN_PATH = listOf(
+            LatLng(40.7783119, -73.9627630),
+            LatLng(40.7776355, -73.9611664),
+            LatLng(40.7770011, -73.9616294),
+            LatLng(40.7776743, -73.9632228),
+            LatLng(40.7783119, -73.9627630),
+        )
+
+        // Rural Path
+        val RURAL_PATH = listOf(
+            LatLng(37.254529, -122.380897),
+            LatLng(37.255065, -122.381627),
+            LatLng(37.257540, -122.383720),
+            LatLng(37.261200, -122.383950),
+            LatLng(37.264780, -122.388210),
+            LatLng(37.268520, -122.392450),
+            LatLng(37.272110, -122.397640),
+            LatLng(37.276430, -122.401120),
+            LatLng(37.280850, -122.403560),
+            LatLng(37.286018, -122.405072),
+            LatLng(37.291040, -122.404210),
+            LatLng(37.295800, -122.401980),
+            LatLng(37.300120, -122.399540),
+            LatLng(37.304550, -122.397210),
+            LatLng(37.309200, -122.395100),
+            LatLng(37.313450, -122.392840),
+            LatLng(37.317200, -122.390510),
+            LatLng(37.320850, -122.388740),
+            LatLng(37.323540, -122.387600),
+            LatLng(37.325269, -122.386728),
+        )
+    }
+}
+
+enum class EnvironmentType(val label: String) {
+    URBAN("Urban"),
+    RURAL("Rural"),
+}
+
+@Composable
+fun PathFollowingScreen() {
+    var isMapSteady by remember { mutableStateOf(false) }
+
+    // UX Fade logic
+    val activity = LocalContext.current as PathFollowingActivity
+    var showControls by remember { mutableStateOf(true) }
+
+    LaunchedEffect(Unit) {
+        activity.touchEventFlow.collect {
+            showControls = true
+        }
+    }
+
+    LaunchedEffect(showControls) {
+        if (showControls) {
+            kotlinx.coroutines.delay(3000)
+            showControls = false
+        }
+    }
+
+    val controlsAlpha by animateFloatAsState(
+        targetValue = if (showControls) 1f else 0.2f,
+        animationSpec = tween(500),
+    )
+
+    // Environment Selection State
+    var selectedEnv by remember { mutableStateOf(EnvironmentType.URBAN) }
+    var currentPath by remember { mutableStateOf(PathFollowingActivity.URBAN_PATH) }
+
+    // Path Calculations State
+    val pathCalculations = remember(currentPath) {
+        val cumulative = DoubleArray(currentPath.size)
+        var total = 0.0
+        cumulative[0] = 0.0
+        for (i in 1 until currentPath.size) {
+            val dist = SphericalUtil.computeDistanceBetween(currentPath[i - 1], currentPath[i])
+            total += dist
+            cumulative[i] = total
+        }
+        Pair(cumulative, total)
+    }
+    val cumulativeDistances = pathCalculations.first
+    val totalDistance = pathCalculations.second
+
+    // Animation Controls State
+    var isPlaying by remember { mutableStateOf(false) }
+    var progress by remember { mutableFloatStateOf(0.0f) }
+    var isUserScrubbing by remember { mutableStateOf(false) }
+    var elapsedDistance by remember { mutableDoubleStateOf(0.0) }
+
+    val lifecycleOwner = LocalLifecycleOwner.current
+    DisposableEffect(lifecycleOwner) {
+        val observer = LifecycleEventObserver { _, event ->
+            if (event == Lifecycle.Event.ON_PAUSE || event == Lifecycle.Event.ON_STOP || event == Lifecycle.Event.ON_DESTROY) {
+                isPlaying = false
+            }
+        }
+        lifecycleOwner.lifecycle.addObserver(observer)
+        onDispose {
+            lifecycleOwner.lifecycle.removeObserver(observer)
+        }
+    }
+
+    // Camera Parameter Sliders State
+    var cameraRange by remember { mutableFloatStateOf(300f) }
+    var groundAltitude by remember { mutableFloatStateOf(20f) }
+    var headingOffset by remember { mutableFloatStateOf(0f) }
+    var cameraTilt by remember { mutableFloatStateOf(70f) }
+    var followSpeedMps by remember { mutableFloatStateOf(30f) }
+
+    // Interpolated Position & Heading
+    var currentLatLng by remember(currentPath) { mutableStateOf(currentPath.first()) }
+    var currentHeading by remember { mutableStateOf<Double?>(null) }
+    var targetHeading by remember { mutableDoubleStateOf(120.0) }
+
+    // Helper to calculate position for given elapsed distance
+    fun updatePositionForDistance(dist: Double) {
+        if (currentPath.isEmpty()) return
+        var index = 0
+        while (index < cumulativeDistances.size - 1 && cumulativeDistances[index + 1] < dist) {
+            index++
+        }
+        val p1 = currentPath[index]
+        val p2 = if (index < currentPath.size - 1) currentPath[index + 1] else p1
+
+        val segStartDist = cumulativeDistances[index]
+        val segEndDist =
+            if (index < cumulativeDistances.size - 1) cumulativeDistances[index + 1] else totalDistance
+        val segLen = segEndDist - segStartDist
+
+        val fraction = if (segLen > 0) ((dist - segStartDist) / segLen).coerceIn(0.0, 1.0) else 0.0
+        currentLatLng = SphericalUtil.interpolate(p1, p2, fraction)
+        val bearing = SphericalUtil.computeHeading(p1, p2)
+
+        val targetHeadingRaw = (bearing + headingOffset + 360.0) % 360.0
+        val computedHeading = if (currentHeading == null || isUserScrubbing || !isPlaying) {
+            targetHeadingRaw
+        } else {
+            var diff = (targetHeadingRaw - currentHeading!!) % 360.0
+            if (diff > 180.0) diff -= 360.0
+            if (diff < -180.0) diff += 360.0
+            (currentHeading!! + diff * 0.12 + 360.0) % 360.0
+        }
+        currentHeading = computedHeading
+        targetHeading = computedHeading
+    }
+
+    // Switch Environment logic
+    fun switchEnvironment(env: EnvironmentType) {
+        selectedEnv = env
+        isPlaying = false
+        currentHeading = null
+        progress = 0f
+        elapsedDistance = 0.0
+        if (env == EnvironmentType.RURAL) {
+            currentPath = PathFollowingActivity.RURAL_PATH
+            cameraRange = 450f
+            groundAltitude = 40f
+            cameraTilt = 75f
+        } else {
+            currentPath = PathFollowingActivity.URBAN_PATH
+            cameraRange = 300f
+            groundAltitude = 20f
+            cameraTilt = 70f
+        }
+        updatePositionForDistance(0.0)
+    }
+
+    // Animation Loop synced to VSYNC
+    LaunchedEffect(isPlaying) {
+        if (!isPlaying) return@LaunchedEffect
+        var lastTimeNanos = withFrameNanos { it }
+        while (isPlaying) {
+            val nowNanos = withFrameNanos { it }
+            val dt = (nowNanos - lastTimeNanos) / 1_000_000_000.0
+            lastTimeNanos = nowNanos
+
+            val stepDistance = followSpeedMps * dt
+            elapsedDistance += stepDistance
+
+            if (elapsedDistance >= totalDistance) {
+                elapsedDistance = 0.0
+            }
+
+            if (!isUserScrubbing && totalDistance > 0) {
+                progress = (elapsedDistance / totalDistance).toFloat().coerceIn(0f, 1f)
+            }
+            updatePositionForDistance(elapsedDistance)
+        }
+    }
+
+    // Dynamic Camera State
+    val dynamicCamera =
+        remember(currentLatLng, targetHeading, cameraTilt, cameraRange, groundAltitude) {
+            camera {
+                center = latLngAltitude {
+                    latitude = currentLatLng.latitude
+                    longitude = currentLatLng.longitude
+                    altitude = groundAltitude.toDouble()
+                }
+                heading = targetHeading
+                tilt = cameraTilt.toDouble()
+                range = cameraRange.toDouble()
+                roll = 0.0
+            }
+        }
+
+    // Polyline Config
+    val polylineConfig = remember(currentPath) {
+        PolylineConfig(
+            key = "path_following_polyline",
+            points = currentPath.map { latLng ->
+                latLngAltitude {
+                    latitude = latLng.latitude
+                    longitude = latLng.longitude
+                    altitude = 5.0
+                }
+            },
+            color = Color.BLUE,
+            width = 10f,
+            altitudeMode = AltitudeMode.RELATIVE_TO_GROUND,
+        )
+    }
+
+    Box(
+        modifier = Modifier
+            .fillMaxSize()
+            .semantics { contentDescription = if (isMapSteady) "MapSteady" else "MapLoading" },
+    ) {
+        // 1. Full Screen 3D Map
+        GoogleMap3D(
+            camera = dynamicCamera,
+            polylines = listOf(polylineConfig),
+            modifier = Modifier.fillMaxSize(),
+            onMapSteady = {
+                isMapSteady = true
+            },
+        )
+
+        // 2. Control Panel Card at Bottom
+        Card(
+            modifier = Modifier
+                .align(Alignment.BottomCenter)
+                .padding(16.dp)
+                .fillMaxWidth()
+                .alpha(controlsAlpha),
+        ) {
+            Column(
+                modifier = Modifier
+                    .padding(16.dp)
+                    .heightIn(max = 320.dp)
+                    .verticalScroll(rememberScrollState()),
+            ) {
+                // Environment Selector
+                Text(
+                    text = "Path Environment:",
+                    style = MaterialTheme.typography.labelLarge,
+                )
+
+                Row(
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .padding(vertical = 4.dp),
+                    horizontalArrangement = Arrangement.SpaceBetween,
+                ) {
+                    EnvironmentType.entries.forEach { env ->
+                        Row(
+                            verticalAlignment = Alignment.CenterVertically,
+                            modifier = Modifier
+                                .weight(1f)
+                                .selectable(
+                                    selected = (selectedEnv == env),
+                                    onClick = { switchEnvironment(env) },
+                                    role = Role.RadioButton,
+                                ),
+                        ) {
+                            RadioButton(
+                                selected = (selectedEnv == env),
+                                onClick = null,
+                            )
+                            Text(
+                                text = env.label,
+                                style = MaterialTheme.typography.bodyMedium,
+                                modifier = Modifier.padding(start = 4.dp),
+                            )
+                        }
+                    }
+                }
+
+                // Play / Pause and Progress Slider Row
+                Row(
+                    verticalAlignment = Alignment.CenterVertically,
+                    modifier = Modifier.fillMaxWidth(),
+                ) {
+                    IconButton(
+                        onClick = { isPlaying = !isPlaying },
                     ) {
-                        Text(
-                            text = "TODO: Path Following sample will be implemented here.",
-                            style = MaterialTheme.typography.headlineSmall,
+                        Icon(
+                            imageVector = if (isPlaying) Icons.Filled.Pause else Icons.Filled.PlayArrow,
+                            contentDescription = "Play or Pause animation",
                         )
                     }
+
+                    Slider(
+                        value = progress,
+                        onValueChange = { newValue ->
+                            isUserScrubbing = true
+                            progress = newValue
+                            elapsedDistance = totalDistance * newValue
+                            updatePositionForDistance(elapsedDistance)
+                        },
+                        onValueChangeFinished = {
+                            isUserScrubbing = false
+                        },
+                        modifier = Modifier
+                            .weight(1f)
+                            .semantics { contentDescription = "Path Progress Slider" },
+                    )
                 }
+
+                // Camera Controls Sliders
+                Text(
+                    text = "Camera Range: ${cameraRange.toInt()}m",
+                    style = MaterialTheme.typography.labelMedium,
+                )
+                Slider(
+                    value = cameraRange,
+                    onValueChange = {
+                        cameraRange = it
+                        updatePositionForDistance(elapsedDistance)
+                    },
+                    valueRange = 50f..1000f,
+                    modifier = Modifier.semantics { contentDescription = "Camera Range Slider" },
+                )
+
+                val maxAltitude = if (selectedEnv == EnvironmentType.RURAL) 2000f else 200f
+                Text(
+                    text = "Ground Altitude: ${groundAltitude.toInt()}m",
+                    style = MaterialTheme.typography.labelMedium,
+                )
+                Slider(
+                    value = groundAltitude.coerceIn(2f, maxAltitude),
+                    onValueChange = {
+                        groundAltitude = it
+                        updatePositionForDistance(elapsedDistance)
+                    },
+                    valueRange = 2f..maxAltitude,
+                    modifier = Modifier.semantics { contentDescription = "Ground Altitude Slider" },
+                )
+
+                Text(
+                    text = "Heading Offset: ${headingOffset.toInt()}°",
+                    style = MaterialTheme.typography.labelMedium,
+                )
+                Slider(
+                    value = headingOffset,
+                    onValueChange = {
+                        headingOffset = it
+                        updatePositionForDistance(elapsedDistance)
+                    },
+                    valueRange = -180f..180f,
+                    modifier = Modifier.semantics { contentDescription = "Heading Offset Slider" },
+                )
+
+                Text(
+                    text = "Camera Tilt: ${cameraTilt.toInt()}°",
+                    style = MaterialTheme.typography.labelMedium,
+                )
+                Slider(
+                    value = cameraTilt,
+                    onValueChange = {
+                        cameraTilt = it
+                        updatePositionForDistance(elapsedDistance)
+                    },
+                    valueRange = 0f..85f,
+                    modifier = Modifier.semantics { contentDescription = "Camera Tilt Slider" },
+                )
+
+                Text(
+                    text = "Follow Speed: ${followSpeedMps.toInt()} m/s",
+                    style = MaterialTheme.typography.labelMedium,
+                )
+                Slider(
+                    value = followSpeedMps,
+                    onValueChange = { followSpeedMps = it },
+                    valueRange = 5f..100f,
+                    modifier = Modifier.semantics { contentDescription = "Follow Speed Slider" },
+                )
             }
         }
     }
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 9275f79e..d5829b06 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
@@ -20,35 +20,145 @@ import android.os.Bundle
 import androidx.activity.ComponentActivity
 import androidx.activity.compose.setContent
 import androidx.activity.enableEdgeToEdge
+import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+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.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.MaterialTheme
-import androidx.compose.material3.Scaffold
+import androidx.compose.material3.RadioButton
+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
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
-import androidx.core.view.WindowCompat
-import androidx.core.view.WindowInsetsCompat
-import androidx.core.view.WindowInsetsControllerCompat
+import androidx.compose.ui.semantics.Role
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.dp
+import com.google.android.gms.maps.model.LatLng
+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
 
 class RoadmapModeActivity : ComponentActivity() {
+
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         enableEdgeToEdge()
         setContent {
             MaterialTheme {
-                Scaffold(modifier = Modifier.fillMaxSize()) { innerPadding ->
-                    Box(
-                        modifier = Modifier
-                            .fillMaxSize()
-                            .padding(innerPadding),
-                        contentAlignment = Alignment.Center,
-                    ) {
-                        Text(
-                            text = "TODO: Roadmap Mode sample will be implemented here.",
-                            style = MaterialTheme.typography.headlineSmall,
-                        )
+                Surface(
+                    modifier = Modifier.fillMaxSize(),
+                    color = MaterialTheme.colorScheme.background,
+                ) {
+                    RoadmapModeScreen()
+                }
+            }
+        }
+    }
+
+    companion object {
+        // San Francisco Financial District
+        val SF_LOCATION = LatLng(37.7915, -122.4010)
+    }
+}
+
+@Composable
+fun RoadmapModeScreen() {
+    var selectedMapMode by remember { mutableIntStateOf(Map3DMode.ROADMAP) }
+
+    val initialLocation = RoadmapModeActivity.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
+            },
+        )
+    }
+
+    Box(modifier = Modifier.fillMaxSize()) {
+        GoogleMap3D(
+            camera = currentCameraState,
+            mapMode = selectedMapMode,
+            modifier = Modifier.fillMaxSize(),
+        )
+
+        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(12.dp),
+            ) {
+                Text(
+                    text = "Map Mode",
+                    style = MaterialTheme.typography.labelLarge,
+                    fontWeight = FontWeight.Bold,
+                )
+
+                Spacer(modifier = Modifier.height(8.dp))
+
+                Row(
+                    modifier = Modifier.fillMaxWidth(),
+                    horizontalArrangement = Arrangement.SpaceBetween,
+                    verticalAlignment = Alignment.CenterVertically,
+                ) {
+                    val modes = listOf(
+                        Map3DMode.ROADMAP to "Roadmap",
+                        Map3DMode.HYBRID to "Hybrid",
+                        Map3DMode.SATELLITE to "Satellite",
+                    )
+
+                    modes.forEach { (modeValue, modeTitle) ->
+                        Row(
+                            modifier = Modifier
+                                .selectable(
+                                    selected = (selectedMapMode == modeValue),
+                                    onClick = { selectedMapMode = modeValue },
+                                    role = Role.RadioButton,
+                                )
+                                .padding(vertical = 4.dp),
+                            verticalAlignment = Alignment.CenterVertically,
+                        ) {
+                            RadioButton(
+                                selected = (selectedMapMode == modeValue),
+                                onClick = null,
+                            )
+                            Spacer(modifier = Modifier.width(4.dp))
+                            Text(
+                                text = modeTitle,
+                                style = MaterialTheme.typography.bodyMedium,
+                            )
+                        }
                     }
                 }
             }
diff --git a/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/routes/RouteEngine.kt b/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/routes/RouteEngine.kt
index 9dff7f6c..a22dca93 100644
--- a/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/routes/RouteEngine.kt
+++ b/Maps3DSamples/ComposeDemos/app/src/main/java/com/example/composedemos/routes/RouteEngine.kt
@@ -29,6 +29,17 @@ data class PositionAndHeading(
 )
 
 object RouteEngine {
+    fun calculateCumulativeDistances(route: List<LatLng>): DoubleArray {
+        if (route.isEmpty()) return doubleArrayOf(0.0)
+
+        val cumulativeDistances = DoubleArray(route.size)
+        cumulativeDistances[0] = 0.0
+        for (i in 1 until route.size) {
+            cumulativeDistances[i] = cumulativeDistances[i - 1] + haversineDistance(route[i - 1], route[i])
+        }
+        return cumulativeDistances
+    }
+
     fun calculatePositionAndHeading(
         route: List<LatLng>,
         cumulativeDistances: DoubleArray,
@@ -58,11 +69,7 @@ object RouteEngine {
     ): Flow<PositionAndHeading> = combine(routeFlow, progressFlow) { route, progress ->
         if (route.size < 2) return@combine PositionAndHeading(LatLng(0.0, 0.0), 0f)
 
-        val cumulativeDistances = DoubleArray(route.size)
-        cumulativeDistances[0] = 0.0
-        for (i in 1 until route.size) {
-            cumulativeDistances[i] = cumulativeDistances[i - 1] + haversineDistance(route[i - 1], route[i])
-        }
+        val cumulativeDistances = calculateCumulativeDistances(route)
         val totalDistance = cumulativeDistances.last()
         val distance = totalDistance * progress.toDouble()
 
diff --git a/Maps3DSamples/advanced/app/src/main/java/com/example/advancedmaps3dsamples/scenarios/CameraAttributesScreen.kt b/Maps3DSamples/advanced/app/src/main/java/com/example/advancedmaps3dsamples/scenarios/CameraAttributesScreen.kt
index f420cb76..415559cf 100644
--- a/Maps3DSamples/advanced/app/src/main/java/com/example/advancedmaps3dsamples/scenarios/CameraAttributesScreen.kt
+++ b/Maps3DSamples/advanced/app/src/main/java/com/example/advancedmaps3dsamples/scenarios/CameraAttributesScreen.kt
@@ -69,7 +69,9 @@ fun CameraControlDemoScreen(
   Box(modifier = modifier.fillMaxSize()) {
     Column(modifier = Modifier.fillMaxSize()) {
       ThreeDMap(
-        modifier = Modifier.fillMaxWidth().weight(1f),
+        modifier = Modifier
+          .fillMaxWidth()
+          .weight(1f),
         mapsConfig = scenario.mapsConfig,
         viewModel = viewModel,
       )
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 9f1f25f6..bd14fbdc 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
@@ -69,7 +69,26 @@ fun GoogleMap3D(
     popovers: List<PopoverConfig> = emptyList(),
     cameraRestriction: CameraRestriction? = null,
     @Map3DMode mapMode: Int = Map3DMode.SATELLITE,
-    options: Map3DInitConfig = Map3DInitConfig.create(),
+    options: Map3DInitConfig = Map3DInitConfig.create(
+        centerLat = 0.0,
+        centerLng = 0.0,
+        centerAlt = 0.0,
+        heading = 0.0,
+        tilt = 0.0,
+        roll = 0.0,
+        range = 10_000_000.0, // Default range wide view
+        minHeading = 0.0,
+        maxHeading = 360.0,
+        minTilt = 0.0,
+        maxTilt = 90.0,
+        bounds = null,
+        mapMode = Map3DMode.SATELLITE, // using the class from com.google.android.gms.maps3d.model.Map3DMode
+        mapId = null,
+        minAltitude = 0.0,
+        maxAltitude = 1000000.0,
+        language = java.util.Locale.getDefault().language,
+        region = java.util.Locale.getDefault().country,
+    ),
     onMapReady: (GoogleMap3D) -> Unit = {},
     onMapSteady: () -> Unit = {},
     onMapClick: ((LatLngAltitude) -> Unit)? = null,
diff --git a/maps3d-compose/src/main/java/com/google/maps/android/compose3d/Map3DState.kt b/maps3d-compose/src/main/java/com/google/maps/android/compose3d/Map3DState.kt
index 43cd549b..11539222 100644
--- a/maps3d-compose/src/main/java/com/google/maps/android/compose3d/Map3DState.kt
+++ b/maps3d-compose/src/main/java/com/google/maps/android/compose3d/Map3DState.kt
@@ -25,6 +25,7 @@ import com.google.android.gms.maps3d.model.Glyph
 import com.google.android.gms.maps3d.model.Hole
 import com.google.android.gms.maps3d.model.Marker
 import com.google.android.gms.maps3d.model.Model
+import com.google.android.gms.maps3d.model.Orientation
 import com.google.android.gms.maps3d.model.PinConfiguration
 import com.google.android.gms.maps3d.model.Polygon
 import com.google.android.gms.maps3d.model.Polyline
@@ -195,7 +196,10 @@ class Map3DState {
             if (existing != null) {
                 val (oldConfig, model) = existing
                 if (oldConfig != config) {
-                    // Config changed, update by adding again with same ID!
+                    // Config changed.
+                    // Note: We dynamically update the model's properties by adding it again
+                    // with the same underlying ID (`model.id`). Under the hood, this acts as a safe,
+                    // efficient upsert operation to the renderer.
                     val newModel = createModel(map, config, model.id)
                     if (newModel != null) {
                         models[config.key] = Pair(config, newModel)