Structured Retain Cycles

[tylerjames]

I've got a @Dependency that is a client structured similarly to the WebSocket demo app.

Basically my FeatureClient needs to interact with some other clients (WebRTCClient and SignalingClient) and so it needs to create and hold onto a class that implements WebRTCClientDelegate and SignalingClientDelegate.

I've noticed that my FeatureClientDelegate does not get deallocated and will get created again next time I load my feature.

My FeatureClientDelegate is created in an initializeConnect closure like this:

static func live() -> FeatureClient {
  let kinesisClient = KinesisClient.live(mobileClient: awsMobileClient)
  var clientDelegate: VideoClientDelegate?

  return .init(
    initializeConnection: { channelArn in
      let endpoints = try await kinesisClient.getKinesisEndpoints(channelArn)
      try kinesisClient.registerKinesisSignaling(endpoints.https)
      let iceConfigs = try await kinesisClient.getIceServerConfigs(channelArn, clientId)
      let rtcServers = kinesisClient.rtcServerList(iceConfigs)
      
      let wrtcClient = WebRTCClient(iceServers: rtcServers, isAudioOn: true)
      let awsCredentials = try await kinesisClient.getAWSCredentials()
      
      guard let signedURL = kinesisClient.getSignedURL(endpoints, channelArn, clientId, awsCredentials) else {
        throw VideoClientError.configurationError
      }
      
      let signalingClient = SignalingClient(serverUrl: signedURL)
      let featureClientDelegate = FeatureClientDelegate(webRTCClient: wrtcClient,
                                                  signalingClient: signalingClient)
      clientDelegate = featureClientDelegate
    })
}

I call it from my store like this:

case .viewLoaded:
  state.connectionState = .connecting
  return .run(operation: { [state] send in
    try await withThrowingTaskGroup(
      of: Void.self,
      body: { group in
        group.addTask {
          try await client.initializeVideo(state.channelArn)
          await send(.initializationResult(.success(())))
        }
        
        group.addTask {
          try await Task.sleep(nanoseconds: 10 * NSEC_PER_SEC)
          client.disconnect()
        }
        
        try await group.next()
        group.cancelAll()
      })
  }, catch: { error, send in
    await send(.connectResult(.failure(TimeoutError.initializationTimeout)))
  })

Successfully making it through this initialization seems to create a retain cycle somehow. I don't know if it's obvious from this code or if I'm creating my FeatureClientDelegate class incorrectly. I see that the one in the WebSocket demo is nested inside an actor like this:

final actor WebSocketActor: GlobalActor {
final class Delegate: NSObject, URLSessionWebSocketDelegate {

But I'm not sure if that's for memory reasons or just for concurrency reasons.

Sorry for the lengthy post, I'm just not quite sure how to clear this problem. Thanks!

[acosmicflamingo]

Hi @tylerjames ! Forgive me if I'm completely wrong; I don't often answer these questions because I'm not confident in what I know hahaha ;)

Your FeatureClientDelegate is a class type and it's being assigning to clientDelegate of optional-type VideoClientDelegate (which can be assumed to be a class type too). The clientDelegate variable is also global with respect to the closure passed to initializeConnection. Could the source of the retain cycle be coming from var clientDelegate: VideoClientDelegate?? What happens if you make clientDelegate a weak reference type (weak var clientDelegate: VideoClientDelegate?)? Does this fix the problem?

[tylerjames]

That sounds plausible. I've had to move on from this for now but when I come back to it I'll look into that idea.

Thanks!