[pull] androidx-main from androidx:androidx-main

camera/camera-camera2-pipe-integration/src/androidTest/java/androidx/camera/camera2/pipe/integration/testing/TestUseCaseCamera.kt

@@ -103,33 +103,24 @@ class TestUseCaseCamera(
             )
 
         val cameraStateAdapter = CameraStateAdapter()
-        val graphStateToCameraStateAdapter = GraphStateToCameraStateAdapter(cameraStateAdapter)
         val useCaseCameraConfig =
             UseCaseCameraConfig.create(
-                useCases = useCases,
                 cameraGraphConfigProvider = configProvider,
                 cameraGraphFactory = { config -> cameraPipe.createCameraGraph(config) },
-                graphStateToCameraStateAdapter = graphStateToCameraStateAdapter,
+                graphStateToCameraStateAdapter = GraphStateToCameraStateAdapter(cameraStateAdapter),
                 sessionConfigAdapter = sessionConfigAdapter,
                 isExtensions = false,
                 sessionProcessor = null,
             )
-        useCaseGraphContext =
-            UseCaseGraphContext(
-                cameraGraphProvider = { useCaseCameraConfig.provideCameraGraph() },
-                cameraStateAdapter = cameraStateAdapter,
-                streamConfigMapProvider = { useCaseCameraConfig.provideStreamConfigMap() },
-                graphStateToCameraStateAdapter = graphStateToCameraStateAdapter,
-            )
-
+        useCaseGraphContext = useCaseCameraConfig.provideUseCaseGraphContext(cameraStateAdapter)
         sessionConfigAdapter.getValidSessionConfigOrNull()?.let { sessionConfig ->
             CameraInteropStateCallbackRepository().updateCallbacks(sessionConfig)
         }
     }
 
     override val requestControl: UseCaseCameraRequestControl =
         UseCaseCameraRequestControlImpl(
-                capturePipeline =
+                capturePipelineProvider = {
                     object : CapturePipeline {
                         override var template: Int = CameraDevice.TEMPLATE_PREVIEW
 
@@ -149,14 +140,16 @@ class TestUseCaseCamera(
                             flashMode: Int,
                             flashType: Int,
                         ): CameraCapturePipeline = FakeCameraCapturePipeline()
-                    },
-                state =
+                    }
+                },
+                useCaseCameraStateProvider = {
                     UseCaseCameraState(
                         useCaseGraphContext,
                         templateParamsOverride = NoOpTemplateParamsOverride,
-                    ),
+                    )
+                },
                 useCaseGraphContext = useCaseGraphContext,
