How to do Cleanup on Dismissal of a Child Reducer (internally)?

[piojost]

I'm currently doing some navigation refactoring and starting to use the destination pattern with PresentationState. There is a child feature that is presented as a sheet. The child feature has to somehow notice that it is being dismissed to do some work such as closing network connections or stopping audio playback.
Before refactoring the child feature wasn't optional and the sheet was controlled by an enum:

struct ParentFeature: Reducer {
  struct State {
    var childFeature = ChildFeature.State()
    var sheet: Sheet?
    // …

    public enum Sheet: Identifiable {
      public var id: Self { self }

      case child
      // …
    }
  }
}

As the child feature state wasn't optional, we could send an action on disappear of the child view, so the child reducer could do the cleanup, when the sheet was pulled down:

struct ChildFeature: Reducer {
  @Dependency(\.someDependency) var someDependency

  public func reduce(into state: inout State, action: Action) -> Effect<Action> {
    switch action {
    case .onDisappear:
      someDependency.finish(state.item)
      return .none
  // …

When using PresentationState, this is obviously not possible as we get an error:

An "ifLet" received a presentation action when destination state was absent. …
Action:
ParentFeature.Action.destination(.presented(.childFeature(.onDisappear)))

My current workaround is to move the cleanup code to a static function and call it from the parent reducer on dismiss:

// in parent reducer body:
case .destination(.dismiss):
  if case let .childFeature(state) = state.destination {
    ChildFeature.onDismiss(item: state.item)
  }
  return .none

// in child reducer:
// Always call this function, when ChildFeature goes out of scope
public static func onDismiss(item: Item) {
   @Dependency(\.someDependency.finish) var finish
   finish(state.item)
}

That is a problem, because we have to remember to add that dismiss handling everywhere the ChildFeature can be presented. The cleanup has to happen inside the child instead, but I'm missing how the child could observe dismissal before it's too late. I hoped the docs would have a solution, but didn't find anything.

It would be highly appreciated if anyone could point me in the right direction.

[mbrandonw]

Hi @piojost, when using the ifLet operator, all child effects are automatically canceled when child state is nil'd out, and so you can use this knowledge in your dependency to do any necessary tear down. For example, a play endpoint on an AudioPlayerClient could listen for cancellation to automatically stop:

play: { url in 
  await withTaskCancellationHandler {
    await player.play()
  } onCancel: {
    player.stop()
  }
}

This does require your dependency to be a little more deeply ingrained with Swift concurrency, but that has other benefits too. For example, in the above code, the player.play needs to be async and suspend for as long as the audio is playing. That allows you to tie the lifetime of the playing audio to the lifetime of the effect, and so when the effect is cancelled, the onCancel closure will be invoked, and you can stop the player.

This can work with any kind of effect too. Do you think that will help in your situation?

[piojost]

Thanks for your quick reply, @mbrandonw. That's really elegant in most situations.

There is still one case, where I don't see how to apply this pattern. We have a STOMP dependency, that returns an AsyncStream:

public struct StompClient {
    public var connect: @Sendable (String) async throws -> AsyncThrowingStream<ServerEvent, Error>
    // …
    public var finish: @Sendable () async -> Void
}

Currently finish() is called from the reducer when the feature is dismissed. It disconnects the STOMP session and nils out our STOMP service, as it is not needed anymore:

private enum StompClientKey: DependencyKey {
    static let stateHolder = StateHolder()

    static let liveValue = LiveChatClient(
        // …
        finish: {
            await stateHolder.stompChat?.disconnect()
            await stateHolder.setStompChat(nil)
        }
    )
}

Task cancellation can happen because of two reasons:

• the child state is nil'd out
• the application enters the background

In the first case, the service should be nil'd out, but in the second case, it is important that the service isn't nil'd out, because a reconnect should happen as soon as the application enters the foreground again. The effect can listen for cancellation, but doesn't know the reason.

[mbrandonw]

Why are effects cancelled when the application enters the background? TCA isn't doing that, so are you specifically doing that?

[piojost]

Actually, there was a misunderstanding on my part. I was confusing cancellation with AsyncStream's general termination. The stream does not terminate as a result of cancellation in the scenario I described.

Many thanks. You've helped me a lot!