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

.github/workflows/ksp-snapshot-integration.yml

@@ -69,7 +69,7 @@ jobs:
           # Gradle flags match those used in presubmit.yml, plus:
           # * disabling validating integration patches as a patch file may already be applied
           # * disabling klibs cross compilation because it is not supported with cinterops
-          # * disabling non-Jvm tests to avoid memory exhaustion
+          # * setting max workers to 2 to avoid memory exhaustion
           gradle-flags: >
             --max-workers=2
             -Pkotlin.native.enableKlibsCrossCompilation=false
@@ -81,8 +81,5 @@ jobs:
             --stacktrace
             -x validateIntegrationPatches
             -x checkKotlinApiTarget
-            -x linuxX64Test
-            -x wasmJsBrowserTest
-            -x jsBrowserTest
           # Disable the cache since this is the only build using the latest KSP.
           gradle-cache-disabled: true

camera/camera-camera2-pipe/src/main/java/androidx/camera/camera2/pipe/FrameGraph.kt

@@ -59,7 +59,7 @@ public interface FrameGraph : CameraGraphBase<FrameGraph.Session>, CameraControl
     public fun captureWith(
         streamIds: Set<StreamId> = emptySet(),
         parameters: Map<Any, Any?> = emptyMap(),
-        capacity: Int = 1,
+        capacity: Int = DEFAULT_FRAME_BUFFER_CAPACITY,
     ): FrameBuffer
 
     /**
@@ -74,4 +74,16 @@ public interface FrameGraph : CameraGraphBase<FrameGraph.Session>, CameraControl
      * Example: A [Session] should *not* be held during video recording.
      */
     @RestrictTo(RestrictTo.Scope.LIBRARY_GROUP) public interface Session : CameraGraph.Session
+
+    public companion object {
+        private const val DEFAULT_FRAME_BUFFER_CAPACITY = 1
+
+        /** Utility function for the common case of attaching a single stream. See [captureWith]. */
+        @JvmStatic
+        public fun FrameGraph.captureWith(
+            streamId: StreamId,
+            parameters: Map<Any, Any?> = emptyMap(),
+            capacity: Int = DEFAULT_FRAME_BUFFER_CAPACITY,
+        ): FrameBuffer = captureWith(setOf(streamId), parameters, capacity)
+    }
 }

camera/camera-camera2-pipe/src/main/java/androidx/camera/camera2/pipe/Frames.kt

@@ -27,7 +27,9 @@ import androidx.annotation.RestrictTo
  */
 @RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
 @JvmInline
-public value class FrameNumber(public val value: Long)
+public value class FrameNumber(public val value: Long) {
+    override fun toString(): String = "Frame-$value"
+}
 
 /** [FrameInfo] is a wrapper around [TotalCaptureResult]. */
 @RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)

camera/camera-camera2-pipe/src/main/java/androidx/camera/camera2/pipe/graph/Controller3A.kt

@@ -770,8 +770,10 @@ internal class Controller3A(
             }
 
         debug {
-            "lock3AForCapture result: meetsAeCondition = $meetsAeCondition" +
-                ", meetsAfCondition = $meetsAfCondition, meetsAwbCondition = $meetsAwbCondition"
+            "lock3AForCapture state ${frameMetadata.frameNumber}: " +
+                "meetsAeCondition = $meetsAeCondition, " +
+                "meetsAfCondition = $meetsAfCondition, " +
+                "meetsAwbCondition = $meetsAwbCondition"
         }
 
         meetsAeCondition && meetsAfCondition && meetsAwbCondition

camera/camera-camera2-pipe/src/main/java/androidx/camera/camera2/pipe/internal/FrameState.kt

