Camera Feature Policy API

app/build.gradle.kts

@@ -163,6 +163,7 @@ dependencies {
     implementation(project(":data:settings"))
     implementation(project(":core:settings:datastore-prefs"))
     implementation(project(":core:settings"))
+
     implementation(project(":core:model"))
     implementation(libs.androidx.datastore.preferences)
 

app/src/androidTest/java/com/google/jetpackcamera/CaptureModeSettingsTest.kt

@@ -32,6 +32,10 @@ import com.google.common.truth.Truth.assertThat
 import com.google.common.truth.TruthJUnit.assume
 import com.google.jetpackcamera.model.CaptureMode
 import com.google.jetpackcamera.model.ConcurrentCameraMode
+import com.google.jetpackcamera.model.ImageOutputFormat
+import com.google.jetpackcamera.settings.model.CameraFeaturePolicy
+import com.google.jetpackcamera.settings.model.OptionVisibility
+import com.google.jetpackcamera.settings.model.SettingConfig
 import com.google.jetpackcamera.ui.components.capture.CAPTURE_BUTTON
 import com.google.jetpackcamera.ui.components.capture.CAPTURE_MODE_TOGGLE_BUTTON
 import com.google.jetpackcamera.ui.components.capture.ROW_QUICK_SETTINGS_CAPTURE_MODE
@@ -58,6 +62,7 @@ import com.google.jetpackcamera.utils.waitForCaptureButton
 import com.google.jetpackcamera.utils.waitForCaptureModeToggleState
 import com.google.jetpackcamera.utils.waitForNodeWithTag
 import com.google.jetpackcamera.utils.waitForNodeWithTagToDisappear
+import org.junit.After
 import org.junit.Rule
 import org.junit.Test
 import org.junit.runner.RunWith
@@ -73,6 +78,12 @@ internal class CaptureModeSettingsTest {
 
     private val instrumentation = InstrumentationRegistry.getInstrumentation()
     private val uiDevice = UiDevice.getInstance(instrumentation)
+
+    @After
+    fun tearDown() {
+        AppModule.testCameraFeaturePolicy = null
+    }
+
     private fun ComposeTestRule.checkCaptureModeSettingState(captureMode: CaptureMode? = null) =
         visitQuickSettings {
             captureMode?.let {
@@ -157,11 +168,8 @@ internal class CaptureModeSettingsTest {
                 // should not be able to switch between capture modes
                 onNodeWithTag(ROW_QUICK_SETTINGS_CAPTURE_MODE).assertDoesNotExist()
             }
-            // verify switch is disabled and locked on video only
-            assertThat(composeTestRule.isCaptureModeToggleEnabled()).isFalse()
-            assertThat(
-                composeTestRule.getCaptureModeToggleState()
-            ).isEqualTo(CaptureMode.VIDEO_ONLY)
+            // verify switch is removed when mode switching is not supported
+            composeTestRule.onNodeWithTag(CAPTURE_MODE_TOGGLE_BUTTON).assertDoesNotExist()
 
             // set concurrent camera mode back to off in settings
             composeTestRule.setConcurrentCameraModeInSettings(ConcurrentCameraMode.OFF)
@@ -228,30 +236,36 @@ internal class CaptureModeSettingsTest {
 
     @Test
     fun hdr_supports_video_only() {
-        runMainActivityScenarioTest {
-            composeTestRule.waitForCaptureButton()
+        AppModule.testCameraFeaturePolicy = CameraFeaturePolicy(
+            imageFormat = SettingConfig(
+                defaultValue = ImageOutputFormat.JPEG,
+                visibility = OptionVisibility.Hidden
+            )
+        )
+        try {
+            runMainActivityScenarioTest {
+                composeTestRule.waitForCaptureButton()
 
-            // Switch to VIDEO_ONLY first since STANDARD doesn't support HDR
-            composeTestRule.setCaptureMode(CaptureMode.VIDEO_ONLY)
-            composeTestRule.setHdrEnabled(true)
+                // Switch to VIDEO_ONLY first since STANDARD doesn't support HDR
+                composeTestRule.setCaptureMode(CaptureMode.VIDEO_ONLY)
+                composeTestRule.setHdrEnabled(true)
 
-            // check that switch is disabled and only supports video
-            composeTestRule.waitForNodeWithTag(CAPTURE_MODE_TOGGLE_BUTTON)
-            // should not be able use capture toggle
-            assume().that(composeTestRule.isCaptureModeToggleEnabled()).isFalse()
-            assume().that(composeTestRule.getCaptureModeToggleState())
-                .isEqualTo(CaptureMode.VIDEO_ONLY)
+                // check that switch is removed when mode switching is not supported
+                composeTestRule.onNodeWithTag(CAPTURE_MODE_TOGGLE_BUTTON).assertDoesNotExist()
 
-            composeTestRule.visitQuickSettings {
-                // capture mode should be video only
-                assertThat(getCurrentCaptureMode()).isEqualTo(CaptureMode.VIDEO_ONLY)
-                onNodeWithTag(ROW_QUICK_SETTINGS_CAPTURE_MODE).assertDoesNotExist()
-            }
-            assertThat(composeTestRule.isCaptureModeToggleEnabled()).isFalse()
+                composeTestRule.visitQuickSettings {
+                    // capture mode should be video only
+                    assertThat(getCurrentCaptureMode()).isEqualTo(CaptureMode.VIDEO_ONLY)
+                    onNodeWithTag(ROW_QUICK_SETTINGS_CAPTURE_MODE).assertDoesNotExist()
+                }
+                composeTestRule.onNodeWithTag(CAPTURE_MODE_TOGGLE_BUTTON).assertDoesNotExist()
 
-            composeTestRule.setHdrEnabled(false)
-            // Remains VIDEO_ONLY since we explicitly switched to it
-            composeTestRule.checkCaptureModeSettingState(CaptureMode.VIDEO_ONLY)
+                composeTestRule.setHdrEnabled(false)
+                // Remains VIDEO_ONLY since we explicitly switched to it
+                composeTestRule.checkCaptureModeSettingState(CaptureMode.VIDEO_ONLY)
+            }
+        } finally {
+            AppModule.testCameraFeaturePolicy = null
         }
     }
 
@@ -326,7 +340,7 @@ internal class CaptureModeSettingsTest {
     }
 
     @Test
-    fun image_intent_disables_capture_mode_toggle() {
+    fun image_intent_removes_capture_mode_toggle() {
         val timeStamp = System.currentTimeMillis()
         val uri = getTestUri(PICTURES_DIR_PATH, timeStamp, "jpg")
         val result =
@@ -338,10 +352,7 @@ internal class CaptureModeSettingsTest {
                 composeTestRule.visitQuickSettings {
                     checkCaptureModeSettingState(CaptureMode.IMAGE_ONLY)
                 }
-                assertThat(composeTestRule.isCaptureModeToggleEnabled()).isFalse()
-                assertThat(
-                    composeTestRule.getCaptureModeToggleState()
-                ).isEqualTo(CaptureMode.IMAGE_ONLY)
+                composeTestRule.onNodeWithTag(CAPTURE_MODE_TOGGLE_BUTTON).assertDoesNotExist()
 
                 uiDevice.pressBack()
             }
@@ -370,7 +381,7 @@ internal class CaptureModeSettingsTest {
     }
 
     @Test
-    fun video_intent_disables_capture_mode_toggle() {
+    fun video_intent_removes_capture_mode_toggle() {
         val timeStamp = System.currentTimeMillis()
         val uri = getTestUri(MOVIES_DIR_PATH, timeStamp, "mp4")
         val result =
@@ -382,10 +393,7 @@ internal class CaptureModeSettingsTest {
                 composeTestRule.visitQuickSettings {
                     checkCaptureModeSettingState(CaptureMode.VIDEO_ONLY)
                 }
-                assertThat(composeTestRule.isCaptureModeToggleEnabled()).isFalse()
-                assertThat(
-                    composeTestRule.getCaptureModeToggleState()
-                ).isEqualTo(CaptureMode.VIDEO_ONLY)
+                composeTestRule.onNodeWithTag(CAPTURE_MODE_TOGGLE_BUTTON).assertDoesNotExist()
 
                 uiDevice.pressBack()
             }

app/src/androidTest/java/com/google/jetpackcamera/featurepolicy/AspectRatioFeaturePolicyDeviceTest.kt

@@ -0,0 +1,171 @@
+/*
+ * 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.featurepolicy
+
+import androidx.compose.ui.test.assertIsOn
+import androidx.compose.ui.test.junit4.createEmptyComposeRule
+import androidx.compose.ui.test.onNodeWithTag
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.rule.GrantPermissionRule
+import com.google.jetpackcamera.AppModule
+import com.google.jetpackcamera.model.AspectRatio
+import com.google.jetpackcamera.settings.model.CameraFeaturePolicy
+import com.google.jetpackcamera.settings.model.OptionVisibility
+import com.google.jetpackcamera.settings.model.SettingConfig
+import com.google.jetpackcamera.ui.components.capture.QUICK_SETTINGS_RATIO_1_1_BUTTON
+import com.google.jetpackcamera.ui.components.capture.QUICK_SETTINGS_RATIO_3_4_BUTTON
+import com.google.jetpackcamera.ui.components.capture.QUICK_SETTINGS_RATIO_9_16_BUTTON
+import com.google.jetpackcamera.ui.components.capture.ROW_QUICK_SETTINGS_ASPECT_RATIO
+import com.google.jetpackcamera.utils.TEST_REQUIRED_PERMISSIONS
+import com.google.jetpackcamera.utils.runMainActivityScenarioTest
+import com.google.jetpackcamera.utils.visitQuickSettings
+import com.google.jetpackcamera.utils.waitForCaptureButton
+import org.junit.After
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+internal class AspectRatioFeaturePolicyDeviceTest {
+
+    @get:Rule
+    val permissionsRule: GrantPermissionRule =
+        GrantPermissionRule.grant(*(TEST_REQUIRED_PERMISSIONS).toTypedArray())
+
+    @get:Rule
+    val composeTestRule = createEmptyComposeRule()
+
+    @After
+    fun tearDown() {
+        AppModule.testCameraFeaturePolicy = null
+    }
+
+    // /////////////////////////////////////////////////////////////////////////
+    //
+    // Section A: Default Values
+    //
+    // /////////////////////////////////////////////////////////////////////////
+
+    @Test
+    fun defaultAspectRatio_oneOne_startsInOneOne() {
+        AppModule.testCameraFeaturePolicy = CameraFeaturePolicy(
+            aspectRatio = SettingConfig(defaultValue = AspectRatio.ONE_ONE)
+        )
+
+        runMainActivityScenarioTest {
+            composeTestRule.waitForCaptureButton()
+            composeTestRule.visitQuickSettings {
+                onNodeWithTag(QUICK_SETTINGS_RATIO_1_1_BUTTON).assertIsOn()
+            }
+        }
+    }
+
+    @Test
+    fun defaultAspectRatio_threeFour_startsInThreeFour() {
+        AppModule.testCameraFeaturePolicy = CameraFeaturePolicy(
+            aspectRatio = SettingConfig(defaultValue = AspectRatio.THREE_FOUR)
+        )
+
+        runMainActivityScenarioTest {
+            composeTestRule.waitForCaptureButton()
+            composeTestRule.visitQuickSettings {
+                onNodeWithTag(QUICK_SETTINGS_RATIO_3_4_BUTTON).assertIsOn()
+            }
+        }
+    }
+
+    @Test
+    fun defaultAspectRatio_nineSixteen_startsInNineSixteen() {
+        AppModule.testCameraFeaturePolicy = CameraFeaturePolicy(
+            aspectRatio = SettingConfig(defaultValue = AspectRatio.NINE_SIXTEEN)
+        )
+
+        runMainActivityScenarioTest {
+            composeTestRule.waitForCaptureButton()
+            composeTestRule.visitQuickSettings {
+                onNodeWithTag(QUICK_SETTINGS_RATIO_9_16_BUTTON).assertIsOn()
+            }
+        }
+    }
+
+    // /////////////////////////////////////////////////////////////////////////
+    //
+    // Section B: Hidden
+    //
+    // /////////////////////////////////////////////////////////////////////////
+
+    @Test
+    fun hiddenAspectRatio_removesAspectRatioControlFromQuickSettings() {
+        AppModule.testCameraFeaturePolicy = CameraFeaturePolicy(
+            aspectRatio = SettingConfig(
+                defaultValue = AspectRatio.ONE_ONE,
+                visibility = OptionVisibility.Hidden
+            )
+        )
+
+        runMainActivityScenarioTest {
+            composeTestRule.waitForCaptureButton()
+            composeTestRule.visitQuickSettings {
+                onNodeWithTag(ROW_QUICK_SETTINGS_ASPECT_RATIO).assertDoesNotExist()
+            }
+        }
+    }
+
+    // /////////////////////////////////////////////////////////////////////////
+    //
+    // Section C: OptionsEnabled / Filtering
+    //
+    // /////////////////////////////////////////////////////////////////////////
+
+    @Test
+    fun optionsEnabled_oneOneAndThreeFour_displaysOnlyThoseInQuickSettings() {
+        AppModule.testCameraFeaturePolicy = CameraFeaturePolicy(
+            aspectRatio = SettingConfig(
+                defaultValue = AspectRatio.ONE_ONE,
+                visibility = OptionVisibility.Only(
+                    setOf(AspectRatio.ONE_ONE, AspectRatio.THREE_FOUR)
+                )
+            )
+        )
+
+        runMainActivityScenarioTest {
+            composeTestRule.waitForCaptureButton()
+            composeTestRule.visitQuickSettings {
+                onNodeWithTag(ROW_QUICK_SETTINGS_ASPECT_RATIO).assertExists()
+                onNodeWithTag(QUICK_SETTINGS_RATIO_1_1_BUTTON).assertExists()
+                onNodeWithTag(QUICK_SETTINGS_RATIO_3_4_BUTTON).assertExists()
+                onNodeWithTag(QUICK_SETTINGS_RATIO_9_16_BUTTON).assertDoesNotExist()
+            }
+        }
+    }
+
+    @Test
+    fun optionsEnabled_singleOptionViaFactory_removesAspectRatioControlFromQuickSettings() {
+        AppModule.testCameraFeaturePolicy = CameraFeaturePolicy(
+            aspectRatio = SettingConfig(
+                defaultValue = AspectRatio.ONE_ONE,
+                visibility = OptionVisibility.from(setOf(AspectRatio.ONE_ONE))
+            )
+        )
+
+        runMainActivityScenarioTest {
+            composeTestRule.waitForCaptureButton()
+            composeTestRule.visitQuickSettings {
+                onNodeWithTag(ROW_QUICK_SETTINGS_ASPECT_RATIO).assertDoesNotExist()
+            }
+        }
+    }
+}