add compact layout counter-rotation and mode readout

app/src/main/AndroidManifest.xml

@@ -70,9 +70,9 @@
         <profileable android:shell="true"/>
         <activity
             android:name=".MainActivity"
+            android:configChanges="orientation|screenSize|smallestScreenSize|screenLayout|keyboardHidden"
             android:exported="true"
             android:label="@string/app_name_short"
-            android:screenOrientation="nosensor"
             android:theme="@style/Theme.JetpackCamera">
             <intent-filter>
                 <action android:name="android.intent.action.MAIN" />

app/src/main/java/com/google/jetpackcamera/MainActivity.kt

@@ -18,6 +18,7 @@ package com.google.jetpackcamera
 import android.app.Activity
 import android.content.Intent
 import android.content.pm.ActivityInfo
+import android.content.res.Configuration
 import android.hardware.Camera
 import android.net.Uri
 import android.os.Build
@@ -31,6 +32,7 @@ import androidx.activity.compose.setContent
 import androidx.activity.enableEdgeToEdge
 import androidx.activity.viewModels
 import androidx.annotation.RequiresApi
+import androidx.annotation.VisibleForTesting
 import androidx.compose.foundation.background
 import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.foundation.layout.Arrangement
@@ -81,6 +83,26 @@ import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.launch
 
 private const val TAG = "MainActivity"
+private const val LARGE_SCREEN_MIN_WIDTH_DP = 600
+
+/**
+ * Resolves the Activity's [ActivityInfo] screen orientation policy for the current window posture.
+ *
+ * Full-screen compact handhelds (`!isInMultiWindowMode && smallestScreenWidthDp < 600`) lock the
+ * window to [ActivityInfo.SCREEN_ORIENTATION_NOSENSOR] so the UI counter-rotates via sensor
+ * gravity without triggering a system window rotation. Multi-window panes and large screens
+ * (`smallestScreenWidthDp >= 600`) use [ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED] so the OS
+ * does not apply 1:1 portrait compatibility letterboxing.
+ */
+@VisibleForTesting
+internal fun resolveRequestedOrientation(
+    isInMultiWindowMode: Boolean,
+    smallestScreenWidthDp: Int
+): Int = if (!isInMultiWindowMode && smallestScreenWidthDp < LARGE_SCREEN_MIN_WIDTH_DP) {
+    ActivityInfo.SCREEN_ORIENTATION_NOSENSOR
+} else {
+    ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED
+}
 
 /**
  * Activity for the JetpackCameraApp.
@@ -103,6 +125,10 @@ class MainActivity : ComponentActivity() {
             navigationBarStyle = SystemBarStyle.dark(android.graphics.Color.TRANSPARENT)
         )
         super.onCreate(savedInstanceState)
+        updateRequestedOrientation(resources.configuration)
+        addOnMultiWindowModeChangedListener { info ->
+            updateRequestedOrientation(resources.configuration, info.isInMultiWindowMode)
+        }
         cameraLaunchConfigProvider.setIntent(intent)
         var uiState: MainActivityUiState by mutableStateOf(Loading)
 
@@ -194,6 +220,24 @@ class MainActivity : ComponentActivity() {
         }
     }
 
+    override fun onConfigurationChanged(newConfig: Configuration) {
+        super.onConfigurationChanged(newConfig)
+        updateRequestedOrientation(newConfig)
+    }
+
+    private fun updateRequestedOrientation(
+        configuration: Configuration,
+        multiWindowMode: Boolean = isInMultiWindowMode
+    ) {
+        val targetOrientation = resolveRequestedOrientation(
+            isInMultiWindowMode = multiWindowMode,
+            smallestScreenWidthDp = configuration.smallestScreenWidthDp
+        )
+        if (requestedOrientation != targetOrientation) {
+            requestedOrientation = targetOrientation
+        }
+    }
+
     private val debugSettings: DebugSettings
         get() = cameraLaunchConfigProvider.config.value.debugSettings
 

app/src/test/java/com/google/jetpackcamera/MainActivityOrientationTest.kt

@@ -0,0 +1,73 @@
+/*
+ * Copyright (C) 2026 The Android Open Source Project
+ *
+ * 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.google.jetpackcamera
+
+import android.content.pm.ActivityInfo
+import com.google.common.truth.Truth.assertThat
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+
+/**
+ * Unit tests for [resolveRequestedOrientation].
+ */
+@RunWith(JUnit4::class)
+class MainActivityOrientationTest {
+
+    @Test
+    fun resolveRequestedOrientation_fullScreenCompactPhone_locksToNoSensor() {
+        assertThat(
+            resolveRequestedOrientation(
+                isInMultiWindowMode = false,
+                smallestScreenWidthDp = 411
+            )
+        ).isEqualTo(ActivityInfo.SCREEN_ORIENTATION_NOSENSOR)
+
+        assertThat(
+            resolveRequestedOrientation(
+                isInMultiWindowMode = false,
+                smallestScreenWidthDp = 599
+            )
+        ).isEqualTo(ActivityInfo.SCREEN_ORIENTATION_NOSENSOR)
+    }
+
+    @Test
+    fun resolveRequestedOrientation_multiWindowCompact_allowsUnspecifiedOrientation() {
+        assertThat(
+            resolveRequestedOrientation(
+                isInMultiWindowMode = true,
+                smallestScreenWidthDp = 411
+            )
+        ).isEqualTo(ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED)
+    }
+
+    @Test
+    fun resolveRequestedOrientation_largeScreenOrFoldable_allowsUnspecifiedOrientation() {
+        assertThat(
+            resolveRequestedOrientation(
+                isInMultiWindowMode = false,
+                smallestScreenWidthDp = 600
+            )
+        ).isEqualTo(ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED)
+
+        assertThat(
+            resolveRequestedOrientation(
+                isInMultiWindowMode = true,
+                smallestScreenWidthDp = 673
+            )
+        ).isEqualTo(ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED)
+    }
+}

