How to store reference type entities in a Reducer

[schornon]

Hey everyone! I started a new project ~month ago, and it's my first large one with TCA. It builds with SwiftUI and TCA 1.6.0.
I have a question about reference types: how to store them in reducer's state? I saw some info on the swift forum that it's not really designed to store reference types because of, for example, Equatable issues. So, technically, I can store some class object in the State, but it doesn't trigger SwiftUI views to update.
Next, I tried to move my class to the dependency, but in this case my views haven't access to it. Mb I missed something and can get access to reducer's dependencies through some magic tca's api?

In my current case, my class required to be ObservableObject.
Some code to be more specific:

class SomeService: ObservableObject {
    @Published var foo: Bool = false
    var bar: PassthroughSubject<Void, Never> = .init()
}

@Reducer
struct Feature {
    
    struct State: Equatable {
        
    }
    
    enum Action {
        
    }
    
    var body: some Reducer<State, Action> {
        Reduce { state, action in
            return .none
        }
    }
}

So, I want to store SomeService somewhere in the Feature, swiftui's view required to have access to SomeService object, I want to observe SomeService changes inside the Feature.
How can I archive this?

[kamcma]

The short answer is you don't store reference types in state*. Reference types, which can be mutated from afar, are not a good fit for a uni-directional architecture like TCA, which prescribes that state may only be mutated in response to receiving actions. If a dependency you interact with, eg an Apple API, emits a reference type, you need to make a value type you can map it into before returning those values to state.

You are correct to notice that these kinds of APIs, either because you need to hold onto some long-lived reference type, or because they emit or take references types in their API, need to be wrapped in the dependency system. You interact with dependencies you've defined almost always in effects. I highly recommend looking through the case studies and examples in this repo to see just how far you can get with only interacting with dependencies in the reducer through effects. Which is to say: you probably don't want to have access to services in your views. Views should be thin, and merely send actions to the reducer, and there you interact with the service.

There are some advanced use cases where you'd want to interact with the same dependency in a reducer and a view. An example I can think of is stuff around AVFoundation, where a SwiftUI VideoPlayer view wants to be handed an AVPlayer, but you'd want to be able to interact with that same AVPlayer from a reducer to start/stop/observe etc programmatically. This scenario isn't well-tread ground by the case studies, so there may be various solutions. I could imagine defining a dependency interface and registering it with both swift-dependencies and the SwiftUI environment. That interface should perhaps be wrapping a global actor, as demonstrated in the WebSockets case study, so that both the reducer layer and the view layer are interacting with the same, single mutable state. But again, this is a pretty advanced case and most dependency interaction can be accomplished purely reducer-side through effects.

*Caveat: there are some TCA tools coming, called "shared state", that will allow you to define a different kind of state. This won't be as naive as just storing vanilla reference types in state, but will be a system for defining state that has reference(ish) behavior. Ie, can be mutated from afar independent of an action being sent, but you still want to be able to observe it. Keep an eye on this repo for an announcement of these tools. But they are not available as of 1.8.0.

[schornon]

Thank you for your response!

There are some advanced use cases where you'd want to interact with the same dependency in a reducer and a view. An example I can think of is stuff around AVFoundation, where a SwiftUI VideoPlayer view wants to be handed an AVPlayer, but you'd want to be able to interact with that same AVPlayer from a reducer to start/stop/observe etc programmatically.

Well, I already faced this problem and I solved it this way:

extension DependencyValues {
    var mediaPlayer: MediaPlayerClient {
        get { self[MediaPlayerClient.self] }
        set { self[MediaPlayerClient.self] = newValue }
    }
}

// MARK: - Client
@DependencyClient
struct MediaPlayerClient {
    var load: @Sendable (Media) async throws -> Void
    var player: @Sendable () -> AVPlayer = { AVPlayer() }
    var play: @Sendable () async -> Void
    var pause: @Sendable () async -> Void
    var seekBy: @Sendable (_ seconds: CMTimeValue) async -> Void
    var playerTimeControlStatus: @Sendable () -> AsyncStream<AVPlayer.TimeControlStatus> = { .finished }
    
