A modern programming language that makes developers happier.

kotlinlang

I encountered a race condition in my Android app, and I’m unsure of the underlying cause. I have code roughly like that in the :thread:.

I’ve kept the context of my use case a bit, as I am building a webrtc streaming app.

The problem I encounter is that sometimes, the `CameraStream.videoSink` gets gc’ed, and so never receives any frames to send on to the webrtc stream. But it’s only sometimes, not all the time.

```interface Camera {
  fun addListener(listener: VideoSink)
}

class CameraImpl : Camera {
  private val listenersLock = Any()
  private val listeners = mutableListOf&lt;WeakReference&lt;VideoSink&gt;&gt;()
  override fun addListener(listener: VideoSink) {
    synchronized(listenersLock) {
      listeners.add(WeakReference(listener))
    }
  }

  // Other methods for dealing with camera
}


interface Stream {
  fun onFrame(frame: VideoFrame)
}

class CameraStream(
  private val camera: Camera,
  private val stream: Stream,
) {

  private val videoSink = VideoSink { frame -&gt;
    stream.onFrame(frame)
  }

  init {
    camera.addListener(videoSink)
  }
}```

The bug is generally reproducible on a fresh install, I think because the additional delay related to granting camera permission creates the timing needed to reproduce.

But I am unsure why `videoSink` gets gc’ed. The instance of `CameraStream` is long-lived, so I would expect it to retain `CameraStream.videoSink`. But I may misunderstand the Kotlin garbage collector.

Are you sure `CameraStream` reference is kept?

Maybe it's detached when asking for camera permissions, as the app goes to "background"

The `CameraStream` is instantiated and passed as a delegate to another class, and the reference to that class is definitely kept

I’ll see if I can put together a minimal reproducer