Handling external delegate

[JeromeTonnelierOgury]

Hi again!

I have an external SDK (let's say a VideoStreamer) and I want to handle it from my reducer.
Basically I can load a video and I get the various callbacks from a classic delegate.

I guess my "main" Recuder should have a copy of this VideoStreamer (it's a class, to by reference should be fine), but how can I get back some stuff inside the Reducer from a delegate from the VideoStreamer ?
I initially thought of a Combine object or an async variable, but it seems that many people use an AsyncStream. What is the best approach to handle a delegate ?

Thanks!

[mbrandonw]

Hi @JeromeTonnelierOgury, all external SDK's should be considered dependencies and so should be wrapped in an interface and registered with the dependency management system that comes with the library. You should not hold any reference types in your state because that makes equatability essentially impossible.

The dependency interface you create will expose endpoints for the various things you can invoke on VideoStreamer, and the dependency can feed data back into the system via either a publisher or async sequence. While async sequences are the new hotness in Swift, they also have their drawbacks, so it really just depends whichever you are more comfortable with.

We have lots of examples of implementing this kind of dependency in our demos and case studies:

• Speech recognizer from the Standups app
• Audio player and Audio recorder from voice memos app
• And lots of examples in our isowords app.

[JeromeTonnelierOgury]

Thanks a lot for all of this, I'll have a look then!

[JeromeTonnelierOgury]

If I get it right @mbrandonw, I must do something like this ?

struct TCAVideoPlayer {
  // sasically transform every delegate method into a @Sendable var
   var loaded: @Sendable () -> async Bool
}

extension TCAVideoPlayer: DependencyKey {
   static let liveValue: TCAVideoPlayer {
      let originalPlayer = VideoStreamer()
      return TCAVideoPlayer(
         loaded: { //implementation }
   }
}

Is that the right direction ? Thanks 🙏

[mbrandonw]

Hi @JeromeTonnelierOgury, I see you posted this question on the Swift forums too, and I just want to mention that I don't really think this is a TCA-specific question anymore.

Abstractly, you have a generic dependency/protocol that you want to inject into your feature. You really have no choice but to either introduce a generic to the feature that touches the dependency (which is viral and will cause generics to be introduced to any feature touching this feature), or introduce some kind of erasure like @Alex293 mentioned. The latter is most likely the way to go, and so you should focus your energy on figuring out how you can erase your protocol in the most reasonable way possible.

This problem exists whether you are using TCA or not, and so you may find that asking the question in a more general forum, such as the Apple developer forums will get you more attention.

[JeromeTonnelierOgury]

Thanks @mbrandonw but I have to disagree if you may 😊

Yes, it's an issue with generics and erasure, but my issue here is : how can I use the @Dependency TCA feature with a generic in the end.
If it was not for the @Dependency, I would surely know how to inject it in any object. I would just have to declare a var videoManager: VideoManager and that's it.

But here, I cannot use a variable as you stated, I must use a @Dependency along with everything else (the @sendable wrapper and so on)
No one ever encountered this issue with injecting a generic dependency ?
I guess it would look something like this, maybe this can help you see where I am going ?

struct TCAVideoPlayer {
   var videoManager: VideoManager // base protocol object, erased on can say ? 
  // basically transform every delegate method into a @Sendable var
   var loaded: @Sendable () -> async Bool
}

extension TCAVideoPlayer: DependencyKey {
   static func liveValue(_: manager VideoManager): TCAVideoPlayer {
      let originalPlayer = VideoStreamer()
      return TCAVideoPlayer(
         videoManager: manager,
         loaded: { //implementation }
   }
}

// and then later on
// this would specialize the overall behavior with a YoutubeVideoPlayer
let videoView = VideoView(store: VideoStore(withDependency: TCAVideoPlayer.liveValue(YoutubeVideoPlayer)))

I don't know if it's clearer or not ?
Thanks for your help, much appreciated 🙏

[Alex293]

Can you provide a trimmed down version of your view ?
Is it generic ? If your view is generic then you cannot use erasure and need multiple dependencies, if your view isn't I believe you should remove any associated object / generic from you dependency and keep them at the implementation level

[JeromeTonnelierOgury]

I don't have the View w/o TCA anymore, but basically it would look like this (this would be for the VideoBar which would have the 2 buttons loadand show

struct VideoBar: View {
    let videoManager: VideoManager
    var body: some View {
            HStack(spacing: 10) {
                Group {
                    Button("Load") {
                        videoManager.load()
                    }
                    Button("Show") {
                        videoManager.show()
                    }
                }
                .tint(.blue)
                .foregroundColor(.black)
                .buttonBorderShape(.capsule)
                .buttonStyle(.borderedProminent)
            }
        }
}

and I would instanciate it with a simple let view = VideoBar(videoManager: YoutubeVideoManager) when I want to handle youtube videos and let view = VideoBar(videoManager: LocalVideoManager) when I want to handle local file.

But I can't just use the same for the store as it seems that I have to use a dependency rather than a simple var, that's the whole point. In the end, the VideoManager protocol acts as an erasure since I don't need to know what's going on inside each method. I just need access to load and show, do you see what I mean ?

[mbrandonw]

I'm not sure I see why you can't use VideoManager as a dependency in the exact same way it is provided to the view you demonstrate above. You would do something like:

private enum VideoManagerKey: TestDependencyKey {
  static let testValue: any VideoManager = /* Some kind of mock or unimplemented conformance */
}
extension DependencyValues {
  var videoManager: any VideoManager {
    get { self[VideoManagerKey.self] }
    set { self[VideoManagerKey.self] = newValue }
  }
}

That provides a type erased VideoManager to anyone using @Dependency(\.videoManager) just as you did in your view above.

It's worth noting that in this erasure you can't really do anything with the video property. It's effectively an Any. But it doesn't seem you are using the video property in the view. Maybe you can even drop that associated type.