    struct Media: Hashable {
        let url: URL
    }
}

// MARK: - Live
extension MediaPlayerClient: DependencyKey {
    static let liveValue: MediaPlayerClient = {
        let actor = MediaPlayerActor()
        return Self(
            load: { audio in
                try await actor.load(audio: audio)
            },
            player: {
                actor.player
            },
            play: {
                await actor.play()
            },
            pause: {
                await actor.pause()
            },
            seekBy: { seconds in
                await actor.seekBy(seconds)
            } ,
            playerTimeControlStatus: {
                actor.player.publisher(for: \.timeControlStatus).stream
            }
        )
    }()
    
    private actor MediaPlayerActor {
        let player: AVPlayer
        
        init() {
            self.player = AVPlayer()
        }
        
        @MainActor
        func load(audio: Media) async throws {
            await pause()
            let newItem = AVPlayerItem(url: audio.url)
            player.replaceCurrentItem(with: newItem)
        }
        
        func play() async {
            player.play()
        }
        
        func pause() async {
            player.pause()
        }
        
        func seekBy(_ seconds: CMTimeValue) {
            let currentTime = player.currentTime()
            let newTime = CMTimeAdd(currentTime, CMTime(value: seconds, timescale: 1))
            player.seek(to: newTime, toleranceBefore: .positiveInfinity, toleranceAfter: .positiveInfinity)
        }
    }
}

extension Publisher where Failure == Never {
    public var stream: AsyncStream<Output> {
        AsyncStream { continuation in
            let cancellable = self.sink { completion in
                continuation.finish()
            } receiveValue: { value in
                 continuation.yield(value)
            }
            continuation.onTermination = { continuation in
                cancellable.cancel()
            }
        }
    }
}

and then my view has access to AVPlayer through State:

struct State: Equatable {
    var player: AVPlayer {
        @Dependency(\.mediaPlayer) var mediaPlayer
        return mediaPlayer.player()
    }
}

In case with AVPlayer it works well because we don't need to have 2 active AVPlayers simultaneously.
But in my current task, I have two bullet points:

1. Each time when I define @Dependency(\.someService) var someService I need to have brand-new reference type object inside. One screen == One Reducer == One unique reference type object inside. I guess I need something like built-in @Dependency(\.uuid), where one defined dependency == unique uuid. But, in this case, I can't use my previous approach to have access to this dependency from view.
2. I marked SomeService as ObservableObject because in this specific case, this object is a built-in to the another framework. But, I guess, I still can use your example to adopt it for my case.

[kamcma]

extension Publisher where Failure == Never {
    public var stream: AsyncStream<Output> {
        AsyncStream { continuation in
            let cancellable = self.sink { completion in
                continuation.finish()
            } receiveValue: { value in
                 continuation.yield(value)
            }
            continuation.onTermination = { continuation in
                cancellable.cancel()
            }
        }
    }
}

I don't believe this custom extension is necessary. Publisher provides a values property that gives you the publisher's output as an async sequence.

and then my view has access to AVPlayer through State:

struct State: Equatable {
    var player: AVPlayer {
        @Dependency(\.mediaPlayer) var mediaPlayer
        return mediaPlayer.player()
    }
}

This gives me pause. It could lead to testing difficulties, among other things. In my version, you do have the player property on your MediaPlayerActor, but don't expose it on the MediaPlayerClient you register with swift-dependencies. But then you do expose it on some MediaPlayerClientForEnvironment that you register with the SwiftUI environment, and then access it directly in the view, without ever having passed it through state.