@@ -78,21 +78,28 @@ internal class FrameState(
 
     private val state = atomic(STARTED)
     private val streamResultCount = atomic(0)
-    private val outputFrameListeners = CopyOnWriteArrayList<Frame.Listener>()
+    // A list of ListenerState, one for each listener.
+    private val listenerStates = CopyOnWriteArrayList<ListenerState>()
 
     fun addListener(listener: Frame.Listener) {
-        listener.onFrameStarted(frameNumber, frameTimestamp)
-
-        // Note: This operation is safe since the outputFrameListeners is a CopyOnWriteArrayList.
-        outputFrameListeners.add(listener)
+        val listenerState = ListenerState(listener)
+        listenerStates.add(listenerState)
+
+        val currentFrameState = state.value
+
+        // Listeners can be added during any Frame state. We want to trigger the callbacks that were
+        // already triggered before the listener is added.
+        when (currentFrameState) {
+            STARTED -> listenerState.invokeOnStarted(frameNumber, frameTimestamp)
+            FRAME_INFO_COMPLETE ->
+                listenerState.invokeOnFrameInfoAvailable(frameNumber, frameTimestamp)
+            STREAM_RESULTS_COMPLETE ->
+                listenerState.invokeOnImagesAvailable(frameNumber, frameTimestamp)
+            COMPLETE -> listenerState.invokeOnFrameComplete(frameNumber, frameTimestamp)
+        }
     }
 
     fun onFrameInfoComplete() {
-        // Invoke the onOutputResultsAvailable onOutputMetadataAvailable.
-        for (i in outputFrameListeners.indices) {
-            outputFrameListeners[i].onFrameInfoAvailable()
-        }
-
         val state =
             state.updateAndGet { current ->
                 when (current) {
@@ -105,25 +112,23 @@ internal class FrameState(
                 }
             }
 
+        for (listenerState in listenerStates) {
+            listenerState.invokeOnFrameInfoAvailable(frameNumber, frameTimestamp)
+        }
+
         if (state == COMPLETE) {
             invokeOnFrameComplete()
         }
     }
 
     fun onStreamResultComplete(streamId: StreamId) {
-        val allResultsCompleted = streamResultCount.incrementAndGet() != imageOutputs.size
+        val hasResultsRemaining = streamResultCount.incrementAndGet() != imageOutputs.size
 
-        // Invoke the onOutputResultsAvailable listener.
-        for (i in outputFrameListeners.indices) {
-            outputFrameListeners[i].onImageAvailable(streamId)
+        for (listenerState in listenerStates) {
+            listenerState.invokeOnImageAvailable(streamId)
         }
 
-        if (allResultsCompleted) return
-
-        // Invoke the onOutputResultsAvailable listener.
-        for (i in outputFrameListeners.indices) {
-            outputFrameListeners[i].onImagesAvailable()
-        }
+        if (hasResultsRemaining) return
 
         val state =
             state.updateAndGet { current ->
@@ -137,15 +142,18 @@ internal class FrameState(
                 }
             }
 
+        for (listenerState in listenerStates) {
+            listenerState.invokeOnImagesAvailable(frameNumber, frameTimestamp)
+        }
+
         if (state == COMPLETE) {
             invokeOnFrameComplete()
         }
     }
 
     private fun invokeOnFrameComplete() {
-        // Invoke the onOutputResultsAvailable listener.
-        for (i in outputFrameListeners.indices) {
-            outputFrameListeners[i].onFrameComplete()
+        for (listenerState in listenerStates) {
+            listenerState.invokeOnFrameComplete(frameNumber, frameTimestamp)
         }
     }
 

camera/camera-camera2-pipe/src/main/java/androidx/camera/camera2/pipe/internal/ListenerState.kt

@@ -19,6 +19,7 @@ package androidx.camera.camera2.pipe.internal
 import androidx.camera.camera2.pipe.CameraTimestamp
 import androidx.camera.camera2.pipe.Frame
 import androidx.camera.camera2.pipe.FrameNumber
+import androidx.camera.camera2.pipe.StreamId
 import kotlinx.atomicfu.atomic
 
 internal class ListenerState(val listener: Frame.Listener) {
@@ -83,4 +84,13 @@ internal class ListenerState(val listener: Frame.Listener) {
             listener.onFrameComplete()
         }
     }
+
+    /**
+     * Invokes [listener.onImageAvailable(streamId)].
+     *
+     * @param streamId The [StreamId] that the image is available
+     */
+    fun invokeOnImageAvailable(streamId: StreamId) {
+        listener.onImageAvailable(streamId)
+    }
 }

camera/camera-camera2-pipe/src/test/java/androidx/camera/camera2/pipe/internal/FrameStateTest.kt

@@ -17,6 +17,7 @@
 package androidx.camera.camera2.pipe.internal
 
 import androidx.camera.camera2.pipe.CameraTimestamp
+import androidx.camera.camera2.pipe.Frame
 import androidx.camera.camera2.pipe.FrameNumber
 import androidx.camera.camera2.pipe.OutputId
 import androidx.camera.camera2.pipe.OutputStatus
@@ -29,6 +30,11 @@ import androidx.camera.camera2.pipe.testing.FakeImage
 import androidx.camera.camera2.pipe.testing.FakeRequestMetadata
 import androidx.camera.camera2.pipe.testing.FakeSurfaces
 import com.google.common.truth.Truth.assertThat
+import kotlinx.atomicfu.atomic
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.joinAll
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
 import org.junit.After
 import org.junit.Test
 import org.junit.runner.RunWith
@@ -63,6 +69,35 @@ class FrameStateTest {
     private val fakeFrameInfo =
         FakeFrameInfo(metadata = fakeFrameMetadata, requestMetadata = fakeRequestMetadata)
 
+    private val fakeListener =
+        object : Frame.Listener {
+            val frameStartedCalled = atomic(0)
+            val frameInfoAvailableCalled = atomic(0)
+            val imageAvailableCalled = atomic(0)
+            val frameCompletedCalled = atomic(0)
+
+            override fun onFrameStarted(frameNumber: FrameNumber, frameTimestamp: CameraTimestamp) {
+                frameStartedCalled.incrementAndGet()
+            }
+
+            override fun onFrameInfoAvailable() {
+                frameInfoAvailableCalled.incrementAndGet()
+            }
+
+            override fun onImageAvailable(streamId: StreamId) {
+                // Do nothing. ListenerState doesn't care about onImageAvailable on stream level
+                // currently.
+            }
+
+            override fun onImagesAvailable() {
+                imageAvailableCalled.incrementAndGet()
+            }
+
+            override fun onFrameComplete() {
+                frameCompletedCalled.incrementAndGet()
+            }
+        }
+
     private val frameState =
         FrameState(
             requestMetadata = fakeRequestMetadata,
@@ -207,4 +242,125 @@ class FrameStateTest {
         assertThat(frameState.frameInfoOutput.status).isEqualTo(OutputStatus.UNAVAILABLE)
         assertThat(frameState.frameInfoOutput.outputOrNull()).isNull()
     }
+
+    @Test
+    fun addListener_invokesOnStarted_whenStateIsStarted() {
+        // FrameState's initial state is STARTED
+        frameState.addListener(fakeListener)
+
+        assertThat(fakeListener.frameStartedCalled.value).isEqualTo(1)
+        assertThat(fakeListener.frameInfoAvailableCalled.value).isEqualTo(0)
+        assertThat(fakeListener.imageAvailableCalled.value).isEqualTo(0)
+        assertThat(fakeListener.frameCompletedCalled.value).isEqualTo(0)
+    }
+
+    @Test
+    fun addListener_stateIsFrameInfoAvailable_invokesStartAndFrameInfoComplete() {
+        frameState.onFrameInfoComplete()
+
+        frameState.addListener(fakeListener)
+
+        assertThat(fakeListener.frameStartedCalled.value).isEqualTo(1)
+        assertThat(fakeListener.frameInfoAvailableCalled.value).isEqualTo(1)
+        assertThat(fakeListener.imageAvailableCalled.value).isEqualTo(0)
+        assertThat(fakeListener.frameCompletedCalled.value).isEqualTo(0)
+    }
+
+    @Test
+    fun addListener_stateIsImagesAvailable_invokesStartAndImagesAvailable() {
+        // All stream result completed
+        frameState.onStreamResultComplete(stream1Id)
+        frameState.onStreamResultComplete(stream2Id)
+
+        frameState.addListener(fakeListener)
+
+        assertThat(fakeListener.frameStartedCalled.value).isEqualTo(1)
+        assertThat(fakeListener.frameInfoAvailableCalled.value).isEqualTo(0)
+        assertThat(fakeListener.imageAvailableCalled.value).isEqualTo(1)
+        assertThat(fakeListener.frameCompletedCalled.value).isEqualTo(0)
+    }
+
+    @Test
+    fun addListener_stateIsFrameComplete_invokesAllCallbacks() {
+        frameState.onStreamResultComplete(stream1Id)
+        frameState.onStreamResultComplete(stream2Id)
+        frameState.onFrameInfoComplete()
+
+        frameState.addListener(fakeListener)
+
+        assertThat(fakeListener.frameStartedCalled.value).isEqualTo(1)
+        assertThat(fakeListener.frameInfoAvailableCalled.value).isEqualTo(1)
+        assertThat(fakeListener.imageAvailableCalled.value).isEqualTo(1)
+        assertThat(fakeListener.frameCompletedCalled.value).isEqualTo(1)
+    }
+
+    @Test
+    fun onFrameInfoComplete_invokesOnFrameInfoAvailable() {
+        frameState.addListener(fakeListener)
+
+        frameState.onFrameInfoComplete()
+
+        assertThat(fakeListener.frameStartedCalled.value).isEqualTo(1)
+        assertThat(fakeListener.frameInfoAvailableCalled.value).isEqualTo(1)
+        assertThat(fakeListener.imageAvailableCalled.value).isEqualTo(0)
+        assertThat(fakeListener.frameCompletedCalled.value).isEqualTo(0)
+    }
+
+    @Test
+    fun onStreamResultComplete_doesNotHaveStreamResultForAllStreams_doesNotInvokesOnImagesAvailable() {
+        frameState.addListener(fakeListener)
+
+        frameState.onStreamResultComplete(stream1Id)
+
+        assertThat(fakeListener.frameStartedCalled.value).isEqualTo(1)
+        assertThat(fakeListener.frameInfoAvailableCalled.value).isEqualTo(0)
+        assertThat(fakeListener.imageAvailableCalled.value).isEqualTo(0)
+        assertThat(fakeListener.frameCompletedCalled.value).isEqualTo(0)
+    }
+
+    @Test
+    fun onStreamResultComplete_invokesOnImagesAvailable_afterAllStreamsComplete() {
+        frameState.addListener(fakeListener)
+
+        frameState.onStreamResultComplete(stream1Id)
+        frameState.onStreamResultComplete(stream2Id)
+
+        assertThat(fakeListener.frameStartedCalled.value).isEqualTo(1)
+        assertThat(fakeListener.frameInfoAvailableCalled.value).isEqualTo(0)
+        assertThat(fakeListener.imageAvailableCalled.value).isEqualTo(1)
+        assertThat(fakeListener.frameCompletedCalled.value).isEqualTo(0)
+    }
+
+    @Test
+    fun frameState_transitionsToComplete_allCallbacksAreTriggered() {
+        frameState.addListener(fakeListener)
+
+        frameState.onFrameInfoComplete()
+        frameState.onStreamResultComplete(stream1Id)
+        frameState.onStreamResultComplete(stream2Id)
+
+        assertThat(fakeListener.frameStartedCalled.value).isEqualTo(1)
+        assertThat(fakeListener.frameInfoAvailableCalled.value).isEqualTo(1)
+        assertThat(fakeListener.imageAvailableCalled.value).isEqualTo(1)
+        assertThat(fakeListener.frameCompletedCalled.value).isEqualTo(1)
+    }
+
+    @Test
+    fun concurrentFrameStateChangeAndNewListenerAdded_ensureCallbacksCalledOnce() = runBlocking {
+        val numCoroutines = 4
+
+        val jobs =
+            listOf(
+                launch(Dispatchers.Default) { frameState.onFrameInfoComplete() },
+                launch(Dispatchers.Default) { frameState.onStreamResultComplete(stream1Id) },
+                launch(Dispatchers.Default) { frameState.addListener(fakeListener) },
+                launch(Dispatchers.Default) { frameState.onStreamResultComplete(stream2Id) },
+            )
+        jobs.joinAll()
+
+        assertThat(fakeListener.frameStartedCalled.value).isEqualTo(1)
+        assertThat(fakeListener.frameInfoAvailableCalled.value).isEqualTo(1)
+        assertThat(fakeListener.imageAvailableCalled.value).isEqualTo(1)
+        assertThat(fakeListener.frameCompletedCalled.value).isEqualTo(1)
+    }
 }

development/project-creator/java-template/groupId/artifactId/src/main/java/groupId/package-info.java → compose/runtime/runtime/src/commonMain/kotlin/androidx/compose/runtime/Anchor.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) <YEAR> The Android Open Source Project
+ * Copyright 2026 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,7 +14,8 @@
  * limitations under the License.
  */
 
-/**
- * Insert package level documentation here
- */
-package <PACKAGE>;
+package androidx.compose.runtime
+
+internal interface Anchor {
+    val valid: Boolean
+}