[external/jetpack-camera-app] Upstream merge am: 4919941812 am: 310a14dd9e
Original change: https://android-review.googlesource.com/c/platform/external/jetpack-camera-app/+/3263806
Change-Id: I5a11c0c61dc54c3d7c026892d6fb144e1a8602e2
Signed-off-by: Automerger Merge Worker <[email protected]>
diff --git a/.gitignore b/.gitignore
index 4e44987..7b74e6c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -15,4 +15,5 @@
local.properties
.idea/deploymentTargetDropDown.xml
.idea/gradle.xml
-.idea/deploymentTargetSelector.xml
\ No newline at end of file
+.idea/deploymentTargetSelector.xml
+.idea/androidTestResultsUserPreferences.xml
\ No newline at end of file
diff --git a/app/src/androidTest/java/com/google/jetpackcamera/ImageCaptureDeviceTest.kt b/app/src/androidTest/java/com/google/jetpackcamera/ImageCaptureDeviceTest.kt
index 3d86388..7edae9a 100644
--- a/app/src/androidTest/java/com/google/jetpackcamera/ImageCaptureDeviceTest.kt
+++ b/app/src/androidTest/java/com/google/jetpackcamera/ImageCaptureDeviceTest.kt
@@ -16,29 +16,35 @@
package com.google.jetpackcamera
import android.app.Activity
-import android.content.ComponentName
-import android.content.Intent
import android.net.Uri
import android.os.Environment
import android.provider.MediaStore
import androidx.compose.ui.test.isDisplayed
import androidx.compose.ui.test.junit4.createEmptyComposeRule
+import androidx.compose.ui.test.longClick
import androidx.compose.ui.test.onNodeWithTag
import androidx.compose.ui.test.performClick
+import androidx.compose.ui.test.performTouchInput
import androidx.test.ext.junit.runners.AndroidJUnit4
import androidx.test.platform.app.InstrumentationRegistry
import androidx.test.rule.GrantPermissionRule
import androidx.test.uiautomator.UiDevice
+import com.google.common.truth.Truth
import com.google.jetpackcamera.feature.preview.ui.CAPTURE_BUTTON
import com.google.jetpackcamera.feature.preview.ui.IMAGE_CAPTURE_FAILURE_TAG
import com.google.jetpackcamera.feature.preview.ui.IMAGE_CAPTURE_SUCCESS_TAG
+import com.google.jetpackcamera.feature.preview.ui.VIDEO_CAPTURE_EXTERNAL_UNSUPPORTED_TAG
import com.google.jetpackcamera.utils.APP_REQUIRED_PERMISSIONS
import com.google.jetpackcamera.utils.APP_START_TIMEOUT_MILLIS
import com.google.jetpackcamera.utils.IMAGE_CAPTURE_TIMEOUT_MILLIS
+import com.google.jetpackcamera.utils.VIDEO_CAPTURE_TIMEOUT_MILLIS
+import com.google.jetpackcamera.utils.deleteFilesInDirAfterTimestamp
+import com.google.jetpackcamera.utils.doesImageFileExist
+import com.google.jetpackcamera.utils.getIntent
+import com.google.jetpackcamera.utils.getTestUri
import com.google.jetpackcamera.utils.runScenarioTest
import com.google.jetpackcamera.utils.runScenarioTestForResult
import java.io.File
-import java.net.URLConnection
import org.junit.Rule
import org.junit.Test
import org.junit.runner.RunWith
@@ -71,16 +77,18 @@
composeTestRule.waitUntil(timeoutMillis = IMAGE_CAPTURE_TIMEOUT_MILLIS) {
composeTestRule.onNodeWithTag(IMAGE_CAPTURE_SUCCESS_TAG).isDisplayed()
}
- assert(File(DIR_PATH).lastModified() > timeStamp)
- deleteFilesInDirAfterTimestamp(timeStamp)
+ Truth.assertThat(File(DIR_PATH).lastModified() > timeStamp).isTrue()
+ deleteFilesInDirAfterTimestamp(DIR_PATH, instrumentation, timeStamp)
}
@Test
fun image_capture_external() {
val timeStamp = System.currentTimeMillis()
- val uri = getTestUri(timeStamp)
+ val uri = getTestUri(DIR_PATH, timeStamp, "jpg")
val result =
- runScenarioTestForResult<MainActivity>(getIntent(uri)) {
+ runScenarioTestForResult<MainActivity>(
+ getIntent(uri, MediaStore.ACTION_IMAGE_CAPTURE)
+ ) {
// Wait for the capture button to be displayed
composeTestRule.waitUntil(timeoutMillis = APP_START_TIMEOUT_MILLIS) {
composeTestRule.onNodeWithTag(CAPTURE_BUTTON).isDisplayed()
@@ -90,16 +98,18 @@
.assertExists()
.performClick()
}
- assert(result?.resultCode == Activity.RESULT_OK)
- assert(doesImageFileExist(uri))
- deleteFilesInDirAfterTimestamp(timeStamp)
+ Truth.assertThat(result?.resultCode).isEqualTo(Activity.RESULT_OK)
+ Truth.assertThat(doesImageFileExist(uri, "image")).isTrue()
+ deleteFilesInDirAfterTimestamp(DIR_PATH, instrumentation, timeStamp)
}
@Test
fun image_capture_external_illegal_uri() {
val uri = Uri.parse("asdfasdf")
val result =
- runScenarioTestForResult<MainActivity>(getIntent(uri)) {
+ runScenarioTestForResult<MainActivity>(
+ getIntent(uri, MediaStore.ACTION_IMAGE_CAPTURE)
+ ) {
// Wait for the capture button to be displayed
composeTestRule.waitUntil(timeoutMillis = APP_START_TIMEOUT_MILLIS) {
composeTestRule.onNodeWithTag(CAPTURE_BUTTON).isDisplayed()
@@ -113,55 +123,34 @@
}
uiDevice.pressBack()
}
- assert(result?.resultCode == Activity.RESULT_CANCELED)
- assert(!doesImageFileExist(uri))
+ Truth.assertThat(result?.resultCode).isEqualTo(Activity.RESULT_CANCELED)
+ Truth.assertThat(doesImageFileExist(uri, "image")).isFalse()
}
- private fun doesImageFileExist(uri: Uri): Boolean {
- val file = File(uri.path)
- if (file.exists()) {
- val mimeType = URLConnection.guessContentTypeFromName(uri.path)
- return mimeType != null && mimeType.startsWith("image")
- }
- return false
- }
-
- private fun deleteFilesInDirAfterTimestamp(timeStamp: Long): Boolean {
- var hasDeletedFile = false
- for (file in File(DIR_PATH).listFiles()) {
- if (file.lastModified() >= timeStamp) {
- file.delete()
- if (file.exists()) {
- file.getCanonicalFile().delete()
- if (file.exists()) {
- instrumentation.targetContext.applicationContext.deleteFile(file.getName())
- }
+ @Test
+ fun video_capture_during_image_capture_external() {
+ val timeStamp = System.currentTimeMillis()
+ val uri = getTestUri(DIR_PATH, timeStamp, "mp4")
+ val result =
+ runScenarioTestForResult<MainActivity>(
+ getIntent(uri, MediaStore.ACTION_IMAGE_CAPTURE)
+ ) {
+ // Wait for the capture button to be displayed
+ composeTestRule.waitUntil(timeoutMillis = APP_START_TIMEOUT_MILLIS) {
+ composeTestRule.onNodeWithTag(CAPTURE_BUTTON).isDisplayed()
}
- hasDeletedFile = true
+
+ composeTestRule.onNodeWithTag(CAPTURE_BUTTON)
+ .assertExists()
+ .performTouchInput { longClick() }
+ composeTestRule.waitUntil(timeoutMillis = VIDEO_CAPTURE_TIMEOUT_MILLIS) {
+ composeTestRule.onNodeWithTag(VIDEO_CAPTURE_EXTERNAL_UNSUPPORTED_TAG)
+ .isDisplayed()
+ }
+ uiDevice.pressBack()
}
- }
- return hasDeletedFile
- }
-
- private fun getTestUri(timeStamp: Long): Uri {
- return Uri.fromFile(
- File(
- Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES),
- "$timeStamp.jpg"
- )
- )
- }
-
- private fun getIntent(uri: Uri): Intent {
- val intent = Intent(MediaStore.ACTION_IMAGE_CAPTURE)
- intent.setComponent(
- ComponentName(
- "com.google.jetpackcamera",
- "com.google.jetpackcamera.MainActivity"
- )
- )
- intent.putExtra(MediaStore.EXTRA_OUTPUT, uri)
- return intent
+ Truth.assertThat(result?.resultCode).isEqualTo(Activity.RESULT_CANCELED)
+ Truth.assertThat(doesImageFileExist(uri, "video")).isFalse()
}
companion object {
diff --git a/app/src/androidTest/java/com/google/jetpackcamera/VideoRecordingDeviceTest.kt b/app/src/androidTest/java/com/google/jetpackcamera/VideoRecordingDeviceTest.kt
index ee81021..545b406 100644
--- a/app/src/androidTest/java/com/google/jetpackcamera/VideoRecordingDeviceTest.kt
+++ b/app/src/androidTest/java/com/google/jetpackcamera/VideoRecordingDeviceTest.kt
@@ -15,27 +15,36 @@
*/
package com.google.jetpackcamera
-import android.app.Instrumentation
-import android.content.ComponentName
-import android.content.Context
-import android.content.Intent
+import android.app.Activity
import android.net.Uri
import android.os.Environment
-import androidx.activity.result.ActivityResultRegistry
-import androidx.activity.result.contract.ActivityResultContract
-import androidx.activity.result.contract.ActivityResultContracts
-import androidx.core.app.ActivityOptionsCompat
-import androidx.test.core.app.ActivityScenario
-import androidx.test.core.app.ApplicationProvider
+import android.provider.MediaStore
+import androidx.compose.ui.test.ComposeTimeoutException
+import androidx.compose.ui.test.isDisplayed
+import androidx.compose.ui.test.junit4.createEmptyComposeRule
+import androidx.compose.ui.test.onNodeWithTag
+import androidx.compose.ui.test.performClick
+import androidx.compose.ui.test.performTouchInput
import androidx.test.ext.junit.runners.AndroidJUnit4
import androidx.test.platform.app.InstrumentationRegistry
import androidx.test.rule.GrantPermissionRule
-import androidx.test.uiautomator.By
import androidx.test.uiautomator.UiDevice
-import androidx.test.uiautomator.Until
+import com.google.common.truth.Truth
import com.google.jetpackcamera.feature.preview.ui.CAPTURE_BUTTON
-import com.google.jetpackcamera.feature.preview.ui.VIDEO_CAPTURE_EXTERNAL_UNSUPPORTED_TAG
+import com.google.jetpackcamera.feature.preview.ui.IMAGE_CAPTURE_EXTERNAL_UNSUPPORTED_TAG
+import com.google.jetpackcamera.feature.preview.ui.VIDEO_CAPTURE_FAILURE_TAG
+import com.google.jetpackcamera.feature.preview.ui.VIDEO_CAPTURE_SUCCESS_TAG
import com.google.jetpackcamera.utils.APP_REQUIRED_PERMISSIONS
+import com.google.jetpackcamera.utils.APP_START_TIMEOUT_MILLIS
+import com.google.jetpackcamera.utils.IMAGE_CAPTURE_TIMEOUT_MILLIS
+import com.google.jetpackcamera.utils.VIDEO_CAPTURE_TIMEOUT_MILLIS
+import com.google.jetpackcamera.utils.VIDEO_DURATION_MILLIS
+import com.google.jetpackcamera.utils.deleteFilesInDirAfterTimestamp
+import com.google.jetpackcamera.utils.doesImageFileExist
+import com.google.jetpackcamera.utils.getIntent
+import com.google.jetpackcamera.utils.getTestUri
+import com.google.jetpackcamera.utils.runScenarioTest
+import com.google.jetpackcamera.utils.runScenarioTestForResult
import java.io.File
import org.junit.Rule
import org.junit.Test
@@ -47,73 +56,120 @@
val permissionsRule: GrantPermissionRule =
GrantPermissionRule.grant(*(APP_REQUIRED_PERMISSIONS).toTypedArray())
+ @get:Rule
+ val composeTestRule = createEmptyComposeRule()
+
private val instrumentation = InstrumentationRegistry.getInstrumentation()
- private var activityScenario: ActivityScenario<MainActivity>? = null
private val uiDevice = UiDevice.getInstance(instrumentation)
@Test
- fun video_capture_external_with_image_capture_intent() = run {
+ fun video_capture() = runScenarioTest<MainActivity> {
val timeStamp = System.currentTimeMillis()
- val uri = getTestUri(timeStamp)
- getTestRegistry {
- activityScenario = ActivityScenario.launchActivityForResult(it)
- uiDevice.wait(
- Until.findObject(By.res(CAPTURE_BUTTON)),
- 5000
- )
- uiDevice.findObject(By.res(CAPTURE_BUTTON)).longClick()
- uiDevice.wait(
- Until.findObject(By.res(VIDEO_CAPTURE_EXTERNAL_UNSUPPORTED_TAG)),
- 5000
- )
- uiDevice.pressBack()
- activityScenario!!.result
- }.register("key", TEST_CONTRACT) { result ->
- assert(!result)
- }.launch(uri)
- }
-
- private fun getTestRegistry(
- launch: (Intent) -> Instrumentation.ActivityResult
- ): ActivityResultRegistry {
- val testRegistry = object : ActivityResultRegistry() {
- override fun <I, O> onLaunch(
- requestCode: Int,
- contract: ActivityResultContract<I, O>,
- input: I,
- options: ActivityOptionsCompat?
- ) {
- // contract.create
- val launchIntent = contract.createIntent(
- ApplicationProvider.getApplicationContext(),
- input
- )
- val result: Instrumentation.ActivityResult = launch(launchIntent)
- dispatchResult(requestCode, result.resultCode, result.resultData)
- }
+ // Wait for the capture button to be displayed
+ composeTestRule.waitUntil(timeoutMillis = APP_START_TIMEOUT_MILLIS) {
+ composeTestRule.onNodeWithTag(CAPTURE_BUTTON).isDisplayed()
}
- return testRegistry
+ longClickForVideoRecording()
+ composeTestRule.waitUntil(timeoutMillis = VIDEO_CAPTURE_TIMEOUT_MILLIS) {
+ composeTestRule.onNodeWithTag(VIDEO_CAPTURE_SUCCESS_TAG).isDisplayed()
+ }
+ Truth.assertThat(File(DIR_PATH).lastModified() > timeStamp).isTrue()
+ deleteFilesInDirAfterTimestamp(DIR_PATH, instrumentation, timeStamp)
}
- private fun getTestUri(timeStamp: Long): Uri {
- return Uri.fromFile(
- File(
- Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES),
- "$timeStamp.mp4"
- )
- )
+ @Test
+ fun video_capture_external_intent() {
+ val timeStamp = System.currentTimeMillis()
+ val uri = getTestUri(DIR_PATH, timeStamp, "mp4")
+ val result =
+ runScenarioTestForResult<MainActivity>(
+ getIntent(uri, MediaStore.ACTION_VIDEO_CAPTURE)
+ ) {
+ // Wait for the capture button to be displayed
+ composeTestRule.waitUntil(timeoutMillis = APP_START_TIMEOUT_MILLIS) {
+ composeTestRule.onNodeWithTag(CAPTURE_BUTTON).isDisplayed()
+ }
+ longClickForVideoRecording()
+ }
+ Truth.assertThat(result?.resultCode).isEqualTo(Activity.RESULT_OK)
+ Truth.assertThat(doesImageFileExist(uri, "video")).isTrue()
+ deleteFilesInDirAfterTimestamp(DIR_PATH, instrumentation, timeStamp)
+ }
+
+ @Test
+ fun video_capture_external_illegal_uri() {
+ val uri = Uri.parse("asdfasdf")
+ val result =
+ runScenarioTestForResult<MainActivity>(
+ getIntent(uri, MediaStore.ACTION_VIDEO_CAPTURE)
+ ) {
+ // Wait for the capture button to be displayed
+ composeTestRule.waitUntil(timeoutMillis = APP_START_TIMEOUT_MILLIS) {
+ composeTestRule.onNodeWithTag(CAPTURE_BUTTON).isDisplayed()
+ }
+ longClickForVideoRecording()
+ composeTestRule.waitUntil(timeoutMillis = VIDEO_CAPTURE_TIMEOUT_MILLIS) {
+ composeTestRule.onNodeWithTag(VIDEO_CAPTURE_FAILURE_TAG).isDisplayed()
+ }
+ uiDevice.pressBack()
+ }
+ Truth.assertThat(result?.resultCode).isEqualTo(Activity.RESULT_CANCELED)
+ Truth.assertThat(doesImageFileExist(uri, "video")).isFalse()
+ }
+
+ @Test
+ fun image_capture_during_video_capture_external() {
+ val timeStamp = System.currentTimeMillis()
+ val uri = getTestUri(ImageCaptureDeviceTest.DIR_PATH, timeStamp, "mp4")
+ val result =
+ runScenarioTestForResult<MainActivity>(
+ getIntent(uri, MediaStore.ACTION_VIDEO_CAPTURE)
+ ) {
+ // Wait for the capture button to be displayed
+ composeTestRule.waitUntil(timeoutMillis = APP_START_TIMEOUT_MILLIS) {
+ composeTestRule.onNodeWithTag(CAPTURE_BUTTON).isDisplayed()
+ }
+
+ composeTestRule.onNodeWithTag(CAPTURE_BUTTON)
+ .assertExists()
+ .performClick()
+ composeTestRule.waitUntil(timeoutMillis = IMAGE_CAPTURE_TIMEOUT_MILLIS) {
+ composeTestRule.onNodeWithTag(
+ IMAGE_CAPTURE_EXTERNAL_UNSUPPORTED_TAG
+ ).isDisplayed()
+ }
+ uiDevice.pressBack()
+ }
+ Truth.assertThat(result?.resultCode).isEqualTo(Activity.RESULT_CANCELED)
+ Truth.assertThat(doesImageFileExist(uri, "image")).isFalse()
+ }
+
+ private fun longClickForVideoRecording() {
+ composeTestRule.onNodeWithTag(CAPTURE_BUTTON)
+ .assertExists()
+ .performTouchInput {
+ down(center)
+ }
+ idleForVideoDuration()
+ composeTestRule.onNodeWithTag(CAPTURE_BUTTON)
+ .assertExists()
+ .performTouchInput {
+ up()
+ }
+ }
+
+ private fun idleForVideoDuration() {
+ // TODO: replace with a check for the timestamp UI of the video duration
+ try {
+ composeTestRule.waitUntil(timeoutMillis = VIDEO_DURATION_MILLIS) {
+ composeTestRule.onNodeWithTag("dummyTagForLongPress").isDisplayed()
+ }
+ } catch (e: ComposeTimeoutException) {
+ }
}
companion object {
- private val TEST_CONTRACT = object : ActivityResultContracts.TakePicture() {
- override fun createIntent(context: Context, uri: Uri): Intent {
- return super.createIntent(context, uri).apply {
- component = ComponentName(
- ApplicationProvider.getApplicationContext(),
- MainActivity::class.java
- )
- }
- }
- }
+ val DIR_PATH: String =
+ Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_MOVIES).path
}
}
diff --git a/app/src/androidTest/java/com/google/jetpackcamera/utils/UiTestUtil.kt b/app/src/androidTest/java/com/google/jetpackcamera/utils/UiTestUtil.kt
index af2c512..782ede2 100644
--- a/app/src/androidTest/java/com/google/jetpackcamera/utils/UiTestUtil.kt
+++ b/app/src/androidTest/java/com/google/jetpackcamera/utils/UiTestUtil.kt
@@ -17,7 +17,10 @@
import android.app.Activity
import android.app.Instrumentation
+import android.content.ComponentName
import android.content.Intent
+import android.net.Uri
+import android.provider.MediaStore
import androidx.compose.ui.semantics.SemanticsProperties
import androidx.compose.ui.test.isDisplayed
import androidx.compose.ui.test.junit4.ComposeTestRule
@@ -28,9 +31,13 @@
import com.google.jetpackcamera.feature.preview.R
import com.google.jetpackcamera.feature.preview.quicksettings.ui.QUICK_SETTINGS_FLIP_CAMERA_BUTTON
import com.google.jetpackcamera.settings.model.LensFacing
+import java.io.File
+import java.net.URLConnection
const val APP_START_TIMEOUT_MILLIS = 10_000L
const val IMAGE_CAPTURE_TIMEOUT_MILLIS = 5_000L
+const val VIDEO_CAPTURE_TIMEOUT_MILLIS = 5_000L
+const val VIDEO_DURATION_MILLIS = 2_000L
inline fun <reified T : Activity> runScenarioTest(
crossinline block: ActivityScenario<T>.() -> Unit
@@ -89,3 +96,54 @@
}
}
}
+
+fun getTestUri(directoryPath: String, timeStamp: Long, suffix: String): Uri {
+ return Uri.fromFile(
+ File(
+ directoryPath,
+ "$timeStamp.$suffix"
+ )
+ )
+}
+
+fun deleteFilesInDirAfterTimestamp(
+ directoryPath: String,
+ instrumentation: Instrumentation,
+ timeStamp: Long
+): Boolean {
+ var hasDeletedFile = false
+ for (file in File(directoryPath).listFiles()) {
+ if (file.lastModified() >= timeStamp) {
+ file.delete()
+ if (file.exists()) {
+ file.getCanonicalFile().delete()
+ if (file.exists()) {
+ instrumentation.targetContext.applicationContext.deleteFile(file.getName())
+ }
+ }
+ hasDeletedFile = true
+ }
+ }
+ return hasDeletedFile
+}
+
+fun doesImageFileExist(uri: Uri, prefix: String): Boolean {
+ val file = File(uri.path)
+ if (file.exists()) {
+ val mimeType = URLConnection.guessContentTypeFromName(uri.path)
+ return mimeType != null && mimeType.startsWith(prefix)
+ }
+ return false
+}
+
+fun getIntent(uri: Uri, action: String): Intent {
+ val intent = Intent(action)
+ intent.setComponent(
+ ComponentName(
+ "com.google.jetpackcamera",
+ "com.google.jetpackcamera.MainActivity"
+ )
+ )
+ intent.putExtra(MediaStore.EXTRA_OUTPUT, uri)
+ return intent
+}
diff --git a/app/src/main/java/com/google/jetpackcamera/MainActivity.kt b/app/src/main/java/com/google/jetpackcamera/MainActivity.kt
index f00aee6..04dfaf9 100644
--- a/app/src/main/java/com/google/jetpackcamera/MainActivity.kt
+++ b/app/src/main/java/com/google/jetpackcamera/MainActivity.kt
@@ -51,6 +51,7 @@
import androidx.compose.ui.semantics.semantics
import androidx.compose.ui.semantics.testTagsAsResourceId
import androidx.compose.ui.unit.dp
+import androidx.core.content.IntentCompat
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.lifecycleScope
import androidx.lifecycle.repeatOnLifecycle
@@ -70,6 +71,7 @@
import kotlinx.coroutines.launch
private const val TAG = "MainActivity"
+private const val KEY_DEBUG_MODE = "KEY_DEBUG_MODE"
/**
* Activity for the JetpackCameraApp.
@@ -136,6 +138,7 @@
) {
JcaApp(
previewMode = getPreviewMode(),
+ isDebugMode = isDebugMode,
openAppSettings = ::openAppSettings,
onRequestWindowColorMode = { colorMode ->
// Window color mode APIs require API level 26+
@@ -159,40 +162,61 @@
}
}
- private fun getPreviewMode(): PreviewMode {
- if (intent == null || MediaStore.ACTION_IMAGE_CAPTURE != intent.action) {
- return PreviewMode.StandardMode { event ->
- if (event is PreviewViewModel.ImageCaptureEvent.ImageSaved) {
- val intent = Intent(Camera.ACTION_NEW_PICTURE)
- intent.setData(event.savedUri)
- sendBroadcast(intent)
- }
- }
- } else {
- var uri = if (intent.extras == null ||
- !intent.extras!!.containsKey(MediaStore.EXTRA_OUTPUT)
- ) {
- null
- } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
- intent.extras!!.getParcelable(
- MediaStore.EXTRA_OUTPUT,
- Uri::class.java
- )
- } else {
- @Suppress("DEPRECATION")
- intent.extras!!.getParcelable(MediaStore.EXTRA_OUTPUT)
- }
- if (uri == null && intent.clipData != null && intent.clipData!!.itemCount != 0) {
- uri = intent.clipData!!.getItemAt(0).uri
- }
- return PreviewMode.ExternalImageCaptureMode(uri) { event ->
- if (event is PreviewViewModel.ImageCaptureEvent.ImageSaved) {
- setResult(RESULT_OK)
- finish()
- }
+ private val isDebugMode: Boolean
+ get() = intent?.getBooleanExtra(KEY_DEBUG_MODE, false) ?: false
+
+ private fun getStandardMode(): PreviewMode.StandardMode {
+ return PreviewMode.StandardMode { event ->
+ if (event is PreviewViewModel.ImageCaptureEvent.ImageSaved) {
+ val intent = Intent(Camera.ACTION_NEW_PICTURE)
+ intent.setData(event.savedUri)
+ sendBroadcast(intent)
}
}
}
+
+ private fun getExternalCaptureUri(): Uri? {
+ return IntentCompat.getParcelableExtra(
+ intent,
+ MediaStore.EXTRA_OUTPUT,
+ Uri::class.java
+ ) ?: intent?.clipData?.getItemAt(0)?.uri
+ }
+
+ private fun getPreviewMode(): PreviewMode {
+ return intent?.action?.let { action ->
+ when (action) {
+ MediaStore.ACTION_IMAGE_CAPTURE ->
+ PreviewMode.ExternalImageCaptureMode(getExternalCaptureUri()) { event ->
+ Log.d(TAG, "onImageCapture, event: $event")
+ if (event is PreviewViewModel.ImageCaptureEvent.ImageSaved) {
+ val resultIntent = Intent()
+ resultIntent.putExtra(MediaStore.EXTRA_OUTPUT, event.savedUri)
+ setResult(RESULT_OK, resultIntent)
+ Log.d(TAG, "onImageCapture, finish()")
+ finish()
+ }
+ }
+
+ MediaStore.ACTION_VIDEO_CAPTURE ->
+ PreviewMode.ExternalVideoCaptureMode(getExternalCaptureUri()) { event ->
+ Log.d(TAG, "onVideoCapture, event: $event")
+ if (event is PreviewViewModel.VideoCaptureEvent.VideoSaved) {
+ val resultIntent = Intent()
+ resultIntent.putExtra(MediaStore.EXTRA_OUTPUT, event.savedUri)
+ setResult(RESULT_OK, resultIntent)
+ Log.d(TAG, "onVideoCapture, finish()")
+ finish()
+ }
+ }
+
+ else -> {
+ Log.w(TAG, "Ignoring external intent with unknown action.")
+ getStandardMode()
+ }
+ }
+ } ?: getStandardMode()
+ }
}
/**
diff --git a/app/src/main/java/com/google/jetpackcamera/ui/JcaApp.kt b/app/src/main/java/com/google/jetpackcamera/ui/JcaApp.kt
index 2f2ea31..1e16d5b 100644
--- a/app/src/main/java/com/google/jetpackcamera/ui/JcaApp.kt
+++ b/app/src/main/java/com/google/jetpackcamera/ui/JcaApp.kt
@@ -42,11 +42,13 @@
/*TODO(b/306236646): remove after still capture*/
previewMode: PreviewMode,
modifier: Modifier = Modifier,
+ isDebugMode: Boolean,
onRequestWindowColorMode: (Int) -> Unit,
onFirstFrameCaptureCompleted: () -> Unit
) {
JetpackCameraNavHost(
previewMode = previewMode,
+ isDebugMode = isDebugMode,
onOpenAppSettings = openAppSettings,
onRequestWindowColorMode = onRequestWindowColorMode,
onFirstFrameCaptureCompleted = onFirstFrameCaptureCompleted,
@@ -59,6 +61,7 @@
private fun JetpackCameraNavHost(
modifier: Modifier = Modifier,
previewMode: PreviewMode,
+ isDebugMode: Boolean,
onOpenAppSettings: () -> Unit,
onRequestWindowColorMode: (Int) -> Unit,
onFirstFrameCaptureCompleted: () -> Unit,
@@ -102,7 +105,8 @@
onNavigateToSettings = { navController.navigate(SETTINGS_ROUTE) },
onRequestWindowColorMode = onRequestWindowColorMode,
onFirstFrameCaptureCompleted = onFirstFrameCaptureCompleted,
- previewMode = previewMode
+ previewMode = previewMode,
+ isDebugMode = isDebugMode
)
}
composable(SETTINGS_ROUTE) {
diff --git a/core/camera/Android.bp b/core/camera/Android.bp
index fc9c829..b5a8c62 100644
--- a/core/camera/Android.bp
+++ b/core/camera/Android.bp
@@ -21,4 +21,7 @@
sdk_version: "34",
min_sdk_version: "21",
manifest: "src/main/AndroidManifest.xml",
+ kotlincflags: [
+ "-Xcontext-receivers",
+ ],
}
diff --git a/core/camera/build.gradle.kts b/core/camera/build.gradle.kts
index 4fb048a..cc471c3 100644
--- a/core/camera/build.gradle.kts
+++ b/core/camera/build.gradle.kts
@@ -84,6 +84,10 @@
kotlin {
jvmToolchain(17)
}
+
+ kotlinOptions {
+ freeCompilerArgs += "-Xcontext-receivers"
+ }
}
dependencies {
@@ -94,10 +98,16 @@
testImplementation(libs.mockito.core)
androidTestImplementation(libs.androidx.junit)
androidTestImplementation(libs.androidx.espresso.core)
+ androidTestImplementation(libs.kotlinx.coroutines.test)
+ androidTestImplementation(libs.rules)
+ androidTestImplementation(libs.truth)
// Futures
implementation(libs.futures.ktx)
+ // LiveData
+ implementation(libs.androidx.lifecycle.livedata)
+
// CameraX
implementation(libs.camera.core)
implementation(libs.camera.camera2)
diff --git a/core/camera/src/androidTest/java/com/google/jetpackcamera/core/camera/CameraXCameraUseCaseTest.kt b/core/camera/src/androidTest/java/com/google/jetpackcamera/core/camera/CameraXCameraUseCaseTest.kt
new file mode 100644
index 0000000..5cd9d75
--- /dev/null
+++ b/core/camera/src/androidTest/java/com/google/jetpackcamera/core/camera/CameraXCameraUseCaseTest.kt
@@ -0,0 +1,245 @@
+/*
+ * Copyright (C) 2024 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.core.camera
+
+import android.app.Application
+import android.content.ContentResolver
+import android.graphics.SurfaceTexture
+import android.net.Uri
+import android.view.Surface
+import androidx.concurrent.futures.DirectExecutor
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.filters.LargeTest
+import androidx.test.platform.app.InstrumentationRegistry
+import androidx.test.rule.GrantPermissionRule
+import com.google.jetpackcamera.core.camera.CameraUseCase.OnVideoRecordEvent.OnVideoRecordError
+import com.google.jetpackcamera.core.camera.CameraUseCase.OnVideoRecordEvent.OnVideoRecordStatus
+import com.google.jetpackcamera.core.camera.CameraUseCase.OnVideoRecordEvent.OnVideoRecorded
+import com.google.jetpackcamera.core.camera.utils.APP_REQUIRED_PERMISSIONS
+import com.google.jetpackcamera.settings.ConstraintsRepository
+import com.google.jetpackcamera.settings.SettableConstraintsRepository
+import com.google.jetpackcamera.settings.SettableConstraintsRepositoryImpl
+import com.google.jetpackcamera.settings.model.CameraAppSettings
+import com.google.jetpackcamera.settings.model.DEFAULT_CAMERA_APP_SETTINGS
+import com.google.jetpackcamera.settings.model.FlashMode
+import com.google.jetpackcamera.settings.model.LensFacing
+import java.io.File
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.channels.ReceiveChannel
+import kotlinx.coroutines.flow.filterNotNull
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.produceIn
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.withTimeoutOrNull
+import org.junit.After
+import org.junit.Assert.fail
+import org.junit.Assume.assumeTrue
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@LargeTest
+@RunWith(AndroidJUnit4::class)
+class CameraXCameraUseCaseTest {
+
+ companion object {
+ private const val STATUS_VERIFY_COUNT = 5
+ private const val GENERAL_TIMEOUT_MS = 3_000L
+ private const val STATUS_VERIFY_TIMEOUT_MS = 10_000L
+ }
+
+ @get:Rule
+ val permissionsRule: GrantPermissionRule =
+ GrantPermissionRule.grant(*(APP_REQUIRED_PERMISSIONS).toTypedArray())
+
+ private val instrumentation = InstrumentationRegistry.getInstrumentation()
+ private val context = instrumentation.context
+ private val application = context.applicationContext as Application
+ private val videosToDelete = mutableSetOf<Uri>()
+ private lateinit var useCaseScope: CoroutineScope
+
+ @Before
+ fun setup() {
+ useCaseScope = CoroutineScope(Dispatchers.Default)
+ }
+
+ @After
+ fun tearDown() {
+ useCaseScope.cancel()
+ deleteVideos()
+ }
+
+ @Test
+ fun canRecordVideo(): Unit = runBlocking {
+ // Arrange.
+ val cameraUseCase = createAndInitCameraXUseCase()
+ cameraUseCase.runCameraOnMain()
+
+ // Act.
+ val recordEvent = cameraUseCase.startRecordingAndGetEvents()
+
+ // Assert.
+ recordEvent.onRecordStatus.await(STATUS_VERIFY_TIMEOUT_MS)
+
+ // Act.
+ cameraUseCase.stopVideoRecording()
+
+ // Assert.
+ recordEvent.onRecorded.await()
+ }
+
+ @Test
+ fun recordVideoWithFlashModeOn_shouldEnableTorch(): Unit = runBlocking {
+ // Arrange.
+ val lensFacing = LensFacing.BACK
+ val constraintsRepository = SettableConstraintsRepositoryImpl()
+ val cameraUseCase = createAndInitCameraXUseCase(
+ constraintsRepository = constraintsRepository
+ )
+ assumeTrue("No flash unit, skip the test.", constraintsRepository.hasFlashUnit(lensFacing))
+ cameraUseCase.runCameraOnMain()
+
+ // Arrange: Create a ReceiveChannel to observe the torch enabled state.
+ val torchEnabled: ReceiveChannel<Boolean> = cameraUseCase.getCurrentCameraState()
+ .map { it.torchEnabled }
+ .produceIn(this)
+
+ // Assert: The initial torch enabled should be false.
+ torchEnabled.awaitValue(false)
+
+ // Act: Start recording with FlashMode.ON
+ cameraUseCase.setFlashMode(FlashMode.ON)
+ val recordEvent = cameraUseCase.startRecordingAndGetEvents()
+
+ // Assert: Torch enabled transitions to true.
+ torchEnabled.awaitValue(true)
+
+ // Act: Ensure enough data is received and stop recording.
+ recordEvent.onRecordStatus.await(STATUS_VERIFY_TIMEOUT_MS)
+ cameraUseCase.stopVideoRecording()
+
+ // Assert: Torch enabled transitions to false.
+ torchEnabled.awaitValue(false)
+
+ // Clean-up.
+ torchEnabled.cancel()
+ }
+
+ private suspend fun createAndInitCameraXUseCase(
+ appSettings: CameraAppSettings = DEFAULT_CAMERA_APP_SETTINGS,
+ constraintsRepository: SettableConstraintsRepository = SettableConstraintsRepositoryImpl()
+ ) = CameraXCameraUseCase(
+ application,
+ useCaseScope,
+ Dispatchers.Default,
+ constraintsRepository
+ ).apply {
+ initialize(appSettings, CameraUseCase.UseCaseMode.STANDARD)
+ providePreviewSurface()
+ }
+
+ private data class RecordEvents(
+ val onRecorded: CompletableDeferred<Unit>,
+ val onRecordStatus: CompletableDeferred<Unit>
+ )
+
+ private suspend fun CompletableDeferred<*>.await(timeoutMs: Long = GENERAL_TIMEOUT_MS) =
+ withTimeoutOrNull(timeoutMs) {
+ await()
+ Unit
+ } ?: fail("Timeout while waiting for the Deferred to complete")
+
+ private suspend fun <T> ReceiveChannel<T>.awaitValue(
+ expectedValue: T,
+ timeoutMs: Long = GENERAL_TIMEOUT_MS
+ ) = withTimeoutOrNull(timeoutMs) {
+ for (value in this@awaitValue) {
+ if (value == expectedValue) return@withTimeoutOrNull
+ }
+ } ?: fail("Timeout while waiting for expected value: $expectedValue")
+
+ private suspend fun CameraXCameraUseCase.startRecordingAndGetEvents(
+ statusVerifyCount: Int = STATUS_VERIFY_COUNT
+ ): RecordEvents {
+ val onRecorded = CompletableDeferred<Unit>()
+ val onRecordStatus = CompletableDeferred<Unit>()
+ var statusCount = 0
+ startVideoRecording(null, false) {
+ when (it) {
+ is OnVideoRecorded -> {
+ val videoUri = it.savedUri
+ if (videoUri != Uri.EMPTY) {
+ videosToDelete.add(videoUri)
+ }
+ onRecorded.complete(Unit)
+ }
+ is OnVideoRecordError -> onRecorded.complete(Unit)
+ is OnVideoRecordStatus -> {
+ statusCount++
+ if (statusCount == statusVerifyCount) {
+ onRecordStatus.complete(Unit)
+ }
+ }
+ }
+ }
+ return RecordEvents(onRecorded, onRecordStatus)
+ }
+
+ private fun CameraXCameraUseCase.providePreviewSurface() {
+ useCaseScope.launch {
+ getSurfaceRequest().filterNotNull().first().let { surfaceRequest ->
+ val surfaceTexture = SurfaceTexture(0)
+ surfaceTexture.setDefaultBufferSize(640, 480)
+ val surface = Surface(surfaceTexture)
+ surfaceRequest.provideSurface(surface, DirectExecutor.INSTANCE) {
+ surface.release()
+ surfaceTexture.release()
+ }
+ }
+ }
+ }
+
+ private suspend fun CameraXCameraUseCase.runCameraOnMain() {
+ useCaseScope.launch(Dispatchers.Main) { runCamera() }
+ instrumentation.waitForIdleSync()
+ }
+
+ private suspend fun ConstraintsRepository.hasFlashUnit(lensFacing: LensFacing): Boolean =
+ systemConstraints.first()!!.perLensConstraints[lensFacing]!!.hasFlashUnit
+
+ private fun deleteVideos() {
+ for (uri in videosToDelete) {
+ when (uri.scheme) {
+ ContentResolver.SCHEME_CONTENT -> {
+ try {
+ context.contentResolver.delete(uri, null, null)
+ } catch (e: RuntimeException) {
+ // Ignore any exception.
+ }
+ }
+ ContentResolver.SCHEME_FILE -> {
+ File(uri.path!!).delete()
+ }
+ }
+ }
+ }
+}
diff --git a/core/camera/src/androidTest/java/com/google/jetpackcamera/core/camera/utils/AppTestUtil.kt b/core/camera/src/androidTest/java/com/google/jetpackcamera/core/camera/utils/AppTestUtil.kt
new file mode 100644
index 0000000..509029e
--- /dev/null
+++ b/core/camera/src/androidTest/java/com/google/jetpackcamera/core/camera/utils/AppTestUtil.kt
@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2024 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.core.camera.utils
+
+import android.os.Build
+
+val APP_REQUIRED_PERMISSIONS: List<String> = buildList {
+ add(android.Manifest.permission.CAMERA)
+ add(android.Manifest.permission.RECORD_AUDIO)
+ if (Build.VERSION.SDK_INT <= 28) {
+ add(android.Manifest.permission.WRITE_EXTERNAL_STORAGE)
+ }
+}
diff --git a/core/camera/src/main/AndroidManifest.xml b/core/camera/src/main/AndroidManifest.xml
index 39bd3ea..150f8d8 100644
--- a/core/camera/src/main/AndroidManifest.xml
+++ b/core/camera/src/main/AndroidManifest.xml
@@ -15,6 +15,11 @@
~ limitations under the License.
-->
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+ xmlns:tools="http://schemas.android.com/tools"
package="com.google.jetpackcamera.core.camera">
- <uses-permission android:name = "android.permission.RECORD_AUDIO" />
+ <uses-permission android:name="android.permission.CAMERA" />
+ <uses-permission android:name="android.permission.RECORD_AUDIO" />
+ <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"
+ android:maxSdkVersion="28"
+ tools:ignore="ScopedStorage" />
</manifest>
diff --git a/core/camera/src/main/java/com/google/jetpackcamera/core/camera/CameraEvent.kt b/core/camera/src/main/java/com/google/jetpackcamera/core/camera/CameraEvent.kt
index 27ea15f..0fe8cc6 100644
--- a/core/camera/src/main/java/com/google/jetpackcamera/core/camera/CameraEvent.kt
+++ b/core/camera/src/main/java/com/google/jetpackcamera/core/camera/CameraEvent.kt
@@ -15,8 +15,6 @@
*/
package com.google.jetpackcamera.core.camera
-import androidx.camera.core.MeteringPoint
-
/**
* An event that can be sent to the camera coroutine.
*/
@@ -25,5 +23,5 @@
/**
* Represents a focus metering event, that the camera can act on.
*/
- class FocusMeteringEvent(val meteringPoint: MeteringPoint) : CameraEvent
+ data class FocusMeteringEvent(val x: Float, val y: Float) : CameraEvent
}
diff --git a/core/camera/src/main/java/com/google/jetpackcamera/core/camera/CameraExt.kt b/core/camera/src/main/java/com/google/jetpackcamera/core/camera/CameraExt.kt
new file mode 100644
index 0000000..df24af5
--- /dev/null
+++ b/core/camera/src/main/java/com/google/jetpackcamera/core/camera/CameraExt.kt
@@ -0,0 +1,134 @@
+/*
+ * Copyright (C) 2024 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.core.camera
+
+import android.annotation.SuppressLint
+import android.hardware.camera2.CameraCharacteristics
+import androidx.annotation.OptIn
+import androidx.camera.camera2.interop.Camera2CameraInfo
+import androidx.camera.camera2.interop.ExperimentalCamera2Interop
+import androidx.camera.core.CameraInfo
+import androidx.camera.core.CameraSelector
+import androidx.camera.core.DynamicRange as CXDynamicRange
+import androidx.camera.core.ExperimentalImageCaptureOutputFormat
+import androidx.camera.core.ImageCapture
+import androidx.camera.core.Preview
+import androidx.camera.core.UseCase
+import androidx.camera.core.UseCaseGroup
+import androidx.camera.video.Recorder
+import androidx.camera.video.VideoCapture
+import com.google.jetpackcamera.settings.model.DynamicRange
+import com.google.jetpackcamera.settings.model.ImageOutputFormat
+import com.google.jetpackcamera.settings.model.LensFacing
+
+val CameraInfo.appLensFacing: LensFacing
+ get() = when (this.lensFacing) {
+ CameraSelector.LENS_FACING_FRONT -> LensFacing.FRONT
+ CameraSelector.LENS_FACING_BACK -> LensFacing.BACK
+ else -> throw IllegalArgumentException(
+ "Unknown CameraSelector.LensFacing -> LensFacing mapping. " +
+ "[CameraSelector.LensFacing: ${this.lensFacing}]"
+ )
+ }
+
+fun CXDynamicRange.toSupportedAppDynamicRange(): DynamicRange? {
+ return when (this) {
+ CXDynamicRange.SDR -> DynamicRange.SDR
+ CXDynamicRange.HLG_10_BIT -> DynamicRange.HLG10
+ // All other dynamic ranges unsupported. Return null.
+ else -> null
+ }
+}
+
+fun DynamicRange.toCXDynamicRange(): CXDynamicRange {
+ return when (this) {
+ com.google.jetpackcamera.settings.model.DynamicRange.SDR -> CXDynamicRange.SDR
+ com.google.jetpackcamera.settings.model.DynamicRange.HLG10 -> CXDynamicRange.HLG_10_BIT
+ }
+}
+
+fun LensFacing.toCameraSelector(): CameraSelector = when (this) {
+ LensFacing.FRONT -> CameraSelector.DEFAULT_FRONT_CAMERA
+ LensFacing.BACK -> CameraSelector.DEFAULT_BACK_CAMERA
+}
+
+@SuppressLint("RestrictedApi")
+fun CameraSelector.toAppLensFacing(): LensFacing = when (this.lensFacing) {
+ CameraSelector.LENS_FACING_FRONT -> LensFacing.FRONT
+ CameraSelector.LENS_FACING_BACK -> LensFacing.BACK
+ else -> throw IllegalArgumentException(
+ "Unknown CameraSelector -> LensFacing mapping. [CameraSelector: $this]"
+ )
+}
+
+val CameraInfo.sensorLandscapeRatio: Float
+ @OptIn(ExperimentalCamera2Interop::class)
+ get() = Camera2CameraInfo.from(this)
+ .getCameraCharacteristic(CameraCharacteristics.SENSOR_INFO_ACTIVE_ARRAY_SIZE)
+ ?.let { sensorRect ->
+ if (sensorRect.width() > sensorRect.height()) {
+ sensorRect.width().toFloat() / sensorRect.height()
+ } else {
+ sensorRect.height().toFloat() / sensorRect.width()
+ }
+ } ?: Float.NaN
+
+@OptIn(ExperimentalImageCaptureOutputFormat::class)
+fun Int.toAppImageFormat(): ImageOutputFormat? {
+ return when (this) {
+ ImageCapture.OUTPUT_FORMAT_JPEG -> ImageOutputFormat.JPEG
+ ImageCapture.OUTPUT_FORMAT_JPEG_ULTRA_HDR -> ImageOutputFormat.JPEG_ULTRA_HDR
+ // All other output formats unsupported. Return null.
+ else -> null
+ }
+}
+
+/**
+ * Checks if preview stabilization is supported by the device.
+ *
+ */
+val CameraInfo.isPreviewStabilizationSupported: Boolean
+ get() = Preview.getPreviewCapabilities(this).isStabilizationSupported
+
+/**
+ * Checks if video stabilization is supported by the device.
+ *
+ */
+val CameraInfo.isVideoStabilizationSupported: Boolean
+ get() = Recorder.getVideoCapabilities(this).isStabilizationSupported
+
+fun CameraInfo.filterSupportedFixedFrameRates(desired: Set<Int>): Set<Int> {
+ return buildSet {
+ this@filterSupportedFixedFrameRates.supportedFrameRateRanges.forEach { e ->
+ if (e.upper == e.lower && desired.contains(e.upper)) {
+ add(e.upper)
+ }
+ }
+ }
+}
+
+val CameraInfo.supportedImageFormats: Set<ImageOutputFormat>
+ @OptIn(ExperimentalImageCaptureOutputFormat::class)
+ get() = ImageCapture.getImageCaptureCapabilities(this).supportedOutputFormats
+ .mapNotNull(Int::toAppImageFormat)
+ .toSet()
+
+fun UseCaseGroup.getVideoCapture() = getUseCaseOrNull<VideoCapture<Recorder>>()
+fun UseCaseGroup.getImageCapture() = getUseCaseOrNull<ImageCapture>()
+
+private inline fun <reified T : UseCase> UseCaseGroup.getUseCaseOrNull(): T? {
+ return useCases.filterIsInstance<T>().singleOrNull()
+}
diff --git a/core/camera/src/main/java/com/google/jetpackcamera/core/camera/CameraSession.kt b/core/camera/src/main/java/com/google/jetpackcamera/core/camera/CameraSession.kt
new file mode 100644
index 0000000..fbed566
--- /dev/null
+++ b/core/camera/src/main/java/com/google/jetpackcamera/core/camera/CameraSession.kt
@@ -0,0 +1,728 @@
+/*
+ * Copyright (C) 2024 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.core.camera
+
+import android.Manifest
+import android.content.ContentValues
+import android.content.Context
+import android.content.pm.PackageManager
+import android.hardware.camera2.CameraCaptureSession
+import android.hardware.camera2.CaptureRequest
+import android.hardware.camera2.CaptureResult
+import android.hardware.camera2.TotalCaptureResult
+import android.net.Uri
+import android.os.Build
+import android.os.SystemClock
+import android.provider.MediaStore
+import android.util.Log
+import android.util.Range
+import androidx.annotation.OptIn
+import androidx.camera.camera2.interop.Camera2CameraInfo
+import androidx.camera.camera2.interop.Camera2Interop
+import androidx.camera.camera2.interop.ExperimentalCamera2Interop
+import androidx.camera.core.Camera
+import androidx.camera.core.CameraControl
+import androidx.camera.core.CameraEffect
+import androidx.camera.core.CameraInfo
+import androidx.camera.core.CameraSelector
+import androidx.camera.core.ExperimentalImageCaptureOutputFormat
+import androidx.camera.core.FocusMeteringAction
+import androidx.camera.core.ImageCapture
+import androidx.camera.core.Preview
+import androidx.camera.core.SurfaceOrientedMeteringPointFactory
+import androidx.camera.core.TorchState
+import androidx.camera.core.UseCaseGroup
+import androidx.camera.core.ViewPort
+import androidx.camera.core.resolutionselector.AspectRatioStrategy
+import androidx.camera.core.resolutionselector.ResolutionSelector
+import androidx.camera.video.FileOutputOptions
+import androidx.camera.video.MediaStoreOutputOptions
+import androidx.camera.video.Recorder
+import androidx.camera.video.Recording
+import androidx.camera.video.VideoCapture
+import androidx.camera.video.VideoRecordEvent
+import androidx.camera.video.VideoRecordEvent.Finalize.ERROR_NONE
+import androidx.concurrent.futures.await
+import androidx.core.content.ContextCompat
+import androidx.core.content.ContextCompat.checkSelfPermission
+import androidx.lifecycle.asFlow
+import com.google.jetpackcamera.core.camera.effects.SingleSurfaceForcingEffect
+import com.google.jetpackcamera.settings.model.AspectRatio
+import com.google.jetpackcamera.settings.model.CaptureMode
+import com.google.jetpackcamera.settings.model.DeviceRotation
+import com.google.jetpackcamera.settings.model.DynamicRange
+import com.google.jetpackcamera.settings.model.FlashMode
+import com.google.jetpackcamera.settings.model.ImageOutputFormat
+import com.google.jetpackcamera.settings.model.LensFacing
+import com.google.jetpackcamera.settings.model.Stabilization
+import java.io.File
+import java.util.Date
+import java.util.concurrent.Executor
+import kotlin.coroutines.ContinuationInterceptor
+import kotlin.math.abs
+import kotlinx.atomicfu.atomic
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.CoroutineStart
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.asExecutor
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.currentCoroutineContext
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.collectLatest
+import kotlinx.coroutines.flow.filterNotNull
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.onCompletion
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+
+private const val TAG = "CameraSession"
+
+context(CameraSessionContext)
+internal suspend fun runSingleCameraSession(
+ sessionSettings: PerpetualSessionSettings.SingleCamera,
+ useCaseMode: CameraUseCase.UseCaseMode,
+ // TODO(tm): ImageCapture should go through an event channel like VideoCapture
+ onImageCaptureCreated: (ImageCapture) -> Unit = {}
+) = coroutineScope {
+ val lensFacing = sessionSettings.cameraInfo.appLensFacing
+ Log.d(TAG, "Starting new single camera session for $lensFacing")
+
+ val initialTransientSettings = transientSettings
+ .filterNotNull()
+ .first()
+
+ val useCaseGroup = createUseCaseGroup(
+ cameraInfo = sessionSettings.cameraInfo,
+ initialTransientSettings = initialTransientSettings,
+ stabilizePreviewMode = sessionSettings.stabilizePreviewMode,
+ stabilizeVideoMode = sessionSettings.stabilizeVideoMode,
+ aspectRatio = sessionSettings.aspectRatio,
+ targetFrameRate = sessionSettings.targetFrameRate,
+ dynamicRange = sessionSettings.dynamicRange,
+ imageFormat = sessionSettings.imageFormat,
+ useCaseMode = useCaseMode,
+ effect = when (sessionSettings.captureMode) {
+ CaptureMode.SINGLE_STREAM -> SingleSurfaceForcingEffect(this@coroutineScope)
+ CaptureMode.MULTI_STREAM -> null
+ }
+ ).apply {
+ getImageCapture()?.let(onImageCaptureCreated)
+ }
+
+ cameraProvider.runWith(sessionSettings.cameraInfo.cameraSelector, useCaseGroup) { camera ->
+ Log.d(TAG, "Camera session started")
+
+ launch {
+ processFocusMeteringEvents(camera.cameraControl)
+ }
+
+ launch {
+ processVideoControlEvents(
+ camera,
+ useCaseGroup.getVideoCapture(),
+ captureTypeSuffix = when (sessionSettings.captureMode) {
+ CaptureMode.MULTI_STREAM -> "MultiStream"
+ CaptureMode.SINGLE_STREAM -> "SingleStream"
+ }
+ )
+ }
+
+ launch {
+ camera.cameraInfo.torchState.asFlow().collectLatest { torchState ->
+ currentCameraState.update { old ->
+ old.copy(torchEnabled = torchState == TorchState.ON)
+ }
+ }
+ }
+
+ applyDeviceRotation(initialTransientSettings.deviceRotation, useCaseGroup)
+ processTransientSettingEvents(
+ camera,
+ useCaseGroup,
+ initialTransientSettings,
+ transientSettings
+ )
+ }
+}
+
+context(CameraSessionContext)
+internal suspend fun processTransientSettingEvents(
+ camera: Camera,
+ useCaseGroup: UseCaseGroup,
+ initialTransientSettings: TransientSessionSettings,
+ transientSettings: StateFlow<TransientSessionSettings?>
+) {
+ var prevTransientSettings = initialTransientSettings
+ transientSettings.filterNotNull().collectLatest { newTransientSettings ->
+ // Apply camera control settings
+ if (prevTransientSettings.zoomScale != newTransientSettings.zoomScale) {
+ camera.cameraInfo.zoomState.value?.let { zoomState ->
+ val finalScale =
+ (zoomState.zoomRatio * newTransientSettings.zoomScale).coerceIn(
+ zoomState.minZoomRatio,
+ zoomState.maxZoomRatio
+ )
+ camera.cameraControl.setZoomRatio(finalScale)
+ currentCameraState.update { old ->
+ old.copy(zoomScale = finalScale)
+ }
+ }
+ }
+
+ useCaseGroup.getImageCapture()?.let { imageCapture ->
+ if (prevTransientSettings.flashMode != newTransientSettings.flashMode) {
+ setFlashModeInternal(
+ imageCapture = imageCapture,
+ flashMode = newTransientSettings.flashMode,
+ isFrontFacing = camera.cameraInfo.appLensFacing == LensFacing.FRONT
+ )
+ }
+ }
+
+ if (prevTransientSettings.deviceRotation
+ != newTransientSettings.deviceRotation
+ ) {
+ Log.d(
+ TAG,
+ "Updating device rotation from " +
+ "${prevTransientSettings.deviceRotation} -> " +
+ "${newTransientSettings.deviceRotation}"
+ )
+ applyDeviceRotation(newTransientSettings.deviceRotation, useCaseGroup)
+ }
+
+ prevTransientSettings = newTransientSettings
+ }
+}
+
+internal fun applyDeviceRotation(deviceRotation: DeviceRotation, useCaseGroup: UseCaseGroup) {
+ val targetRotation = deviceRotation.toUiSurfaceRotation()
+ useCaseGroup.useCases.forEach {
+ when (it) {
+ is Preview -> {
+ // Preview's target rotation should not be updated with device rotation.
+ // Instead, preview rotation should match the display rotation.
+ // When Preview is created, it is initialized with the display rotation.
+ // This will need to be updated separately if the display rotation is not
+ // locked. Currently the app is locked to portrait orientation.
+ }
+
+ is ImageCapture -> {
+ it.targetRotation = targetRotation
+ }
+
+ is VideoCapture<*> -> {
+ it.targetRotation = targetRotation
+ }
+ }
+ }
+}
+
+context(CameraSessionContext)
+internal fun createUseCaseGroup(
+ cameraInfo: CameraInfo,
+ initialTransientSettings: TransientSessionSettings,
+ stabilizePreviewMode: Stabilization,
+ stabilizeVideoMode: Stabilization,
+ aspectRatio: AspectRatio,
+ targetFrameRate: Int,
+ dynamicRange: DynamicRange,
+ imageFormat: ImageOutputFormat,
+ useCaseMode: CameraUseCase.UseCaseMode,
+ effect: CameraEffect? = null
+): UseCaseGroup {
+ val previewUseCase =
+ createPreviewUseCase(
+ cameraInfo,
+ aspectRatio,
+ stabilizePreviewMode
+ )
+ val imageCaptureUseCase = if (useCaseMode != CameraUseCase.UseCaseMode.VIDEO_ONLY) {
+ createImageUseCase(cameraInfo, aspectRatio, dynamicRange, imageFormat)
+ } else {
+ null
+ }
+ val videoCaptureUseCase = if (useCaseMode != CameraUseCase.UseCaseMode.IMAGE_ONLY) {
+ createVideoUseCase(
+ cameraInfo,
+ aspectRatio,
+ targetFrameRate,
+ stabilizeVideoMode,
+ dynamicRange,
+ backgroundDispatcher
+ )
+ } else {
+ null
+ }
+
+ imageCaptureUseCase?.let {
+ setFlashModeInternal(
+ imageCapture = imageCaptureUseCase,
+ flashMode = initialTransientSettings.flashMode,
+ isFrontFacing = cameraInfo.appLensFacing == LensFacing.FRONT
+ )
+ }
+
+ return UseCaseGroup.Builder().apply {
+ Log.d(
+ TAG,
+ "Setting initial device rotation to ${initialTransientSettings.deviceRotation}"
+ )
+ setViewPort(
+ ViewPort.Builder(
+ aspectRatio.ratio,
+ // Initialize rotation to Preview's rotation, which comes from Display rotation
+ previewUseCase.targetRotation
+ ).build()
+ )
+ addUseCase(previewUseCase)
+ imageCaptureUseCase?.let {
+ if (dynamicRange == DynamicRange.SDR ||
+ imageFormat == ImageOutputFormat.JPEG_ULTRA_HDR
+ ) {
+ addUseCase(imageCaptureUseCase)
+ }
+ }
+
+ // Not to bind VideoCapture when Ultra HDR is enabled to keep the app design simple.
+ videoCaptureUseCase?.let {
+ if (imageFormat == ImageOutputFormat.JPEG) {
+ addUseCase(videoCaptureUseCase)
+ }
+ }
+
+ effect?.let { addEffect(it) }
+ }.build()
+}
+
+@OptIn(ExperimentalImageCaptureOutputFormat::class)
+private fun createImageUseCase(
+ cameraInfo: CameraInfo,
+ aspectRatio: AspectRatio,
+ dynamicRange: DynamicRange,
+ imageFormat: ImageOutputFormat
+): ImageCapture {
+ val builder = ImageCapture.Builder()
+ builder.setResolutionSelector(
+ getResolutionSelector(cameraInfo.sensorLandscapeRatio, aspectRatio)
+ )
+ if (dynamicRange != DynamicRange.SDR && imageFormat == ImageOutputFormat.JPEG_ULTRA_HDR
+ ) {
+ builder.setOutputFormat(ImageCapture.OUTPUT_FORMAT_JPEG_ULTRA_HDR)
+ }
+ return builder.build()
+}
+
+private fun createVideoUseCase(
+ cameraInfo: CameraInfo,
+ aspectRatio: AspectRatio,
+ targetFrameRate: Int,
+ stabilizeVideoMode: Stabilization,
+ dynamicRange: DynamicRange,
+ backgroundDispatcher: CoroutineDispatcher
+): VideoCapture<Recorder> {
+ val sensorLandscapeRatio = cameraInfo.sensorLandscapeRatio
+ val recorder = Recorder.Builder()
+ .setAspectRatio(
+ getAspectRatioForUseCase(sensorLandscapeRatio, aspectRatio)
+ )
+ .setExecutor(backgroundDispatcher.asExecutor()).build()
+ return VideoCapture.Builder(recorder).apply {
+ // set video stabilization
+ if (stabilizeVideoMode == Stabilization.ON) {
+ setVideoStabilizationEnabled(true)
+ }
+ // set target fps
+ if (targetFrameRate != TARGET_FPS_AUTO) {
+ setTargetFrameRate(Range(targetFrameRate, targetFrameRate))
+ }
+
+ setDynamicRange(dynamicRange.toCXDynamicRange())
+ }.build()
+}
+
+private fun getAspectRatioForUseCase(sensorLandscapeRatio: Float, aspectRatio: AspectRatio): Int {
+ return when (aspectRatio) {
+ AspectRatio.THREE_FOUR -> androidx.camera.core.AspectRatio.RATIO_4_3
+ AspectRatio.NINE_SIXTEEN -> androidx.camera.core.AspectRatio.RATIO_16_9
+ else -> {
+ // Choose the aspect ratio which maximizes FOV by being closest to the sensor ratio
+ if (
+ abs(sensorLandscapeRatio - AspectRatio.NINE_SIXTEEN.landscapeRatio.toFloat()) <
+ abs(sensorLandscapeRatio - AspectRatio.THREE_FOUR.landscapeRatio.toFloat())
+ ) {
+ androidx.camera.core.AspectRatio.RATIO_16_9
+ } else {
+ androidx.camera.core.AspectRatio.RATIO_4_3
+ }
+ }
+ }
+}
+
+context(CameraSessionContext)
+private fun createPreviewUseCase(
+ cameraInfo: CameraInfo,
+ aspectRatio: AspectRatio,
+ stabilizePreviewMode: Stabilization
+): Preview = Preview.Builder().apply {
+ updateCameraStateWithCaptureResults(targetCameraInfo = cameraInfo)
+
+ // set preview stabilization
+ if (stabilizePreviewMode == Stabilization.ON) {
+ setPreviewStabilizationEnabled(true)
+ }
+
+ setResolutionSelector(
+ getResolutionSelector(cameraInfo.sensorLandscapeRatio, aspectRatio)
+ )
+}.build()
+ .apply {
+ setSurfaceProvider { surfaceRequest ->
+ surfaceRequests.update { surfaceRequest }
+ }
+ }
+
+private fun getResolutionSelector(
+ sensorLandscapeRatio: Float,
+ aspectRatio: AspectRatio
+): ResolutionSelector {
+ val aspectRatioStrategy = when (aspectRatio) {
+ AspectRatio.THREE_FOUR -> AspectRatioStrategy.RATIO_4_3_FALLBACK_AUTO_STRATEGY
+ AspectRatio.NINE_SIXTEEN -> AspectRatioStrategy.RATIO_16_9_FALLBACK_AUTO_STRATEGY
+ else -> {
+ // Choose the resolution selector strategy which maximizes FOV by being closest
+ // to the sensor aspect ratio
+ if (
+ abs(sensorLandscapeRatio - AspectRatio.NINE_SIXTEEN.landscapeRatio.toFloat()) <
+ abs(sensorLandscapeRatio - AspectRatio.THREE_FOUR.landscapeRatio.toFloat())
+ ) {
+ AspectRatioStrategy.RATIO_16_9_FALLBACK_AUTO_STRATEGY
+ } else {
+ AspectRatioStrategy.RATIO_4_3_FALLBACK_AUTO_STRATEGY
+ }
+ }
+ }
+ return ResolutionSelector.Builder().setAspectRatioStrategy(aspectRatioStrategy).build()
+}
+
+context(CameraSessionContext)
+private fun setFlashModeInternal(
+ imageCapture: ImageCapture,
+ flashMode: FlashMode,
+ isFrontFacing: Boolean
+) {
+ val isScreenFlashRequired =
+ isFrontFacing && (flashMode == FlashMode.ON || flashMode == FlashMode.AUTO)
+
+ if (isScreenFlashRequired) {
+ imageCapture.screenFlash = object : ImageCapture.ScreenFlash {
+ override fun apply(
+ expirationTimeMillis: Long,
+ listener: ImageCapture.ScreenFlashListener
+ ) {
+ Log.d(TAG, "ImageCapture.ScreenFlash: apply")
+ screenFlashEvents.trySend(
+ CameraUseCase.ScreenFlashEvent(CameraUseCase.ScreenFlashEvent.Type.APPLY_UI) {
+ listener.onCompleted()
+ }
+ )
+ }
+
+ override fun clear() {
+ Log.d(TAG, "ImageCapture.ScreenFlash: clear")
+ screenFlashEvents.trySend(
+ CameraUseCase.ScreenFlashEvent(CameraUseCase.ScreenFlashEvent.Type.CLEAR_UI) {}
+ )
+ }
+ }
+ }
+
+ imageCapture.flashMode = when (flashMode) {
+ FlashMode.OFF -> ImageCapture.FLASH_MODE_OFF // 2
+
+ FlashMode.ON -> if (isScreenFlashRequired) {
+ ImageCapture.FLASH_MODE_SCREEN // 3
+ } else {
+ ImageCapture.FLASH_MODE_ON // 1
+ }
+
+ FlashMode.AUTO -> if (isScreenFlashRequired) {
+ ImageCapture.FLASH_MODE_SCREEN // 3
+ } else {
+ ImageCapture.FLASH_MODE_AUTO // 0
+ }
+ }
+ Log.d(TAG, "Set flash mode to: ${imageCapture.flashMode}")
+}
+
+private suspend fun startVideoRecordingInternal(
+ initialMuted: Boolean,
+ videoCaptureUseCase: VideoCapture<Recorder>,
+ captureTypeSuffix: String,
+ context: Context,
+ videoCaptureUri: Uri?,
+ shouldUseUri: Boolean,
+ onVideoRecord: (CameraUseCase.OnVideoRecordEvent) -> Unit
+): Recording {
+ Log.d(TAG, "recordVideo")
+ // todo(b/336886716): default setting to enable or disable audio when permission is granted
+
+ // ok. there is a difference between MUTING and ENABLING audio
+ // audio must be enabled in order to be muted
+ // if the video recording isnt started with audio enabled, you will not be able to unmute it
+ // the toggle should only affect whether or not the audio is muted.
+ // the permission will determine whether or not the audio is enabled.
+ val audioEnabled = checkSelfPermission(
+ context,
+ Manifest.permission.RECORD_AUDIO
+ ) == PackageManager.PERMISSION_GRANTED
+
+ val pendingRecord = if (shouldUseUri) {
+ val fileOutputOptions = FileOutputOptions.Builder(
+ File(videoCaptureUri!!.path!!)
+ ).build()
+ videoCaptureUseCase.output.prepareRecording(context, fileOutputOptions)
+ } else {
+ val name = "JCA-recording-${Date()}-$captureTypeSuffix.mp4"
+ val contentValues =
+ ContentValues().apply {
+ put(MediaStore.Video.Media.DISPLAY_NAME, name)
+ }
+ val mediaStoreOutput =
+ MediaStoreOutputOptions.Builder(
+ context.contentResolver,
+ MediaStore.Video.Media.EXTERNAL_CONTENT_URI
+ )
+ .setContentValues(contentValues)
+ .build()
+ videoCaptureUseCase.output.prepareRecording(context, mediaStoreOutput)
+ }
+ pendingRecord.apply {
+ if (audioEnabled) {
+ withAudioEnabled()
+ }
+ }
+ val callbackExecutor: Executor =
+ (
+ currentCoroutineContext()[ContinuationInterceptor] as?
+ CoroutineDispatcher
+ )?.asExecutor() ?: ContextCompat.getMainExecutor(context)
+ return pendingRecord.start(callbackExecutor) { onVideoRecordEvent ->
+ Log.d(TAG, onVideoRecordEvent.toString())
+ when (onVideoRecordEvent) {
+ is VideoRecordEvent.Finalize -> {
+ when (onVideoRecordEvent.error) {
+ ERROR_NONE ->
+ onVideoRecord(
+ CameraUseCase.OnVideoRecordEvent.OnVideoRecorded(
+ onVideoRecordEvent.outputResults.outputUri
+ )
+ )
+
+ else ->
+ onVideoRecord(
+ CameraUseCase.OnVideoRecordEvent.OnVideoRecordError(
+ onVideoRecordEvent.cause
+ )
+ )
+ }
+ }
+
+ is VideoRecordEvent.Status -> {
+ onVideoRecord(
+ CameraUseCase.OnVideoRecordEvent.OnVideoRecordStatus(
+ onVideoRecordEvent.recordingStats.audioStats
+ .audioAmplitude
+ )
+ )
+ }
+ }
+ }.apply {
+ mute(initialMuted)
+ }
+}
+
+private suspend fun runVideoRecording(
+ camera: Camera,
+ videoCapture: VideoCapture<Recorder>,
+ captureTypeSuffix: String,
+ context: Context,
+ transientSettings: StateFlow<TransientSessionSettings?>,
+ videoCaptureUri: Uri?,
+ shouldUseUri: Boolean,
+ onVideoRecord: (CameraUseCase.OnVideoRecordEvent) -> Unit
+) {
+ var currentSettings = transientSettings.filterNotNull().first()
+
+ startVideoRecordingInternal(
+ initialMuted = currentSettings.audioMuted,
+ videoCapture,
+ captureTypeSuffix,
+ context,
+ videoCaptureUri,
+ shouldUseUri,
+ onVideoRecord
+ ).use { recording ->
+
+ fun TransientSessionSettings.isFlashModeOn() = flashMode == FlashMode.ON
+ val isFrontCameraSelector =
+ camera.cameraInfo.cameraSelector == CameraSelector.DEFAULT_FRONT_CAMERA
+
+ if (currentSettings.isFlashModeOn()) {
+ if (!isFrontCameraSelector) {
+ camera.cameraControl.enableTorch(true).await()
+ } else {
+ Log.d(TAG, "Unable to enable torch for front camera.")
+ }
+ }
+
+ transientSettings.filterNotNull()
+ .onCompletion {
+ // Could do some fancier tracking of whether the torch was enabled before
+ // calling this.
+ camera.cameraControl.enableTorch(false)
+ }
+ .collectLatest { newTransientSettings ->
+ if (currentSettings.audioMuted != newTransientSettings.audioMuted) {
+ recording.mute(newTransientSettings.audioMuted)
+ }
+ if (currentSettings.isFlashModeOn() != newTransientSettings.isFlashModeOn()) {
+ if (!isFrontCameraSelector) {
+ camera.cameraControl.enableTorch(newTransientSettings.isFlashModeOn())
+ } else {
+ Log.d(TAG, "Unable to update torch for front camera.")
+ }
+ }
+ currentSettings = newTransientSettings
+ }
+ }
+}
+
+context(CameraSessionContext)
+internal suspend fun processFocusMeteringEvents(cameraControl: CameraControl) {
+ surfaceRequests.map { surfaceRequest ->
+ surfaceRequest?.resolution?.run {
+ Log.d(
+ TAG,
+ "Waiting to process focus points for surface with resolution: " +
+ "$width x $height"
+ )
+ SurfaceOrientedMeteringPointFactory(width.toFloat(), height.toFloat())
+ }
+ }.collectLatest { meteringPointFactory ->
+ for (event in focusMeteringEvents) {
+ meteringPointFactory?.apply {
+ Log.d(TAG, "tapToFocus, processing event: $event")
+ val meteringPoint = createPoint(event.x, event.y)
+ val action = FocusMeteringAction.Builder(meteringPoint).build()
+ cameraControl.startFocusAndMetering(action)
+ } ?: run {
+ Log.w(TAG, "Ignoring event due to no SurfaceRequest: $event")
+ }
+ }
+ }
+}
+
+context(CameraSessionContext)
+internal suspend fun processVideoControlEvents(
+ camera: Camera,
+ videoCapture: VideoCapture<Recorder>?,
+ captureTypeSuffix: String
+) = coroutineScope {
+ var recordingJob: Job? = null
+
+ for (event in videoCaptureControlEvents) {
+ when (event) {
+ is VideoCaptureControlEvent.StartRecordingEvent -> {
+ if (videoCapture == null) {
+ throw RuntimeException(
+ "Attempted video recording with null videoCapture"
+ )
+ }
+
+ recordingJob = launch(start = CoroutineStart.UNDISPATCHED) {
+ runVideoRecording(
+ camera,
+ videoCapture,
+ captureTypeSuffix,
+ context,
+ transientSettings,
+ event.videoCaptureUri,
+ event.shouldUseUri,
+ event.onVideoRecord
+ )
+ }
+ }
+
+ VideoCaptureControlEvent.StopRecordingEvent -> {
+ recordingJob?.cancel()
+ recordingJob = null
+ }
+ }
+ }
+}
+
+/**
+ * Applies a CaptureCallback to the provided image capture builder
+ */
+context(CameraSessionContext)
+@OptIn(ExperimentalCamera2Interop::class)
+private fun Preview.Builder.updateCameraStateWithCaptureResults(
+ targetCameraInfo: CameraInfo
+): Preview.Builder {
+ val isFirstFrameTimestampUpdated = atomic(false)
+ val targetCameraLogicalId = Camera2CameraInfo.from(targetCameraInfo).cameraId
+ Camera2Interop.Extender(this).setSessionCaptureCallback(
+ object : CameraCaptureSession.CaptureCallback() {
+ override fun onCaptureCompleted(
+ session: CameraCaptureSession,
+ request: CaptureRequest,
+ result: TotalCaptureResult
+ ) {
+ super.onCaptureCompleted(session, request, result)
+ val logicalCameraId = session.device.id
+ if (logicalCameraId != targetCameraLogicalId) return
+ try {
+ val physicalCameraId = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+ result.get(CaptureResult.LOGICAL_MULTI_CAMERA_ACTIVE_PHYSICAL_ID)
+ } else {
+ null
+ }
+ currentCameraState.update { old ->
+ if (old.debugInfo.logicalCameraId != logicalCameraId ||
+ old.debugInfo.physicalCameraId != physicalCameraId
+ ) {
+ old.copy(debugInfo = DebugInfo(logicalCameraId, physicalCameraId))
+ } else {
+ old
+ }
+ }
+ if (!isFirstFrameTimestampUpdated.value) {
+ currentCameraState.update { old ->
+ old.copy(
+ sessionFirstFrameTimestamp = SystemClock.elapsedRealtimeNanos()
+ )
+ }
+ isFirstFrameTimestampUpdated.value = true
+ }
+ } catch (_: Exception) {
+ }
+ }
+ }
+ )
+ return this
+}
diff --git a/core/camera/src/main/java/com/google/jetpackcamera/core/camera/CameraSessionContext.kt b/core/camera/src/main/java/com/google/jetpackcamera/core/camera/CameraSessionContext.kt
new file mode 100644
index 0000000..1425bbb
--- /dev/null
+++ b/core/camera/src/main/java/com/google/jetpackcamera/core/camera/CameraSessionContext.kt
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2024 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.core.camera
+
+import android.content.Context
+import androidx.camera.core.SurfaceRequest
+import androidx.camera.lifecycle.ProcessCameraProvider
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.channels.SendChannel
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+
+/**
+ * Context that can be shared by all functions in a camera session.
+ *
+ * Can be used to confer context (such as reactive state or session-wide parameters)
+ * on context receivers using [with] in a camera session.
+ */
+internal data class CameraSessionContext(
+ val context: Context,
+ val cameraProvider: ProcessCameraProvider,
+ val backgroundDispatcher: CoroutineDispatcher,
+ val screenFlashEvents: SendChannel<CameraUseCase.ScreenFlashEvent>,
+ val focusMeteringEvents: Channel<CameraEvent.FocusMeteringEvent>,
+ val videoCaptureControlEvents: Channel<VideoCaptureControlEvent>,
+ val currentCameraState: MutableStateFlow<CameraState>,
+ val surfaceRequests: MutableStateFlow<SurfaceRequest?>,
+ val transientSettings: StateFlow<TransientSessionSettings?>
+)
diff --git a/core/camera/src/main/java/com/google/jetpackcamera/core/camera/CameraSessionSettings.kt b/core/camera/src/main/java/com/google/jetpackcamera/core/camera/CameraSessionSettings.kt
new file mode 100644
index 0000000..b96c6a3
--- /dev/null
+++ b/core/camera/src/main/java/com/google/jetpackcamera/core/camera/CameraSessionSettings.kt
@@ -0,0 +1,66 @@
+/*
+ * Copyright (C) 2024 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.core.camera
+
+import androidx.camera.core.CameraInfo
+import com.google.jetpackcamera.settings.model.AspectRatio
+import com.google.jetpackcamera.settings.model.CaptureMode
+import com.google.jetpackcamera.settings.model.DeviceRotation
+import com.google.jetpackcamera.settings.model.DynamicRange
+import com.google.jetpackcamera.settings.model.FlashMode
+import com.google.jetpackcamera.settings.model.ImageOutputFormat
+import com.google.jetpackcamera.settings.model.Stabilization
+
+/**
+ * Camera settings that persist as long as a camera is running.
+ *
+ * Any change in these settings will require calling [ProcessCameraProvider.runWith] with
+ * updates [CameraSelector] and/or [UseCaseGroup]
+ */
+internal sealed interface PerpetualSessionSettings {
+ val aspectRatio: AspectRatio
+
+ data class SingleCamera(
+ val cameraInfo: CameraInfo,
+ override val aspectRatio: AspectRatio,
+ val captureMode: CaptureMode,
+ val targetFrameRate: Int,
+ val stabilizePreviewMode: Stabilization,
+ val stabilizeVideoMode: Stabilization,
+ val dynamicRange: DynamicRange,
+ val imageFormat: ImageOutputFormat
+ ) : PerpetualSessionSettings
+
+ data class ConcurrentCamera(
+ val primaryCameraInfo: CameraInfo,
+ val secondaryCameraInfo: CameraInfo,
+ override val aspectRatio: AspectRatio
+ ) : PerpetualSessionSettings
+}
+
+/**
+ * Camera settings that can change while the camera is running.
+ *
+ * Any changes in these settings can be applied either directly to use cases via their
+ * setter methods or to [androidx.camera.core.CameraControl].
+ * The use cases typically will not need to be re-bound.
+ */
+internal data class TransientSessionSettings(
+ val audioMuted: Boolean,
+ val deviceRotation: DeviceRotation,
+ val flashMode: FlashMode,
+ val zoomScale: Float
+)
diff --git a/core/camera/src/main/java/com/google/jetpackcamera/core/camera/CameraUseCase.kt b/core/camera/src/main/java/com/google/jetpackcamera/core/camera/CameraUseCase.kt
index 4c8fbc8..02477d8 100644
--- a/core/camera/src/main/java/com/google/jetpackcamera/core/camera/CameraUseCase.kt
+++ b/core/camera/src/main/java/com/google/jetpackcamera/core/camera/CameraUseCase.kt
@@ -22,13 +22,15 @@
import com.google.jetpackcamera.settings.model.AspectRatio
import com.google.jetpackcamera.settings.model.CameraAppSettings
import com.google.jetpackcamera.settings.model.CaptureMode
+import com.google.jetpackcamera.settings.model.ConcurrentCameraMode
import com.google.jetpackcamera.settings.model.DeviceRotation
import com.google.jetpackcamera.settings.model.DynamicRange
import com.google.jetpackcamera.settings.model.FlashMode
import com.google.jetpackcamera.settings.model.ImageOutputFormat
import com.google.jetpackcamera.settings.model.LensFacing
import com.google.jetpackcamera.settings.model.LowLightBoost
-import kotlinx.coroutines.flow.SharedFlow
+import com.google.jetpackcamera.settings.model.Stabilization
+import kotlinx.coroutines.channels.ReceiveChannel
import kotlinx.coroutines.flow.StateFlow
/**
@@ -40,7 +42,11 @@
*
* @return list of available lenses.
*/
- suspend fun initialize(disableVideoCapture: Boolean)
+ suspend fun initialize(
+ cameraAppSettings: CameraAppSettings,
+ useCaseMode: UseCaseMode,
+ isDebugMode: Boolean = false
+ )
/**
* Starts the camera.
@@ -66,7 +72,11 @@
ignoreUri: Boolean = false
): ImageCapture.OutputFileResults
- suspend fun startVideoRecording(onVideoRecord: (OnVideoRecordEvent) -> Unit)
+ suspend fun startVideoRecording(
+ videoCaptureUri: Uri?,
+ shouldUseUri: Boolean,
+ onVideoRecord: (OnVideoRecordEvent) -> Unit
+ )
fun stopVideoRecording()
@@ -76,7 +86,7 @@
fun getSurfaceRequest(): StateFlow<SurfaceRequest?>
- fun getScreenFlashEvents(): SharedFlow<ScreenFlashEvent>
+ fun getScreenFlashEvents(): ReceiveChannel<ScreenFlashEvent>
fun getCurrentSettings(): StateFlow<CameraAppSettings?>
@@ -96,12 +106,20 @@
fun setDeviceRotation(deviceRotation: DeviceRotation)
+ suspend fun setConcurrentCameraMode(concurrentCameraMode: ConcurrentCameraMode)
+
suspend fun setLowLightBoost(lowLightBoost: LowLightBoost)
suspend fun setImageFormat(imageFormat: ImageOutputFormat)
suspend fun setAudioMuted(isAudioMuted: Boolean)
+ suspend fun setVideoCaptureStabilization(videoCaptureStabilization: Stabilization)
+
+ suspend fun setPreviewStabilization(previewStabilization: Stabilization)
+
+ suspend fun setTargetFrameRate(targetFrameRate: Int)
+
/**
* Represents the events required for screen flash.
*/
@@ -116,15 +134,25 @@
* Represents the events for video recording.
*/
sealed interface OnVideoRecordEvent {
- object OnVideoRecorded : OnVideoRecordEvent
+ data class OnVideoRecorded(val savedUri: Uri) : OnVideoRecordEvent
data class OnVideoRecordStatus(val audioAmplitude: Double) : OnVideoRecordEvent
- object OnVideoRecordError : OnVideoRecordEvent
+ data class OnVideoRecordError(val error: Throwable?) : OnVideoRecordEvent
+ }
+
+ enum class UseCaseMode {
+ STANDARD,
+ IMAGE_ONLY,
+ VIDEO_ONLY
}
}
data class CameraState(
val zoomScale: Float = 1f,
- val sessionFirstFrameTimestamp: Long = 0L
+ val sessionFirstFrameTimestamp: Long = 0L,
+ val torchEnabled: Boolean = false,
+ val debugInfo: DebugInfo = DebugInfo(null, null)
)
+
+data class DebugInfo(val logicalCameraId: String?, val physicalCameraId: String?)
diff --git a/core/camera/src/main/java/com/google/jetpackcamera/core/camera/CameraXCameraUseCase.kt b/core/camera/src/main/java/com/google/jetpackcamera/core/camera/CameraXCameraUseCase.kt
index 7561056..2f7f99a 100644
--- a/core/camera/src/main/java/com/google/jetpackcamera/core/camera/CameraXCameraUseCase.kt
+++ b/core/camera/src/main/java/com/google/jetpackcamera/core/camera/CameraXCameraUseCase.kt
@@ -15,63 +15,36 @@
*/
package com.google.jetpackcamera.core.camera
-import android.Manifest
import android.app.Application
import android.content.ContentResolver
import android.content.ContentValues
-import android.content.pm.PackageManager
-import android.hardware.camera2.CameraCaptureSession
-import android.hardware.camera2.CameraCharacteristics
-import android.hardware.camera2.CaptureRequest
-import android.hardware.camera2.TotalCaptureResult
import android.net.Uri
+import android.os.Build
import android.os.Environment
-import android.os.SystemClock
+import android.os.Environment.DIRECTORY_DOCUMENTS
import android.provider.MediaStore
import android.util.Log
-import android.util.Range
-import androidx.annotation.OptIn
-import androidx.camera.camera2.interop.Camera2CameraInfo
-import androidx.camera.camera2.interop.Camera2Interop
-import androidx.camera.camera2.interop.ExperimentalCamera2Interop
-import androidx.camera.core.AspectRatio.RATIO_16_9
-import androidx.camera.core.AspectRatio.RATIO_4_3
-import androidx.camera.core.CameraEffect
import androidx.camera.core.CameraInfo
import androidx.camera.core.CameraSelector
import androidx.camera.core.DynamicRange as CXDynamicRange
-import androidx.camera.core.ExperimentalImageCaptureOutputFormat
-import androidx.camera.core.FocusMeteringAction
import androidx.camera.core.ImageCapture
import androidx.camera.core.ImageCapture.OutputFileOptions
-import androidx.camera.core.ImageCapture.ScreenFlash
import androidx.camera.core.ImageCaptureException
-import androidx.camera.core.Preview
-import androidx.camera.core.SurfaceOrientedMeteringPointFactory
import androidx.camera.core.SurfaceRequest
-import androidx.camera.core.UseCaseGroup
-import androidx.camera.core.ViewPort
-import androidx.camera.core.resolutionselector.AspectRatioStrategy
-import androidx.camera.core.resolutionselector.ResolutionSelector
import androidx.camera.core.takePicture
import androidx.camera.lifecycle.ProcessCameraProvider
import androidx.camera.lifecycle.awaitInstance
-import androidx.camera.video.MediaStoreOutputOptions
import androidx.camera.video.Recorder
-import androidx.camera.video.Recording
-import androidx.camera.video.VideoCapture
-import androidx.camera.video.VideoRecordEvent
-import androidx.camera.video.VideoRecordEvent.Finalize.ERROR_NONE
-import androidx.core.content.ContextCompat
-import androidx.core.content.ContextCompat.checkSelfPermission
-import com.google.jetpackcamera.core.camera.CameraUseCase.ScreenFlashEvent.Type
-import com.google.jetpackcamera.core.camera.effects.SingleSurfaceForcingEffect
+import com.google.jetpackcamera.core.camera.DebugCameraInfoUtil.getAllCamerasPropertiesJSONArray
+import com.google.jetpackcamera.core.camera.DebugCameraInfoUtil.writeFileExternalStorage
+import com.google.jetpackcamera.core.common.DefaultDispatcher
+import com.google.jetpackcamera.core.common.IODispatcher
import com.google.jetpackcamera.settings.SettableConstraintsRepository
-import com.google.jetpackcamera.settings.SettingsRepository
import com.google.jetpackcamera.settings.model.AspectRatio
import com.google.jetpackcamera.settings.model.CameraAppSettings
import com.google.jetpackcamera.settings.model.CameraConstraints
import com.google.jetpackcamera.settings.model.CaptureMode
+import com.google.jetpackcamera.settings.model.ConcurrentCameraMode
import com.google.jetpackcamera.settings.model.DeviceRotation
import com.google.jetpackcamera.settings.model.DynamicRange
import com.google.jetpackcamera.settings.model.FlashMode
@@ -82,36 +55,26 @@
import com.google.jetpackcamera.settings.model.SupportedStabilizationMode
import com.google.jetpackcamera.settings.model.SystemConstraints
import dagger.hilt.android.scopes.ViewModelScoped
+import java.io.File
import java.io.FileNotFoundException
import java.text.SimpleDateFormat
import java.util.Calendar
-import java.util.Date
import java.util.Locale
-import java.util.concurrent.Executor
import javax.inject.Inject
-import kotlin.coroutines.ContinuationInterceptor
-import kotlin.math.abs
import kotlin.properties.Delegates
-import kotlinx.atomicfu.atomic
import kotlinx.coroutines.CoroutineDispatcher
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.asExecutor
import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.channels.trySendBlocking
import kotlinx.coroutines.coroutineScope
-import kotlinx.coroutines.currentCoroutineContext
-import kotlinx.coroutines.flow.MutableSharedFlow
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.asSharedFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.flow.collectLatest
-import kotlinx.coroutines.flow.consumeAsFlow
import kotlinx.coroutines.flow.distinctUntilChanged
import kotlinx.coroutines.flow.filterNotNull
-import kotlinx.coroutines.flow.first
import kotlinx.coroutines.flow.map
import kotlinx.coroutines.flow.update
-import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
private const val TAG = "CameraXCameraUseCase"
const val TARGET_FPS_AUTO = 0
@@ -127,63 +90,38 @@
@Inject
constructor(
private val application: Application,
- private val coroutineScope: CoroutineScope,
- private val defaultDispatcher: CoroutineDispatcher,
- private val settingsRepository: SettingsRepository,
+ @DefaultDispatcher private val defaultDispatcher: CoroutineDispatcher,
+ @IODispatcher private val iODispatcher: CoroutineDispatcher,
private val constraintsRepository: SettableConstraintsRepository
) : CameraUseCase {
private lateinit var cameraProvider: ProcessCameraProvider
- private lateinit var imageCaptureUseCase: ImageCapture
+ private var imageCaptureUseCase: ImageCapture? = null
- /**
- * Applies a CaptureCallback to the provided image capture builder
- */
- @OptIn(ExperimentalCamera2Interop::class)
- private fun setOnCaptureCompletedCallback(previewBuilder: Preview.Builder) {
- val isFirstFrameTimestampUpdated = atomic(false)
- val captureCallback = object : CameraCaptureSession.CaptureCallback() {
- override fun onCaptureCompleted(
- session: CameraCaptureSession,
- request: CaptureRequest,
- result: TotalCaptureResult
- ) {
- super.onCaptureCompleted(session, request, result)
- try {
- if (!isFirstFrameTimestampUpdated.value) {
- _currentCameraState.update { old ->
- old.copy(
- sessionFirstFrameTimestamp = SystemClock.elapsedRealtimeNanos()
- )
- }
- isFirstFrameTimestampUpdated.value = true
- }
- } catch (_: Exception) {}
- }
- }
-
- // Create an Extender to attach Camera2 options
- val imageCaptureExtender = Camera2Interop.Extender(previewBuilder)
-
- // Attach the Camera2 CaptureCallback
- imageCaptureExtender.setSessionCaptureCallback(captureCallback)
- }
-
- private var videoCaptureUseCase: VideoCapture<Recorder>? = null
- private var recording: Recording? = null
- private lateinit var captureMode: CaptureMode
private lateinit var systemConstraints: SystemConstraints
- private var disableVideoCapture by Delegates.notNull<Boolean>()
+ private var useCaseMode by Delegates.notNull<CameraUseCase.UseCaseMode>()
- private val screenFlashEvents: MutableSharedFlow<CameraUseCase.ScreenFlashEvent> =
- MutableSharedFlow()
+ private val screenFlashEvents: Channel<CameraUseCase.ScreenFlashEvent> =
+ Channel(capacity = Channel.UNLIMITED)
private val focusMeteringEvents =
Channel<CameraEvent.FocusMeteringEvent>(capacity = Channel.CONFLATED)
+ private val videoCaptureControlEvents = Channel<VideoCaptureControlEvent>()
private val currentSettings = MutableStateFlow<CameraAppSettings?>(null)
- override suspend fun initialize(externalImageCapture: Boolean) {
- this.disableVideoCapture = externalImageCapture
+ // Could be improved by setting initial value only when camera is initialized
+ private val _currentCameraState = MutableStateFlow(CameraState())
+ override fun getCurrentCameraState(): StateFlow<CameraState> = _currentCameraState.asStateFlow()
+
+ private val _surfaceRequest = MutableStateFlow<SurfaceRequest?>(null)
+ override fun getSurfaceRequest(): StateFlow<SurfaceRequest?> = _surfaceRequest.asStateFlow()
+
+ override suspend fun initialize(
+ cameraAppSettings: CameraAppSettings,
+ useCaseMode: CameraUseCase.UseCaseMode,
+ isDebugMode: Boolean
+ ) {
+ this.useCaseMode = useCaseMode
cameraProvider = ProcessCameraProvider.awaitInstance(application)
// updates values for available cameras
@@ -198,6 +136,10 @@
// Build and update the system constraints
systemConstraints = SystemConstraints(
availableLenses = availableCameraLenses,
+ concurrentCamerasSupported = cameraProvider.availableConcurrentCameraInfos.any {
+ it.map { cameraInfo -> cameraInfo.cameraSelector.toAppLensFacing() }
+ .toSet() == setOf(LensFacing.FRONT, LensFacing.BACK)
+ },
perLensConstraints = buildMap {
val availableCameraInfos = cameraProvider.availableCameraInfos
for (lensFacing in availableCameraLenses) {
@@ -209,17 +151,19 @@
.toSet()
val supportedStabilizationModes = buildSet {
- if (isPreviewStabilizationSupported(camInfo)) {
+ if (camInfo.isPreviewStabilizationSupported) {
add(SupportedStabilizationMode.ON)
}
- if (isVideoStabilizationSupported(camInfo)) {
+ if (camInfo.isVideoStabilizationSupported) {
add(SupportedStabilizationMode.HIGH_QUALITY)
}
}
- val supportedFixedFrameRates = getSupportedFrameRates(camInfo)
- val supportedImageFormats = getSupportedImageFormats(camInfo)
+ val supportedFixedFrameRates =
+ camInfo.filterSupportedFixedFrameRates(FIXED_FRAME_RATES)
+ val supportedImageFormats = camInfo.supportedImageFormats
+ val hasFlashUnit = camInfo.hasFlashUnit()
put(
lensFacing,
@@ -233,7 +177,8 @@
// Ultra HDR now.
Pair(CaptureMode.SINGLE_STREAM, setOf(ImageOutputFormat.JPEG)),
Pair(CaptureMode.MULTI_STREAM, supportedImageFormats)
- )
+ ),
+ hasFlashUnit = hasFlashUnit
)
)
}
@@ -244,43 +189,27 @@
constraintsRepository.updateSystemConstraints(systemConstraints)
currentSettings.value =
- settingsRepository.defaultCameraAppSettings.first()
+ cameraAppSettings
.tryApplyDynamicRangeConstraints()
- .tryApplyAspectRatioForExternalCapture(externalImageCapture)
+ .tryApplyAspectRatioForExternalCapture(this.useCaseMode)
.tryApplyImageFormatConstraints()
+ .tryApplyFrameRateConstraints()
+ .tryApplyStabilizationConstraints()
+ .tryApplyConcurrentCameraModeConstraints()
+ if (isDebugMode && Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+ withContext(iODispatcher) {
+ val cameraProperties =
+ getAllCamerasPropertiesJSONArray(cameraProvider.availableCameraInfos).toString()
+ val file = File(
+ Environment.getExternalStoragePublicDirectory(DIRECTORY_DOCUMENTS),
+ "JCACameraProperties.json"
+ )
+ writeFileExternalStorage(file, cameraProperties)
+ Log.d(TAG, "JCACameraProperties written to ${file.path}. \n$cameraProperties")
+ }
+ }
}
- /**
- * Camera settings that persist as long as a camera is running.
- *
- * Any change in these settings will require calling [ProcessCameraProvider.runWith] with
- * updates [CameraSelector] and/or [UseCaseGroup]
- */
- private data class PerpetualSessionSettings(
- val cameraSelector: CameraSelector,
- val aspectRatio: AspectRatio,
- val captureMode: CaptureMode,
- val targetFrameRate: Int,
- val stabilizePreviewMode: Stabilization,
- val stabilizeVideoMode: Stabilization,
- val dynamicRange: DynamicRange,
- val imageFormat: ImageOutputFormat
- )
-
- /**
- * Camera settings that can change while the camera is running.
- *
- * Any changes in these settings can be applied either directly to use cases via their
- * setter methods or to [androidx.camera.core.CameraControl].
- * The use cases typically will not need to be re-bound.
- */
- private data class TransientSessionSettings(
- val audioMuted: Boolean,
- val deviceRotation: DeviceRotation,
- val flashMode: FlashMode,
- val zoomScale: Float
- )
-
override suspend fun runCamera() = coroutineScope {
Log.d(TAG, "runCamera")
@@ -295,127 +224,98 @@
zoomScale = currentCameraSettings.zoomScale
)
- val cameraSelector = when (currentCameraSettings.cameraLensFacing) {
- LensFacing.FRONT -> CameraSelector.DEFAULT_FRONT_CAMERA
- LensFacing.BACK -> CameraSelector.DEFAULT_BACK_CAMERA
- }
+ when (currentCameraSettings.concurrentCameraMode) {
+ ConcurrentCameraMode.OFF -> {
+ val cameraSelector = when (currentCameraSettings.cameraLensFacing) {
+ LensFacing.FRONT -> CameraSelector.DEFAULT_FRONT_CAMERA
+ LensFacing.BACK -> CameraSelector.DEFAULT_BACK_CAMERA
+ }
- PerpetualSessionSettings(
- cameraSelector = cameraSelector,
- aspectRatio = currentCameraSettings.aspectRatio,
- captureMode = currentCameraSettings.captureMode,
- targetFrameRate = currentCameraSettings.targetFrameRate,
- stabilizePreviewMode = currentCameraSettings.previewStabilization,
- stabilizeVideoMode = currentCameraSettings.videoCaptureStabilization,
- dynamicRange = currentCameraSettings.dynamicRange,
- imageFormat = currentCameraSettings.imageFormat
- )
+ PerpetualSessionSettings.SingleCamera(
+ cameraInfo = cameraProvider.getCameraInfo(cameraSelector),
+ aspectRatio = currentCameraSettings.aspectRatio,
+ captureMode = currentCameraSettings.captureMode,
+ targetFrameRate = currentCameraSettings.targetFrameRate,
+ stabilizePreviewMode = currentCameraSettings.previewStabilization,
+ stabilizeVideoMode = currentCameraSettings.videoCaptureStabilization,
+ dynamicRange = currentCameraSettings.dynamicRange,
+ imageFormat = currentCameraSettings.imageFormat
+ )
+ }
+ ConcurrentCameraMode.DUAL -> {
+ val primaryFacing = currentCameraSettings.cameraLensFacing
+ val secondaryFacing = primaryFacing.flip()
+ cameraProvider.availableConcurrentCameraInfos.firstNotNullOf {
+ var primaryCameraInfo: CameraInfo? = null
+ var secondaryCameraInfo: CameraInfo? = null
+ it.forEach { cameraInfo ->
+ if (cameraInfo.appLensFacing == primaryFacing) {
+ primaryCameraInfo = cameraInfo
+ } else if (cameraInfo.appLensFacing == secondaryFacing) {
+ secondaryCameraInfo = cameraInfo
+ }
+ }
+
+ primaryCameraInfo?.let { nonNullPrimary ->
+ secondaryCameraInfo?.let { nonNullSecondary ->
+ PerpetualSessionSettings.ConcurrentCamera(
+ primaryCameraInfo = nonNullPrimary,
+ secondaryCameraInfo = nonNullSecondary,
+ aspectRatio = currentCameraSettings.aspectRatio
+ )
+ }
+ }
+ }
+ }
+ }
}.distinctUntilChanged()
.collectLatest { sessionSettings ->
- Log.d(TAG, "Starting new camera session")
- val cameraInfo = sessionSettings.cameraSelector.filter(
- cameraProvider.availableCameraInfos
- ).first()
+ coroutineScope {
+ with(
+ CameraSessionContext(
+ context = application,
+ cameraProvider = cameraProvider,
+ backgroundDispatcher = defaultDispatcher,
+ screenFlashEvents = screenFlashEvents,
+ focusMeteringEvents = focusMeteringEvents,
+ videoCaptureControlEvents = videoCaptureControlEvents,
+ currentCameraState = _currentCameraState,
+ surfaceRequests = _surfaceRequest,
+ transientSettings = transientSettings
+ )
+ ) {
+ try {
+ when (sessionSettings) {
+ is PerpetualSessionSettings.SingleCamera -> runSingleCameraSession(
+ sessionSettings,
+ useCaseMode = useCaseMode
+ ) { imageCapture ->
+ imageCaptureUseCase = imageCapture
+ }
- val lensFacing = sessionSettings.cameraSelector.toAppLensFacing()
- val cameraConstraints = checkNotNull(
- systemConstraints.perLensConstraints[lensFacing]
- ) {
- "Unable to retrieve CameraConstraints for $lensFacing. " +
- "Was the use case initialized?"
- }
-
- val initialTransientSettings = transientSettings
- .filterNotNull()
- .first()
-
- val useCaseGroup = createUseCaseGroup(
- cameraInfo,
- sessionSettings,
- initialTransientSettings,
- cameraConstraints.supportedStabilizationModes,
- effect = when (sessionSettings.captureMode) {
- CaptureMode.SINGLE_STREAM -> SingleSurfaceForcingEffect(coroutineScope)
- CaptureMode.MULTI_STREAM -> null
- }
- )
-
- var prevTransientSettings = initialTransientSettings
- cameraProvider.runWith(sessionSettings.cameraSelector, useCaseGroup) { camera ->
- Log.d(TAG, "Camera session started")
-
- launch {
- focusMeteringEvents.consumeAsFlow().collect {
- val focusMeteringAction =
- FocusMeteringAction.Builder(it.meteringPoint).build()
- Log.d(TAG, "Starting focus and metering")
- camera.cameraControl.startFocusAndMetering(focusMeteringAction)
- }
- }
-
- transientSettings.filterNotNull().collectLatest { newTransientSettings ->
- // Apply camera control settings
- if (prevTransientSettings.zoomScale != newTransientSettings.zoomScale) {
- cameraInfo.zoomState.value?.let { zoomState ->
- val finalScale =
- (zoomState.zoomRatio * newTransientSettings.zoomScale).coerceIn(
- zoomState.minZoomRatio,
- zoomState.maxZoomRatio
+ is PerpetualSessionSettings.ConcurrentCamera ->
+ runConcurrentCameraSession(
+ sessionSettings,
+ useCaseMode = CameraUseCase.UseCaseMode.VIDEO_ONLY
)
- camera.cameraControl.setZoomRatio(finalScale)
- _currentCameraState.update { old ->
- old.copy(zoomScale = finalScale)
- }
}
+ } finally {
+ // TODO(tm): This shouldn't be necessary. Cancellation of the
+ // coroutineScope by collectLatest should cause this to
+ // occur naturally.
+ cameraProvider.unbindAll()
}
-
- if (prevTransientSettings.flashMode != newTransientSettings.flashMode) {
- setFlashModeInternal(
- flashMode = newTransientSettings.flashMode,
- isFrontFacing = sessionSettings.cameraSelector
- == CameraSelector.DEFAULT_FRONT_CAMERA
- )
- }
-
- if (prevTransientSettings.deviceRotation
- != newTransientSettings.deviceRotation
- ) {
- Log.d(
- TAG,
- "Updating device rotation from " +
- "${prevTransientSettings.deviceRotation} -> " +
- "${newTransientSettings.deviceRotation}"
- )
- val targetRotation =
- newTransientSettings.deviceRotation.toUiSurfaceRotation()
- useCaseGroup.useCases.forEach {
- when (it) {
- is Preview -> {
- // Preview rotation should always be natural orientation
- // in order to support seamless handling of orientation
- // configuration changes in UI
- }
-
- is ImageCapture -> {
- it.targetRotation = targetRotation
- }
-
- is VideoCapture<*> -> {
- it.targetRotation = targetRotation
- }
- }
- }
- }
-
- prevTransientSettings = newTransientSettings
}
}
}
}
override suspend fun takePicture(onCaptureStarted: (() -> Unit)) {
+ if (imageCaptureUseCase == null) {
+ throw RuntimeException("Attempted take picture with null imageCapture use case")
+ }
try {
- val imageProxy = imageCaptureUseCase.takePicture(onCaptureStarted)
+ val imageProxy = imageCaptureUseCase!!.takePicture(onCaptureStarted)
Log.d(TAG, "onCaptureSuccess")
imageProxy.close()
} catch (exception: Exception) {
@@ -431,6 +331,9 @@
imageCaptureUri: Uri?,
ignoreUri: Boolean
): ImageCapture.OutputFileResults {
+ if (imageCaptureUseCase == null) {
+ throw RuntimeException("Attempted take picture with null imageCapture use case")
+ }
val eligibleContentValues = getEligibleContentValues()
val outputFileOptions: OutputFileOptions
if (ignoreUri) {
@@ -470,7 +373,7 @@
}
}
try {
- val outputFileResults = imageCaptureUseCase.takePicture(
+ val outputFileResults = imageCaptureUseCase!!.takePicture(
outputFileOptions,
onCaptureStarted
)
@@ -502,89 +405,26 @@
}
override suspend fun startVideoRecording(
+ videoCaptureUri: Uri?,
+ shouldUseUri: Boolean,
onVideoRecord: (CameraUseCase.OnVideoRecordEvent) -> Unit
) {
- if (videoCaptureUseCase == null) {
- throw RuntimeException("Attempted video recording with null videoCapture use case")
+ if (shouldUseUri && videoCaptureUri == null) {
+ val e = RuntimeException("Null Uri is provided.")
+ Log.d(TAG, "takePicture onError: $e")
+ throw e
}
- Log.d(TAG, "recordVideo")
- // todo(b/336886716): default setting to enable or disable audio when permission is granted
-
- // ok. there is a difference between MUTING and ENABLING audio
- // audio must be enabled in order to be muted
- // if the video recording isnt started with audio enabled, you will not be able to unmute it
- // the toggle should only affect whether or not the audio is muted.
- // the permission will determine whether or not the audio is enabled.
- val audioEnabled = (
- checkSelfPermission(
- this.application.baseContext,
- Manifest.permission.RECORD_AUDIO
+ videoCaptureControlEvents.send(
+ VideoCaptureControlEvent.StartRecordingEvent(
+ videoCaptureUri,
+ shouldUseUri,
+ onVideoRecord
)
- == PackageManager.PERMISSION_GRANTED
- )
- val captureTypeString =
- when (captureMode) {
- CaptureMode.MULTI_STREAM -> "MultiStream"
- CaptureMode.SINGLE_STREAM -> "SingleStream"
- }
- val name = "JCA-recording-${Date()}-$captureTypeString.mp4"
- val contentValues =
- ContentValues().apply {
- put(MediaStore.Video.Media.DISPLAY_NAME, name)
- }
- val mediaStoreOutput =
- MediaStoreOutputOptions.Builder(
- application.contentResolver,
- MediaStore.Video.Media.EXTERNAL_CONTENT_URI
- )
- .setContentValues(contentValues)
- .build()
-
- val callbackExecutor: Executor =
- (
- currentCoroutineContext()[ContinuationInterceptor] as?
- CoroutineDispatcher
- )?.asExecutor() ?: ContextCompat.getMainExecutor(application)
- recording =
- videoCaptureUseCase!!.output
- .prepareRecording(application, mediaStoreOutput)
- .apply {
- if (audioEnabled) {
- withAudioEnabled()
- }
- }
- .start(callbackExecutor) { onVideoRecordEvent ->
- run {
- Log.d(TAG, onVideoRecordEvent.toString())
- when (onVideoRecordEvent) {
- is VideoRecordEvent.Finalize -> {
- when (onVideoRecordEvent.error) {
- ERROR_NONE ->
- onVideoRecord(
- CameraUseCase.OnVideoRecordEvent.OnVideoRecorded
- )
- else ->
- onVideoRecord(
- CameraUseCase.OnVideoRecordEvent.OnVideoRecordError
- )
- }
- }
- is VideoRecordEvent.Status -> {
- onVideoRecord(
- CameraUseCase.OnVideoRecordEvent.OnVideoRecordStatus(
- onVideoRecordEvent.recordingStats.audioStats.audioAmplitude
- )
- )
- }
- }
- }
- }
- currentSettings.value?.audioMuted?.let { recording?.mute(it) }
+ )
}
override fun stopVideoRecording() {
- Log.d(TAG, "stopRecording")
- recording?.stop()
+ videoCaptureControlEvents.trySendBlocking(VideoCaptureControlEvent.StopRecordingEvent)
}
override fun setZoomScale(scale: Float) {
@@ -593,13 +433,6 @@
}
}
- // Could be improved by setting initial value only when camera is initialized
- private val _currentCameraState = MutableStateFlow(CameraState())
- override fun getCurrentCameraState(): StateFlow<CameraState> = _currentCameraState.asStateFlow()
-
- private val _surfaceRequest = MutableStateFlow<SurfaceRequest?>(null)
- override fun getSurfaceRequest(): StateFlow<SurfaceRequest?> = _surfaceRequest.asStateFlow()
-
// Sets the camera to the designated lensFacing direction
override suspend fun setLensFacing(lensFacing: LensFacing) {
currentSettings.update { old ->
@@ -630,12 +463,16 @@
}
private fun CameraAppSettings.tryApplyAspectRatioForExternalCapture(
- externalImageCapture: Boolean
+ useCaseMode: CameraUseCase.UseCaseMode
): CameraAppSettings {
- if (externalImageCapture) {
- return this.copy(aspectRatio = AspectRatio.THREE_FOUR)
+ return when (useCaseMode) {
+ CameraUseCase.UseCaseMode.STANDARD -> this
+ CameraUseCase.UseCaseMode.IMAGE_ONLY ->
+ this.copy(aspectRatio = AspectRatio.THREE_FOUR)
+
+ CameraUseCase.UseCaseMode.VIDEO_ONLY ->
+ this.copy(aspectRatio = AspectRatio.NINE_SIXTEEN)
}
- return this
}
private fun CameraAppSettings.tryApplyImageFormatConstraints(): CameraAppSettings {
@@ -654,21 +491,71 @@
} ?: this
}
- override suspend fun tapToFocus(x: Float, y: Float) {
- Log.d(TAG, "tapToFocus, sending FocusMeteringEvent")
+ private fun CameraAppSettings.tryApplyFrameRateConstraints(): CameraAppSettings {
+ return systemConstraints.perLensConstraints[cameraLensFacing]?.let { constraints ->
+ with(constraints.supportedFixedFrameRates) {
+ val newTargetFrameRate = if (contains(targetFrameRate)) {
+ targetFrameRate
+ } else {
+ TARGET_FPS_AUTO
+ }
- getSurfaceRequest().filterNotNull().map { surfaceRequest ->
- SurfaceOrientedMeteringPointFactory(
- surfaceRequest.resolution.width.toFloat(),
- surfaceRequest.resolution.height.toFloat()
- )
- }.collectLatest { meteringPointFactory ->
- val meteringPoint = meteringPointFactory.createPoint(x, y)
- focusMeteringEvents.send(CameraEvent.FocusMeteringEvent(meteringPoint))
- }
+ [email protected](
+ targetFrameRate = newTargetFrameRate
+ )
+ }
+ } ?: this
}
- override fun getScreenFlashEvents() = screenFlashEvents.asSharedFlow()
+ private fun CameraAppSettings.tryApplyStabilizationConstraints(): CameraAppSettings {
+ return systemConstraints.perLensConstraints[cameraLensFacing]?.let { constraints ->
+ with(constraints.supportedStabilizationModes) {
+ val newVideoStabilization = if (contains(SupportedStabilizationMode.HIGH_QUALITY) &&
+ (targetFrameRate != TARGET_FPS_60)
+ ) {
+ // unlike shouldVideoBeStabilized, doesn't check value of previewStabilization
+ videoCaptureStabilization
+ } else {
+ Stabilization.UNDEFINED
+ }
+ val newPreviewStabilization = if (contains(SupportedStabilizationMode.ON) &&
+ (targetFrameRate in setOf(TARGET_FPS_AUTO, TARGET_FPS_30))
+ ) {
+ previewStabilization
+ } else {
+ Stabilization.UNDEFINED
+ }
+
+ [email protected](
+ previewStabilization = newPreviewStabilization,
+ videoCaptureStabilization = newVideoStabilization
+ )
+ }
+ } ?: this
+ }
+
+ private fun CameraAppSettings.tryApplyConcurrentCameraModeConstraints(): CameraAppSettings =
+ when (concurrentCameraMode) {
+ ConcurrentCameraMode.OFF -> this
+ else ->
+ if (systemConstraints.concurrentCamerasSupported) {
+ copy(
+ targetFrameRate = TARGET_FPS_AUTO,
+ previewStabilization = Stabilization.OFF,
+ videoCaptureStabilization = Stabilization.OFF,
+ dynamicRange = DynamicRange.SDR,
+ captureMode = CaptureMode.MULTI_STREAM
+ )
+ } else {
+ copy(concurrentCameraMode = ConcurrentCameraMode.OFF)
+ }
+ }
+
+ override suspend fun tapToFocus(x: Float, y: Float) {
+ focusMeteringEvents.send(CameraEvent.FocusMeteringEvent(x, y))
+ }
+
+ override fun getScreenFlashEvents() = screenFlashEvents
override fun getCurrentSettings() = currentSettings.asStateFlow()
override fun setFlashMode(flashMode: FlashMode) {
@@ -677,58 +564,9 @@
}
}
- private fun setFlashModeInternal(flashMode: FlashMode, isFrontFacing: Boolean) {
- val isScreenFlashRequired =
- isFrontFacing && (flashMode == FlashMode.ON || flashMode == FlashMode.AUTO)
-
- if (isScreenFlashRequired) {
- imageCaptureUseCase.screenFlash = object : ScreenFlash {
- override fun apply(
- expirationTimeMillis: Long,
- listener: ImageCapture.ScreenFlashListener
- ) {
- Log.d(TAG, "ImageCapture.ScreenFlash: apply")
- coroutineScope.launch {
- screenFlashEvents.emit(
- CameraUseCase.ScreenFlashEvent(Type.APPLY_UI) {
- listener.onCompleted()
- }
- )
- }
- }
-
- override fun clear() {
- Log.d(TAG, "ImageCapture.ScreenFlash: clear")
- coroutineScope.launch {
- screenFlashEvents.emit(
- CameraUseCase.ScreenFlashEvent(Type.CLEAR_UI) {}
- )
- }
- }
- }
- }
-
- imageCaptureUseCase.flashMode = when (flashMode) {
- FlashMode.OFF -> ImageCapture.FLASH_MODE_OFF // 2
-
- FlashMode.ON -> if (isScreenFlashRequired) {
- ImageCapture.FLASH_MODE_SCREEN // 3
- } else {
- ImageCapture.FLASH_MODE_ON // 1
- }
-
- FlashMode.AUTO -> if (isScreenFlashRequired) {
- ImageCapture.FLASH_MODE_SCREEN // 3
- } else {
- ImageCapture.FLASH_MODE_AUTO // 0
- }
- }
- Log.d(TAG, "Set flash mode to: ${imageCaptureUseCase.flashMode}")
- }
-
override fun isScreenFlashEnabled() =
- imageCaptureUseCase.flashMode == ImageCapture.FLASH_MODE_SCREEN &&
- imageCaptureUseCase.screenFlash != null
+ imageCaptureUseCase?.flashMode == ImageCapture.FLASH_MODE_SCREEN &&
+ imageCaptureUseCase?.screenFlash != null
override suspend fun setAspectRatio(aspectRatio: AspectRatio) {
currentSettings.update { old ->
@@ -738,62 +576,16 @@
override suspend fun setCaptureMode(captureMode: CaptureMode) {
currentSettings.update { old ->
- old?.copy(captureMode = captureMode)?.tryApplyImageFormatConstraints()
+ old?.copy(captureMode = captureMode)
+ ?.tryApplyImageFormatConstraints()
+ ?.tryApplyConcurrentCameraModeConstraints()
}
}
- private fun createUseCaseGroup(
- cameraInfo: CameraInfo,
- sessionSettings: PerpetualSessionSettings,
- initialTransientSettings: TransientSessionSettings,
- supportedStabilizationModes: Set<SupportedStabilizationMode>,
- effect: CameraEffect? = null
- ): UseCaseGroup {
- val previewUseCase =
- createPreviewUseCase(cameraInfo, sessionSettings, supportedStabilizationModes)
- imageCaptureUseCase = createImageUseCase(cameraInfo, sessionSettings)
- if (!disableVideoCapture) {
- videoCaptureUseCase =
- createVideoUseCase(cameraInfo, sessionSettings, supportedStabilizationModes)
- }
-
- setFlashModeInternal(
- flashMode = initialTransientSettings.flashMode,
- isFrontFacing = sessionSettings.cameraSelector == CameraSelector.DEFAULT_FRONT_CAMERA
- )
-
- return UseCaseGroup.Builder().apply {
- Log.d(
- TAG,
- "Setting initial device rotation to ${initialTransientSettings.deviceRotation}"
- )
- setViewPort(
- ViewPort.Builder(
- sessionSettings.aspectRatio.ratio,
- initialTransientSettings.deviceRotation.toUiSurfaceRotation()
- ).build()
- )
- addUseCase(previewUseCase)
- if (sessionSettings.dynamicRange == DynamicRange.SDR ||
- sessionSettings.imageFormat == ImageOutputFormat.JPEG_ULTRA_HDR
- ) {
- addUseCase(imageCaptureUseCase)
- }
- // Not to bind VideoCapture when Ultra HDR is enabled to keep the app design simple.
- if (videoCaptureUseCase != null &&
- sessionSettings.imageFormat == ImageOutputFormat.JPEG
- ) {
- addUseCase(videoCaptureUseCase!!)
- }
-
- effect?.let { addEffect(it) }
-
- captureMode = sessionSettings.captureMode
- }.build()
- }
override suspend fun setDynamicRange(dynamicRange: DynamicRange) {
currentSettings.update { old ->
old?.copy(dynamicRange = dynamicRange)
+ ?.tryApplyConcurrentCameraModeConstraints()
}
}
@@ -803,35 +595,42 @@
}
}
+ override suspend fun setConcurrentCameraMode(concurrentCameraMode: ConcurrentCameraMode) {
+ currentSettings.update { old ->
+ old?.copy(concurrentCameraMode = concurrentCameraMode)
+ ?.tryApplyConcurrentCameraModeConstraints()
+ }
+ }
+
override suspend fun setImageFormat(imageFormat: ImageOutputFormat) {
currentSettings.update { old ->
old?.copy(imageFormat = imageFormat)
}
}
- @OptIn(ExperimentalImageCaptureOutputFormat::class)
- private fun getSupportedImageFormats(cameraInfo: CameraInfo): Set<ImageOutputFormat> {
- return ImageCapture.getImageCaptureCapabilities(cameraInfo).supportedOutputFormats
- .mapNotNull(Int::toAppImageFormat)
- .toSet()
+ override suspend fun setPreviewStabilization(previewStabilization: Stabilization) {
+ currentSettings.update { old ->
+ old?.copy(
+ previewStabilization = previewStabilization
+ )?.tryApplyStabilizationConstraints()
+ ?.tryApplyConcurrentCameraModeConstraints()
+ }
}
- @OptIn(ExperimentalImageCaptureOutputFormat::class)
- private fun createImageUseCase(
- cameraInfo: CameraInfo,
- sessionSettings: PerpetualSessionSettings,
- onCloseTrace: () -> Unit = {}
- ): ImageCapture {
- val builder = ImageCapture.Builder()
- builder.setResolutionSelector(
- getResolutionSelector(cameraInfo.sensorLandscapeRatio, sessionSettings.aspectRatio)
- )
- if (sessionSettings.dynamicRange != DynamicRange.SDR &&
- sessionSettings.imageFormat == ImageOutputFormat.JPEG_ULTRA_HDR
- ) {
- builder.setOutputFormat(ImageCapture.OUTPUT_FORMAT_JPEG_ULTRA_HDR)
+ override suspend fun setVideoCaptureStabilization(videoCaptureStabilization: Stabilization) {
+ currentSettings.update { old ->
+ old?.copy(
+ videoCaptureStabilization = videoCaptureStabilization
+ )?.tryApplyStabilizationConstraints()
+ ?.tryApplyConcurrentCameraModeConstraints()
}
- return builder.build()
+ }
+
+ override suspend fun setTargetFrameRate(targetFrameRate: Int) {
+ currentSettings.update { old ->
+ old?.copy(targetFrameRate = targetFrameRate)?.tryApplyFrameRateConstraints()
+ ?.tryApplyConcurrentCameraModeConstraints()
+ }
}
override suspend fun setLowLightBoost(lowLightBoost: LowLightBoost) {
@@ -841,222 +640,12 @@
}
override suspend fun setAudioMuted(isAudioMuted: Boolean) {
- // toggle mute for current in progress recording
- recording?.mute(!isAudioMuted)
-
currentSettings.update { old ->
old?.copy(audioMuted = isAudioMuted)
}
}
- private fun createVideoUseCase(
- cameraInfo: CameraInfo,
- sessionSettings: PerpetualSessionSettings,
- supportedStabilizationMode: Set<SupportedStabilizationMode>
- ): VideoCapture<Recorder> {
- val sensorLandscapeRatio = cameraInfo.sensorLandscapeRatio
- val recorder = Recorder.Builder()
- .setAspectRatio(
- getAspectRatioForUseCase(sensorLandscapeRatio, sessionSettings.aspectRatio)
- )
- .setExecutor(defaultDispatcher.asExecutor()).build()
- return VideoCapture.Builder(recorder).apply {
- // set video stabilization
- if (shouldVideoBeStabilized(sessionSettings, supportedStabilizationMode)
- ) {
- setVideoStabilizationEnabled(true)
- }
- // set target fps
- if (sessionSettings.targetFrameRate != TARGET_FPS_AUTO) {
- setTargetFrameRate(
- Range(sessionSettings.targetFrameRate, sessionSettings.targetFrameRate)
- )
- }
-
- setDynamicRange(sessionSettings.dynamicRange.toCXDynamicRange())
- }.build()
- }
-
- private fun getAspectRatioForUseCase(
- sensorLandscapeRatio: Float,
- aspectRatio: AspectRatio
- ): Int {
- return when (aspectRatio) {
- AspectRatio.THREE_FOUR -> RATIO_4_3
- AspectRatio.NINE_SIXTEEN -> RATIO_16_9
- else -> {
- // Choose the aspect ratio which maximizes FOV by being closest to the sensor ratio
- if (
- abs(sensorLandscapeRatio - AspectRatio.NINE_SIXTEEN.landscapeRatio.toFloat()) <
- abs(sensorLandscapeRatio - AspectRatio.THREE_FOUR.landscapeRatio.toFloat())
- ) {
- RATIO_16_9
- } else {
- RATIO_4_3
- }
- }
- }
- }
-
- private fun shouldVideoBeStabilized(
- sessionSettings: PerpetualSessionSettings,
- supportedStabilizationModes: Set<SupportedStabilizationMode>
- ): Boolean {
- // video is on and target fps is not 60
- return (sessionSettings.targetFrameRate != TARGET_FPS_60) &&
- (supportedStabilizationModes.contains(SupportedStabilizationMode.HIGH_QUALITY)) &&
- // high quality (video only) selected
- (
- sessionSettings.stabilizeVideoMode == Stabilization.ON &&
- sessionSettings.stabilizePreviewMode == Stabilization.UNDEFINED
- )
- }
-
- private fun createPreviewUseCase(
- cameraInfo: CameraInfo,
- sessionSettings: PerpetualSessionSettings,
- supportedStabilizationModes: Set<SupportedStabilizationMode>
- ): Preview {
- val previewUseCaseBuilder = Preview.Builder().apply {
- setTargetRotation(DeviceRotation.Natural.toUiSurfaceRotation())
- }
-
- setOnCaptureCompletedCallback(previewUseCaseBuilder)
-
- // set preview stabilization
- if (shouldPreviewBeStabilized(sessionSettings, supportedStabilizationModes)) {
- previewUseCaseBuilder.setPreviewStabilizationEnabled(true)
- }
-
- previewUseCaseBuilder.setResolutionSelector(
- getResolutionSelector(cameraInfo.sensorLandscapeRatio, sessionSettings.aspectRatio)
- )
-
- return previewUseCaseBuilder.build().apply {
- setSurfaceProvider { surfaceRequest ->
- _surfaceRequest.value = surfaceRequest
- }
- }
- }
-
- private fun getResolutionSelector(
- sensorLandscapeRatio: Float,
- aspectRatio: AspectRatio
- ): ResolutionSelector {
- val aspectRatioStrategy = when (aspectRatio) {
- AspectRatio.THREE_FOUR -> AspectRatioStrategy.RATIO_4_3_FALLBACK_AUTO_STRATEGY
- AspectRatio.NINE_SIXTEEN -> AspectRatioStrategy.RATIO_16_9_FALLBACK_AUTO_STRATEGY
- else -> {
- // Choose the resolution selector strategy which maximizes FOV by being closest
- // to the sensor aspect ratio
- if (
- abs(sensorLandscapeRatio - AspectRatio.NINE_SIXTEEN.landscapeRatio.toFloat()) <
- abs(sensorLandscapeRatio - AspectRatio.THREE_FOUR.landscapeRatio.toFloat())
- ) {
- AspectRatioStrategy.RATIO_16_9_FALLBACK_AUTO_STRATEGY
- } else {
- AspectRatioStrategy.RATIO_4_3_FALLBACK_AUTO_STRATEGY
- }
- }
- }
- return ResolutionSelector.Builder().setAspectRatioStrategy(aspectRatioStrategy).build()
- }
-
- private fun shouldPreviewBeStabilized(
- sessionSettings: PerpetualSessionSettings,
- supportedStabilizationModes: Set<SupportedStabilizationMode>
- ): Boolean {
- // only supported if target fps is 30 or none
- return (
- when (sessionSettings.targetFrameRate) {
- TARGET_FPS_AUTO, TARGET_FPS_30 -> true
- else -> false
- }
- ) &&
- (
- supportedStabilizationModes.contains(SupportedStabilizationMode.ON) &&
- sessionSettings.stabilizePreviewMode == Stabilization.ON
- )
- }
-
companion object {
private val FIXED_FRAME_RATES = setOf(TARGET_FPS_15, TARGET_FPS_30, TARGET_FPS_60)
-
- /**
- * Checks if preview stabilization is supported by the device.
- *
- */
- private fun isPreviewStabilizationSupported(cameraInfo: CameraInfo): Boolean {
- return Preview.getPreviewCapabilities(cameraInfo).isStabilizationSupported
- }
-
- /**
- * Checks if video stabilization is supported by the device.
- *
- */
- private fun isVideoStabilizationSupported(cameraInfo: CameraInfo): Boolean {
- return Recorder.getVideoCapabilities(cameraInfo).isStabilizationSupported
- }
-
- private fun getSupportedFrameRates(camInfo: CameraInfo): Set<Int> {
- return buildSet {
- camInfo.supportedFrameRateRanges.forEach { e ->
- if (e.upper == e.lower && FIXED_FRAME_RATES.contains(e.upper)) {
- add(e.upper)
- }
- }
- }
- }
- }
-}
-
-private fun CXDynamicRange.toSupportedAppDynamicRange(): DynamicRange? {
- return when (this) {
- CXDynamicRange.SDR -> DynamicRange.SDR
- CXDynamicRange.HLG_10_BIT -> DynamicRange.HLG10
- // All other dynamic ranges unsupported. Return null.
- else -> null
- }
-}
-
-private fun DynamicRange.toCXDynamicRange(): CXDynamicRange {
- return when (this) {
- DynamicRange.SDR -> CXDynamicRange.SDR
- DynamicRange.HLG10 -> CXDynamicRange.HLG_10_BIT
- }
-}
-
-private fun LensFacing.toCameraSelector(): CameraSelector = when (this) {
- LensFacing.FRONT -> CameraSelector.DEFAULT_FRONT_CAMERA
- LensFacing.BACK -> CameraSelector.DEFAULT_BACK_CAMERA
-}
-
-private fun CameraSelector.toAppLensFacing(): LensFacing = when (this) {
- CameraSelector.DEFAULT_FRONT_CAMERA -> LensFacing.FRONT
- CameraSelector.DEFAULT_BACK_CAMERA -> LensFacing.BACK
- else -> throw IllegalArgumentException(
- "Unknown CameraSelector -> LensFacing mapping. [CameraSelector: $this]"
- )
-}
-
-private val CameraInfo.sensorLandscapeRatio: Float
- @OptIn(ExperimentalCamera2Interop::class)
- get() = Camera2CameraInfo.from(this)
- .getCameraCharacteristic(CameraCharacteristics.SENSOR_INFO_ACTIVE_ARRAY_SIZE)
- ?.let { sensorRect ->
- if (sensorRect.width() > sensorRect.height()) {
- sensorRect.width().toFloat() / sensorRect.height()
- } else {
- sensorRect.height().toFloat() / sensorRect.width()
- }
- } ?: Float.NaN
-
-@OptIn(ExperimentalImageCaptureOutputFormat::class)
-private fun Int.toAppImageFormat(): ImageOutputFormat? {
- return when (this) {
- ImageCapture.OUTPUT_FORMAT_JPEG -> ImageOutputFormat.JPEG
- ImageCapture.OUTPUT_FORMAT_JPEG_ULTRA_HDR -> ImageOutputFormat.JPEG_ULTRA_HDR
- // All other output formats unsupported. Return null.
- else -> null
}
}
diff --git a/core/camera/src/main/java/com/google/jetpackcamera/core/camera/ConcurrentCameraSession.kt b/core/camera/src/main/java/com/google/jetpackcamera/core/camera/ConcurrentCameraSession.kt
new file mode 100644
index 0000000..1ea84a1
--- /dev/null
+++ b/core/camera/src/main/java/com/google/jetpackcamera/core/camera/ConcurrentCameraSession.kt
@@ -0,0 +1,118 @@
+/*
+ * Copyright (C) 2024 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.core.camera
+
+import android.annotation.SuppressLint
+import android.util.Log
+import androidx.camera.core.CompositionSettings
+import androidx.camera.core.TorchState
+import androidx.lifecycle.asFlow
+import com.google.jetpackcamera.settings.model.DynamicRange
+import com.google.jetpackcamera.settings.model.ImageOutputFormat
+import com.google.jetpackcamera.settings.model.Stabilization
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.flow.collectLatest
+import kotlinx.coroutines.flow.filterNotNull
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+
+private const val TAG = "ConcurrentCameraSession"
+
+context(CameraSessionContext)
+@SuppressLint("RestrictedApi")
+internal suspend fun runConcurrentCameraSession(
+ sessionSettings: PerpetualSessionSettings.ConcurrentCamera,
+ useCaseMode: CameraUseCase.UseCaseMode
+) = coroutineScope {
+ val primaryLensFacing = sessionSettings.primaryCameraInfo.appLensFacing
+ val secondaryLensFacing = sessionSettings.secondaryCameraInfo.appLensFacing
+ Log.d(
+ TAG,
+ "Starting new concurrent camera session " +
+ "[primary: $primaryLensFacing, secondary: $secondaryLensFacing]"
+ )
+
+ val initialTransientSettings = transientSettings
+ .filterNotNull()
+ .first()
+
+ val useCaseGroup = createUseCaseGroup(
+ cameraInfo = sessionSettings.primaryCameraInfo,
+ initialTransientSettings = initialTransientSettings,
+ stabilizePreviewMode = Stabilization.OFF,
+ stabilizeVideoMode = Stabilization.OFF,
+ aspectRatio = sessionSettings.aspectRatio,
+ targetFrameRate = TARGET_FPS_AUTO,
+ dynamicRange = DynamicRange.SDR,
+ imageFormat = ImageOutputFormat.JPEG,
+ useCaseMode = useCaseMode
+ )
+
+ val cameraConfigs = listOf(
+ Pair(
+ sessionSettings.primaryCameraInfo.cameraSelector,
+ CompositionSettings.Builder()
+ .setAlpha(1.0f)
+ .setOffset(0.0f, 0.0f)
+ .setScale(1.0f, 1.0f)
+ .build()
+ ),
+ Pair(
+ sessionSettings.secondaryCameraInfo.cameraSelector,
+ CompositionSettings.Builder()
+ .setAlpha(1.0f)
+ .setOffset(2 / 3f - 0.1f, -2 / 3f + 0.1f)
+ .setScale(1 / 3f, 1 / 3f)
+ .build()
+ )
+ )
+
+ cameraProvider.runWithConcurrent(cameraConfigs, useCaseGroup) { concurrentCamera ->
+ Log.d(TAG, "Concurrent camera session started")
+ val primaryCamera = concurrentCamera.cameras.first {
+ it.cameraInfo.appLensFacing == sessionSettings.primaryCameraInfo.appLensFacing
+ }
+
+ launch {
+ processFocusMeteringEvents(primaryCamera.cameraControl)
+ }
+
+ launch {
+ processVideoControlEvents(
+ primaryCamera,
+ useCaseGroup.getVideoCapture(),
+ captureTypeSuffix = "DualCam"
+ )
+ }
+
+ launch {
+ sessionSettings.primaryCameraInfo.torchState.asFlow().collectLatest { torchState ->
+ currentCameraState.update { old ->
+ old.copy(torchEnabled = torchState == TorchState.ON)
+ }
+ }
+ }
+
+ applyDeviceRotation(initialTransientSettings.deviceRotation, useCaseGroup)
+ processTransientSettingEvents(
+ primaryCamera,
+ useCaseGroup,
+ initialTransientSettings,
+ transientSettings
+ )
+ }
+}
diff --git a/core/camera/src/main/java/com/google/jetpackcamera/core/camera/CoroutineCameraProvider.kt b/core/camera/src/main/java/com/google/jetpackcamera/core/camera/CoroutineCameraProvider.kt
index e6f98ea..a6a032f 100644
--- a/core/camera/src/main/java/com/google/jetpackcamera/core/camera/CoroutineCameraProvider.kt
+++ b/core/camera/src/main/java/com/google/jetpackcamera/core/camera/CoroutineCameraProvider.kt
@@ -15,14 +15,19 @@
*/
package com.google.jetpackcamera.core.camera
+import android.annotation.SuppressLint
import androidx.camera.core.Camera
import androidx.camera.core.CameraSelector
+import androidx.camera.core.CompositionSettings
+import androidx.camera.core.ConcurrentCamera
+import androidx.camera.core.ConcurrentCamera.SingleCameraConfig
import androidx.camera.core.UseCaseGroup
import androidx.camera.lifecycle.ProcessCameraProvider
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.LifecycleOwner
import androidx.lifecycle.LifecycleRegistry
import kotlin.coroutines.CoroutineContext
+import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Job
import kotlinx.coroutines.coroutineScope
@@ -36,12 +41,25 @@
suspend fun <R> ProcessCameraProvider.runWith(
cameraSelector: CameraSelector,
useCases: UseCaseGroup,
- block: suspend (Camera) -> R
+ block: suspend CoroutineScope.(Camera) -> R
): R = coroutineScope {
val scopedLifecycle = CoroutineLifecycleOwner(coroutineContext)
block([email protected](scopedLifecycle, cameraSelector, useCases))
}
+@SuppressLint("RestrictedApi")
+suspend fun <R> ProcessCameraProvider.runWithConcurrent(
+ cameraConfigs: List<Pair<CameraSelector, CompositionSettings>>,
+ useCaseGroup: UseCaseGroup,
+ block: suspend CoroutineScope.(ConcurrentCamera) -> R
+): R = coroutineScope {
+ val scopedLifecycle = CoroutineLifecycleOwner(coroutineContext)
+ val singleCameraConfigs = cameraConfigs.map {
+ SingleCameraConfig(it.first, useCaseGroup, it.second, scopedLifecycle)
+ }
+ block([email protected](singleCameraConfigs))
+}
+
/**
* A [LifecycleOwner] that follows the lifecycle of a coroutine.
*
diff --git a/core/camera/src/main/java/com/google/jetpackcamera/core/camera/DebugCameraInfoUtil.kt b/core/camera/src/main/java/com/google/jetpackcamera/core/camera/DebugCameraInfoUtil.kt
new file mode 100644
index 0000000..cb3645e
--- /dev/null
+++ b/core/camera/src/main/java/com/google/jetpackcamera/core/camera/DebugCameraInfoUtil.kt
@@ -0,0 +1,135 @@
+/*
+ * Copyright (C) 2024 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.core.camera
+
+import android.hardware.camera2.CameraCharacteristics
+import android.os.Build
+import android.os.Environment
+import androidx.annotation.OptIn
+import androidx.annotation.RequiresApi
+import androidx.camera.camera2.interop.Camera2CameraInfo
+import androidx.camera.camera2.interop.ExperimentalCamera2Interop
+import androidx.camera.core.CameraInfo
+import java.io.File
+import java.io.FileOutputStream
+import org.json.JSONArray
+import org.json.JSONObject
+
+private const val TAG = "DebugCameraInfoUtil"
+object DebugCameraInfoUtil {
+ @OptIn(ExperimentalCamera2Interop::class)
+ @RequiresApi(Build.VERSION_CODES.P)
+ fun getAllCamerasPropertiesJSONArray(cameraInfos: List<CameraInfo>): JSONArray {
+ val result = JSONArray()
+ for (cameraInfo in cameraInfos) {
+ var camera2CameraInfo = Camera2CameraInfo.from(cameraInfo)
+ val logicalCameraId = camera2CameraInfo.cameraId
+ val logicalCameraData = JSONObject()
+ logicalCameraData.put(
+ "logical-$logicalCameraId",
+ getCameraPropertiesJSONObject(camera2CameraInfo)
+ )
+ for (physicalCameraInfo in cameraInfo.physicalCameraInfos) {
+ camera2CameraInfo = Camera2CameraInfo.from(physicalCameraInfo)
+ val physicalCameraId = camera2CameraInfo.cameraId
+ logicalCameraData.put(
+ "physical-$physicalCameraId",
+ getCameraPropertiesJSONObject(camera2CameraInfo)
+ )
+ }
+ result.put(logicalCameraData)
+ }
+ return result
+ }
+
+ @OptIn(ExperimentalCamera2Interop::class)
+ private fun getCameraPropertiesJSONObject(cameraInfo: Camera2CameraInfo): JSONObject {
+ val jsonObject = JSONObject()
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+ cameraInfo.getCameraCharacteristic(CameraCharacteristics.LENS_POSE_ROTATION)
+ ?.let {
+ jsonObject.put(
+ CameraCharacteristics.LENS_POSE_ROTATION.name,
+ it.contentToString()
+ )
+ }
+ cameraInfo.getCameraCharacteristic(CameraCharacteristics.LENS_POSE_TRANSLATION)
+ ?.let {
+ jsonObject.put(
+ CameraCharacteristics.LENS_POSE_TRANSLATION.name,
+ it.contentToString()
+ )
+ }
+ cameraInfo.getCameraCharacteristic(CameraCharacteristics.LENS_INTRINSIC_CALIBRATION)
+ ?.let {
+ jsonObject.put(
+ CameraCharacteristics.LENS_INTRINSIC_CALIBRATION.name,
+ it.contentToString()
+ )
+ }
+ }
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+ cameraInfo.getCameraCharacteristic(CameraCharacteristics.LENS_DISTORTION)
+ ?.let {
+ jsonObject.put(
+ CameraCharacteristics.LENS_DISTORTION.name,
+ it.contentToString()
+ )
+ }
+ }
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+ cameraInfo.getCameraCharacteristic(CameraCharacteristics.CONTROL_ZOOM_RATIO_RANGE)
+ ?.let { jsonObject.put(CameraCharacteristics.CONTROL_ZOOM_RATIO_RANGE.name, it) }
+ }
+ cameraInfo.getCameraCharacteristic(CameraCharacteristics.LENS_INFO_AVAILABLE_FOCAL_LENGTHS)
+ ?.let {
+ jsonObject.put(
+ CameraCharacteristics.LENS_INFO_AVAILABLE_FOCAL_LENGTHS.name,
+ it.contentToString()
+ )
+ }
+ cameraInfo.getCameraCharacteristic(CameraCharacteristics.LENS_INFO_MINIMUM_FOCUS_DISTANCE)
+ ?.let {
+ jsonObject.put(
+ CameraCharacteristics.LENS_INFO_MINIMUM_FOCUS_DISTANCE.name,
+ it
+ )
+ }
+ cameraInfo.getCameraCharacteristic(CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES)
+ ?.let {
+ jsonObject.put(
+ CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES.name,
+ it.contentToString()
+ )
+ }
+
+ return jsonObject
+ }
+
+ fun writeFileExternalStorage(file: File, textToWrite: String) {
+ // Checking the availability state of the External Storage.
+ val state = Environment.getExternalStorageState()
+ if (Environment.MEDIA_MOUNTED != state) {
+ // If it isn't mounted - we can't write into it.
+ return
+ }
+
+ file.createNewFile()
+ FileOutputStream(file).use { outputStream ->
+ outputStream.write(textToWrite.toByteArray())
+ }
+ }
+}
diff --git a/core/camera/src/main/java/com/google/jetpackcamera/core/camera/VideoCaptureControlEvent.kt b/core/camera/src/main/java/com/google/jetpackcamera/core/camera/VideoCaptureControlEvent.kt
new file mode 100644
index 0000000..822c5cd
--- /dev/null
+++ b/core/camera/src/main/java/com/google/jetpackcamera/core/camera/VideoCaptureControlEvent.kt
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2024 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.core.camera
+
+import android.net.Uri
+
+/**
+ * Represents events that control video capture operations.
+ */
+sealed interface VideoCaptureControlEvent {
+
+ /**
+ * Starts video recording.
+ *
+ * @param onVideoRecord Callback to handle video recording events.
+ */
+ class StartRecordingEvent(
+ val videoCaptureUri: Uri?,
+ val shouldUseUri: Boolean,
+ val onVideoRecord: (CameraUseCase.OnVideoRecordEvent) -> Unit
+ ) : VideoCaptureControlEvent
+
+ /**
+ * Stops video recording.
+ */
+ data object StopRecordingEvent : VideoCaptureControlEvent
+}
diff --git a/core/camera/src/main/java/com/google/jetpackcamera/core/camera/effects/ShaderCopy.kt b/core/camera/src/main/java/com/google/jetpackcamera/core/camera/effects/ShaderCopy.kt
index fc32ecd..0677b23 100644
--- a/core/camera/src/main/java/com/google/jetpackcamera/core/camera/effects/ShaderCopy.kt
+++ b/core/camera/src/main/java/com/google/jetpackcamera/core/camera/effects/ShaderCopy.kt
@@ -490,8 +490,7 @@
private const val EGL_GL_COLORSPACE_BT2020_HLG_EXT = 0x3540
private val TEN_BIT_REQUIRED_EGL_EXTENSIONS = listOf(
- "EGL_EXT_gl_colorspace_bt2020_hlg",
- "EGL_EXT_yuv_surface"
+ "EGL_EXT_gl_colorspace_bt2020_hlg"
)
private fun FloatArray.toBuffer(): FloatBuffer {
diff --git a/core/camera/src/main/java/com/google/jetpackcamera/core/camera/test/FakeCameraUseCase.kt b/core/camera/src/main/java/com/google/jetpackcamera/core/camera/test/FakeCameraUseCase.kt
index 4245f59..f865a63 100644
--- a/core/camera/src/main/java/com/google/jetpackcamera/core/camera/test/FakeCameraUseCase.kt
+++ b/core/camera/src/main/java/com/google/jetpackcamera/core/camera/test/FakeCameraUseCase.kt
@@ -25,27 +25,24 @@
import com.google.jetpackcamera.settings.model.AspectRatio
import com.google.jetpackcamera.settings.model.CameraAppSettings
import com.google.jetpackcamera.settings.model.CaptureMode
+import com.google.jetpackcamera.settings.model.ConcurrentCameraMode
import com.google.jetpackcamera.settings.model.DeviceRotation
import com.google.jetpackcamera.settings.model.DynamicRange
import com.google.jetpackcamera.settings.model.FlashMode
import com.google.jetpackcamera.settings.model.ImageOutputFormat
import com.google.jetpackcamera.settings.model.LensFacing
import com.google.jetpackcamera.settings.model.LowLightBoost
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.SupervisorJob
-import kotlinx.coroutines.flow.MutableSharedFlow
+import com.google.jetpackcamera.settings.model.Stabilization
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.channels.Channel.Factory.UNLIMITED
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.flow.collectLatest
import kotlinx.coroutines.flow.onCompletion
import kotlinx.coroutines.flow.update
-import kotlinx.coroutines.launch
class FakeCameraUseCase(
- private val coroutineScope: CoroutineScope =
- CoroutineScope(SupervisorJob() + Dispatchers.Default),
defaultCameraSettings: CameraAppSettings = CameraAppSettings()
) : CameraUseCase {
private val availableLenses = listOf(LensFacing.FRONT, LensFacing.BACK)
@@ -60,11 +57,15 @@
var isLensFacingFront = false
private var isScreenFlash = true
- private var screenFlashEvents = MutableSharedFlow<CameraUseCase.ScreenFlashEvent>()
+ private var screenFlashEvents = Channel<CameraUseCase.ScreenFlashEvent>(capacity = UNLIMITED)
private val currentSettings = MutableStateFlow(defaultCameraSettings)
- override suspend fun initialize(disableVideoCapture: Boolean) {
+ override suspend fun initialize(
+ cameraAppSettings: CameraAppSettings,
+ useCaseMode: CameraUseCase.UseCaseMode,
+ isDebugMode: Boolean
+ ) {
initialized = true
}
@@ -103,14 +104,12 @@
throw IllegalStateException("Usecases not bound")
}
if (isScreenFlash) {
- coroutineScope.launch {
- screenFlashEvents.emit(
- CameraUseCase.ScreenFlashEvent(CameraUseCase.ScreenFlashEvent.Type.APPLY_UI) { }
- )
- screenFlashEvents.emit(
- CameraUseCase.ScreenFlashEvent(CameraUseCase.ScreenFlashEvent.Type.CLEAR_UI) { }
- )
- }
+ screenFlashEvents.trySend(
+ CameraUseCase.ScreenFlashEvent(CameraUseCase.ScreenFlashEvent.Type.APPLY_UI) { }
+ )
+ screenFlashEvents.trySend(
+ CameraUseCase.ScreenFlashEvent(CameraUseCase.ScreenFlashEvent.Type.CLEAR_UI) { }
+ )
}
numPicturesTaken += 1
}
@@ -127,12 +126,12 @@
}
fun emitScreenFlashEvent(event: CameraUseCase.ScreenFlashEvent) {
- coroutineScope.launch {
- screenFlashEvents.emit(event)
- }
+ screenFlashEvents.trySend(event)
}
override suspend fun startVideoRecording(
+ videoCaptureUri: Uri?,
+ shouldUseUri: Boolean,
onVideoRecord: (CameraUseCase.OnVideoRecordEvent) -> Unit
) {
if (!useCasesBinded) {
@@ -203,6 +202,12 @@
}
}
+ override suspend fun setConcurrentCameraMode(concurrentCameraMode: ConcurrentCameraMode) {
+ currentSettings.update { old ->
+ old.copy(concurrentCameraMode = concurrentCameraMode)
+ }
+ }
+
override suspend fun setImageFormat(imageFormat: ImageOutputFormat) {
currentSettings.update { old ->
old.copy(imageFormat = imageFormat)
@@ -220,4 +225,22 @@
old.copy(audioMuted = isAudioMuted)
}
}
+
+ override suspend fun setVideoCaptureStabilization(videoCaptureStabilization: Stabilization) {
+ currentSettings.update { old ->
+ old.copy(videoCaptureStabilization = videoCaptureStabilization)
+ }
+ }
+
+ override suspend fun setPreviewStabilization(previewStabilization: Stabilization) {
+ currentSettings.update { old ->
+ old.copy(previewStabilization = previewStabilization)
+ }
+ }
+
+ override suspend fun setTargetFrameRate(targetFrameRate: Int) {
+ currentSettings.update { old ->
+ old.copy(targetFrameRate = targetFrameRate)
+ }
+ }
}
diff --git a/core/camera/src/test/java/com/google/jetpackcamera/core/camera/test/FakeCameraUseCaseTest.kt b/core/camera/src/test/java/com/google/jetpackcamera/core/camera/test/FakeCameraUseCaseTest.kt
index ad47e41..00cedf3 100644
--- a/core/camera/src/test/java/com/google/jetpackcamera/core/camera/test/FakeCameraUseCaseTest.kt
+++ b/core/camera/src/test/java/com/google/jetpackcamera/core/camera/test/FakeCameraUseCaseTest.kt
@@ -17,10 +17,12 @@
import com.google.common.truth.Truth
import com.google.jetpackcamera.core.camera.CameraUseCase
+import com.google.jetpackcamera.settings.model.DEFAULT_CAMERA_APP_SETTINGS
import com.google.jetpackcamera.settings.model.FlashMode
import com.google.jetpackcamera.settings.model.LensFacing
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.consumeAsFlow
import kotlinx.coroutines.flow.toList
import kotlinx.coroutines.launch
import kotlinx.coroutines.test.StandardTestDispatcher
@@ -39,7 +41,7 @@
private val testScope = TestScope()
private val testDispatcher = StandardTestDispatcher(testScope.testScheduler)
- private val cameraUseCase = FakeCameraUseCase(testScope)
+ private val cameraUseCase = FakeCameraUseCase()
@Before
fun setup() {
@@ -53,7 +55,10 @@
@Test
fun canInitialize() = runTest(testDispatcher) {
- cameraUseCase.initialize(false)
+ cameraUseCase.initialize(
+ cameraAppSettings = DEFAULT_CAMERA_APP_SETTINGS,
+ useCaseMode = CameraUseCase.UseCaseMode.STANDARD
+ )
}
@Test
@@ -124,7 +129,7 @@
initAndRunCamera()
val events = mutableListOf<CameraUseCase.ScreenFlashEvent>()
backgroundScope.launch(UnconfinedTestDispatcher(testScheduler)) {
- cameraUseCase.getScreenFlashEvents().toList(events)
+ cameraUseCase.getScreenFlashEvents().consumeAsFlow().toList(events)
}
// FlashMode.ON in front facing camera automatically enables screen flash
@@ -144,7 +149,10 @@
private fun TestScope.initAndRunCamera() {
backgroundScope.launch(UnconfinedTestDispatcher(testScheduler)) {
- cameraUseCase.initialize(false)
+ cameraUseCase.initialize(
+ cameraAppSettings = DEFAULT_CAMERA_APP_SETTINGS,
+ useCaseMode = CameraUseCase.UseCaseMode.STANDARD
+ )
cameraUseCase.runCamera()
}
}
diff --git a/core/common/src/main/java/com/google/jetpackcamera/core/common/CommonModule.kt b/core/common/src/main/java/com/google/jetpackcamera/core/common/CommonModule.kt
index 519f90f..2f93743 100644
--- a/core/common/src/main/java/com/google/jetpackcamera/core/common/CommonModule.kt
+++ b/core/common/src/main/java/com/google/jetpackcamera/core/common/CommonModule.kt
@@ -19,6 +19,7 @@
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent
+import javax.inject.Qualifier
import javax.inject.Singleton
import kotlinx.coroutines.CoroutineDispatcher
import kotlinx.coroutines.CoroutineScope
@@ -32,9 +33,22 @@
@InstallIn(SingletonComponent::class)
class CommonModule {
@Provides
+ @DefaultDispatcher
fun provideDefaultDispatcher(): CoroutineDispatcher = Dispatchers.Default
+ @Provides
+ @IODispatcher
+ fun provideIODispatcher(): CoroutineDispatcher = Dispatchers.IO
+
@Singleton
@Provides
fun providesCoroutineScope() = CoroutineScope(SupervisorJob() + Dispatchers.Default)
}
+
+@Qualifier
+@Retention(AnnotationRetention.BINARY)
+annotation class DefaultDispatcher
+
+@Qualifier
+@Retention(AnnotationRetention.BINARY)
+annotation class IODispatcher
diff --git a/data/settings/src/main/java/com/google/jetpackcamera/settings/LocalSettingsRepository.kt b/data/settings/src/main/java/com/google/jetpackcamera/settings/LocalSettingsRepository.kt
index 8183542..fb10dc2 100644
--- a/data/settings/src/main/java/com/google/jetpackcamera/settings/LocalSettingsRepository.kt
+++ b/data/settings/src/main/java/com/google/jetpackcamera/settings/LocalSettingsRepository.kt
@@ -38,9 +38,7 @@
import kotlinx.coroutines.flow.first
import kotlinx.coroutines.flow.map
-const val TARGET_FPS_NONE = 0
const val TARGET_FPS_15 = 15
-const val TARGET_FPS_30 = 30
const val TARGET_FPS_60 = 60
/**
diff --git a/data/settings/src/main/java/com/google/jetpackcamera/settings/model/CameraAppSettings.kt b/data/settings/src/main/java/com/google/jetpackcamera/settings/model/CameraAppSettings.kt
index 712a0cc..1daa078 100644
--- a/data/settings/src/main/java/com/google/jetpackcamera/settings/model/CameraAppSettings.kt
+++ b/data/settings/src/main/java/com/google/jetpackcamera/settings/model/CameraAppSettings.kt
@@ -35,7 +35,8 @@
val targetFrameRate: Int = TARGET_FPS_AUTO,
val imageFormat: ImageOutputFormat = ImageOutputFormat.JPEG,
val audioMuted: Boolean = false,
- val deviceRotation: DeviceRotation = DeviceRotation.Natural
+ val deviceRotation: DeviceRotation = DeviceRotation.Natural,
+ val concurrentCameraMode: ConcurrentCameraMode = ConcurrentCameraMode.OFF
)
fun SystemConstraints.forCurrentLens(cameraAppSettings: CameraAppSettings): CameraConstraints? {
diff --git a/data/settings/src/main/java/com/google/jetpackcamera/settings/model/ConcurrentCameraMode.kt b/data/settings/src/main/java/com/google/jetpackcamera/settings/model/ConcurrentCameraMode.kt
new file mode 100644
index 0000000..621296a
--- /dev/null
+++ b/data/settings/src/main/java/com/google/jetpackcamera/settings/model/ConcurrentCameraMode.kt
@@ -0,0 +1,21 @@
+/*
+ * Copyright (C) 2024 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.settings.model
+
+enum class ConcurrentCameraMode {
+ OFF,
+ DUAL
+}
diff --git a/data/settings/src/main/java/com/google/jetpackcamera/settings/model/Constraints.kt b/data/settings/src/main/java/com/google/jetpackcamera/settings/model/Constraints.kt
index 51a1eb4..8b75351 100644
--- a/data/settings/src/main/java/com/google/jetpackcamera/settings/model/Constraints.kt
+++ b/data/settings/src/main/java/com/google/jetpackcamera/settings/model/Constraints.kt
@@ -17,6 +17,7 @@
data class SystemConstraints(
val availableLenses: List<LensFacing>,
+ val concurrentCamerasSupported: Boolean,
val perLensConstraints: Map<LensFacing, CameraConstraints>
)
@@ -24,7 +25,8 @@
val supportedStabilizationModes: Set<SupportedStabilizationMode>,
val supportedFixedFrameRates: Set<Int>,
val supportedDynamicRanges: Set<DynamicRange>,
- val supportedImageFormatsMap: Map<CaptureMode, Set<ImageOutputFormat>>
+ val supportedImageFormatsMap: Map<CaptureMode, Set<ImageOutputFormat>>,
+ val hasFlashUnit: Boolean
)
/**
@@ -33,6 +35,7 @@
val TYPICAL_SYSTEM_CONSTRAINTS =
SystemConstraints(
availableLenses = listOf(LensFacing.FRONT, LensFacing.BACK),
+ concurrentCamerasSupported = false,
perLensConstraints = buildMap {
for (lensFacing in listOf(LensFacing.FRONT, LensFacing.BACK)) {
put(
@@ -44,7 +47,8 @@
supportedImageFormatsMap = mapOf(
Pair(CaptureMode.SINGLE_STREAM, setOf(ImageOutputFormat.JPEG)),
Pair(CaptureMode.MULTI_STREAM, setOf(ImageOutputFormat.JPEG))
- )
+ ),
+ hasFlashUnit = lensFacing == LensFacing.BACK
)
)
}
diff --git a/feature/preview/Android.bp b/feature/preview/Android.bp
index a146711..a3d8366 100644
--- a/feature/preview/Android.bp
+++ b/feature/preview/Android.bp
@@ -19,6 +19,7 @@
"hilt_android",
"androidx.hilt_hilt-navigation-compose",
"androidx.compose.ui_ui-tooling",
+ "kotlin-reflect",
"kotlinx_coroutines_guava",
"androidx.datastore_datastore",
"libprotobuf-java-lite",
diff --git a/feature/preview/build.gradle.kts b/feature/preview/build.gradle.kts
index 81a3ddb..5ba5f3a 100644
--- a/feature/preview/build.gradle.kts
+++ b/feature/preview/build.gradle.kts
@@ -89,6 +89,8 @@
}
dependencies {
+ // Reflect
+ implementation(libs.kotlin.reflect)
// Compose
val composeBom = platform(libs.compose.bom)
implementation(composeBom)
diff --git a/feature/preview/src/main/java/com/google/jetpackcamera/feature/preview/CaptureModeToggleUiState.kt b/feature/preview/src/main/java/com/google/jetpackcamera/feature/preview/CaptureModeToggleUiState.kt
index 86e084f..04b7a5e 100644
--- a/feature/preview/src/main/java/com/google/jetpackcamera/feature/preview/CaptureModeToggleUiState.kt
+++ b/feature/preview/src/main/java/com/google/jetpackcamera/feature/preview/CaptureModeToggleUiState.kt
@@ -21,6 +21,8 @@
import com.google.jetpackcamera.feature.preview.ui.HDR_IMAGE_UNSUPPORTED_ON_SINGLE_STREAM_TAG
import com.google.jetpackcamera.feature.preview.ui.HDR_VIDEO_UNSUPPORTED_ON_DEVICE_TAG
import com.google.jetpackcamera.feature.preview.ui.HDR_VIDEO_UNSUPPORTED_ON_LENS_TAG
+import com.google.jetpackcamera.feature.preview.ui.IMAGE_CAPTURE_EXTERNAL_UNSUPPORTED_TAG
+import com.google.jetpackcamera.feature.preview.ui.IMAGE_CAPTURE_UNSUPPORTED_CONCURRENT_CAMERA_TAG
import com.google.jetpackcamera.feature.preview.ui.VIDEO_CAPTURE_EXTERNAL_UNSUPPORTED_TAG
sealed interface CaptureModeToggleUiState {
@@ -43,6 +45,15 @@
VIDEO_CAPTURE_EXTERNAL_UNSUPPORTED_TAG,
R.string.toast_video_capture_external_unsupported
),
+ IMAGE_CAPTURE_EXTERNAL_UNSUPPORTED(
+ IMAGE_CAPTURE_EXTERNAL_UNSUPPORTED_TAG,
+ R.string.toast_image_capture_external_unsupported
+
+ ),
+ IMAGE_CAPTURE_UNSUPPORTED_CONCURRENT_CAMERA(
+ IMAGE_CAPTURE_UNSUPPORTED_CONCURRENT_CAMERA_TAG,
+ R.string.toast_image_capture_unsupported_concurrent_camera
+ ),
HDR_VIDEO_UNSUPPORTED_ON_DEVICE(
HDR_VIDEO_UNSUPPORTED_ON_DEVICE_TAG,
R.string.toast_hdr_video_unsupported_on_device
diff --git a/feature/preview/src/main/java/com/google/jetpackcamera/feature/preview/PreviewMode.kt b/feature/preview/src/main/java/com/google/jetpackcamera/feature/preview/PreviewMode.kt
index de1c7d8..dc3f8e7 100644
--- a/feature/preview/src/main/java/com/google/jetpackcamera/feature/preview/PreviewMode.kt
+++ b/feature/preview/src/main/java/com/google/jetpackcamera/feature/preview/PreviewMode.kt
@@ -36,4 +36,12 @@
val imageCaptureUri: Uri?,
val onImageCapture: (PreviewViewModel.ImageCaptureEvent) -> Unit
) : PreviewMode
+
+ /**
+ * Under this mode, the app is launched by an external intent to capture a video.
+ */
+ data class ExternalVideoCaptureMode(
+ val videoCaptureUri: Uri?,
+ val onVideoCapture: (PreviewViewModel.VideoCaptureEvent) -> Unit
+ ) : PreviewMode
}
diff --git a/feature/preview/src/main/java/com/google/jetpackcamera/feature/preview/PreviewScreen.kt b/feature/preview/src/main/java/com/google/jetpackcamera/feature/preview/PreviewScreen.kt
index f4c7e34..55583a2 100644
--- a/feature/preview/src/main/java/com/google/jetpackcamera/feature/preview/PreviewScreen.kt
+++ b/feature/preview/src/main/java/com/google/jetpackcamera/feature/preview/PreviewScreen.kt
@@ -59,6 +59,7 @@
import com.google.jetpackcamera.feature.preview.ui.debouncedOrientationFlow
import com.google.jetpackcamera.settings.model.AspectRatio
import com.google.jetpackcamera.settings.model.CaptureMode
+import com.google.jetpackcamera.settings.model.ConcurrentCameraMode
import com.google.jetpackcamera.settings.model.DEFAULT_CAMERA_APP_SETTINGS
import com.google.jetpackcamera.settings.model.DynamicRange
import com.google.jetpackcamera.settings.model.FlashMode
@@ -77,11 +78,12 @@
fun PreviewScreen(
onNavigateToSettings: () -> Unit,
previewMode: PreviewMode,
+ isDebugMode: Boolean,
modifier: Modifier = Modifier,
onRequestWindowColorMode: (Int) -> Unit = {},
onFirstFrameCaptureCompleted: () -> Unit = {},
viewModel: PreviewViewModel = hiltViewModel<PreviewViewModel, PreviewViewModel.Factory>
- { factory -> factory.create(previewMode) }
+ { factory -> factory.create(previewMode, isDebugMode) }
) {
Log.d(TAG, "PreviewScreen")
@@ -140,6 +142,7 @@
onChangeAspectRatio = viewModel::setAspectRatio,
onChangeCaptureMode = viewModel::setCaptureMode,
onChangeDynamicRange = viewModel::setDynamicRange,
+ onChangeConcurrentCameraMode = viewModel::setConcurrentCameraMode,
onLowLightBoost = viewModel::setLowLightBoost,
onChangeImageFormat = viewModel::setImageFormat,
onToggleWhenDisabled = viewModel::showSnackBarForDisabledHdrToggle,
@@ -173,6 +176,7 @@
onChangeAspectRatio: (AspectRatio) -> Unit = {},
onChangeCaptureMode: (CaptureMode) -> Unit = {},
onChangeDynamicRange: (DynamicRange) -> Unit = {},
+ onChangeConcurrentCameraMode: (ConcurrentCameraMode) -> Unit = {},
onLowLightBoost: (LowLightBoost) -> Unit = {},
onChangeImageFormat: (ImageOutputFormat) -> Unit = {},
onToggleWhenDisabled: (CaptureModeToggleUiState.DisabledReason) -> Unit = {},
@@ -185,7 +189,11 @@
Boolean,
(PreviewViewModel.ImageCaptureEvent) -> Unit
) -> Unit = { _, _, _, _ -> },
- onStartVideoRecording: () -> Unit = {},
+ onStartVideoRecording: (
+ Uri?,
+ Boolean,
+ (PreviewViewModel.VideoCaptureEvent) -> Unit
+ ) -> Unit = { _, _, _ -> },
onStopVideoRecording: () -> Unit = {},
onToastShown: () -> Unit = {},
onRequestWindowColorMode: (Int) -> Unit = {},
@@ -232,13 +240,13 @@
isOpen = previewUiState.quickSettingsIsOpen,
toggleIsOpen = onToggleQuickSettings,
currentCameraSettings = previewUiState.currentCameraSettings,
- systemConstraints = previewUiState.systemConstraints,
onLensFaceClick = onSetLensFacing,
onFlashModeClick = onChangeFlash,
onAspectRatioClick = onChangeAspectRatio,
onCaptureModeClick = onChangeCaptureMode,
onDynamicRangeClick = onChangeDynamicRange,
onImageOutputFormatClick = onChangeImageFormat,
+ onConcurrentCameraModeClick = onChangeConcurrentCameraMode,
onLowLightBoostClick = onLowLightBoost
)
// relative-grid style overlay on top of preview display
diff --git a/feature/preview/src/main/java/com/google/jetpackcamera/feature/preview/PreviewUiState.kt b/feature/preview/src/main/java/com/google/jetpackcamera/feature/preview/PreviewUiState.kt
index dfd20d1..5152bbe 100644
--- a/feature/preview/src/main/java/com/google/jetpackcamera/feature/preview/PreviewUiState.kt
+++ b/feature/preview/src/main/java/com/google/jetpackcamera/feature/preview/PreviewUiState.kt
@@ -42,7 +42,10 @@
val lastBlinkTimeStamp: Long = 0,
val previewMode: PreviewMode,
val captureModeToggleUiState: CaptureModeToggleUiState,
- val sessionFirstFrameTimestamp: Long = 0L
+ val sessionFirstFrameTimestamp: Long = 0L,
+ val currentPhysicalCameraId: String? = null,
+ val currentLogicalCameraId: String? = null,
+ val isDebugMode: Boolean = false
) : PreviewUiState
}
diff --git a/feature/preview/src/main/java/com/google/jetpackcamera/feature/preview/PreviewViewModel.kt b/feature/preview/src/main/java/com/google/jetpackcamera/feature/preview/PreviewViewModel.kt
index 7142a1a..fef3aa1 100644
--- a/feature/preview/src/main/java/com/google/jetpackcamera/feature/preview/PreviewViewModel.kt
+++ b/feature/preview/src/main/java/com/google/jetpackcamera/feature/preview/PreviewViewModel.kt
@@ -26,27 +26,35 @@
import androidx.tracing.traceAsync
import com.google.jetpackcamera.core.camera.CameraUseCase
import com.google.jetpackcamera.core.common.traceFirstFramePreview
+import com.google.jetpackcamera.feature.preview.ui.IMAGE_CAPTURE_EXTERNAL_UNSUPPORTED_TAG
import com.google.jetpackcamera.feature.preview.ui.IMAGE_CAPTURE_FAILURE_TAG
import com.google.jetpackcamera.feature.preview.ui.IMAGE_CAPTURE_SUCCESS_TAG
import com.google.jetpackcamera.feature.preview.ui.SnackbarData
import com.google.jetpackcamera.feature.preview.ui.VIDEO_CAPTURE_EXTERNAL_UNSUPPORTED_TAG
+import com.google.jetpackcamera.feature.preview.ui.VIDEO_CAPTURE_FAILURE_TAG
+import com.google.jetpackcamera.feature.preview.ui.VIDEO_CAPTURE_SUCCESS_TAG
import com.google.jetpackcamera.settings.ConstraintsRepository
+import com.google.jetpackcamera.settings.SettingsRepository
import com.google.jetpackcamera.settings.model.AspectRatio
import com.google.jetpackcamera.settings.model.CameraAppSettings
import com.google.jetpackcamera.settings.model.CameraConstraints
import com.google.jetpackcamera.settings.model.CaptureMode
+import com.google.jetpackcamera.settings.model.ConcurrentCameraMode
import com.google.jetpackcamera.settings.model.DeviceRotation
import com.google.jetpackcamera.settings.model.DynamicRange
import com.google.jetpackcamera.settings.model.FlashMode
import com.google.jetpackcamera.settings.model.ImageOutputFormat
import com.google.jetpackcamera.settings.model.LensFacing
import com.google.jetpackcamera.settings.model.LowLightBoost
+import com.google.jetpackcamera.settings.model.Stabilization
import com.google.jetpackcamera.settings.model.SystemConstraints
import com.google.jetpackcamera.settings.model.forCurrentLens
import dagger.assisted.Assisted
import dagger.assisted.AssistedFactory
import dagger.assisted.AssistedInject
import dagger.hilt.android.lifecycle.HiltViewModel
+import kotlin.reflect.KProperty
+import kotlin.reflect.full.memberProperties
import kotlin.time.Duration.Companion.seconds
import kotlinx.atomicfu.atomic
import kotlinx.coroutines.CoroutineStart
@@ -59,6 +67,8 @@
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.flow.combine
import kotlinx.coroutines.flow.filterNotNull
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.transform
import kotlinx.coroutines.flow.transformWhile
import kotlinx.coroutines.flow.update
import kotlinx.coroutines.launch
@@ -72,7 +82,9 @@
@HiltViewModel(assistedFactory = PreviewViewModel.Factory::class)
class PreviewViewModel @AssistedInject constructor(
@Assisted val previewMode: PreviewMode,
+ @Assisted val isDebugMode: Boolean,
private val cameraUseCase: CameraUseCase,
+ private val settingsRepository: SettingsRepository,
private val constraintsRepository: ConstraintsRepository
) : ViewModel() {
private val _previewUiState: MutableStateFlow<PreviewUiState> =
@@ -95,11 +107,27 @@
// Eagerly initialize the CameraUseCase and encapsulate in a Deferred that can be
// used to ensure we don't start the camera before initialization is complete.
private var initializationDeferred: Deferred<Unit> = viewModelScope.async {
- cameraUseCase.initialize(previewMode is PreviewMode.ExternalImageCaptureMode)
+ cameraUseCase.initialize(
+ cameraAppSettings = settingsRepository.defaultCameraAppSettings.first(),
+ previewMode.toUseCaseMode(),
+ isDebugMode
+ )
}
init {
viewModelScope.launch {
+ launch {
+ var oldCameraAppSettings: CameraAppSettings? = null
+ settingsRepository.defaultCameraAppSettings.transform { new ->
+ val old = oldCameraAppSettings
+ if (old != null) {
+ emit(getSettingsDiff(old, new))
+ }
+ oldCameraAppSettings = new
+ }.collect { diffQueue ->
+ applySettingsDiff(diffQueue)
+ }
+ }
combine(
cameraUseCase.getCurrentSettings().filterNotNull(),
constraintsRepository.systemConstraints.filterNotNull(),
@@ -116,7 +144,10 @@
captureModeToggleUiState = getCaptureToggleUiState(
systemConstraints,
cameraAppSettings
- )
+ ),
+ isDebugMode = isDebugMode,
+ currentLogicalCameraId = cameraState.debugInfo.logicalCameraId,
+ currentPhysicalCameraId = cameraState.debugInfo.physicalCameraId
)
is PreviewUiState.NotReady ->
@@ -129,7 +160,10 @@
captureModeToggleUiState = getCaptureToggleUiState(
systemConstraints,
cameraAppSettings
- )
+ ),
+ isDebugMode = isDebugMode,
+ currentLogicalCameraId = cameraState.debugInfo.logicalCameraId,
+ currentPhysicalCameraId = cameraState.debugInfo.physicalCameraId
)
}
}
@@ -137,6 +171,70 @@
}
}
+ private fun PreviewMode.toUseCaseMode() = when (this) {
+ is PreviewMode.ExternalImageCaptureMode -> CameraUseCase.UseCaseMode.IMAGE_ONLY
+ is PreviewMode.ExternalVideoCaptureMode -> CameraUseCase.UseCaseMode.VIDEO_ONLY
+ is PreviewMode.StandardMode -> CameraUseCase.UseCaseMode.STANDARD
+ }
+
+ /**
+ * Returns the difference between two [CameraAppSettings] as a mapping of <[KProperty], [Any]>.
+ */
+ private fun getSettingsDiff(
+ oldCameraAppSettings: CameraAppSettings,
+ newCameraAppSettings: CameraAppSettings
+ ): Map<KProperty<Any?>, Any?> = buildMap<KProperty<Any?>, Any?> {
+ CameraAppSettings::class.memberProperties.forEach { property ->
+ if (property.get(oldCameraAppSettings) != property.get(newCameraAppSettings)) {
+ put(property, property.get(newCameraAppSettings))
+ }
+ }
+ }
+
+ /**
+ * Iterates through a queue of [Pair]<[KProperty], [Any]> and attempt to apply them to
+ * [CameraUseCase].
+ */
+ private suspend fun applySettingsDiff(diffSettingsMap: Map<KProperty<Any?>, Any?>) {
+ diffSettingsMap.entries.forEach { entry ->
+ when (entry.key) {
+ CameraAppSettings::cameraLensFacing -> {
+ cameraUseCase.setLensFacing(entry.value as LensFacing)
+ }
+
+ CameraAppSettings::flashMode -> {
+ cameraUseCase.setFlashMode(entry.value as FlashMode)
+ }
+
+ CameraAppSettings::captureMode -> {
+ cameraUseCase.setCaptureMode(entry.value as CaptureMode)
+ }
+
+ CameraAppSettings::aspectRatio -> {
+ cameraUseCase.setAspectRatio(entry.value as AspectRatio)
+ }
+
+ CameraAppSettings::previewStabilization -> {
+ cameraUseCase.setPreviewStabilization(entry.value as Stabilization)
+ }
+
+ CameraAppSettings::videoCaptureStabilization -> {
+ cameraUseCase.setVideoCaptureStabilization(
+ entry.value as Stabilization
+ )
+ }
+
+ CameraAppSettings::targetFrameRate -> {
+ cameraUseCase.setTargetFrameRate(entry.value as Int)
+ }
+
+ CameraAppSettings::darkMode -> {}
+
+ else -> TODO("Unhandled CameraAppSetting $entry")
+ }
+ }
+ }
+
private fun getCaptureToggleUiState(
systemConstraints: SystemConstraints,
cameraAppSettings: CameraAppSettings
@@ -152,12 +250,19 @@
it.size > 1
} ?: false
val isShown = previewMode is PreviewMode.ExternalImageCaptureMode ||
+ previewMode is PreviewMode.ExternalVideoCaptureMode ||
cameraAppSettings.imageFormat == ImageOutputFormat.JPEG_ULTRA_HDR ||
- cameraAppSettings.dynamicRange == DynamicRange.HLG10
+ cameraAppSettings.dynamicRange == DynamicRange.HLG10 ||
+ cameraAppSettings.concurrentCameraMode == ConcurrentCameraMode.DUAL
val enabled = previewMode !is PreviewMode.ExternalImageCaptureMode &&
- hdrDynamicRangeSupported && hdrImageFormatSupported
+ previewMode !is PreviewMode.ExternalVideoCaptureMode &&
+ hdrDynamicRangeSupported &&
+ hdrImageFormatSupported &&
+ cameraAppSettings.concurrentCameraMode == ConcurrentCameraMode.OFF
return if (isShown) {
- val currentMode = if (previewMode is PreviewMode.ExternalImageCaptureMode ||
+ val currentMode = if (
+ cameraAppSettings.concurrentCameraMode == ConcurrentCameraMode.OFF &&
+ previewMode is PreviewMode.ExternalImageCaptureMode ||
cameraAppSettings.imageFormat == ImageOutputFormat.JPEG_ULTRA_HDR
) {
CaptureModeToggleUiState.ToggleMode.CAPTURE_TOGGLE_IMAGE
@@ -170,11 +275,13 @@
CaptureModeToggleUiState.Disabled(
currentMode,
getCaptureToggleUiStateDisabledReason(
+ currentMode,
hdrDynamicRangeSupported,
hdrImageFormatSupported,
systemConstraints,
cameraAppSettings.cameraLensFacing,
- cameraAppSettings.captureMode
+ cameraAppSettings.captureMode,
+ cameraAppSettings.concurrentCameraMode
)
)
}
@@ -184,69 +291,96 @@
}
private fun getCaptureToggleUiStateDisabledReason(
+ captureModeToggleUiState: CaptureModeToggleUiState.ToggleMode,
hdrDynamicRangeSupported: Boolean,
hdrImageFormatSupported: Boolean,
systemConstraints: SystemConstraints,
currentLensFacing: LensFacing,
- currentCaptureMode: CaptureMode
+ currentCaptureMode: CaptureMode,
+ concurrentCameraMode: ConcurrentCameraMode
): CaptureModeToggleUiState.DisabledReason {
- if (previewMode is PreviewMode.ExternalImageCaptureMode) {
- return CaptureModeToggleUiState.DisabledReason.VIDEO_CAPTURE_EXTERNAL_UNSUPPORTED
- }
- if (!hdrImageFormatSupported) {
- // First assume HDR image is only unsupported on this capture mode
- var disabledReason = when (currentCaptureMode) {
- CaptureMode.MULTI_STREAM ->
- CaptureModeToggleUiState.DisabledReason.HDR_IMAGE_UNSUPPORTED_ON_MULTI_STREAM
- CaptureMode.SINGLE_STREAM ->
- CaptureModeToggleUiState.DisabledReason.HDR_IMAGE_UNSUPPORTED_ON_SINGLE_STREAM
- }
- // Check if other capture modes supports HDR image on this lens
- systemConstraints
- .perLensConstraints[currentLensFacing]
- ?.supportedImageFormatsMap
- ?.filterKeys { it != currentCaptureMode }
- ?.values
- ?.forEach { supportedFormats ->
- if (supportedFormats.size > 1) {
- // Found another capture mode that supports HDR image,
- // return previously discovered disabledReason
- return disabledReason
- }
+ when (captureModeToggleUiState) {
+ CaptureModeToggleUiState.ToggleMode.CAPTURE_TOGGLE_VIDEO -> {
+ if (previewMode is PreviewMode.ExternalVideoCaptureMode) {
+ return CaptureModeToggleUiState.DisabledReason
+ .IMAGE_CAPTURE_EXTERNAL_UNSUPPORTED
}
- // HDR image is not supported by this lens
- disabledReason = CaptureModeToggleUiState.DisabledReason.HDR_IMAGE_UNSUPPORTED_ON_LENS
- // Check if any other lens supports HDR image
- systemConstraints
- .perLensConstraints
- .filterKeys { it != currentLensFacing }
- .values
- .forEach { constraints ->
- constraints.supportedImageFormatsMap.values.forEach { supportedFormats ->
- if (supportedFormats.size > 1) {
- // Found another lens that supports HDR image,
- // return previously discovered disabledReason
- return disabledReason
+
+ if (concurrentCameraMode == ConcurrentCameraMode.DUAL) {
+ return CaptureModeToggleUiState.DisabledReason
+ .IMAGE_CAPTURE_UNSUPPORTED_CONCURRENT_CAMERA
+ }
+
+ if (!hdrImageFormatSupported) {
+ // First check if Ultra HDR image is supported on other capture modes
+ if (systemConstraints
+ .perLensConstraints[currentLensFacing]
+ ?.supportedImageFormatsMap
+ ?.anySupportsUltraHdr { it != currentCaptureMode } == true
+ ) {
+ return when (currentCaptureMode) {
+ CaptureMode.MULTI_STREAM ->
+ CaptureModeToggleUiState.DisabledReason
+ .HDR_IMAGE_UNSUPPORTED_ON_MULTI_STREAM
+
+ CaptureMode.SINGLE_STREAM ->
+ CaptureModeToggleUiState.DisabledReason
+ .HDR_IMAGE_UNSUPPORTED_ON_SINGLE_STREAM
}
}
+
+ // Check if any other lens supports HDR image
+ if (systemConstraints.anySupportsUltraHdr { it != currentLensFacing }) {
+ return CaptureModeToggleUiState.DisabledReason.HDR_IMAGE_UNSUPPORTED_ON_LENS
+ }
+
+ // No lenses support HDR image on device
+ return CaptureModeToggleUiState.DisabledReason.HDR_IMAGE_UNSUPPORTED_ON_DEVICE
}
- // No lenses support HDR image on device
- return CaptureModeToggleUiState.DisabledReason.HDR_IMAGE_UNSUPPORTED_ON_DEVICE
- } else if (!hdrDynamicRangeSupported) {
- systemConstraints.perLensConstraints.forEach { entry ->
- if (entry.key != currentLensFacing) {
- val cameraConstraints = systemConstraints.perLensConstraints[entry.key]
- if (cameraConstraints?.let { it.supportedDynamicRanges.size > 1 } == true) {
+
+ throw RuntimeException("Unknown DisabledReason for video mode.")
+ }
+
+ CaptureModeToggleUiState.ToggleMode.CAPTURE_TOGGLE_IMAGE -> {
+ if (previewMode is PreviewMode.ExternalImageCaptureMode) {
+ return CaptureModeToggleUiState.DisabledReason
+ .VIDEO_CAPTURE_EXTERNAL_UNSUPPORTED
+ }
+
+ if (!hdrDynamicRangeSupported) {
+ if (systemConstraints.anySupportsHdrDynamicRange { it != currentLensFacing }) {
return CaptureModeToggleUiState.DisabledReason.HDR_VIDEO_UNSUPPORTED_ON_LENS
}
+ return CaptureModeToggleUiState.DisabledReason.HDR_VIDEO_UNSUPPORTED_ON_DEVICE
}
+
+ throw RuntimeException("Unknown DisabledReason for image mode.")
}
- return CaptureModeToggleUiState.DisabledReason.HDR_VIDEO_UNSUPPORTED_ON_DEVICE
- } else {
- throw RuntimeException("Unknown CaptureModeUnsupportedReason.")
}
}
+ private fun SystemConstraints.anySupportsHdrDynamicRange(
+ lensFilter: (LensFacing) -> Boolean
+ ): Boolean = perLensConstraints.asSequence().firstOrNull {
+ lensFilter(it.key) && it.value.supportedDynamicRanges.size > 1
+ } != null
+
+ private fun Map<CaptureMode, Set<ImageOutputFormat>>.anySupportsUltraHdr(
+ captureModeFilter: (CaptureMode) -> Boolean
+ ): Boolean = asSequence().firstOrNull {
+ captureModeFilter(it.key) && it.value.contains(ImageOutputFormat.JPEG_ULTRA_HDR)
+ } != null
+
+ private fun SystemConstraints.anySupportsUltraHdr(
+ captureModeFilter: (CaptureMode) -> Boolean = { true },
+ lensFilter: (LensFacing) -> Boolean
+ ): Boolean = perLensConstraints.asSequence().firstOrNull { lensConstraints ->
+ lensFilter(lensConstraints.key) &&
+ lensConstraints.value.supportedImageFormatsMap.anySupportsUltraHdr {
+ captureModeFilter(it)
+ }
+ } != null
+
fun startCamera() {
Log.d(TAG, "startCamera")
stopCamera()
@@ -325,7 +459,29 @@
)
}
+ private fun showExternalVideoCaptureUnsupportedToast() {
+ viewModelScope.launch {
+ _previewUiState.update { old ->
+ (old as? PreviewUiState.Ready)?.copy(
+ snackBarToShow = SnackbarData(
+ cookie = "Image-ExternalVideoCaptureMode",
+ stringResource = R.string.toast_image_capture_external_unsupported,
+ withDismissAction = true,
+ testTag = IMAGE_CAPTURE_EXTERNAL_UNSUPPORTED_TAG
+ )
+ ) ?: old
+ }
+ }
+ }
+
fun captureImage() {
+ if (previewUiState.value is PreviewUiState.Ready &&
+ (previewUiState.value as PreviewUiState.Ready).previewMode is
+ PreviewMode.ExternalVideoCaptureMode
+ ) {
+ showExternalVideoCaptureUnsupportedToast()
+ return
+ }
Log.d(TAG, "captureImage")
viewModelScope.launch {
captureImageInternal(
@@ -348,6 +504,32 @@
ignoreUri: Boolean = false,
onImageCapture: (ImageCaptureEvent) -> Unit
) {
+ if (previewUiState.value is PreviewUiState.Ready &&
+ (previewUiState.value as PreviewUiState.Ready).previewMode is
+ PreviewMode.ExternalVideoCaptureMode
+ ) {
+ showExternalVideoCaptureUnsupportedToast()
+ return
+ }
+
+ if (previewUiState.value is PreviewUiState.Ready &&
+ (previewUiState.value as PreviewUiState.Ready).previewMode is
+ PreviewMode.ExternalVideoCaptureMode
+ ) {
+ viewModelScope.launch {
+ _previewUiState.update { old ->
+ (old as? PreviewUiState.Ready)?.copy(
+ snackBarToShow = SnackbarData(
+ cookie = "Image-ExternalVideoCaptureMode",
+ stringResource = R.string.toast_image_capture_external_unsupported,
+ withDismissAction = true,
+ testTag = IMAGE_CAPTURE_EXTERNAL_UNSUPPORTED_TAG
+ )
+ ) ?: old
+ }
+ }
+ return
+ }
Log.d(TAG, "captureImageWithUri")
viewModelScope.launch {
captureImageInternal(
@@ -424,7 +606,11 @@
}
}
- fun startVideoRecording() {
+ fun startVideoRecording(
+ videoCaptureUri: Uri?,
+ shouldUseUri: Boolean,
+ onVideoCapture: (VideoCaptureEvent) -> Unit
+ ) {
if (previewUiState.value is PreviewUiState.Ready &&
(previewUiState.value as PreviewUiState.Ready).previewMode is
PreviewMode.ExternalImageCaptureMode
@@ -448,23 +634,29 @@
recordingJob = viewModelScope.launch {
val cookie = "Video-${videoCaptureStartedCount.incrementAndGet()}"
try {
- cameraUseCase.startVideoRecording {
+ cameraUseCase.startVideoRecording(videoCaptureUri, shouldUseUri) {
var audioAmplitude = 0.0
var snackbarToShow: SnackbarData? = null
when (it) {
- CameraUseCase.OnVideoRecordEvent.OnVideoRecorded -> {
+ is CameraUseCase.OnVideoRecordEvent.OnVideoRecorded -> {
+ Log.d(TAG, "cameraUseCase.startRecording OnVideoRecorded")
+ onVideoCapture(VideoCaptureEvent.VideoSaved(it.savedUri))
snackbarToShow = SnackbarData(
cookie = cookie,
stringResource = R.string.toast_video_capture_success,
- withDismissAction = true
+ withDismissAction = true,
+ testTag = VIDEO_CAPTURE_SUCCESS_TAG
)
}
- CameraUseCase.OnVideoRecordEvent.OnVideoRecordError -> {
+ is CameraUseCase.OnVideoRecordEvent.OnVideoRecordError -> {
+ Log.d(TAG, "cameraUseCase.startRecording OnVideoRecordError")
+ onVideoCapture(VideoCaptureEvent.VideoCaptureError(it.error))
snackbarToShow = SnackbarData(
cookie = cookie,
stringResource = R.string.toast_video_capture_failure,
- withDismissAction = true
+ withDismissAction = true,
+ testTag = VIDEO_CAPTURE_FAILURE_TAG
)
}
@@ -517,6 +709,12 @@
}
}
+ fun setConcurrentCameraMode(concurrentCameraMode: ConcurrentCameraMode) {
+ viewModelScope.launch {
+ cameraUseCase.setConcurrentCameraMode(concurrentCameraMode)
+ }
+ }
+
fun setLowLightBoost(lowLightBoost: LowLightBoost) {
viewModelScope.launch {
cameraUseCase.setLowLightBoost(lowLightBoost)
@@ -585,7 +783,7 @@
@AssistedFactory
interface Factory {
- fun create(previewMode: PreviewMode): PreviewViewModel
+ fun create(previewMode: PreviewMode, isDebugMode: Boolean): PreviewViewModel
}
sealed interface ImageCaptureEvent {
@@ -597,4 +795,14 @@
val exception: Exception
) : ImageCaptureEvent
}
+
+ sealed interface VideoCaptureEvent {
+ data class VideoSaved(
+ val savedUri: Uri
+ ) : VideoCaptureEvent
+
+ data class VideoCaptureError(
+ val error: Throwable?
+ ) : VideoCaptureEvent
+ }
}
diff --git a/feature/preview/src/main/java/com/google/jetpackcamera/feature/preview/ScreenFlash.kt b/feature/preview/src/main/java/com/google/jetpackcamera/feature/preview/ScreenFlash.kt
index 7cd1a4f..7bd075a 100644
--- a/feature/preview/src/main/java/com/google/jetpackcamera/feature/preview/ScreenFlash.kt
+++ b/feature/preview/src/main/java/com/google/jetpackcamera/feature/preview/ScreenFlash.kt
@@ -45,7 +45,7 @@
init {
scope.launch {
- cameraUseCase.getScreenFlashEvents().collect { event ->
+ for (event in cameraUseCase.getScreenFlashEvents()) {
_screenFlashUiState.emit(
when (event.type) {
CameraUseCase.ScreenFlashEvent.Type.APPLY_UI ->
diff --git a/feature/preview/src/main/java/com/google/jetpackcamera/feature/preview/quicksettings/QuickSettingsEnums.kt b/feature/preview/src/main/java/com/google/jetpackcamera/feature/preview/quicksettings/QuickSettingsEnums.kt
index db13cd2..2ee1e78 100644
--- a/feature/preview/src/main/java/com/google/jetpackcamera/feature/preview/quicksettings/QuickSettingsEnums.kt
+++ b/feature/preview/src/main/java/com/google/jetpackcamera/feature/preview/quicksettings/QuickSettingsEnums.kt
@@ -26,6 +26,7 @@
import androidx.compose.material.icons.filled.HdrOff
import androidx.compose.material.icons.filled.HdrOn
import androidx.compose.material.icons.filled.Nightlight
+import androidx.compose.material.icons.filled.PictureInPicture
import androidx.compose.material.icons.outlined.Nightlight
import androidx.compose.runtime.Composable
import androidx.compose.ui.graphics.painter.Painter
@@ -167,3 +168,20 @@
R.string.quick_settings_lowlightboost_disabled_description
}
}
+
+enum class CameraConcurrentCameraMode : QuickSettingsEnum {
+ OFF {
+ override fun getDrawableResId() = R.drawable.picture_in_picture_off_icon
+ override fun getImageVector() = null
+ override fun getTextResId() = R.string.quick_settings_concurrent_camera_off
+ override fun getDescriptionResId() =
+ R.string.quick_settings_concurrent_camera_off_description
+ },
+ DUAL {
+ override fun getDrawableResId() = null
+ override fun getImageVector() = Icons.Filled.PictureInPicture
+ override fun getTextResId() = R.string.quick_settings_concurrent_camera_dual
+ override fun getDescriptionResId() =
+ R.string.quick_settings_concurrent_camera_dual_description
+ }
+}
diff --git a/feature/preview/src/main/java/com/google/jetpackcamera/feature/preview/quicksettings/QuickSettingsScreen.kt b/feature/preview/src/main/java/com/google/jetpackcamera/feature/preview/quicksettings/QuickSettingsScreen.kt
index 59e97bc..7dbb474 100644
--- a/feature/preview/src/main/java/com/google/jetpackcamera/feature/preview/quicksettings/QuickSettingsScreen.kt
+++ b/feature/preview/src/main/java/com/google/jetpackcamera/feature/preview/quicksettings/QuickSettingsScreen.kt
@@ -44,27 +44,28 @@
import com.google.jetpackcamera.feature.preview.R
import com.google.jetpackcamera.feature.preview.quicksettings.ui.ExpandedQuickSetRatio
import com.google.jetpackcamera.feature.preview.quicksettings.ui.QUICK_SETTINGS_CAPTURE_MODE_BUTTON
+import com.google.jetpackcamera.feature.preview.quicksettings.ui.QUICK_SETTINGS_CONCURRENT_CAMERA_MODE_BUTTON
import com.google.jetpackcamera.feature.preview.quicksettings.ui.QUICK_SETTINGS_FLASH_BUTTON
import com.google.jetpackcamera.feature.preview.quicksettings.ui.QUICK_SETTINGS_FLIP_CAMERA_BUTTON
import com.google.jetpackcamera.feature.preview.quicksettings.ui.QUICK_SETTINGS_HDR_BUTTON
-import com.google.jetpackcamera.feature.preview.quicksettings.ui.QUICK_SETTINGS_LOW_LIGHT_BOOST_BUTTON
import com.google.jetpackcamera.feature.preview.quicksettings.ui.QUICK_SETTINGS_RATIO_BUTTON
import com.google.jetpackcamera.feature.preview.quicksettings.ui.QuickFlipCamera
import com.google.jetpackcamera.feature.preview.quicksettings.ui.QuickSetCaptureMode
+import com.google.jetpackcamera.feature.preview.quicksettings.ui.QuickSetConcurrentCamera
import com.google.jetpackcamera.feature.preview.quicksettings.ui.QuickSetFlash
import com.google.jetpackcamera.feature.preview.quicksettings.ui.QuickSetHdr
-import com.google.jetpackcamera.feature.preview.quicksettings.ui.QuickSetLowLightBoost
import com.google.jetpackcamera.feature.preview.quicksettings.ui.QuickSetRatio
import com.google.jetpackcamera.feature.preview.quicksettings.ui.QuickSettingsGrid
import com.google.jetpackcamera.settings.model.AspectRatio
import com.google.jetpackcamera.settings.model.CameraAppSettings
+import com.google.jetpackcamera.settings.model.CameraConstraints
import com.google.jetpackcamera.settings.model.CaptureMode
+import com.google.jetpackcamera.settings.model.ConcurrentCameraMode
import com.google.jetpackcamera.settings.model.DynamicRange
import com.google.jetpackcamera.settings.model.FlashMode
import com.google.jetpackcamera.settings.model.ImageOutputFormat
import com.google.jetpackcamera.settings.model.LensFacing
import com.google.jetpackcamera.settings.model.LowLightBoost
-import com.google.jetpackcamera.settings.model.SystemConstraints
import com.google.jetpackcamera.settings.model.TYPICAL_SYSTEM_CONSTRAINTS
import com.google.jetpackcamera.settings.model.forCurrentLens
@@ -75,7 +76,6 @@
fun QuickSettingsScreenOverlay(
previewUiState: PreviewUiState.Ready,
currentCameraSettings: CameraAppSettings,
- systemConstraints: SystemConstraints,
toggleIsOpen: () -> Unit,
onLensFaceClick: (lensFace: LensFacing) -> Unit,
onFlashModeClick: (flashMode: FlashMode) -> Unit,
@@ -83,6 +83,7 @@
onCaptureModeClick: (captureMode: CaptureMode) -> Unit,
onDynamicRangeClick: (dynamicRange: DynamicRange) -> Unit,
onImageOutputFormatClick: (imageOutputFormat: ImageOutputFormat) -> Unit,
+ onConcurrentCameraModeClick: (concurrentCameraMode: ConcurrentCameraMode) -> Unit,
onLowLightBoostClick: (lowLightBoost: LowLightBoost) -> Unit,
modifier: Modifier = Modifier,
isOpen: Boolean = false
@@ -125,7 +126,6 @@
ExpandedQuickSettingsUi(
previewUiState = previewUiState,
currentCameraSettings = currentCameraSettings,
- systemConstraints = systemConstraints,
shouldShowQuickSetting = shouldShowQuickSetting,
setVisibleQuickSetting = { enum: IsExpandedQuickSetting ->
shouldShowQuickSetting = enum
@@ -136,6 +136,7 @@
onCaptureModeClick = onCaptureModeClick,
onDynamicRangeClick = onDynamicRangeClick,
onImageOutputFormatClick = onImageOutputFormatClick,
+ onConcurrentCameraModeClick = onConcurrentCameraModeClick,
onLowLightBoostClick = onLowLightBoostClick
)
}
@@ -157,7 +158,6 @@
private fun ExpandedQuickSettingsUi(
previewUiState: PreviewUiState.Ready,
currentCameraSettings: CameraAppSettings,
- systemConstraints: SystemConstraints,
onLensFaceClick: (newLensFace: LensFacing) -> Unit,
onFlashModeClick: (flashMode: FlashMode) -> Unit,
onAspectRatioClick: (aspectRation: AspectRatio) -> Unit,
@@ -166,6 +166,7 @@
setVisibleQuickSetting: (IsExpandedQuickSetting) -> Unit,
onDynamicRangeClick: (dynamicRange: DynamicRange) -> Unit,
onImageOutputFormatClick: (imageOutputFormat: ImageOutputFormat) -> Unit,
+ onConcurrentCameraModeClick: (concurrentCameraMode: ConcurrentCameraMode) -> Unit,
onLowLightBoostClick: (lowLightBoost: LowLightBoost) -> Unit
) {
Column(
@@ -216,7 +217,9 @@
QuickSetCaptureMode(
modifier = Modifier.testTag(QUICK_SETTINGS_CAPTURE_MODE_BUTTON),
setCaptureMode = { c: CaptureMode -> onCaptureModeClick(c) },
- currentCaptureMode = currentCameraSettings.captureMode
+ currentCaptureMode = currentCameraSettings.captureMode,
+ enabled = currentCameraSettings.concurrentCameraMode ==
+ ConcurrentCameraMode.OFF
)
}
@@ -224,6 +227,24 @@
currentCameraSettings
)
add {
+ fun CameraConstraints.hdrDynamicRangeSupported(): Boolean =
+ this.supportedDynamicRanges.size > 1
+
+ fun CameraConstraints.hdrImageFormatSupported(): Boolean =
+ supportedImageFormatsMap[currentCameraSettings.captureMode]
+ ?.let { it.size > 1 } ?: false
+
+ // TODO(tm): Move this to PreviewUiState
+ fun shouldEnable(): Boolean = when {
+ currentCameraSettings.concurrentCameraMode !=
+ ConcurrentCameraMode.OFF -> false
+ else -> (
+ cameraConstraints?.hdrDynamicRangeSupported() == true &&
+ previewUiState.previewMode is PreviewMode.StandardMode
+ ) ||
+ cameraConstraints?.hdrImageFormatSupported() == true
+ }
+
QuickSetHdr(
modifier = Modifier.testTag(QUICK_SETTINGS_HDR_BUTTON),
onClick = { d: DynamicRange, i: ImageOutputFormat ->
@@ -234,24 +255,26 @@
selectedImageOutputFormat = currentCameraSettings.imageFormat,
hdrDynamicRange = currentCameraSettings.defaultHdrDynamicRange,
hdrImageFormat = currentCameraSettings.defaultHdrImageOutputFormat,
- hdrDynamicRangeSupported = cameraConstraints?.let
- { it.supportedDynamicRanges.size > 1 } ?: false,
- hdrImageFormatSupported =
- cameraConstraints?.supportedImageFormatsMap?.get(
- currentCameraSettings.captureMode
- )?.let { it.size > 1 } ?: false,
- previewMode = previewUiState.previewMode
+ hdrDynamicRangeSupported =
+ cameraConstraints?.hdrDynamicRangeSupported() ?: false,
+ previewMode = previewUiState.previewMode,
+ enabled = shouldEnable()
)
}
add {
- QuickSetLowLightBoost(
- modifier = Modifier.testTag(QUICK_SETTINGS_LOW_LIGHT_BOOST_BUTTON),
- onClick = {
- l: LowLightBoost ->
- onLowLightBoostClick(l)
+ QuickSetConcurrentCamera(
+ modifier =
+ Modifier.testTag(QUICK_SETTINGS_CONCURRENT_CAMERA_MODE_BUTTON),
+ setConcurrentCameraMode = { c: ConcurrentCameraMode ->
+ onConcurrentCameraModeClick(c)
},
- selectedLowLightBoost = currentCameraSettings.lowLightBoost
+ currentConcurrentCameraMode =
+ currentCameraSettings.concurrentCameraMode,
+ enabled =
+ previewUiState.systemConstraints.concurrentCamerasSupported &&
+ previewUiState.previewMode
+ !is PreviewMode.ExternalImageCaptureMode
)
}
}
@@ -280,7 +303,6 @@
captureModeToggleUiState = CaptureModeToggleUiState.Invisible
),
currentCameraSettings = CameraAppSettings(),
- systemConstraints = TYPICAL_SYSTEM_CONSTRAINTS,
onLensFaceClick = { },
onFlashModeClick = { },
shouldShowQuickSetting = IsExpandedQuickSetting.NONE,
@@ -289,6 +311,7 @@
onCaptureModeClick = { },
onDynamicRangeClick = { },
onImageOutputFormatClick = { },
+ onConcurrentCameraModeClick = { },
onLowLightBoostClick = { }
)
}
@@ -306,7 +329,6 @@
captureModeToggleUiState = CaptureModeToggleUiState.Invisible
),
currentCameraSettings = CameraAppSettings(dynamicRange = DynamicRange.HLG10),
- systemConstraints = TYPICAL_SYSTEM_CONSTRAINTS_WITH_HDR,
onLensFaceClick = { },
onFlashModeClick = { },
shouldShowQuickSetting = IsExpandedQuickSetting.NONE,
@@ -315,6 +337,7 @@
onCaptureModeClick = { },
onDynamicRangeClick = { },
onImageOutputFormatClick = { },
+ onConcurrentCameraModeClick = { },
onLowLightBoostClick = { }
)
}
diff --git a/feature/preview/src/main/java/com/google/jetpackcamera/feature/preview/quicksettings/ui/QuickSettingsComponents.kt b/feature/preview/src/main/java/com/google/jetpackcamera/feature/preview/quicksettings/ui/QuickSettingsComponents.kt
index 0e6b85f..66e2bc7 100644
--- a/feature/preview/src/main/java/com/google/jetpackcamera/feature/preview/quicksettings/ui/QuickSettingsComponents.kt
+++ b/feature/preview/src/main/java/com/google/jetpackcamera/feature/preview/quicksettings/ui/QuickSettingsComponents.kt
@@ -49,6 +49,7 @@
import com.google.jetpackcamera.feature.preview.R
import com.google.jetpackcamera.feature.preview.quicksettings.CameraAspectRatio
import com.google.jetpackcamera.feature.preview.quicksettings.CameraCaptureMode
+import com.google.jetpackcamera.feature.preview.quicksettings.CameraConcurrentCameraMode
import com.google.jetpackcamera.feature.preview.quicksettings.CameraDynamicRange
import com.google.jetpackcamera.feature.preview.quicksettings.CameraFlashMode
import com.google.jetpackcamera.feature.preview.quicksettings.CameraLensFace
@@ -56,6 +57,7 @@
import com.google.jetpackcamera.feature.preview.quicksettings.QuickSettingsEnum
import com.google.jetpackcamera.settings.model.AspectRatio
import com.google.jetpackcamera.settings.model.CaptureMode
+import com.google.jetpackcamera.settings.model.ConcurrentCameraMode
import com.google.jetpackcamera.settings.model.DynamicRange
import com.google.jetpackcamera.settings.model.FlashMode
import com.google.jetpackcamera.settings.model.ImageOutputFormat
@@ -113,8 +115,8 @@
hdrDynamicRange: DynamicRange,
hdrImageFormat: ImageOutputFormat,
hdrDynamicRangeSupported: Boolean,
- hdrImageFormatSupported: Boolean,
- previewMode: PreviewMode
+ previewMode: PreviewMode,
+ enabled: Boolean
) {
val enum =
if (selectedDynamicRange == hdrDynamicRange ||
@@ -146,8 +148,7 @@
onClick(newDynamicRange, newImageOutputFormat)
},
isHighLighted = (selectedDynamicRange != DynamicRange.SDR),
- enabled = (hdrDynamicRangeSupported && previewMode is PreviewMode.StandardMode) ||
- hdrImageFormatSupported
+ enabled = enabled
)
}
@@ -250,7 +251,8 @@
fun QuickSetCaptureMode(
setCaptureMode: (CaptureMode) -> Unit,
currentCaptureMode: CaptureMode,
- modifier: Modifier = Modifier
+ modifier: Modifier = Modifier,
+ enabled: Boolean = true
) {
val enum: CameraCaptureMode =
when (currentCaptureMode) {
@@ -265,7 +267,33 @@
CaptureMode.MULTI_STREAM -> setCaptureMode(CaptureMode.SINGLE_STREAM)
CaptureMode.SINGLE_STREAM -> setCaptureMode(CaptureMode.MULTI_STREAM)
}
+ },
+ enabled = enabled
+ )
+}
+
+@Composable
+fun QuickSetConcurrentCamera(
+ setConcurrentCameraMode: (ConcurrentCameraMode) -> Unit,
+ currentConcurrentCameraMode: ConcurrentCameraMode,
+ modifier: Modifier = Modifier,
+ enabled: Boolean = true
+) {
+ val enum: CameraConcurrentCameraMode =
+ when (currentConcurrentCameraMode) {
+ ConcurrentCameraMode.OFF -> CameraConcurrentCameraMode.OFF
+ ConcurrentCameraMode.DUAL -> CameraConcurrentCameraMode.DUAL
}
+ QuickSettingUiItem(
+ modifier = modifier,
+ enum = enum,
+ onClick = {
+ when (currentConcurrentCameraMode) {
+ ConcurrentCameraMode.OFF -> setConcurrentCameraMode(ConcurrentCameraMode.DUAL)
+ ConcurrentCameraMode.DUAL -> setConcurrentCameraMode(ConcurrentCameraMode.OFF)
+ }
+ },
+ enabled = enabled
)
}
diff --git a/feature/preview/src/main/java/com/google/jetpackcamera/feature/preview/quicksettings/ui/TestTags.kt b/feature/preview/src/main/java/com/google/jetpackcamera/feature/preview/quicksettings/ui/TestTags.kt
index 7334407..5a226e6 100644
--- a/feature/preview/src/main/java/com/google/jetpackcamera/feature/preview/quicksettings/ui/TestTags.kt
+++ b/feature/preview/src/main/java/com/google/jetpackcamera/feature/preview/quicksettings/ui/TestTags.kt
@@ -16,6 +16,7 @@
package com.google.jetpackcamera.feature.preview.quicksettings.ui
const val QUICK_SETTINGS_CAPTURE_MODE_BUTTON = "QuickSettingsCaptureModeButton"
+const val QUICK_SETTINGS_CONCURRENT_CAMERA_MODE_BUTTON = "QuickSettingsConcurrentCameraModeButton"
const val QUICK_SETTINGS_DROP_DOWN = "QuickSettingsDropDown"
const val QUICK_SETTINGS_HDR_BUTTON = "QuickSettingsHdrButton"
const val QUICK_SETTINGS_FLASH_BUTTON = "QuickSettingsFlashButton"
diff --git a/feature/preview/src/main/java/com/google/jetpackcamera/feature/preview/ui/CameraControlsOverlay.kt b/feature/preview/src/main/java/com/google/jetpackcamera/feature/preview/ui/CameraControlsOverlay.kt
index a8c8a3b..9563db9 100644
--- a/feature/preview/src/main/java/com/google/jetpackcamera/feature/preview/ui/CameraControlsOverlay.kt
+++ b/feature/preview/src/main/java/com/google/jetpackcamera/feature/preview/ui/CameraControlsOverlay.kt
@@ -33,6 +33,7 @@
import androidx.compose.material.icons.outlined.CameraAlt
import androidx.compose.material.icons.outlined.Videocam
import androidx.compose.material3.LocalContentColor
+import androidx.compose.material3.LocalTextStyle
import androidx.compose.runtime.Composable
import androidx.compose.runtime.CompositionLocalProvider
import androidx.compose.runtime.LaunchedEffect
@@ -48,6 +49,7 @@
import androidx.compose.ui.platform.testTag
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
import androidx.core.util.Preconditions
import com.google.jetpackcamera.feature.preview.CaptureModeToggleUiState
import com.google.jetpackcamera.feature.preview.MultipleEventsCutter
@@ -96,7 +98,11 @@
Boolean,
(PreviewViewModel.ImageCaptureEvent) -> Unit
) -> Unit = { _, _, _, _ -> },
- onStartVideoRecording: () -> Unit = {},
+ onStartVideoRecording: (
+ Uri?,
+ Boolean,
+ (PreviewViewModel.VideoCaptureEvent) -> Unit
+ ) -> Unit = { _, _, _ -> },
onStopVideoRecording: () -> Unit = {}
) {
// Show the current zoom level for a short period of time, only when the level changes.
@@ -131,6 +137,8 @@
previewUiState = previewUiState,
audioAmplitude = previewUiState.audioAmplitude,
zoomLevel = previewUiState.zoomScale,
+ physicalCameraId = previewUiState.currentPhysicalCameraId,
+ logicalCameraId = previewUiState.currentLogicalCameraId,
showZoomLevel = zoomLevelDisplayState.showZoomLevel,
isQuickSettingsOpen = previewUiState.quickSettingsIsOpen,
currentCameraSettings = previewUiState.currentCameraSettings,
@@ -200,6 +208,8 @@
modifier: Modifier = Modifier,
audioAmplitude: Double,
previewUiState: PreviewUiState.Ready,
+ physicalCameraId: String? = null,
+ logicalCameraId: String? = null,
zoomLevel: Float,
showZoomLevel: Boolean,
isQuickSettingsOpen: Boolean,
@@ -218,12 +228,25 @@
onToggleAudioMuted: () -> Unit = {},
onChangeImageFormat: (ImageOutputFormat) -> Unit = {},
onToggleWhenDisabled: (CaptureModeToggleUiState.DisabledReason) -> Unit = {},
- onStartVideoRecording: () -> Unit = {},
+ onStartVideoRecording: (
+ Uri?,
+ Boolean,
+ (PreviewViewModel.VideoCaptureEvent) -> Unit
+ ) -> Unit = { _, _, _ -> },
onStopVideoRecording: () -> Unit = {}
) {
Column(modifier = modifier, horizontalAlignment = Alignment.CenterHorizontally) {
- if (showZoomLevel) {
- ZoomScaleText(zoomLevel)
+ CompositionLocalProvider(
+ LocalTextStyle provides LocalTextStyle.current.copy(fontSize = 20.sp)
+ ) {
+ Column(horizontalAlignment = Alignment.CenterHorizontally) {
+ if (showZoomLevel) {
+ ZoomScaleText(zoomLevel)
+ }
+ if (previewUiState.isDebugMode) {
+ CurrentCameraIdText(physicalCameraId, logicalCameraId)
+ }
+ }
}
Row(
@@ -292,7 +315,11 @@
(PreviewViewModel.ImageCaptureEvent) -> Unit
) -> Unit = { _, _, _, _ -> },
onToggleQuickSettings: () -> Unit = {},
- onStartVideoRecording: () -> Unit = {},
+ onStartVideoRecording: (
+ Uri?,
+ Boolean,
+ (PreviewViewModel.VideoCaptureEvent) -> Unit
+ ) -> Unit = { _, _, _ -> },
onStopVideoRecording: () -> Unit = {}
) {
val multipleEventsCutter = remember { MultipleEventsCutter() }
@@ -319,6 +346,14 @@
previewUiState.previewMode.onImageCapture
)
}
+
+ else -> {
+ onCaptureImageWithUri(
+ context.contentResolver,
+ null,
+ false
+ ) {}
+ }
}
}
if (isQuickSettingsOpen) {
@@ -326,12 +361,30 @@
}
},
onLongPress = {
- onStartVideoRecording()
+ when (previewUiState.previewMode) {
+ is PreviewMode.StandardMode -> {
+ onStartVideoRecording(null, false) {}
+ }
+
+ is PreviewMode.ExternalVideoCaptureMode -> {
+ onStartVideoRecording(
+ previewUiState.previewMode.videoCaptureUri,
+ true,
+ previewUiState.previewMode.onVideoCapture
+ )
+ }
+
+ else -> {
+ onStartVideoRecording(null, false) {}
+ }
+ }
if (isQuickSettingsOpen) {
onToggleQuickSettings()
}
},
- onRelease = { onStopVideoRecording() },
+ onRelease = {
+ onStopVideoRecording()
+ },
videoRecordingState = videoRecordingState
)
}
diff --git a/feature/preview/src/main/java/com/google/jetpackcamera/feature/preview/ui/PreviewScreenComponents.kt b/feature/preview/src/main/java/com/google/jetpackcamera/feature/preview/ui/PreviewScreenComponents.kt
index 4995e97..25a0f28 100644
--- a/feature/preview/src/main/java/com/google/jetpackcamera/feature/preview/ui/PreviewScreenComponents.kt
+++ b/feature/preview/src/main/java/com/google/jetpackcamera/feature/preview/ui/PreviewScreenComponents.kt
@@ -35,6 +35,7 @@
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.BoxWithConstraints
+import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.aspectRatio
import androidx.compose.foundation.layout.fillMaxHeight
@@ -89,7 +90,6 @@
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.Dp
import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
import com.google.jetpackcamera.feature.preview.PreviewUiState
import com.google.jetpackcamera.feature.preview.R
import com.google.jetpackcamera.feature.preview.VideoRecordingState
@@ -422,20 +422,41 @@
}
@Composable
-fun ZoomScaleText(zoomScale: Float, modifier: Modifier = Modifier) {
+fun ZoomScaleText(zoomScale: Float) {
val contentAlpha = animateFloatAsState(
targetValue = 10f,
label = "zoomScaleAlphaAnimation",
animationSpec = tween()
)
Text(
- modifier = Modifier.alpha(contentAlpha.value),
- text = "%.1fx".format(zoomScale),
- fontSize = 20.sp
+ modifier = Modifier
+ .alpha(contentAlpha.value)
+ .testTag(ZOOM_RATIO_TAG),
+ text = stringResource(id = R.string.zoom_scale_text, zoomScale)
)
}
@Composable
+fun CurrentCameraIdText(physicalCameraId: String?, logicalCameraId: String?) {
+ Column(horizontalAlignment = Alignment.CenterHorizontally) {
+ Row {
+ Text(text = stringResource(R.string.debug_text_logical_camera_id_prefix))
+ Text(
+ modifier = Modifier.testTag(LOGICAL_CAMERA_ID_TAG),
+ text = logicalCameraId ?: "---"
+ )
+ }
+ Row {
+ Text(text = stringResource(R.string.debug_text_physical_camera_id_prefix))
+ Text(
+ modifier = Modifier.testTag(PHYSICAL_CAMERA_ID_TAG),
+ text = physicalCameraId ?: "---"
+ )
+ }
+ }
+}
+
+@Composable
fun CaptureButton(
onClick: () -> Unit,
onLongPress: () -> Unit,
diff --git a/feature/preview/src/main/java/com/google/jetpackcamera/feature/preview/ui/TestTags.kt b/feature/preview/src/main/java/com/google/jetpackcamera/feature/preview/ui/TestTags.kt
index 5391125..077a971 100644
--- a/feature/preview/src/main/java/com/google/jetpackcamera/feature/preview/ui/TestTags.kt
+++ b/feature/preview/src/main/java/com/google/jetpackcamera/feature/preview/ui/TestTags.kt
@@ -19,7 +19,12 @@
const val FLIP_CAMERA_BUTTON = "FlipCameraButton"
const val IMAGE_CAPTURE_SUCCESS_TAG = "ImageCaptureSuccessTag"
const val IMAGE_CAPTURE_FAILURE_TAG = "ImageCaptureFailureTag"
-const val VIDEO_CAPTURE_EXTERNAL_UNSUPPORTED_TAG = "ImageCaptureExternalUnsupportedTag"
+const val IMAGE_CAPTURE_EXTERNAL_UNSUPPORTED_TAG = "ImageCaptureExternalUnsupportedTag"
+const val IMAGE_CAPTURE_UNSUPPORTED_CONCURRENT_CAMERA_TAG =
+ "ImageCaptureUnsupportedConcurrentCameraTag"
+const val VIDEO_CAPTURE_EXTERNAL_UNSUPPORTED_TAG = "VideoCaptureExternalUnsupportedTag"
+const val VIDEO_CAPTURE_SUCCESS_TAG = "VideoCaptureSuccessTag"
+const val VIDEO_CAPTURE_FAILURE_TAG = "VideoCaptureFailureTag"
const val PREVIEW_DISPLAY = "PreviewDisplay"
const val SCREEN_FLASH_OVERLAY = "ScreenFlashOverlay"
const val SETTINGS_BUTTON = "SettingsButton"
@@ -31,3 +36,6 @@
const val HDR_IMAGE_UNSUPPORTED_ON_MULTI_STREAM_TAG = "HdrImageUnsupportedOnMultiStreamTag"
const val HDR_VIDEO_UNSUPPORTED_ON_DEVICE_TAG = "HdrVideoUnsupportedOnDeviceTag"
const val HDR_VIDEO_UNSUPPORTED_ON_LENS_TAG = "HdrVideoUnsupportedOnDeviceTag"
+const val ZOOM_RATIO_TAG = "ZoomRatioTag"
+const val LOGICAL_CAMERA_ID_TAG = "LogicalCameraIdTag"
+const val PHYSICAL_CAMERA_ID_TAG = "PhysicalCameraIdTag"
diff --git a/feature/preview/src/main/res/drawable/picture_in_picture_off_icon.xml b/feature/preview/src/main/res/drawable/picture_in_picture_off_icon.xml
new file mode 100644
index 0000000..3c394b1
--- /dev/null
+++ b/feature/preview/src/main/res/drawable/picture_in_picture_off_icon.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+ ~ Copyright (C) 2024 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.
+ -->
+<vector android:height="72dp" android:tint="#000000"
+ android:viewportHeight="960" android:viewportWidth="960"
+ android:width="72dp" xmlns:android="http://schemas.android.com/apk/res/android">
+ <path android:fillColor="@android:color/white" android:pathData="M700,520Q725,520 742.5,502.5Q760,485 760,460L760,340Q760,315 742.5,297.5Q725,280 700,280L480,280Q463,280 451.5,291.5Q440,303 440,320Q440,337 451.5,348.5Q463,360 480,360L680,360L680,360L680,440L640,440Q623,440 611.5,451.5Q600,463 600,480Q600,497 612,508.5Q624,520 641,520L700,520ZM840,720Q825,720 812.5,709.5Q800,699 800,679L800,240Q800,240 800,240Q800,240 800,240L361,240Q341,240 331,227.5Q321,215 321,200Q321,185 331,172.5Q341,160 361,160L800,160Q833,160 856.5,183.5Q880,207 880,240L880,680Q880,700 867.5,710Q855,720 840,720ZM577,463L577,463L577,463L577,463Q577,463 577,463Q577,463 577,463ZM383,497L383,497Q383,497 383,497Q383,497 383,497L383,497Q383,497 383,497Q383,497 383,497L383,497ZM790,903L686,800L160,800Q127,800 103.5,776.5Q80,753 80,720L80,240Q80,207 103.5,183.5Q127,160 160,160L160,160L240,240L160,240Q160,240 160,240Q160,240 160,240L160,720Q160,720 160,720Q160,720 160,720L606,720L54,168Q42,156 42,139.5Q42,123 54,111Q66,99 82.5,99Q99,99 111,111L847,847Q859,859 859,875Q859,891 847,903Q835,915 818.5,915Q802,915 790,903Z"/>
+</vector>
diff --git a/feature/preview/src/main/res/values/strings.xml b/feature/preview/src/main/res/values/strings.xml
index fc81069..77d80e0 100644
--- a/feature/preview/src/main/res/values/strings.xml
+++ b/feature/preview/src/main/res/values/strings.xml
@@ -20,6 +20,10 @@
<string name="flip_camera_content_description">Flip Camera</string>
<string name="audio_visualizer_icon">An icon of a microphone</string>
+ <string name="zoom_scale_text">%1$.2fx</string>
+
+ <string name="debug_text_physical_camera_id_prefix">Physical ID: </string>
+ <string name="debug_text_logical_camera_id_prefix">Logical ID: </string>
<string name="toast_image_capture_success">Image Capture Success</string>
<string name="toast_video_capture_success">Video Capture Success</string>
@@ -27,6 +31,8 @@
<string name="toast_capture_failure">Image Capture Failure</string>
<string name="toast_video_capture_failure">Video Capture Failure</string>
<string name="toast_video_capture_external_unsupported">Video not supported while app is in image-only capture mode</string>
+ <string name="toast_image_capture_external_unsupported">Image capture not supported while app is in video-only capture mode</string>
+ <string name="toast_image_capture_unsupported_concurrent_camera">Image capture not supported in dual camera mode</string>
<string name="stabilization_icon_description_preview_and_video">Preview is Stabilized</string>
<string name="stabilization_icon_description_video_only">Only Video is Stabilized</string>
<string name="toast_hdr_photo_unsupported_on_device">Ultra HDR photos not supported on this device</string>
@@ -74,4 +80,9 @@
<string name="quick_settings_lowlightboost_disabled">Low light boost off</string>
<string name="quick_settings_lowlightboost_enabled_description">Low light boost on</string>
<string name="quick_settings_lowlightboost_disabled_description">Low light boost off</string>
+
+ <string name="quick_settings_concurrent_camera_off">SINGLE</string>
+ <string name="quick_settings_concurrent_camera_dual">DUAL</string>
+ <string name="quick_settings_concurrent_camera_off_description">Concurrent cameras off</string>
+ <string name="quick_settings_concurrent_camera_dual_description">Concurrent dual camera on</string>
</resources>
diff --git a/feature/preview/src/test/java/com/google/jetpackcamera/feature/preview/PreviewViewModelTest.kt b/feature/preview/src/test/java/com/google/jetpackcamera/feature/preview/PreviewViewModelTest.kt
index ee4bc9e..2d40334 100644
--- a/feature/preview/src/test/java/com/google/jetpackcamera/feature/preview/PreviewViewModelTest.kt
+++ b/feature/preview/src/test/java/com/google/jetpackcamera/feature/preview/PreviewViewModelTest.kt
@@ -22,6 +22,7 @@
import com.google.jetpackcamera.settings.model.FlashMode
import com.google.jetpackcamera.settings.model.LensFacing
import com.google.jetpackcamera.settings.model.TYPICAL_SYSTEM_CONSTRAINTS
+import com.google.jetpackcamera.settings.test.FakeSettingsRepository
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.ExperimentalCoroutinesApi
import kotlinx.coroutines.test.StandardTestDispatcher
@@ -47,8 +48,10 @@
Dispatchers.setMain(StandardTestDispatcher())
previewViewModel = PreviewViewModel(
PreviewMode.StandardMode {},
- cameraUseCase,
- constraintsRepository
+ false,
+ cameraUseCase = cameraUseCase,
+ constraintsRepository = constraintsRepository,
+ settingsRepository = FakeSettingsRepository
)
advanceUntilIdle()
}
@@ -87,7 +90,7 @@
@Test
fun startVideoRecording() = runTest(StandardTestDispatcher()) {
previewViewModel.startCameraUntilRunning()
- previewViewModel.startVideoRecording()
+ previewViewModel.startVideoRecording(null, false) {}
advanceUntilIdle()
assertThat(cameraUseCase.recordingInProgress).isTrue()
}
@@ -95,7 +98,7 @@
@Test
fun stopVideoRecording() = runTest(StandardTestDispatcher()) {
previewViewModel.startCameraUntilRunning()
- previewViewModel.startVideoRecording()
+ previewViewModel.startVideoRecording(null, false) {}
advanceUntilIdle()
previewViewModel.stopVideoRecording()
assertThat(cameraUseCase.recordingInProgress).isFalse()
diff --git a/feature/preview/src/test/java/com/google/jetpackcamera/feature/preview/ScreenFlashTest.kt b/feature/preview/src/test/java/com/google/jetpackcamera/feature/preview/ScreenFlashTest.kt
index 9dd08cc..536e90e 100644
--- a/feature/preview/src/test/java/com/google/jetpackcamera/feature/preview/ScreenFlashTest.kt
+++ b/feature/preview/src/test/java/com/google/jetpackcamera/feature/preview/ScreenFlashTest.kt
@@ -20,6 +20,7 @@
import com.google.jetpackcamera.core.camera.CameraUseCase
import com.google.jetpackcamera.core.camera.test.FakeCameraUseCase
import com.google.jetpackcamera.feature.preview.rules.MainDispatcherRule
+import com.google.jetpackcamera.settings.model.DEFAULT_CAMERA_APP_SETTINGS
import com.google.jetpackcamera.settings.model.FlashMode
import com.google.jetpackcamera.settings.model.LensFacing
import kotlinx.coroutines.ExperimentalCoroutinesApi
@@ -43,7 +44,7 @@
@get:Rule
val mainDispatcherRule = MainDispatcherRule(testDispatcher)
- private val cameraUseCase = FakeCameraUseCase(testScope)
+ private val cameraUseCase = FakeCameraUseCase()
private lateinit var screenFlash: ScreenFlash
@Before
@@ -109,7 +110,10 @@
private fun runCameraTest(testBody: suspend TestScope.() -> Unit) = runTest(testDispatcher) {
backgroundScope.launch(UnconfinedTestDispatcher(testScheduler)) {
- cameraUseCase.initialize(false)
+ cameraUseCase.initialize(
+ DEFAULT_CAMERA_APP_SETTINGS,
+ CameraUseCase.UseCaseMode.STANDARD
+ )
cameraUseCase.runCamera()
}
diff --git a/feature/settings/src/androidTest/java/com/google/jetpackcamera/settings/CameraAppSettingsViewModelTest.kt b/feature/settings/src/androidTest/java/com/google/jetpackcamera/settings/CameraAppSettingsViewModelTest.kt
index ae1a0b0..dbbc72b 100644
--- a/feature/settings/src/androidTest/java/com/google/jetpackcamera/settings/CameraAppSettingsViewModelTest.kt
+++ b/feature/settings/src/androidTest/java/com/google/jetpackcamera/settings/CameraAppSettingsViewModelTest.kt
@@ -22,7 +22,6 @@
import androidx.test.core.app.ApplicationProvider
import androidx.test.platform.app.InstrumentationRegistry
import com.google.common.truth.Truth.assertThat
-import com.google.jetpackcamera.settings.model.DEFAULT_CAMERA_APP_SETTINGS
import com.google.jetpackcamera.settings.model.DarkMode
import com.google.jetpackcamera.settings.model.LensFacing
import com.google.jetpackcamera.settings.model.TYPICAL_SYSTEM_CONSTRAINTS
@@ -85,10 +84,7 @@
}
assertThat(uiState).isEqualTo(
- SettingsUiState.Enabled(
- cameraAppSettings = DEFAULT_CAMERA_APP_SETTINGS,
- systemConstraints = TYPICAL_SYSTEM_CONSTRAINTS
- )
+ TYPICAL_SETTINGS_UISTATE
)
}
@@ -99,8 +95,8 @@
it is SettingsUiState.Enabled
}
- val initialCameraLensFacing = assertIsEnabled(initialState)
- .cameraAppSettings.cameraLensFacing
+ val initialCameraLensFacing =
+ assertIsEnabled(initialState).lensFlipUiState.currentLensFacing
val nextCameraLensFacing = if (initialCameraLensFacing == LensFacing.FRONT) {
LensFacing.BACK
} else {
@@ -111,7 +107,7 @@
advanceUntilIdle()
assertIsEnabled(settingsViewModel.settingsUiState.value).also {
- assertThat(it.cameraAppSettings.cameraLensFacing).isEqualTo(nextCameraLensFacing)
+ assertThat(it.lensFlipUiState.currentLensFacing).isEqualTo(nextCameraLensFacing)
}
}
@@ -122,14 +118,20 @@
it is SettingsUiState.Enabled
}
- val initialDarkMode = assertIsEnabled(initialState).cameraAppSettings.darkMode
+ val initialDarkMode =
+ (assertIsEnabled(initialState).darkModeUiState as DarkModeUiState.Enabled)
+ .currentDarkMode
settingsViewModel.setDarkMode(DarkMode.DARK)
advanceUntilIdle()
- val newDarkMode = assertIsEnabled(settingsViewModel.settingsUiState.value)
- .cameraAppSettings.darkMode
+ val newDarkMode =
+ (
+ assertIsEnabled(settingsViewModel.settingsUiState.value)
+ .darkModeUiState as DarkModeUiState.Enabled
+ )
+ .currentDarkMode
assertEquals(initialDarkMode, DarkMode.SYSTEM)
assertEquals(DarkMode.DARK, newDarkMode)
diff --git a/feature/settings/src/main/java/com/google/jetpackcamera/settings/SettingsScreen.kt b/feature/settings/src/main/java/com/google/jetpackcamera/settings/SettingsScreen.kt
index d5ebc0e..a3ab00e 100644
--- a/feature/settings/src/main/java/com/google/jetpackcamera/settings/SettingsScreen.kt
+++ b/feature/settings/src/main/java/com/google/jetpackcamera/settings/SettingsScreen.kt
@@ -30,12 +30,10 @@
import androidx.hilt.navigation.compose.hiltViewModel
import com.google.jetpackcamera.settings.model.AspectRatio
import com.google.jetpackcamera.settings.model.CaptureMode
-import com.google.jetpackcamera.settings.model.DEFAULT_CAMERA_APP_SETTINGS
import com.google.jetpackcamera.settings.model.DarkMode
import com.google.jetpackcamera.settings.model.FlashMode
import com.google.jetpackcamera.settings.model.LensFacing
import com.google.jetpackcamera.settings.model.Stabilization
-import com.google.jetpackcamera.settings.model.TYPICAL_SYSTEM_CONSTRAINTS
import com.google.jetpackcamera.settings.ui.AspectRatioSetting
import com.google.jetpackcamera.settings.ui.CaptureModeSetting
import com.google.jetpackcamera.settings.ui.DarkModeSetting
@@ -130,47 +128,32 @@
SectionHeader(title = stringResource(id = R.string.section_title_camera_settings))
DefaultCameraFacing(
- settingValue = (uiState.cameraAppSettings.cameraLensFacing == LensFacing.FRONT),
- enabled = with(uiState.systemConstraints.availableLenses) {
- size > 1 && contains(LensFacing.FRONT)
- },
+ lensUiState = uiState.lensFlipUiState,
setDefaultLensFacing = setDefaultLensFacing
)
FlashModeSetting(
- currentFlashMode = uiState.cameraAppSettings.flashMode,
+ flashUiState = uiState.flashUiState,
setFlashMode = setFlashMode
)
TargetFpsSetting(
- currentTargetFps = uiState.cameraAppSettings.targetFrameRate,
- supportedFps = uiState.systemConstraints.perLensConstraints.values.fold(emptySet()) {
- union, constraints ->
- union + constraints.supportedFixedFrameRates
- },
+ fpsUiState = uiState.fpsUiState,
setTargetFps = setTargetFrameRate
)
AspectRatioSetting(
- currentAspectRatio = uiState.cameraAppSettings.aspectRatio,
+ aspectRatioUiState = uiState.aspectRatioUiState,
setAspectRatio = setAspectRatio
)
CaptureModeSetting(
- currentCaptureMode = uiState.cameraAppSettings.captureMode,
+ captureModeUiState = uiState.captureModeUiState,
setCaptureMode = setCaptureMode
)
StabilizationSetting(
- currentVideoStabilization = uiState.cameraAppSettings.videoCaptureStabilization,
- currentPreviewStabilization = uiState.cameraAppSettings.previewStabilization,
- currentTargetFps = uiState.cameraAppSettings.targetFrameRate,
- supportedStabilizationMode = uiState.systemConstraints.perLensConstraints.values.fold(
- emptySet()
- ) {
- union, constraints ->
- union + constraints.supportedStabilizationModes
- },
+ stabilizationUiState = uiState.stabilizationUiState,
setVideoStabilization = setVideoStabilization,
setPreviewStabilization = setPreviewStabilization
)
@@ -178,7 +161,7 @@
SectionHeader(title = stringResource(id = R.string.section_title_app_settings))
DarkModeSetting(
- currentDarkMode = uiState.cameraAppSettings.darkMode,
+ darkModeUiState = uiState.darkModeUiState,
setDarkMode = setDarkMode
)
@@ -190,6 +173,8 @@
)
}
+// will allow you to open stabilization popup or give disabled rationale
+
data class VersionInfoHolder(
val versionName: String,
val buildType: String
@@ -201,10 +186,7 @@
private fun Preview_SettingsScreen() {
SettingsPreviewTheme {
SettingsScreen(
- uiState = SettingsUiState.Enabled(
- DEFAULT_CAMERA_APP_SETTINGS,
- TYPICAL_SYSTEM_CONSTRAINTS
- ),
+ uiState = TYPICAL_SETTINGS_UISTATE,
versionInfo = VersionInfoHolder(
versionName = "1.0.0",
buildType = "release"
diff --git a/feature/settings/src/main/java/com/google/jetpackcamera/settings/SettingsUiState.kt b/feature/settings/src/main/java/com/google/jetpackcamera/settings/SettingsUiState.kt
index 13cf5f0..7f882c3 100644
--- a/feature/settings/src/main/java/com/google/jetpackcamera/settings/SettingsUiState.kt
+++ b/feature/settings/src/main/java/com/google/jetpackcamera/settings/SettingsUiState.kt
@@ -15,16 +15,199 @@
*/
package com.google.jetpackcamera.settings
-import com.google.jetpackcamera.settings.model.CameraAppSettings
-import com.google.jetpackcamera.settings.model.SystemConstraints
+import com.google.jetpackcamera.settings.DisabledRationale.DeviceUnsupportedRationale
+import com.google.jetpackcamera.settings.DisabledRationale.LensUnsupportedRationale
+import com.google.jetpackcamera.settings.model.AspectRatio
+import com.google.jetpackcamera.settings.model.CaptureMode
+import com.google.jetpackcamera.settings.model.DEFAULT_CAMERA_APP_SETTINGS
+import com.google.jetpackcamera.settings.model.DarkMode
+import com.google.jetpackcamera.settings.model.FlashMode
+import com.google.jetpackcamera.settings.model.LensFacing
+import com.google.jetpackcamera.settings.model.Stabilization
+import com.google.jetpackcamera.settings.ui.DEVICE_UNSUPPORTED_TAG
+import com.google.jetpackcamera.settings.ui.FPS_UNSUPPORTED_TAG
+import com.google.jetpackcamera.settings.ui.LENS_UNSUPPORTED_TAG
+import com.google.jetpackcamera.settings.ui.STABILIZATION_UNSUPPORTED_TAG
/**
* Defines the current state of the [SettingsScreen].
*/
sealed interface SettingsUiState {
- object Disabled : SettingsUiState
+ data object Disabled : SettingsUiState
data class Enabled(
- val cameraAppSettings: CameraAppSettings,
- val systemConstraints: SystemConstraints
+ val aspectRatioUiState: AspectRatioUiState,
+ val captureModeUiState: CaptureModeUiState,
+ val darkModeUiState: DarkModeUiState,
+ val flashUiState: FlashUiState,
+ val fpsUiState: FpsUiState,
+ val lensFlipUiState: FlipLensUiState,
+ val stabilizationUiState: StabilizationUiState
) : SettingsUiState
}
+
+/** State for the individual options on Popup dialog settings */
+sealed interface SingleSelectableState {
+ data object Selectable : SingleSelectableState
+ data class Disabled(val disabledRationale: DisabledRationale) : SingleSelectableState
+}
+
+/** Contains information on why a setting is disabled */
+// TODO(b/360921588): Display information on UI regarding disabled rationale
+sealed interface DisabledRationale {
+ val affectedSettingNameResId: Int
+ val reasonTextResId: Int
+ val testTag: String
+
+ /**
+ * Text will be [affectedSettingNameResId] is [R.string.device_unsupported]
+ */
+ data class DeviceUnsupportedRationale(override val affectedSettingNameResId: Int) :
+ DisabledRationale {
+ override val reasonTextResId: Int = R.string.device_unsupported
+ override val testTag = DEVICE_UNSUPPORTED_TAG
+ }
+
+ data class FpsUnsupportedRationale(
+ override val affectedSettingNameResId: Int,
+ val currentFps: Int
+ ) : DisabledRationale {
+ override val reasonTextResId: Int = R.string.fps_unsupported
+ override val testTag = FPS_UNSUPPORTED_TAG
+ }
+
+ data class StabilizationUnsupportedRationale(override val affectedSettingNameResId: Int) :
+ DisabledRationale {
+ override val reasonTextResId = R.string.stabilization_unsupported
+ override val testTag = STABILIZATION_UNSUPPORTED_TAG
+ }
+
+ sealed interface LensUnsupportedRationale : DisabledRationale {
+ data class FrontLensUnsupportedRationale(override val affectedSettingNameResId: Int) :
+ LensUnsupportedRationale {
+ override val reasonTextResId: Int = R.string.front_lens_unsupported
+ override val testTag = LENS_UNSUPPORTED_TAG
+ }
+
+ data class RearLensUnsupportedRationale(override val affectedSettingNameResId: Int) :
+ LensUnsupportedRationale {
+ override val reasonTextResId: Int = R.string.rear_lens_unsupported
+ override val testTag = LENS_UNSUPPORTED_TAG
+ }
+ }
+}
+
+fun getLensUnsupportedRationale(
+ lensFacing: LensFacing,
+ affectedSettingNameResId: Int
+): LensUnsupportedRationale {
+ return when (lensFacing) {
+ LensFacing.BACK -> LensUnsupportedRationale.RearLensUnsupportedRationale(
+ affectedSettingNameResId
+ )
+
+ LensFacing.FRONT -> LensUnsupportedRationale.FrontLensUnsupportedRationale(
+ affectedSettingNameResId
+ )
+ }
+}
+
+/* Settings that currently have constraints **/
+
+sealed interface FpsUiState {
+ data class Enabled(
+ val currentSelection: Int,
+ val fpsAutoState: SingleSelectableState,
+ val fpsFifteenState: SingleSelectableState,
+ val fpsThirtyState: SingleSelectableState,
+ val fpsSixtyState: SingleSelectableState,
+ // Contains text like "Selected FPS only supported by rear lens"
+ val additionalContext: String = ""
+ ) : FpsUiState
+
+ // FPS selection completely disabled. Cannot open dialog.
+ data class Disabled(val disabledRationale: DisabledRationale) : FpsUiState
+}
+
+sealed interface FlipLensUiState {
+ val currentLensFacing: LensFacing
+
+ data class Enabled(
+ override val currentLensFacing: LensFacing
+ ) : FlipLensUiState
+
+ data class Disabled(
+ override val currentLensFacing: LensFacing,
+ val disabledRationale: DisabledRationale
+ ) : FlipLensUiState
+}
+
+sealed interface StabilizationUiState {
+ data class Enabled(
+ val currentPreviewStabilization: Stabilization,
+ val currentVideoStabilization: Stabilization,
+ val stabilizationOnState: SingleSelectableState,
+ val stabilizationHighQualityState: SingleSelectableState,
+ // Contains text like "Selected stabilization mode only supported by rear lens"
+ val additionalContext: String = ""
+ ) : StabilizationUiState
+
+ // Stabilization selection completely disabled. Cannot open dialog.
+ data class Disabled(val disabledRationale: DisabledRationale) : StabilizationUiState
+}
+
+/* Settings that don't currently depend on constraints */
+
+// this could be constrained w/ a check to see if a torch is available?
+sealed interface FlashUiState {
+ data class Enabled(
+ val currentFlashMode: FlashMode,
+ val additionalContext: String = ""
+ ) : FlashUiState
+}
+
+sealed interface AspectRatioUiState {
+ data class Enabled(
+ val currentAspectRatio: AspectRatio,
+ val additionalContext: String = ""
+ ) : AspectRatioUiState
+}
+
+sealed interface CaptureModeUiState {
+ data class Enabled(
+ val currentCaptureMode: CaptureMode,
+ val additionalContext: String = ""
+ ) : CaptureModeUiState
+}
+
+sealed interface DarkModeUiState {
+ data class Enabled(
+ val currentDarkMode: DarkMode,
+ val additionalContext: String = ""
+ ) : DarkModeUiState
+}
+
+/**
+ * Settings Ui State for testing, based on Typical System Constraints.
+ * @see[com.google.jetpackcamera.settings.model.SystemConstraints]
+ */
+val TYPICAL_SETTINGS_UISTATE = SettingsUiState.Enabled(
+ aspectRatioUiState = AspectRatioUiState.Enabled(DEFAULT_CAMERA_APP_SETTINGS.aspectRatio),
+ captureModeUiState = CaptureModeUiState.Enabled(DEFAULT_CAMERA_APP_SETTINGS.captureMode),
+ darkModeUiState = DarkModeUiState.Enabled(DEFAULT_CAMERA_APP_SETTINGS.darkMode),
+ flashUiState =
+ FlashUiState.Enabled(currentFlashMode = DEFAULT_CAMERA_APP_SETTINGS.flashMode),
+ fpsUiState = FpsUiState.Enabled(
+ currentSelection = DEFAULT_CAMERA_APP_SETTINGS.targetFrameRate,
+ fpsAutoState = SingleSelectableState.Selectable,
+ fpsFifteenState = SingleSelectableState.Selectable,
+ fpsThirtyState = SingleSelectableState.Selectable,
+ fpsSixtyState = SingleSelectableState.Disabled(
+ DeviceUnsupportedRationale(R.string.fps_rationale_prefix)
+ )
+ ),
+ lensFlipUiState = FlipLensUiState.Enabled(DEFAULT_CAMERA_APP_SETTINGS.cameraLensFacing),
+ stabilizationUiState =
+ StabilizationUiState.Disabled(
+ DeviceUnsupportedRationale(R.string.stabilization_rationale_prefix)
+ )
+)
diff --git a/feature/settings/src/main/java/com/google/jetpackcamera/settings/SettingsViewModel.kt b/feature/settings/src/main/java/com/google/jetpackcamera/settings/SettingsViewModel.kt
index ea8caf7..43e7a50 100644
--- a/feature/settings/src/main/java/com/google/jetpackcamera/settings/SettingsViewModel.kt
+++ b/feature/settings/src/main/java/com/google/jetpackcamera/settings/SettingsViewModel.kt
@@ -18,12 +18,22 @@
import android.util.Log
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
+import com.google.jetpackcamera.settings.DisabledRationale.DeviceUnsupportedRationale
+import com.google.jetpackcamera.settings.DisabledRationale.FpsUnsupportedRationale
+import com.google.jetpackcamera.settings.DisabledRationale.StabilizationUnsupportedRationale
import com.google.jetpackcamera.settings.model.AspectRatio
+import com.google.jetpackcamera.settings.model.CameraAppSettings
import com.google.jetpackcamera.settings.model.CaptureMode
import com.google.jetpackcamera.settings.model.DarkMode
import com.google.jetpackcamera.settings.model.FlashMode
import com.google.jetpackcamera.settings.model.LensFacing
import com.google.jetpackcamera.settings.model.Stabilization
+import com.google.jetpackcamera.settings.model.SupportedStabilizationMode
+import com.google.jetpackcamera.settings.model.SystemConstraints
+import com.google.jetpackcamera.settings.ui.FPS_15
+import com.google.jetpackcamera.settings.ui.FPS_30
+import com.google.jetpackcamera.settings.ui.FPS_60
+import com.google.jetpackcamera.settings.ui.FPS_AUTO
import dagger.hilt.android.lifecycle.HiltViewModel
import javax.inject.Inject
import kotlinx.coroutines.flow.SharingStarted
@@ -34,6 +44,7 @@
import kotlinx.coroutines.launch
private const val TAG = "SettingsViewModel"
+private val fpsOptions = setOf(FPS_15, FPS_30, FPS_60)
/**
* [ViewModel] for [SettingsScreen].
@@ -50,8 +61,14 @@
constraintsRepository.systemConstraints.filterNotNull()
) { updatedSettings, constraints ->
SettingsUiState.Enabled(
- cameraAppSettings = updatedSettings,
- systemConstraints = constraints
+ aspectRatioUiState = AspectRatioUiState.Enabled(updatedSettings.aspectRatio),
+ captureModeUiState = CaptureModeUiState.Enabled(updatedSettings.captureMode),
+ darkModeUiState = DarkModeUiState.Enabled(updatedSettings.darkMode),
+ flashUiState = FlashUiState.Enabled(updatedSettings.flashMode),
+ fpsUiState = getFpsUiState(constraints, updatedSettings),
+ lensFlipUiState = getLensFlipUiState(constraints, updatedSettings),
+ stabilizationUiState = getStabilizationUiState(constraints, updatedSettings)
+
)
}.stateIn(
scope = viewModelScope,
@@ -59,6 +76,317 @@
initialValue = SettingsUiState.Disabled
)
+ private fun getStabilizationUiState(
+ systemConstraints: SystemConstraints,
+ cameraAppSettings: CameraAppSettings
+ ): StabilizationUiState {
+ val deviceStabilizations: Set<SupportedStabilizationMode> =
+ systemConstraints
+ .perLensConstraints[cameraAppSettings.cameraLensFacing]
+ ?.supportedStabilizationModes
+ ?: emptySet()
+
+ // if no lens supports
+ if (deviceStabilizations.isEmpty()) {
+ return StabilizationUiState.Disabled(
+ DeviceUnsupportedRationale(
+ R.string.stabilization_rationale_prefix
+ )
+ )
+ }
+
+ // if a lens supports but it isn't the current
+ if (systemConstraints.perLensConstraints[cameraAppSettings.cameraLensFacing]
+ ?.supportedStabilizationModes?.isEmpty() == true
+ ) {
+ return StabilizationUiState.Disabled(
+ getLensUnsupportedRationale(
+ cameraAppSettings.cameraLensFacing,
+ R.string.stabilization_rationale_prefix
+ )
+ )
+ }
+
+ // if fps is too high for any stabilization
+ if (cameraAppSettings.targetFrameRate >= TARGET_FPS_60) {
+ return StabilizationUiState.Disabled(
+ FpsUnsupportedRationale(
+ R.string.stabilization_rationale_prefix,
+ FPS_60
+ )
+ )
+ }
+
+ return StabilizationUiState.Enabled(
+ currentPreviewStabilization = cameraAppSettings.previewStabilization,
+ currentVideoStabilization = cameraAppSettings.videoCaptureStabilization,
+ stabilizationOnState = getPreviewStabilizationState(
+ currentFrameRate = cameraAppSettings.targetFrameRate,
+ defaultLensFacing = cameraAppSettings.cameraLensFacing,
+ deviceStabilizations = deviceStabilizations,
+ currentLensStabilizations = systemConstraints
+ .perLensConstraints[cameraAppSettings.cameraLensFacing]
+ ?.supportedStabilizationModes
+ ),
+ stabilizationHighQualityState =
+ getVideoStabilizationState(
+ currentFrameRate = cameraAppSettings.targetFrameRate,
+ deviceStabilizations = deviceStabilizations,
+ defaultLensFacing = cameraAppSettings.cameraLensFacing,
+ currentLensStabilizations = systemConstraints
+ .perLensConstraints[cameraAppSettings.cameraLensFacing]
+ ?.supportedStabilizationModes
+ )
+ )
+ }
+
+ private fun getPreviewStabilizationState(
+ currentFrameRate: Int,
+ defaultLensFacing: LensFacing,
+ deviceStabilizations: Set<SupportedStabilizationMode>,
+ currentLensStabilizations: Set<SupportedStabilizationMode>?
+ ): SingleSelectableState {
+ // if unsupported by device
+ if (!deviceStabilizations.contains(SupportedStabilizationMode.ON)) {
+ return SingleSelectableState.Disabled(
+ disabledRationale =
+ DeviceUnsupportedRationale(R.string.stabilization_rationale_prefix)
+ )
+ }
+
+ // if unsupported by by current lens
+ if (currentLensStabilizations?.contains(SupportedStabilizationMode.ON) == false) {
+ return SingleSelectableState.Disabled(
+ getLensUnsupportedRationale(
+ defaultLensFacing,
+ R.string.stabilization_rationale_prefix
+ )
+ )
+ }
+
+ // if fps is unsupported by preview stabilization
+ if (currentFrameRate == TARGET_FPS_60 || currentFrameRate == TARGET_FPS_15) {
+ return SingleSelectableState.Disabled(
+ FpsUnsupportedRationale(
+ R.string.stabilization_rationale_prefix,
+ currentFrameRate
+ )
+ )
+ }
+
+ return SingleSelectableState.Selectable
+ }
+
+ private fun getVideoStabilizationState(
+ currentFrameRate: Int,
+ defaultLensFacing: LensFacing,
+ deviceStabilizations: Set<SupportedStabilizationMode>,
+ currentLensStabilizations: Set<SupportedStabilizationMode>?
+ ): SingleSelectableState {
+ // if unsupported by device
+ if (!deviceStabilizations.contains(SupportedStabilizationMode.ON)) {
+ return SingleSelectableState.Disabled(
+ disabledRationale =
+ DeviceUnsupportedRationale(R.string.stabilization_rationale_prefix)
+ )
+ }
+
+ // if unsupported by by current lens
+ if (currentLensStabilizations?.contains(SupportedStabilizationMode.HIGH_QUALITY) == false) {
+ return SingleSelectableState.Disabled(
+ getLensUnsupportedRationale(
+ defaultLensFacing,
+ R.string.stabilization_rationale_prefix
+ )
+ )
+ }
+ // if fps is unsupported by preview stabilization
+ if (currentFrameRate == TARGET_FPS_60) {
+ return SingleSelectableState.Disabled(
+ FpsUnsupportedRationale(
+ R.string.stabilization_rationale_prefix,
+ currentFrameRate
+ )
+ )
+ }
+
+ return SingleSelectableState.Selectable
+ }
+
+ /**
+ * Enables or disables default camera switch based on:
+ * - number of cameras available
+ * - if there is a front and rear camera, the camera that the setting would switch to must also
+ * support the other settings
+ * */
+ private fun getLensFlipUiState(
+ systemConstraints: SystemConstraints,
+ currentSettings: CameraAppSettings
+ ): FlipLensUiState {
+ // if there is only one lens, stop here
+ if (!with(systemConstraints.availableLenses) {
+ size > 1 && contains(com.google.jetpackcamera.settings.model.LensFacing.FRONT)
+ }
+ ) {
+ return FlipLensUiState.Disabled(
+ currentLensFacing = currentSettings.cameraLensFacing,
+ disabledRationale =
+ DeviceUnsupportedRationale(
+ // display the lens that isnt supported
+ when (currentSettings.cameraLensFacing) {
+ LensFacing.BACK -> R.string.front_lens_rationale_prefix
+ LensFacing.FRONT -> R.string.rear_lens_rationale_prefix
+ }
+ )
+ )
+ }
+
+ // If multiple lens available, continue
+ val newLensFacing = if (currentSettings.cameraLensFacing == LensFacing.FRONT) {
+ LensFacing.BACK
+ } else {
+ LensFacing.FRONT
+ }
+ val newLensConstraints = systemConstraints.perLensConstraints[newLensFacing]!!
+ // make sure all current settings wont break constraint when changing new default lens
+
+ // if new lens won't support current fps
+ if (currentSettings.targetFrameRate != FPS_AUTO &&
+ !newLensConstraints.supportedFixedFrameRates
+ .contains(currentSettings.targetFrameRate)
+ ) {
+ return FlipLensUiState.Disabled(
+ currentLensFacing = currentSettings.cameraLensFacing,
+ disabledRationale = FpsUnsupportedRationale(
+ when (currentSettings.cameraLensFacing) {
+ LensFacing.BACK -> R.string.front_lens_rationale_prefix
+ LensFacing.FRONT -> R.string.rear_lens_rationale_prefix
+ },
+ currentSettings.targetFrameRate
+ )
+ )
+ }
+
+ // if preview stabilization is currently on and the other lens won't support it
+ if (currentSettings.previewStabilization == Stabilization.ON) {
+ if (!newLensConstraints.supportedStabilizationModes.contains(
+ SupportedStabilizationMode.ON
+ )
+ ) {
+ return FlipLensUiState.Disabled(
+ currentLensFacing = currentSettings.cameraLensFacing,
+ disabledRationale = StabilizationUnsupportedRationale(
+ when (currentSettings.cameraLensFacing) {
+ LensFacing.BACK -> R.string.front_lens_rationale_prefix
+ LensFacing.FRONT -> R.string.rear_lens_rationale_prefix
+ }
+ )
+ )
+ }
+ }
+ // if video stabilization is currently on and the other lens won't support it
+ if (currentSettings.videoCaptureStabilization == Stabilization.ON) {
+ if (!newLensConstraints.supportedStabilizationModes
+ .contains(SupportedStabilizationMode.HIGH_QUALITY)
+ ) {
+ return FlipLensUiState.Disabled(
+ currentLensFacing = currentSettings.cameraLensFacing,
+ disabledRationale = StabilizationUnsupportedRationale(
+ when (currentSettings.cameraLensFacing) {
+ LensFacing.BACK -> R.string.front_lens_rationale_prefix
+ LensFacing.FRONT -> R.string.rear_lens_rationale_prefix
+ }
+ )
+ )
+ }
+ }
+
+ return FlipLensUiState.Enabled(currentLensFacing = currentSettings.cameraLensFacing)
+ }
+
+ private fun getFpsUiState(
+ systemConstraints: SystemConstraints,
+ cameraAppSettings: CameraAppSettings
+ ): FpsUiState {
+ val optionConstraintRationale: MutableMap<Int, SingleSelectableState> = mutableMapOf()
+
+ val currentLensFrameRates: Set<Int> = systemConstraints
+ .perLensConstraints[cameraAppSettings.cameraLensFacing]
+ ?.supportedFixedFrameRates ?: emptySet()
+
+ // if device supports no fixed frame rates, disable
+ if (currentLensFrameRates.isEmpty()) {
+ return FpsUiState.Disabled(
+ DeviceUnsupportedRationale(R.string.no_fixed_fps_rationale_prefix)
+ )
+ }
+
+ // provide selectable states for each of the fps options
+ fpsOptions.forEach { fpsOption ->
+ val fpsUiState = isFpsOptionEnabled(
+ fpsOption,
+ cameraAppSettings.cameraLensFacing,
+ currentLensFrameRates,
+ systemConstraints.perLensConstraints[cameraAppSettings.cameraLensFacing]
+ ?.supportedFixedFrameRates ?: emptySet(),
+ cameraAppSettings.previewStabilization,
+ cameraAppSettings.videoCaptureStabilization
+ )
+ if (fpsUiState is SingleSelectableState.Disabled) {
+ Log.d(TAG, "fps option $fpsOption disabled. ${fpsUiState.disabledRationale::class}")
+ }
+ optionConstraintRationale[fpsOption] = fpsUiState
+ }
+ return FpsUiState.Enabled(
+ currentSelection = cameraAppSettings.targetFrameRate,
+ fpsAutoState = SingleSelectableState.Selectable,
+ fpsFifteenState = optionConstraintRationale[FPS_15]!!,
+ fpsThirtyState = optionConstraintRationale[FPS_30]!!,
+ fpsSixtyState = optionConstraintRationale[FPS_60]!!
+ )
+ }
+
+ /**
+ * Auxiliary function to determine if an FPS option should be disabled or not
+ */
+ private fun isFpsOptionEnabled(
+ fpsOption: Int,
+ defaultLensFacing: LensFacing,
+ deviceFrameRates: Set<Int>,
+ lensFrameRates: Set<Int>,
+ previewStabilization: Stabilization,
+ videoStabilization: Stabilization
+ ): SingleSelectableState {
+ // if device doesnt support the fps option, disable
+ if (!deviceFrameRates.contains(fpsOption)) {
+ return SingleSelectableState.Disabled(
+ disabledRationale = DeviceUnsupportedRationale(R.string.fps_rationale_prefix)
+ )
+ }
+ // if the current lens doesnt support the fps, disable
+ if (!lensFrameRates.contains(fpsOption)) {
+ Log.d(TAG, "FPS disabled for current lens")
+
+ return SingleSelectableState.Disabled(
+ getLensUnsupportedRationale(defaultLensFacing, R.string.fps_rationale_prefix)
+ )
+ }
+
+ // if stabilization is on and the option is incompatible, disable
+ if ((
+ previewStabilization == Stabilization.ON &&
+ (fpsOption == FPS_15 || fpsOption == FPS_60)
+ ) ||
+ (videoStabilization == Stabilization.ON && fpsOption == FPS_60)
+ ) {
+ return SingleSelectableState.Disabled(
+ StabilizationUnsupportedRationale(R.string.fps_rationale_prefix)
+ )
+ }
+
+ return SingleSelectableState.Selectable
+ }
+
fun setDefaultLensFacing(lensFacing: LensFacing) {
viewModelScope.launch {
settingsRepository.updateDefaultLensFacing(lensFacing)
diff --git a/feature/settings/src/main/java/com/google/jetpackcamera/settings/ui/SettingsComponents.kt b/feature/settings/src/main/java/com/google/jetpackcamera/settings/ui/SettingsComponents.kt
index 559f24f..e8c02fb 100644
--- a/feature/settings/src/main/java/com/google/jetpackcamera/settings/ui/SettingsComponents.kt
+++ b/feature/settings/src/main/java/com/google/jetpackcamera/settings/ui/SettingsComponents.kt
@@ -38,7 +38,7 @@
import androidx.compose.material3.Text
import androidx.compose.material3.TopAppBar
import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.ReadOnlyComposable
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.ui.Alignment
@@ -52,14 +52,22 @@
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
+import com.google.jetpackcamera.settings.AspectRatioUiState
+import com.google.jetpackcamera.settings.CaptureModeUiState
+import com.google.jetpackcamera.settings.DarkModeUiState
+import com.google.jetpackcamera.settings.DisabledRationale
+import com.google.jetpackcamera.settings.FlashUiState
+import com.google.jetpackcamera.settings.FlipLensUiState
+import com.google.jetpackcamera.settings.FpsUiState
import com.google.jetpackcamera.settings.R
+import com.google.jetpackcamera.settings.SingleSelectableState
+import com.google.jetpackcamera.settings.StabilizationUiState
import com.google.jetpackcamera.settings.model.AspectRatio
import com.google.jetpackcamera.settings.model.CaptureMode
import com.google.jetpackcamera.settings.model.DarkMode
import com.google.jetpackcamera.settings.model.FlashMode
import com.google.jetpackcamera.settings.model.LensFacing
import com.google.jetpackcamera.settings.model.Stabilization
-import com.google.jetpackcamera.settings.model.SupportedStabilizationMode
import com.google.jetpackcamera.settings.ui.theme.SettingsPreviewTheme
const val FPS_AUTO = 0
@@ -107,27 +115,38 @@
@Composable
fun DefaultCameraFacing(
- settingValue: Boolean,
- enabled: Boolean,
- setDefaultLensFacing: (LensFacing) -> Unit,
- modifier: Modifier = Modifier
+ modifier: Modifier = Modifier,
+ lensUiState: FlipLensUiState,
+ setDefaultLensFacing: (LensFacing) -> Unit
) {
SwitchSettingUI(
- modifier = modifier,
+ modifier = modifier.apply {
+ if (lensUiState is FlipLensUiState.Disabled) {
+ testTag(lensUiState.disabledRationale.testTag)
+ }
+ },
title = stringResource(id = R.string.default_facing_camera_title),
- description = null,
+ description = when (lensUiState) {
+ is FlipLensUiState.Disabled -> {
+ disabledRationaleString(disabledRationale = lensUiState.disabledRationale)
+ }
+
+ is FlipLensUiState.Enabled -> {
+ null
+ }
+ },
leadingIcon = null,
onSwitchChanged = { on ->
setDefaultLensFacing(if (on) LensFacing.FRONT else LensFacing.BACK)
},
- settingValue = settingValue,
- enabled = enabled
+ settingValue = lensUiState.currentLensFacing == LensFacing.FRONT,
+ enabled = lensUiState is FlipLensUiState.Enabled
)
}
@Composable
fun DarkModeSetting(
- currentDarkMode: DarkMode,
+ darkModeUiState: DarkModeUiState,
setDarkMode: (DarkMode) -> Unit,
modifier: Modifier = Modifier
) {
@@ -135,26 +154,34 @@
modifier = modifier,
title = stringResource(id = R.string.dark_mode_title),
leadingIcon = null,
- description = when (currentDarkMode) {
- DarkMode.SYSTEM -> stringResource(id = R.string.dark_mode_description_system)
- DarkMode.DARK -> stringResource(id = R.string.dark_mode_description_dark)
- DarkMode.LIGHT -> stringResource(id = R.string.dark_mode_description_light)
+ enabled = true,
+ description = when (darkModeUiState) {
+ is DarkModeUiState.Enabled -> {
+ when (darkModeUiState.currentDarkMode) {
+ DarkMode.SYSTEM -> stringResource(id = R.string.dark_mode_description_system)
+ DarkMode.DARK -> stringResource(id = R.string.dark_mode_description_dark)
+ DarkMode.LIGHT -> stringResource(id = R.string.dark_mode_description_light)
+ }
+ }
},
popupContents = {
Column(Modifier.selectableGroup()) {
SingleChoiceSelector(
text = stringResource(id = R.string.dark_mode_selector_dark),
- selected = currentDarkMode == DarkMode.DARK,
+ selected = darkModeUiState.currentDarkMode == DarkMode.DARK,
+ enabled = true,
onClick = { setDarkMode(DarkMode.DARK) }
)
SingleChoiceSelector(
text = stringResource(id = R.string.dark_mode_selector_light),
- selected = currentDarkMode == DarkMode.LIGHT,
+ selected = darkModeUiState.currentDarkMode == DarkMode.LIGHT,
+ enabled = true,
onClick = { setDarkMode(DarkMode.LIGHT) }
)
SingleChoiceSelector(
text = stringResource(id = R.string.dark_mode_selector_system),
- selected = currentDarkMode == DarkMode.SYSTEM,
+ selected = darkModeUiState.currentDarkMode == DarkMode.SYSTEM,
+ enabled = true,
onClick = { setDarkMode(DarkMode.SYSTEM) }
)
}
@@ -164,7 +191,7 @@
@Composable
fun FlashModeSetting(
- currentFlashMode: FlashMode,
+ flashUiState: FlashUiState,
setFlashMode: (FlashMode) -> Unit,
modifier: Modifier = Modifier
) {
@@ -172,26 +199,35 @@
modifier = modifier,
title = stringResource(id = R.string.flash_mode_title),
leadingIcon = null,
- description = when (currentFlashMode) {
- FlashMode.AUTO -> stringResource(id = R.string.flash_mode_description_auto)
- FlashMode.ON -> stringResource(id = R.string.flash_mode_description_on)
- FlashMode.OFF -> stringResource(id = R.string.flash_mode_description_off)
+ enabled = true,
+ description =
+ if (flashUiState is FlashUiState.Enabled) {
+ when (flashUiState.currentFlashMode) {
+ FlashMode.AUTO -> stringResource(id = R.string.flash_mode_description_auto)
+ FlashMode.ON -> stringResource(id = R.string.flash_mode_description_on)
+ FlashMode.OFF -> stringResource(id = R.string.flash_mode_description_off)
+ }
+ } else {
+ TODO("flash mode currently has no disabled criteria")
},
popupContents = {
Column(Modifier.selectableGroup()) {
SingleChoiceSelector(
text = stringResource(id = R.string.flash_mode_selector_auto),
- selected = currentFlashMode == FlashMode.AUTO,
+ selected = flashUiState.currentFlashMode == FlashMode.AUTO,
+ enabled = true,
onClick = { setFlashMode(FlashMode.AUTO) }
)
SingleChoiceSelector(
text = stringResource(id = R.string.flash_mode_selector_on),
- selected = currentFlashMode == FlashMode.ON,
+ selected = flashUiState.currentFlashMode == FlashMode.ON,
+ enabled = true,
onClick = { setFlashMode(FlashMode.ON) }
)
SingleChoiceSelector(
text = stringResource(id = R.string.flash_mode_selector_off),
- selected = currentFlashMode == FlashMode.OFF,
+ selected = flashUiState.currentFlashMode == FlashMode.OFF,
+ enabled = true,
onClick = { setFlashMode(FlashMode.OFF) }
)
}
@@ -201,7 +237,7 @@
@Composable
fun AspectRatioSetting(
- currentAspectRatio: AspectRatio,
+ aspectRatioUiState: AspectRatioUiState,
setAspectRatio: (AspectRatio) -> Unit,
modifier: Modifier = Modifier
) {
@@ -209,26 +245,38 @@
modifier = modifier,
title = stringResource(id = R.string.aspect_ratio_title),
leadingIcon = null,
- description = when (currentAspectRatio) {
- AspectRatio.NINE_SIXTEEN -> stringResource(id = R.string.aspect_ratio_description_9_16)
- AspectRatio.THREE_FOUR -> stringResource(id = R.string.aspect_ratio_description_3_4)
- AspectRatio.ONE_ONE -> stringResource(id = R.string.aspect_ratio_description_1_1)
+ description =
+ if (aspectRatioUiState is AspectRatioUiState.Enabled) {
+ when (aspectRatioUiState.currentAspectRatio) {
+ AspectRatio.NINE_SIXTEEN -> stringResource(
+ id = R.string.aspect_ratio_description_9_16
+ )
+
+ AspectRatio.THREE_FOUR -> stringResource(id = R.string.aspect_ratio_description_3_4)
+ AspectRatio.ONE_ONE -> stringResource(id = R.string.aspect_ratio_description_1_1)
+ }
+ } else {
+ TODO("aspect ratio currently has no disabled criteria")
},
+ enabled = true,
popupContents = {
Column(Modifier.selectableGroup()) {
SingleChoiceSelector(
text = stringResource(id = R.string.aspect_ratio_selector_9_16),
- selected = currentAspectRatio == AspectRatio.NINE_SIXTEEN,
+ selected = aspectRatioUiState.currentAspectRatio == AspectRatio.NINE_SIXTEEN,
+ enabled = true,
onClick = { setAspectRatio(AspectRatio.NINE_SIXTEEN) }
)
SingleChoiceSelector(
text = stringResource(id = R.string.aspect_ratio_selector_3_4),
- selected = currentAspectRatio == AspectRatio.THREE_FOUR,
+ selected = aspectRatioUiState.currentAspectRatio == AspectRatio.THREE_FOUR,
+ enabled = true,
onClick = { setAspectRatio(AspectRatio.THREE_FOUR) }
)
SingleChoiceSelector(
text = stringResource(id = R.string.aspect_ratio_selector_1_1),
- selected = currentAspectRatio == AspectRatio.ONE_ONE,
+ selected = aspectRatioUiState.currentAspectRatio == AspectRatio.ONE_ONE,
+ enabled = true,
onClick = { setAspectRatio(AspectRatio.ONE_ONE) }
)
}
@@ -238,7 +286,7 @@
@Composable
fun CaptureModeSetting(
- currentCaptureMode: CaptureMode,
+ captureModeUiState: CaptureModeUiState,
setCaptureMode: (CaptureMode) -> Unit,
modifier: Modifier = Modifier
) {
@@ -246,25 +294,33 @@
modifier = modifier,
title = stringResource(R.string.capture_mode_title),
leadingIcon = null,
- description = when (currentCaptureMode) {
- CaptureMode.MULTI_STREAM -> stringResource(
- id = R.string.capture_mode_description_multi_stream
- )
+ enabled = true,
+ description =
+ if (captureModeUiState is CaptureModeUiState.Enabled) {
+ when (captureModeUiState.currentCaptureMode) {
+ CaptureMode.MULTI_STREAM -> stringResource(
+ id = R.string.capture_mode_description_multi_stream
+ )
- CaptureMode.SINGLE_STREAM -> stringResource(
- id = R.string.capture_mode_description_single_stream
- )
+ CaptureMode.SINGLE_STREAM -> stringResource(
+ id = R.string.capture_mode_description_single_stream
+ )
+ }
+ } else {
+ TODO("capture mode currently has no disabled criteria")
},
popupContents = {
Column(Modifier.selectableGroup()) {
SingleChoiceSelector(
text = stringResource(id = R.string.capture_mode_selector_multi_stream),
- selected = currentCaptureMode == CaptureMode.MULTI_STREAM,
+ selected = captureModeUiState.currentCaptureMode == CaptureMode.MULTI_STREAM,
+ enabled = true,
onClick = { setCaptureMode(CaptureMode.MULTI_STREAM) }
)
SingleChoiceSelector(
text = stringResource(id = R.string.capture_mode_description_single_stream),
- selected = currentCaptureMode == CaptureMode.SINGLE_STREAM,
+ selected = captureModeUiState.currentCaptureMode == CaptureMode.SINGLE_STREAM,
+ enabled = true,
onClick = { setCaptureMode(CaptureMode.SINGLE_STREAM) }
)
}
@@ -274,20 +330,21 @@
@Composable
fun TargetFpsSetting(
- currentTargetFps: Int,
- supportedFps: Set<Int>,
+ fpsUiState: FpsUiState,
setTargetFps: (Int) -> Unit,
modifier: Modifier = Modifier
) {
BasicPopupSetting(
- modifier = modifier,
+ modifier = modifier.apply {
+ if (fpsUiState is FpsUiState.Disabled) {
+ testTag(fpsUiState.disabledRationale.testTag)
+ }
+ },
title = stringResource(id = R.string.fps_title),
- enabled = supportedFps.isNotEmpty(),
+ enabled = fpsUiState is FpsUiState.Enabled,
leadingIcon = null,
- description = if (supportedFps.isEmpty()) {
- stringResource(id = R.string.fps_description_unavailable)
- } else {
- when (currentTargetFps) {
+ description = if (fpsUiState is FpsUiState.Enabled) {
+ when (fpsUiState.currentSelection) {
FPS_15 -> stringResource(id = R.string.fps_description, FPS_15)
FPS_30 -> stringResource(id = R.string.fps_description, FPS_30)
FPS_60 -> stringResource(id = R.string.fps_description, FPS_60)
@@ -295,27 +352,46 @@
id = R.string.fps_description_auto
)
}
+ } else {
+ disabledRationaleString((fpsUiState as FpsUiState.Disabled).disabledRationale)
},
popupContents = {
- Column(Modifier.selectableGroup()) {
- Text(
- text = stringResource(id = R.string.fps_stabilization_disclaimer),
- fontStyle = FontStyle.Italic,
- color = MaterialTheme.colorScheme.onPrimaryContainer
- )
-
- SingleChoiceSelector(
- text = stringResource(id = R.string.fps_selector_auto),
- selected = currentTargetFps == FPS_AUTO,
- onClick = { setTargetFps(FPS_AUTO) }
- )
- listOf(FPS_15, FPS_30, FPS_60).forEach { fpsOption ->
- SingleChoiceSelector(
- text = "%d".format(fpsOption),
- selected = currentTargetFps == fpsOption,
- onClick = { setTargetFps(fpsOption) },
- enabled = supportedFps.contains(fpsOption)
+ if (fpsUiState is FpsUiState.Enabled) {
+ Column(Modifier.selectableGroup()) {
+ Text(
+ text = stringResource(id = R.string.fps_stabilization_disclaimer),
+ fontStyle = FontStyle.Italic,
+ color = MaterialTheme.colorScheme.onPrimaryContainer
)
+
+ SingleChoiceSelector(
+ text = stringResource(id = R.string.fps_selector_auto),
+ selected = fpsUiState.currentSelection == FPS_AUTO,
+ onClick = { setTargetFps(FPS_AUTO) },
+ enabled = fpsUiState.fpsAutoState is SingleSelectableState.Selectable
+ )
+ listOf(FPS_15, FPS_30, FPS_60).forEach { fpsOption ->
+ SingleChoiceSelector(
+ text = "%d".format(fpsOption),
+ selected = fpsUiState.currentSelection == fpsOption,
+ onClick = { setTargetFps(fpsOption) },
+ enabled = when (fpsOption) {
+ FPS_15 ->
+ fpsUiState.fpsFifteenState is
+ SingleSelectableState.Selectable
+
+ FPS_30 ->
+ fpsUiState.fpsThirtyState is
+ SingleSelectableState.Selectable
+
+ FPS_60 ->
+ fpsUiState.fpsSixtyState is
+ SingleSelectableState.Selectable
+
+ else -> false
+ }
+ )
+ }
}
}
}
@@ -352,49 +428,44 @@
* HIGH_QUALITY - Video will be stabilized, preview might be stabilized, depending on the device.
* OFF - Preview and video stabilization is disabled.
*
- * @param supportedStabilizationMode the enabled condition for this setting.
+ * @param stabilizationUiState the state for this setting.
*/
@Composable
fun StabilizationSetting(
- currentPreviewStabilization: Stabilization,
- currentVideoStabilization: Stabilization,
- currentTargetFps: Int,
- supportedStabilizationMode: Set<SupportedStabilizationMode>,
+ stabilizationUiState: StabilizationUiState,
setVideoStabilization: (Stabilization) -> Unit,
setPreviewStabilization: (Stabilization) -> Unit,
modifier: Modifier = Modifier
) {
- // if the preview stabilization was left ON and the target frame rate was set to 15,
- // this setting needs to be reset to OFF
- LaunchedEffect(key1 = currentTargetFps, key2 = currentPreviewStabilization) {
- if (currentTargetFps == FPS_15 &&
- currentPreviewStabilization == Stabilization.ON
- ) {
- setPreviewStabilization(Stabilization.UNDEFINED)
- }
- }
// entire setting disabled when no available fps or target fps = 60
// stabilization is unsupported >30 fps
BasicPopupSetting(
- modifier = modifier,
+ modifier = modifier.apply {
+ when (stabilizationUiState) {
+ is StabilizationUiState.Disabled ->
+ testTag(stabilizationUiState.disabledRationale.testTag)
+
+ else -> {}
+ }
+ },
title = stringResource(R.string.video_stabilization_title),
leadingIcon = null,
- enabled = (
- supportedStabilizationMode.isNotEmpty() &&
- currentTargetFps != FPS_60
- ),
- description = if (supportedStabilizationMode.isEmpty()) {
- stringResource(id = R.string.stabilization_description_unsupported_device)
- } else if (currentTargetFps == FPS_60) {
- stringResource(id = R.string.stabilization_description_unsupported_fps)
- } else {
- stringResource(
- id = getStabilizationStringRes(
- previewStabilization = currentPreviewStabilization,
- videoStabilization = currentVideoStabilization
+ enabled = stabilizationUiState is StabilizationUiState.Enabled,
+ description = when (stabilizationUiState) {
+ is StabilizationUiState.Enabled ->
+ stringResource(
+ id = getStabilizationStringRes(
+ previewStabilization = stabilizationUiState.currentPreviewStabilization,
+ videoStabilization = stabilizationUiState.currentVideoStabilization
+ )
)
- )
+
+ is StabilizationUiState.Disabled -> {
+ // disabled setting description
+ disabledRationaleString(stabilizationUiState.disabledRationale)
+ }
},
+
popupContents = {
Column(Modifier.selectableGroup()) {
Text(
@@ -406,55 +477,96 @@
// on (preview) selector
// disabled if target fps != (30 or off)
// TODO(b/328223562): device always resolves to 30fps when using preview stabilization
- SingleChoiceSelector(
- text = stringResource(id = R.string.stabilization_selector_on),
- secondaryText = stringResource(id = R.string.stabilization_selector_on_info),
- enabled =
- (
- when (currentTargetFps) {
- FPS_AUTO, FPS_30 -> true
- else -> false
- }
- ) &&
- supportedStabilizationMode.contains(SupportedStabilizationMode.ON),
- selected = (currentPreviewStabilization == Stabilization.ON) &&
- (currentVideoStabilization != Stabilization.OFF),
- onClick = {
- setVideoStabilization(Stabilization.UNDEFINED)
- setPreviewStabilization(Stabilization.ON)
- }
- )
+ when (stabilizationUiState) {
+ is StabilizationUiState.Enabled -> {
+ SingleChoiceSelector(
+ modifier = Modifier.apply {
+ if (stabilizationUiState.stabilizationOnState
+ is SingleSelectableState.Disabled
+ ) {
+ testTag(
+ stabilizationUiState.stabilizationOnState
+ .disabledRationale.testTag
+ )
+ }
+ },
+ text = stringResource(id = R.string.stabilization_selector_on),
+ secondaryText = stringResource(
+ id = R.string.stabilization_selector_on_info
+ ),
+ enabled = stabilizationUiState.stabilizationOnState is
+ SingleSelectableState.Selectable,
+ selected = (
+ stabilizationUiState.currentPreviewStabilization
+ == Stabilization.ON
+ ) &&
+ (
+ stabilizationUiState.currentVideoStabilization
+ != Stabilization.OFF
+ ),
+ onClick = {
+ setVideoStabilization(Stabilization.UNDEFINED)
+ setPreviewStabilization(Stabilization.ON)
+ }
+ )
- // high quality selector
- // disabled if target fps = 60 (see VideoCapabilities.isStabilizationSupported)
- SingleChoiceSelector(
- text = stringResource(id = R.string.stabilization_selector_high_quality),
- secondaryText = stringResource(
- id = R.string.stabilization_selector_high_quality_info
- ),
- enabled = (currentTargetFps != FPS_60) &&
- supportedStabilizationMode.contains(
- SupportedStabilizationMode.HIGH_QUALITY
- ),
+ // high quality selector
+ // disabled if target fps = 60 (see VideoCapabilities.isStabilizationSupported)
+ SingleChoiceSelector(
+ modifier = Modifier.apply {
+ if (stabilizationUiState.stabilizationHighQualityState
+ is SingleSelectableState.Disabled
+ ) {
+ testTag(
+ stabilizationUiState.stabilizationHighQualityState
+ .disabledRationale.testTag
+ )
+ }
+ },
+ text = stringResource(
+ id = R.string.stabilization_selector_high_quality
+ ),
+ secondaryText = stringResource(
+ id = R.string.stabilization_selector_high_quality_info
+ ),
+ enabled = stabilizationUiState.stabilizationHighQualityState
+ == SingleSelectableState.Selectable,
- selected = (currentPreviewStabilization == Stabilization.UNDEFINED) &&
- (currentVideoStabilization == Stabilization.ON),
- onClick = {
- setVideoStabilization(Stabilization.ON)
- setPreviewStabilization(Stabilization.UNDEFINED)
- }
- )
+ selected = (
+ stabilizationUiState.currentPreviewStabilization
+ == Stabilization.UNDEFINED
+ ) &&
+ (
+ stabilizationUiState.currentVideoStabilization
+ == Stabilization.ON
+ ),
+ onClick = {
+ setVideoStabilization(Stabilization.ON)
+ setPreviewStabilization(Stabilization.UNDEFINED)
+ }
+ )
- // off selector
- SingleChoiceSelector(
- text = stringResource(id = R.string.stabilization_selector_off),
- selected = (currentPreviewStabilization != Stabilization.ON) &&
- (currentVideoStabilization != Stabilization.ON),
- onClick = {
- setVideoStabilization(Stabilization.OFF)
- setPreviewStabilization(Stabilization.OFF)
+ // off selector
+ SingleChoiceSelector(
+ text = stringResource(id = R.string.stabilization_selector_off),
+ selected = (
+ stabilizationUiState.currentPreviewStabilization
+ != Stabilization.ON
+ ) &&
+ (
+ stabilizationUiState.currentVideoStabilization
+ != Stabilization.ON
+ ),
+ onClick = {
+ setVideoStabilization(Stabilization.OFF)
+ setPreviewStabilization(Stabilization.OFF)
+ },
+ enabled = true
+ )
}
- )
+
+ else -> {}
+ }
}
}
)
@@ -465,7 +577,8 @@
SettingUI(
modifier = modifier,
title = stringResource(id = R.string.version_info_title),
- leadingIcon = null
+ leadingIcon = null,
+ enabled = true
) {
val versionString = versionName +
if (buildType.isNotEmpty()) {
@@ -492,7 +605,7 @@
leadingIcon: @Composable (() -> Unit)?,
popupContents: @Composable () -> Unit,
modifier: Modifier = Modifier,
- enabled: Boolean = true
+ enabled: Boolean
) {
val popupStatus = remember { mutableStateOf(false) }
SettingUI(
@@ -565,25 +678,25 @@
title: String,
leadingIcon: @Composable (() -> Unit)?,
modifier: Modifier = Modifier,
- enabled: Boolean = true,
+ enabled: Boolean,
description: String? = null,
trailingContent: @Composable (() -> Unit)?
) {
ListItem(
modifier = modifier,
headlineContent = {
- when (enabled) {
- true -> Text(title)
- false -> {
- Text(text = title, color = LocalContentColor.current.copy(alpha = .7f))
- }
+ if (enabled) {
+ Text(title)
+ } else {
+ Text(text = title, color = LocalContentColor.current.copy(alpha = .7f))
}
},
supportingContent = {
if (description != null) {
- when (enabled) {
- true -> Text(description)
- false -> Text(
+ if (enabled) {
+ Text(description)
+ } else {
+ Text(
text = description,
color = LocalContentColor.current.copy(alpha = .7f)
)
@@ -605,7 +718,7 @@
onClick: () -> Unit,
modifier: Modifier = Modifier,
secondaryText: String? = null,
- enabled: Boolean = true
+ enabled: Boolean
) {
Row(
modifier
@@ -634,6 +747,34 @@
}
}
+@Composable
+@ReadOnlyComposable
+fun disabledRationaleString(disabledRationale: DisabledRationale): String {
+ return when (disabledRationale) {
+ is DisabledRationale.DeviceUnsupportedRationale -> stringResource(
+
+ disabledRationale.reasonTextResId,
+ stringResource(disabledRationale.affectedSettingNameResId)
+ )
+
+ is DisabledRationale.FpsUnsupportedRationale -> stringResource(
+ disabledRationale.reasonTextResId,
+ stringResource(disabledRationale.affectedSettingNameResId),
+ disabledRationale.currentFps
+ )
+
+ is DisabledRationale.LensUnsupportedRationale -> stringResource(
+ disabledRationale.reasonTextResId,
+ stringResource(disabledRationale.affectedSettingNameResId)
+ )
+
+ is DisabledRationale.StabilizationUnsupportedRationale -> stringResource(
+ disabledRationale.reasonTextResId,
+ stringResource(disabledRationale.affectedSettingNameResId)
+ )
+ }
+}
+
@Preview(name = "Light Mode")
@Preview(name = "Dark Mode", uiMode = Configuration.UI_MODE_NIGHT_YES)
@Composable
diff --git a/feature/settings/src/main/java/com/google/jetpackcamera/settings/ui/TestTags.kt b/feature/settings/src/main/java/com/google/jetpackcamera/settings/ui/TestTags.kt
index ef11b24..8253fc1 100644
--- a/feature/settings/src/main/java/com/google/jetpackcamera/settings/ui/TestTags.kt
+++ b/feature/settings/src/main/java/com/google/jetpackcamera/settings/ui/TestTags.kt
@@ -16,3 +16,9 @@
package com.google.jetpackcamera.settings.ui
const val BACK_BUTTON = "BackButton"
+
+// unsupported rationale tags
+const val DEVICE_UNSUPPORTED_TAG = "DeviceUnsupportedTag"
+const val STABILIZATION_UNSUPPORTED_TAG = "StabilizationUnsupportedTag"
+const val LENS_UNSUPPORTED_TAG = "LensUnsupportedTag"
+const val FPS_UNSUPPORTED_TAG = "FpsUnsupportedTag"
diff --git a/feature/settings/src/main/res/values/strings.xml b/feature/settings/src/main/res/values/strings.xml
index ad8aff6..e41f4fd 100644
--- a/feature/settings/src/main/res/values/strings.xml
+++ b/feature/settings/src/main/res/values/strings.xml
@@ -101,6 +101,24 @@
<string name="fps_stabilization_disclaimer">*Available stabilization modes may change due to selected frame rate.</string>
<string name="lens_stabilization_disclaimer">*Some devices may not support stabilization on both lens.</string>
+ <!-- disabled rationale strings-->
+ <string name="device_unsupported">%1$s is unsupported by the device</string>
+ <string name="fps_unsupported"> %1$s is unsupported at %2$d fps</string>
+ <string name="stabilization_unsupported">%$1s is unsupported by the current stabilization</string>
+ <string name="current_lens_unsupported">%$s is unsupported by the current lens</string>
+ <string name="rear_lens_unsupported">%$s is unsupported by the rear lens</string>
+ <string name="front_lens_unsupported">%$s is unsupported by the front lens</string>
+
+
+ <!-- Rationale prefixes -->
+ <string name="stabilization_rationale_prefix">Stabilization</string>
+ <string name="lens_rationale_prefix">Lens flip</string>
+ <string name="fps_rationale_prefix">Fps</string>
+
+ <string name="front_lens_rationale_prefix">Front lens</string>
+ <string name="rear_lens_rationale_prefix">Rear lens</string>
+ <string name="no_fixed_fps_rationale_prefix">Fixed frame rate</string>
+
<!-- Version info strings -->
<string name="version_info_title">Version</string>
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 930f838..36ea132 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -47,6 +47,7 @@
protobuf = "3.25.2"
robolectric = "4.11.1"
truth = "1.4.2"
+rules = "1.6.1"
[libraries]
accompanist-permissions = { module = "com.google.accompanist:accompanist-permissions", version.ref = "accompanist" }
@@ -59,6 +60,7 @@
androidx-espresso-core = { module = "androidx.test.espresso:espresso-core", version.ref = "androidxTestEspresso" }
androidx-graphics-core = { module = "androidx.graphics:graphics-core", version.ref = "androidxGraphicsCore" }
androidx-junit = { module = "androidx.test.ext:junit", version.ref = "androidxTestJunit" }
+androidx-lifecycle-livedata = { module = "androidx.lifecycle:lifecycle-livedata-ktx", version.ref = "androidxLifecycle" }
androidx-lifecycle-viewmodel-compose = { module = "androidx.lifecycle:lifecycle-viewmodel-compose", version.ref = "androidxLifecycle" }
androidx-lifecycle-runtime-compose = { module = "androidx.lifecycle:lifecycle-runtime-compose", version.ref = "androidxLifecycle" }
androidx-navigation-compose = { module = "androidx.navigation:navigation-compose", version.ref = "androidxNavigationCompose" }
@@ -84,6 +86,7 @@
futures-ktx = { module = "androidx.concurrent:concurrent-futures-ktx", version.ref = "androidxConcurrentFutures" }
hilt-navigation-compose = { module = "androidx.hilt:hilt-navigation-compose", version.ref = "androidxHiltNavigationCompose" }
junit = { module = "junit:junit", version.ref = "junit" }
+kotlin-reflect = { module = "org.jetbrains.kotlin:kotlin-reflect", version.ref = "kotlinPlugin" }
kotlinx-atomicfu = { module = "org.jetbrains.kotlinx:atomicfu", version.ref = "kotlinxAtomicfu" }
kotlinx-coroutines-core = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "kotlinxCoroutines" }
kotlinx-coroutines-test = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-test", version.ref = "kotlinxCoroutines" }
@@ -92,6 +95,7 @@
protobuf-kotlin-lite = { module = "com.google.protobuf:protobuf-kotlin-lite", version.ref = "protobuf" }
robolectric = { module = "org.robolectric:robolectric", version.ref = "robolectric" }
truth = { module = "com.google.truth:truth", version.ref = "truth" }
+rules = { group = "androidx.test", name = "rules", version.ref = "rules" }
[plugins]
android-application = { id = "com.android.application", version.ref = "androidGradlePlugin" }
diff --git a/settings.gradle.kts b/settings.gradle.kts
index b021ba1..7c7842f 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -26,7 +26,7 @@
repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
repositories {
maven {
- setUrl("https://androidx.dev/snapshots/builds/11932573/artifacts/repository")
+ setUrl("https://androidx.dev/snapshots/builds/12167802/artifacts/repository")
}
google()
mavenCentral()