Each time when I define @dependency(.someService) var someService I need to have brand-new reference type object inside. One screen == One Reducer == One unique reference type object inside. I guess I need something like built-in @dependency(.uuid), where one defined dependency == unique uuid. But, in this case, I can't use my previous approach to have access to this dependency from view.

Broadly, a dependency interface that you register with swift-dependencies is supposed to be something that behaves like a static global, that it will not have a different lifetime than your app. Mutable state that you need a single instance of, you hold in the scratch space when creating the dependency. Mutable state that you need per individual endpoint, you hold in the individual end point. If you need a dependency to be able to juggle multiple instance of some mutable state. have a look at the dependency in the WebSockets case study. That dependency is able to hold and interface multiple open WebSockets simultaneously. The cost of this is increasing the complexity of the interface, in that each endpoint takes an ID argument to specify which one you are working with.

[schornon]

Again, I want to thank you for your time!

I don't believe this custom extension is necessary. Publisher provides a values property that gives you the publisher's output as an async sequence.

I got Type 'AVPlayer.TimeControlStatus' does not conform to protocol 'Publisher' using values 😕

But then you do expose it on some MediaPlayerClientForEnvironment that you register with the SwiftUI environment, and then access it directly in the view, without ever having passed it through state.

Sorry, I can't understand that part. Can you show MediaPlayerClientForEnvironment usage, please?

If you need a dependency to be able to juggle multiple instance of some mutable state. have a look at the dependency in the WebSockets case study.

I guess, that's what I need. 🤝

[kamcma]

I may have time to mock up an answer to your second question a little later, but for now the answer to the first question is pretty quick. This compiles for me without your extension. I've simplified the client because all I'm trying to demonstrate is wrapping a publisher in an AsyncStream:

import AVFoundation
import Dependencies
import DependenciesMacros

@DependencyClient
struct MediaPlayerClient {
  var playerTimeControlStatus: @Sendable () -> AsyncStream<AVPlayer.TimeControlStatus> = { .finished }
}

extension MediaPlayerClient: DependencyKey {
  static var liveValue: MediaPlayerClient {

    let player = AVPlayer()

    return MediaPlayerClient(
      playerTimeControlStatus: {
        AsyncStream(player.publisher(for: \.timeControlStatus).values)
      }
    )
  }
}

[schornon]

This compiles for me without your extension

Oh, I didn't wrap it into AsyncStream(...).
Do you receive any new values with this solution? 'cause I got only first one ☹️

return .run { send in
            let playerStatusStream = mediaPlayer.playerTimeControlStatus()
            for await status in playerStatusStream {
                print("status: \(status)")
            }
        }

[mbrandonw]

FWIW, the advice to "never store reference types in state" is soon to not be 100% true. We just released a beta focused on "shared state" that provides a tool for introducing a reference type into state that is both observable and exhaustively testable.

[pro100filipp]

I faced with the exact same problem of AVPlayer dependency and hope it will be helpful to see an up to date solution of mine.

Dependency

import AVKit
import Combine
import Dependencies
import DependenciesMacros
import SwiftUI

@DependencyClient
struct AVPlayerClient: Sendable {
    var play: () async throws -> Void
    var load: (_ url: URL) async throws -> Void
    var avPlayer: @MainActor () -> AVPlayer = { AVPlayer() }

    @MainActor private static let player = AVPlayer()
    @MainActor private static var playerStatusCancellable: AnyCancellable?
    @MainActor private static var playerRateCancellable: AnyCancellable?
    @MainActor private static var endOfPlayObserver: (any NSObjectProtocol)?

    @MainActor
    static func clearResources() {
        playerStatusCancellable?.cancel()
        playerStatusCancellable = nil
        playerRateCancellable?.cancel()
        playerRateCancellable = nil

        guard let endOfPlayObserver else { return }

        NotificationCenter.default.removeObserver(
            endOfPlayObserver,
            name: AVPlayerItem.didPlayToEndTimeNotification,
            object: Self.player.currentItem
        )

        Self.endOfPlayObserver = nil
    }
}