core/model/src/main/java/com/google/jetpackcamera/model/DeviceRotation.kt

@@ -49,6 +49,39 @@ enum class DeviceRotation {
         }
     }
 
+    /**
+     * Returns the clockwise rotation in degrees needed inside a window at [windowRotation] so that
+     * UI elements remain oriented upright against physical gravity (`this` device rotation).
+     *
+     * An upside-down (`180°`) delta is mapped to `0` so camera controls and layouts never flip
+     * upside-down.
+     */
+    fun toGravityRotationDegrees(windowRotation: DeviceRotation): Int {
+        val rawDelta =
+            (
+                (windowRotation.toClockwiseRotationDegrees() - toClockwiseRotationDegrees()) %
+                    360 + 360
+                ) % 360
+        return if (rawDelta == 180) 0 else rawDelta
+    }
+
+    /**
+     * Returns the clockwise rotation in degrees needed to counter-rotate a root container back to
+     * the device's natural portrait coordinate frame when the OS window is rotated to `this`
+     * orientation.
+     */
+    fun toWindowCounterRotationDegrees(): Float {
+        return when (this) {
+            Natural -> 0f
+            Rotated90 -> 90f
+            Rotated180 -> 180f
+            Rotated270 -> -90f
+        }
+    }
+
+    val isLandscape: Boolean
+        get() = this == Rotated90 || this == Rotated270
+
     companion object {
         /**
          * Returns the [DeviceRotation] corresponding to a UI [Surface] rotation constant.

core/model/src/test/java/com/google/jetpackcamera/model/DeviceRotationTest.kt

@@ -0,0 +1,105 @@
+/*
+ * Copyright (C) 2026 The Android Open Source Project
+ *
+ * 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.google.jetpackcamera.model
+
+import android.view.Surface
+import com.google.common.truth.Truth.assertThat
+import org.junit.Test
+
+class DeviceRotationTest {
+
+    @Test
+    fun fromUiSurfaceRotation_mapsAllSurfaceRotationsAndIsInverseOfToUiSurfaceRotation() {
+        assertThat(DeviceRotation.fromUiSurfaceRotation(Surface.ROTATION_0))
+            .isEqualTo(DeviceRotation.Natural)
+        assertThat(DeviceRotation.fromUiSurfaceRotation(Surface.ROTATION_90))
+            .isEqualTo(DeviceRotation.Rotated270)
+        assertThat(DeviceRotation.fromUiSurfaceRotation(Surface.ROTATION_180))
+            .isEqualTo(DeviceRotation.Rotated180)
+        assertThat(DeviceRotation.fromUiSurfaceRotation(Surface.ROTATION_270))
+            .isEqualTo(DeviceRotation.Rotated90)
+        assertThat(DeviceRotation.fromUiSurfaceRotation(-1))
+            .isEqualTo(DeviceRotation.Natural)
+
+        for (rotation in DeviceRotation.entries) {
+            assertThat(DeviceRotation.fromUiSurfaceRotation(rotation.toUiSurfaceRotation()))
+                .isEqualTo(rotation)
+        }
+    }
+
+    @Test
+    fun toGravityRotationDegrees_computesInWindowGravityCompensationAngle() {
+        // Phone upright (Dev 0°, Win 0°) -> Icons 0°
+        assertThat(
+            DeviceRotation.Natural.toGravityRotationDegrees(
+                windowRotation = DeviceRotation.Natural
+            )
+        ).isEqualTo(0)
+
+        // Phone turned 90° CCW with locked portrait window (Dev 270°, Win 0°) -> Icons 90°
+        assertThat(
+            DeviceRotation.Rotated270.toGravityRotationDegrees(
+                windowRotation = DeviceRotation.Natural
+            )
+        ).isEqualTo(90)
+
+        // Phone turned 90° CW with locked portrait window (Dev 90°, Win 0°) -> Icons 270°
+        assertThat(
+            DeviceRotation.Rotated90.toGravityRotationDegrees(
+                windowRotation = DeviceRotation.Natural
+            )
+        ).isEqualTo(270)
+
+        // Foldable/Tablet turned 90° CCW with OS auto-rotate ON (Dev 270°, Win 270°) -> Icons 0°
+        assertThat(
+            DeviceRotation.Rotated270.toGravityRotationDegrees(
+                windowRotation = DeviceRotation.Rotated270
+            )
+        ).isEqualTo(0)
+
+        // Foldable/Tablet turned 90° CCW with OS auto-rotate OFF (Dev 270°, Win 0°) -> Icons 90°
+        assertThat(
+            DeviceRotation.Rotated270.toGravityRotationDegrees(
+                windowRotation = DeviceRotation.Natural
+            )
+        ).isEqualTo(90)
+
+        // Upside-down delta (180°) clamps to 0° so UI never flips upside-down
+        assertThat(
+            DeviceRotation.Rotated180.toGravityRotationDegrees(
+                windowRotation = DeviceRotation.Natural
+            )
+        ).isEqualTo(0)
+        assertThat(
+            DeviceRotation.Rotated90.toGravityRotationDegrees(
+                windowRotation = DeviceRotation.Rotated270
+            )
+        ).isEqualTo(0)
+    }
+
+    @Test
+    fun toWindowCounterRotationDegrees_andIsLandscape_matchAllQuadrants() {
+        assertThat(DeviceRotation.Natural.toWindowCounterRotationDegrees()).isEqualTo(0f)
+        assertThat(DeviceRotation.Rotated90.toWindowCounterRotationDegrees()).isEqualTo(90f)
+        assertThat(DeviceRotation.Rotated180.toWindowCounterRotationDegrees()).isEqualTo(180f)
+        assertThat(DeviceRotation.Rotated270.toWindowCounterRotationDegrees()).isEqualTo(-90f)
+
+        assertThat(DeviceRotation.Natural.isLandscape).isFalse()
+        assertThat(DeviceRotation.Rotated180.isLandscape).isFalse()
+        assertThat(DeviceRotation.Rotated90.isLandscape).isTrue()
+        assertThat(DeviceRotation.Rotated270.isLandscape).isTrue()
+    }
+}