-                useCaseSurfaceManager = useCaseSurfaceManager,
+                useCaseSurfaceManagerProvider = { useCaseSurfaceManager },
                 threads = threads,
             )
             .apply {

camera/camera-camera2-pipe-integration/src/main/java/androidx/camera/camera2/pipe/integration/compat/workaround/CapturePipelineTorchCorrection.kt

@@ -36,6 +36,7 @@ import androidx.camera.core.imagecapture.CameraCapturePipeline
 import androidx.camera.core.impl.CaptureConfig
 import androidx.camera.core.impl.Config
 import javax.inject.Inject
+import javax.inject.Provider
 import kotlinx.coroutines.Deferred
 import kotlinx.coroutines.joinAll
 import kotlinx.coroutines.launch
@@ -52,11 +53,12 @@ public class CapturePipelineTorchCorrection
 @Inject
 constructor(
     cameraProperties: CameraProperties,
-    private val capturePipelineImpl: CapturePipelineImpl,
+    private val capturePipelineImplProvider: Provider<CapturePipelineImpl>,
     private val threads: UseCaseThreads,
     private val torchControl: TorchControl,
 ) : CapturePipeline {
-    private val isLegacyDevice = cameraProperties.metadata.isHardwareLevelLegacy
+    private val isLegacyDevice by lazy { cameraProperties.metadata.isHardwareLevelLegacy }
+    private val capturePipelineImpl by lazy { capturePipelineImplProvider.get() }
 
     override suspend fun submitStillCaptures(
         configs: List<CaptureConfig>,

camera/camera-camera2-pipe-integration/src/main/java/androidx/camera/camera2/pipe/integration/config/UseCaseCameraConfig.kt

@@ -55,50 +55,30 @@ public abstract class UseCaseCameraModule {
         @UseCaseCameraScope
         @Provides
         public fun provideCapturePipeline(
-            capturePipelineImpl: CapturePipelineImpl,
-            capturePipelineTorchCorrection: CapturePipelineTorchCorrection,
+            capturePipelineImplProvider: Provider<CapturePipelineImpl>,
+            capturePipelineTorchCorrectionProvider: Provider<CapturePipelineTorchCorrection>,
         ): CapturePipeline {
             if (CapturePipelineTorchCorrection.isEnabled) {
-                return capturePipelineTorchCorrection
+                return capturePipelineTorchCorrectionProvider.get()
             }
 
-            return capturePipelineImpl
+            return capturePipelineImplProvider.get()
         }
     }
 }
 
 /** Dagger module for binding the [UseCase]'s to the [UseCaseCamera]. */
 @Module
 public data class UseCaseCameraConfig(
-    private val useCases: List<UseCase>,
     private val cameraGraphFactory: (CameraGraph.Config) -> CameraGraph,
     private val graphStateToCameraStateAdapter: GraphStateToCameraStateAdapter,
     private val sessionConfigAdapter: SessionConfigAdapter,
-    private val isExtensions: Boolean,
     private val sessionProcessor: SessionProcessor?,
     private val lazyCreationResult: Lazy<CameraGraphConfigProvider.CameraGraphCreationResult>,
 ) {
     public val cameraGraphConfig: CameraGraph.Config
         get() = lazyCreationResult.value.config
 
-    @UseCaseCameraScope
-    @Provides
-    public fun provideCameraGraph(): CameraGraph {
-        return cameraGraphFactory(cameraGraphConfig)
-    }
-
-    @UseCaseCameraScope
-    @Provides
-    public fun provideStreamConfigMap(): Map<CameraStream.Config, DeferrableSurface> {
-        return lazyCreationResult.value.streamConfigMap
-    }
-
-    @UseCaseCameraScope
-    @Provides
-    public fun provideUseCaseList(): java.util.ArrayList<UseCase> {
-        return java.util.ArrayList(useCases)
-    }
-
     @UseCaseCameraScope
     @Provides
     public fun provideSessionConfigAdapter(): SessionConfigAdapter {
@@ -118,15 +98,13 @@ public data class UseCaseCameraConfig(
     @UseCaseCameraScope
     @Provides
     public fun provideUseCaseGraphContext(
-        cameraStateAdapter: CameraStateAdapter,
-        streamConfigMapProvider: Provider<Map<CameraStream.Config, DeferrableSurface>>,
-        cameraGraphProvider: Provider<CameraGraph>,
+        cameraStateAdapter: CameraStateAdapter
     ): UseCaseGraphContext {
         Camera2Logger.debug { "Prepared UseCaseGraphContext (Deferred)" }
         return UseCaseGraphContext(
-            cameraGraphProvider = cameraGraphProvider,
+            cameraGraphProvider = { cameraGraphFactory(cameraGraphConfig) },
             cameraStateAdapter = cameraStateAdapter,
-            streamConfigMapProvider = streamConfigMapProvider,
+            streamConfigMapProvider = { lazyCreationResult.value.streamConfigMap },
             graphStateToCameraStateAdapter = graphStateToCameraStateAdapter,
         )
     }
@@ -144,10 +122,8 @@ public data class UseCaseCameraConfig(
 
         other as UseCaseCameraConfig
 
-        if (useCases != other.useCases) return false
         if (sessionConfigAdapter != other.sessionConfigAdapter) return false
         if (graphStateToCameraStateAdapter != other.graphStateToCameraStateAdapter) return false
-        if (isExtensions != other.isExtensions) return false
         if (sessionProcessor != other.sessionProcessor) return false
 
         // Intentionally exclude:
@@ -157,18 +133,15 @@ public data class UseCaseCameraConfig(
     }
 
     override fun hashCode(): Int {
-        var result = useCases.hashCode()
-        result = 31 * result + sessionConfigAdapter.hashCode()
+        var result = sessionConfigAdapter.hashCode()
         result = 31 * result + graphStateToCameraStateAdapter.hashCode()
-        result = 31 * result + isExtensions.hashCode()
         result = 31 * result + (sessionProcessor?.hashCode() ?: 0)
         // Intentionally exclude lazyCreationResult and cameraGraphFactory from hash
         return result
     }
 
     public companion object {
         public fun create(
-            useCases: List<UseCase>,
             sessionConfigAdapter: SessionConfigAdapter,
             cameraGraphConfigProvider: CameraGraphConfigProvider,
             cameraGraphFactory: (CameraGraph.Config) -> CameraGraph,
@@ -212,12 +185,10 @@ public data class UseCaseCameraConfig(
             }
 
             return UseCaseCameraConfig(
-                useCases = useCases,
                 sessionConfigAdapter = sessionConfigAdapter,
                 graphStateToCameraStateAdapter = graphStateToCameraStateAdapter,
                 cameraGraphFactory = cameraGraphFactory,
                 sessionProcessor = sessionProcessor,
-                isExtensions = isExtensions,
                 lazyCreationResult = lazyResult,
             )
         }

camera/camera-camera2-pipe-integration/src/main/java/androidx/camera/camera2/pipe/integration/impl/CapturePipeline.kt

@@ -86,6 +86,7 @@ import androidx.camera.core.impl.ConvergenceUtils
 import com.google.common.util.concurrent.ListenableFuture
 import java.util.concurrent.TimeUnit
 import javax.inject.Inject
+import javax.inject.Provider
 import kotlin.reflect.KClass
 import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.CompletableDeferred
@@ -133,7 +134,7 @@ constructor(
     private val requestListener: ComboRequestListener,
     private val useTorchAsFlash: UseTorchAsFlash,
     cameraProperties: CameraProperties,
-    private val useCaseCameraState: UseCaseCameraState,
+    private val useCaseCameraStateProvider: Provider<UseCaseCameraState>,
     private val useCaseGraphContext: UseCaseGraphContext,
 ) : CapturePipeline {
     private enum class PipelineTask {
@@ -149,7 +150,9 @@ constructor(
     )
 
     // If there is no flash unit, skip the flash related task instead of failing the pipeline.
-    private val hasFlashUnit = cameraProperties.isFlashAvailable()
+    private val hasFlashUnit by lazy { cameraProperties.isFlashAvailable() }
+
+    private val useCaseCameraState by lazy { useCaseCameraStateProvider.get() }
 
     override var template: Int = CameraDevice.TEMPLATE_PREVIEW