Aperture: Configure camera after we have camera permissions

Won't hurt, especially on older SDK versions

Change-Id: I6029039a32579d08e5c4cf8a534c732f96938b70

Author: SebaUbuntu

app/src/main/java/org/lineageos/aperture/CameraActivity.kt

@@ -405,25 +405,6 @@ open class CameraActivity : AppCompatActivity(R.layout.activity_camera) {
             }
         }
 
-        if (viewModel.initialCameraMode == CameraMode.VIDEO && !viewModel.isVideoRecordingAvailable.value) {
-            // If an app asked for a video we have to bail out
-            if (viewModel.inSingleCaptureMode.value) {
-                Toast.makeText(
-                    this, getString(R.string.camcorder_unsupported_toast), Toast.LENGTH_LONG
-                ).show()
-                finish()
-                return
-            }
-            // Fallback to photo mode
-            viewModel.initialCameraMode = CameraMode.PHOTO
-        }
-
-        // Initialize the camera configuration
-        if (!viewModel.initializeCameraConfiguration()) {
-            noCamera()
-            return
-        }
-
         // Setup window insets
         ViewCompat.setOnApplyWindowInsetsListener(mainLayout) { _, windowInsets ->
             val insets = windowInsets.getInsets(WindowInsetsCompat.Type.systemBars())
@@ -1407,6 +1388,26 @@ open class CameraActivity : AppCompatActivity(R.layout.activity_camera) {
                 screenFlashView.setController(viewModel.cameraController)
                 screenFlashView.setScreenFlashWindow(window)
 
+                val videoRecordingAvailable = viewModel.isVideoRecordingAvailable()
+                if (viewModel.initialCameraMode == CameraMode.VIDEO && !videoRecordingAvailable) {
+                    // If an app asked for a video we have to bail out
+                    if (viewModel.inSingleCaptureMode.value) {
+                        Toast.makeText(
+                            this@CameraActivity,
+                            R.string.camcorder_unsupported_toast,
+                            Toast.LENGTH_LONG,
+                        ).show()
+                        finish()
+                        return@collect
+                    }
+                    // Fallback to photo mode
+                    viewModel.initialCameraMode = CameraMode.PHOTO
+                }
+
+                if (!viewModel.initializeCameraConfiguration()) {
+                    noCamera()
+                }
+
                 initialized = true
             }
         }

app/src/main/java/org/lineageos/aperture/repositories/CameraRepository.kt

@@ -5,6 +5,7 @@
 
 package org.lineageos.aperture.repositories
 
+import android.Manifest
 import android.content.Context
 import androidx.camera.camera2.interop.Camera2CameraInfo
 import androidx.camera.camera2.interop.ExperimentalCamera2Interop
@@ -17,79 +18,87 @@ import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.flow.SharingStarted
-import kotlinx.coroutines.flow.flowOf
+import kotlinx.coroutines.flow.asFlow
 import kotlinx.coroutines.flow.flowOn
 import kotlinx.coroutines.flow.mapLatest