enum PlayerError: Error {
    case nothingToPlay
    case assetLoadFailed
    case unknown
}

extension AVPlayerClient: DependencyKey {
    static var liveValue: Self {
        Self(
            play: { @MainActor in
                guard Self.player.currentItem != nil else {
                    throw PlayerError.nothingToPlay
                }

                do {
                    try await withTaskCancellationHandler {
                        try await withCheckedThrowingContinuation { continuation in
                            endOfPlayObserver = NotificationCenter.default.addObserver(
                                forName: AVPlayerItem.didPlayToEndTimeNotification,
                                object: Self.player.currentItem,
                                queue: .main
                            ) { _ in continuation.resume() }

                            // Handle errors
                            playerStatusCancellable = Self.player
                                .publisher(for: \.status)
                                .removeDuplicates()
                                .sink {
                                    if $0 == .failed {
                                        continuation.resume(throwing: Self.player.error ?? PlayerError.unknown)
                                    }
                                }

                            playerRateCancellable = Self.player
                                .publisher(for: \.rate, options: [.new])
                                .removeDuplicates()
                                .sink { _ in
                                    if Self.player.rate == 0 {
                                        continuation.resume()
                                    }
                                }

                            if Self.player.rate == 0 {
                                Self.player.play()
                            }
                        }
                        clearResources()
                    } onCancel: {
                        Task { @MainActor in
                            // First pause and then clear to avoid continuation leak
                            Self.player.pause()
                            clearResources()
                        }
                    }
                }
                catch {
                    clearResources()
                    throw error
                }
            },
            load: { @MainActor url in
                do {
                    try await withCheckedThrowingContinuation { continuation in
                        let item = AVPlayerItem(url: url)
                        playerStatusCancellable = item.publisher(for: \.status)
                            .removeDuplicates()
                            .sink {
                                switch $0 {
                                    case .readyToPlay:
                                        continuation.resume()
                                    case .failed:
                                        continuation.resume(throwing: item.error ?? PlayerError.assetLoadFailed)
                                    case .unknown:
                                        break
                                    @unknown default:
                                        break
                                }
                            }

                        Self.player.replaceCurrentItem(with: item)
                    }
                    clearResources()
                }
                catch {
                    clearResources()
                    throw error
                }
            },
            avPlayer: {
                Self.player
            }
        )
    }
}

extension DependencyValues {
    var player: AVPlayerClient {
        get { self[AVPlayerClient.self] }
        set { self[AVPlayerClient.self] = newValue }
    }
}

extension AVPlayerClient: EnvironmentKey {
    static var defaultValue: AVPlayerClient {
        @Dependency(\.player) var player
        return player
    }
}

extension EnvironmentValues {
    var player: AVPlayerClient {
        get { self[AVPlayerClient.self] }
        set { self[AVPlayerClient.self] = newValue }
    }
}

Usage

import AVKit
import ComposableArchitecture
import SwiftUI

@Reducer
struct PlayerFeature {
    @ObservableState
    struct State: Equatable {}

    @Dependency(\.player) private var player

    enum Action {
        case onAppear
    }

    var body: some ReducerOf<Self> {
        Reduce { _, action in
            switch action {
                case .onAppear:
                    return
                        .run { send in
                            try await player.play()
                        }
            }
        }
    }
}

struct PlayerView: View {
    @Environment(\.player) private var player // not necessary if using AVPlayerClient.player
    let store: StoreOf<PlayerFeature>

    var body: some View {
        VideoPlayer(player: player.avPlayer()) // or simply AVPlayerClient.player and make it non-private
            #if os(tvOS)
                .frame(width: 1920, height: 1080)
            #endif
            .onAppear { store.send(.onAppear) }
    }
}

I haven't finished all the work to find out all the possible leaks yet, so any suggestions on this (and on anything you want of course) are welcome.