AsyncStream Delegate with DependencyKey

[jjjeeerrr222]

Hello,

I am using firebase cloud messaging for notifications in my SwiftUI app. I need to handle UIApplicationDelegate's didRegisterForRemoteNotificationsWithDeviceToken to register the token. My code base is modularized and my firebase dependency is split between a test and live dependency following the videos you released on the topic. It has been working really nicely and has made development with previews a breeze.

I need to use AsyncStream to intercept events to the UIApplicationDelegate methods. I am not sure if what i have is the best way to do this.

In my FireBaseClient interface i define:

public enum DelegateAction {
        case application(_ application: UIApplication, deviceToken: Data)
    }
    
    public var delegate: @Sendable () -> AsyncStream<DelegateAction>

In the module with my live implementation i add:

private extension FirebaseClient {
    class Delegate: NSObject, UIApplicationDelegate {
        let continuation: AsyncStream<FirebaseClient.DelegateAction>.Continuation

        init(continuation: AsyncStream<FirebaseClient.DelegateAction>.Continuation) {
          self.continuation = continuation
        }
        
        func application(_ application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
            self.continuation.yield(.application(application, deviceToken: deviceToken))
        }
    }
}

And I set the delegate in liveValue as:

client.delegate = {
            return AsyncStream { continuation in
                let delegate = Delegate(continuation: continuation)
                if var appDelegate = try? await UIApplication.shared.delegate {
                    appDelegate = delegate
                }
                continuation.onTermination = { _ in
                    let _ = delegate
                }
            }
        }

Currently this is giving me an error:

Cannot pass function of type '(AsyncStream<FirebaseClient.DelegateAction>.Continuation) async -> Void' to parameter expecting synchronous function type

But another question would be is this even correct? Will this override the AppDelegate implementation of UIApplicationDelegate?

I guess the underlying question is how can i get access to those methods without having to import the dependencies into AppDelegate

Thanks

[Malauch]

client.delegate = {
            return AsyncStream { continuation in
                let delegate = Delegate(continuation: continuation)
                if var appDelegate = try? await UIApplication.shared.delegate {
                    appDelegate = delegate
                }
                continuation.onTermination = { _ in
                    let _ = delegate
                }
            }
        }

Error is caused by using await in closure which don't provide asynchronous context. AsyncStream build closure is not async one. BTW why do you trying await UIApplication.shared.delegate? As far as I remember, it is normal property which you can access synchronous.

However when I need to listen to UIApplicationDelegate method I use totally different approach. I use AppDelegate as my main point for setting up App's RootReducer and then just send action from methods. It looks like this.

Delegate

public class AppDelegate: NSObject, UIApplicationDelegate {
  public var store: Store<HelperFeature.State, HelperFeature.Action>
  lazy var viewStore = ViewStore(store.stateless)
  
  public override init() {
    self.store = StoreOf<HelperFeature>(
      initialState: .init(showingDebugFields: true),
      reducer: HelperFeature()
    )
    super.init()
  }
  
  public func application(
    _ application: UIApplication,
    didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]? = nil
  ) -> Bool {
    viewStore.send(.appDidFinishLaunching)
    return true
  }
  
  public func applicationWillTerminate(_ application: UIApplication) {
    viewStore.send(.appWillTerminate)
  }
}

App Entry Point

@main
struct MusicDisplayHelperApp: App {
  @UIApplicationDelegateAdaptor var appDelegate: AppDelegate
  
  var body: some Scene {
    WindowGroup {
      HelperView(store: appDelegate.store)
    }
  }
}

BTW in my case delegate lives in separate module. All reacting to action called from AppDelegate is done in Reducer.
Sorry for some oddly specific naming in examples. I just copied it directly from my code base. Also sorry if I misunderstood your problem.

[jjjeeerrr222]

Oh this makes perfect sense! Will be adopting this! Thank you so much