-import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.flow.shareIn
+import org.lineageos.aperture.ext.permissionGranted
 import org.lineageos.aperture.models.Camera
 
 /**
  * Repository that provides camera devices.
  */
 @androidx.annotation.OptIn(ExperimentalCamera2Interop::class, ExperimentalLensFacing::class)
 class CameraRepository(
-    context: Context,
+    private val context: Context,
     coroutineScope: CoroutineScope,
     private val overlaysRepository: OverlaysRepository,
 ) {
     /**
      * CameraX's [ProcessCameraProvider].
      */
-    private val cameraProvider = ProcessCameraProvider.getInstance(
-        context
-    ).get()
+    private val cameraProvider by lazy {
+        requireCameraPermission()
+        ProcessCameraProvider.getInstance(context).get()
+    }
 
     /**
      * CameraX's [ExtensionsManager].
      */
-    val extensionsManager: ExtensionsManager = ExtensionsManager.getInstanceAsync(
-        context, cameraProvider
-    ).get()
+    private val extensionsManager: ExtensionsManager by lazy {
+        ExtensionsManager.getInstanceAsync(context, cameraProvider).get()
+    }
 
     /**
      * List of internal cameras. These should never change.
      */
-    val internalCameras = cameraProvider.availableCameraInfos
-        .filter { cameraXCameraInfo ->
-            cameraXCameraInfo.lensFacing != CameraSelector.LENS_FACING_EXTERNAL
-                    && cameraXCameraInfo.isInternalCameraAllowed()
-        }
-        .mapToCamera()
+    private val internalCameras by lazy {
+        cameraProvider.availableCameraInfos
+            .filter { cameraXCameraInfo ->
+                cameraXCameraInfo.lensFacing != CameraSelector.LENS_FACING_EXTERNAL
+                        && cameraXCameraInfo.isInternalCameraAllowed()
+            }
+            .mapToCamera()
+    }
 
-    val mainBackCamera = internalCameras.firstOrNull { camera ->
-        camera.cameraId == DEFAULT_BACK_CAMERA_ID
+    val mainBackCamera by lazy {
+        internalCameras.firstOrNull { camera ->
+            camera.cameraId == DEFAULT_BACK_CAMERA_ID
+        }
     }
 
-    val mainFrontCamera = internalCameras.firstOrNull { camera ->
-        camera.cameraId == DEFAULT_FRONT_CAMERA_ID
+    val mainFrontCamera by lazy {
+        internalCameras.firstOrNull { camera ->
+            camera.cameraId == DEFAULT_FRONT_CAMERA_ID
+        }
     }
 
     /**
      * List of external cameras. These will change once the user connects or disconnects a camera.
      */
-    val externalCameras = flowOf(
+    private val externalCameras = suspend {
         cameraProvider.availableCameraInfos
             .filter { cameraXCameraInfo ->
                 cameraXCameraInfo.lensFacing == CameraSelector.LENS_FACING_EXTERNAL
             }
             .mapToCamera()
-    )
+    }.asFlow()
         .flowOn(Dispatchers.IO)
-        .stateIn(
+        .shareIn(
             scope = coroutineScope,
-            started = SharingStarted.Eagerly,
-            initialValue = listOf(),
+            started = SharingStarted.WhileSubscribed(),
+            replay = 1,
         )
 
     @OptIn(ExperimentalCoroutinesApi::class)
     val cameras = externalCameras.mapLatest { externalCameras ->
         internalCameras + externalCameras
     }
         .flowOn(Dispatchers.IO)
-        .stateIn(
+        .shareIn(
             scope = coroutineScope,
-            started = SharingStarted.Eagerly,
-            initialValue = internalCameras,
+            started = SharingStarted.WhileSubscribed(),
+            replay = 1,
         )
 
     /**
@@ -140,6 +149,10 @@ class CameraRepository(
         overlaysRepository,
     )
 
+    private fun requireCameraPermission() = require(
+        context.permissionGranted(Manifest.permission.CAMERA)
+    ) { "Camera permission not granted" }
+
     companion object {
         private const val DEFAULT_BACK_CAMERA_ID = "0"
         private const val DEFAULT_FRONT_CAMERA_ID = "1"

app/src/main/java/org/lineageos/aperture/viewmodels/CameraViewModel.kt

@@ -47,6 +47,7 @@ import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.drop
 import kotlinx.coroutines.flow.filter
 import kotlinx.coroutines.flow.filterNotNull
+import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.flatMapLatest
 import kotlinx.coroutines.flow.flowOf
 import kotlinx.coroutines.flow.flowOn
@@ -165,18 +166,6 @@ class CameraViewModel(application: Application) : ApertureViewModel(application)
      */
     val event = _event.asSharedFlow()
 
-    @OptIn(ExperimentalCoroutinesApi::class)
-    val isVideoRecordingAvailable = cameraRepository.cameras
-        .mapLatest { cameras ->
-            cameras.any { it.supportsCameraMode(CameraMode.VIDEO) }
-        }
-        .flowOn(Dispatchers.IO)
-        .stateIn(
-            scope = viewModelScope,
-            started = SharingStarted.Eagerly,
-            initialValue = true,
-        )
-
     /**
      * The initial camera mode.
      */
@@ -250,7 +239,7 @@ class CameraViewModel(application: Application) : ApertureViewModel(application)
         .flowOn(Dispatchers.IO)
         .stateIn(
             scope = viewModelScope,
-            started = SharingStarted.Eagerly,
+            started = SharingStarted.WhileSubscribed(),
             initialValue = mapOf(),
         )
 
@@ -989,7 +978,7 @@ class CameraViewModel(application: Application) : ApertureViewModel(application)
      * Initialize [cameraConfiguration].
      * [initialCameraMode] and [initialCameraFacing] must be initialized.
      */
-    fun initializeCameraConfiguration(): Boolean {
+    suspend fun initializeCameraConfiguration(): Boolean {
         val cameraMode = initialCameraMode
         val cameraFacing = initialCameraFacing
 
@@ -1282,27 +1271,29 @@ class CameraViewModel(application: Application) : ApertureViewModel(application)
 
     fun setCameraMode(
         cameraMode: CameraMode,
-    ) = updateConfiguration<CameraConfiguration> { cameraConfiguration ->
-        if (cameraConfiguration.cameraMode == cameraMode) {
-            return@updateConfiguration cameraConfiguration
-        }
+    ) = viewModelScope.launch {
+        updateConfiguration<CameraConfiguration> { cameraConfiguration ->
+            if (cameraConfiguration.cameraMode == cameraMode) {
+                return@updateConfiguration cameraConfiguration
+            }
 
-        val camera = cameraConfiguration.camera.takeIf {
-            it.supportsCameraMode(cameraMode)
-        } ?: getSuitableCamera(
-            cameraMode,
-            cameraConfiguration.camera.cameraFacing,
-        ) ?: run {
-            Log.e(LOG_TAG, "No camera supports the requested camera mode $cameraMode")
-            return@updateConfiguration cameraConfiguration
-        }
+            val camera = cameraConfiguration.camera.takeIf {
+                it.supportsCameraMode(cameraMode)
+            } ?: getSuitableCamera(
+                cameraMode,
+                cameraConfiguration.camera.cameraFacing,
+            ) ?: run {
+                Log.e(LOG_TAG, "No camera supports the requested camera mode $cameraMode")
+                return@updateConfiguration cameraConfiguration
+            }
 
-        preferencesRepository.lastCameraMode.value = cameraMode
+            preferencesRepository.lastCameraMode.value = cameraMode
 
-        createInitialCameraConfiguration(
-            camera = camera,
-            cameraMode = cameraMode,
-        )
+            createInitialCameraConfiguration(
+                camera = camera,
+                cameraMode = cameraMode,
+            )
+        }
     }
 
     /**
@@ -1615,6 +1606,13 @@ class CameraViewModel(application: Application) : ApertureViewModel(application)
 
     fun fileExists(uri: Uri) = mediaRepository.fileExists(uri)
 
+    /**
+     * Get whether or not any camera currently supports video mode.
+     */
+    suspend fun isVideoRecordingAvailable() = cameraRepository.cameras.first().any {
+        it.supportsCameraMode(CameraMode.VIDEO)
+    }
+
     /**
      * Emit a new event to let the activity handle it.
      */
@@ -1629,11 +1627,11 @@ class CameraViewModel(application: Application) : ApertureViewModel(application)
      * @param cameraFacing The requested [CameraFacing]
      * @return A [Camera] that is compatible with the provided configuration or null
      */
-    private fun getSuitableCamera(
+    private suspend fun getSuitableCamera(
         cameraMode: CameraMode,
         cameraFacing: CameraFacing,
     ): Camera? {
-        val compatibleCameras = cameraRepository.cameras.value
+        val compatibleCameras = cameraRepository.cameras.first()
             .filter { camera ->
                 camera.supportsCameraMode(cameraMode)
             }