Stuck while Implementing WCSessionClient

[inwoodev]

Here is my initial effort in creating a WatchConnectivityClient.

import ComposableArchitecture
import Foundation
import WatchConnectivity



struct WatchConnectivityClient {
    enum Action  {
        case didReceiveMessage([String: Any])
    }
    
    var sendMessage: ([String: Any]) async throws -> [String: Any]?
    var didRecieveMessage: () async -> [String: Any]
}

extension WatchConnectivityClient: DependencyKey {
    static var liveValue: Self = {
        final actor WCSessionActor: GlobalActor {
            private var session: WCSession
            static let shared = WCSessionActor()
            let delegate = Delegate()
            
            private init() {
                self.session = WCSession.default
                self.session.delegate = delegate
                session.activate()
            }
            
            func sendMessage(_ message: [String: Any]) async throws -> [String: Any] {
                return try await withCheckedThrowingContinuation({ continuation in
                    self.session.sendMessage(message, replyHandler: { reply in
                        continuation.resume(returning: reply)
                    }, errorHandler: { error in
                        continuation.resume(throwing: error)
                    })
                })
            }
            
            func didReceiveMessage() async -> [String: Any] {
                await withCheckedContinuation({ continuation in
                    if delegate.continuation == nil {
                        delegate.continuation = continuation
                    }
                    
                })
            }
            
            final class Delegate: NSObject, WCSessionDelegate {
                var continuation: CheckedContinuation<[String : Any], Never>?
                
                
                func session(_ session: WCSession, didReceiveMessage message: [String : Any]) {
                    continuation?.resume(returning: message)
                }
            }
        }
        
        return Self(
            sendMessage: { message in
                try await WCSessionActor.shared.sendMessage(message)
            }, didRecieveMessage: {
                await WCSessionActor.shared.didReceiveMessage()
            }
        )
    }()
}

Just for a test, I implemented only sendMessage, and didSendMessage.

and here is the example AppReducer:

struct WCSessionMessage: Equatable {
    
    let id = UUID().uuidString
    let message: [String: Any]
    
    static func == (lhs: WCSessionMessage, rhs: WCSessionMessage) -> Bool {
        lhs.id == rhs.id
    }
}

struct AppReducer: Reducer {
    struct State: Equatable {
        var receivedMessage: WCSessionMessage = .init(message: [:])
    }
    
    enum Action {
        case sendMessage([String: Any])
        case sendMessageReply(TaskResult<[String: Any]>)
        case receiveMessage
        case onReceivedMessage([String: Any])
    }
    
    @Dependency(\.watchConnectivityClient) var client
    
    func reduce(into state: inout State, action: Action) -> Effect<Action> {
        switch action {
        case .sendMessage(let message):
            return .run { send in
                await send(.sendMessageReply(
                    TaskResult {
                        try await client.sendMessage(message)
                    }
                ))
            }
            
        case .sendMessageReply(.success(_)):
            return .none
            
        case .sendMessageReply(.failure(_)):
            return .none
            
        case .receiveMessage:
            return .run { send in
                await send(.onReceivedMessage(
                    await client.didReceiveMessage()
                ))
            }
            
        case .onReceivedMessage(let receivedMessage):
            state.receivedMessage = WCSessionMessage(message: receivedMessage)
            return .none
        }
    }
}

The example view that is calling the viewStore is implemented as below:

import SwiftUI
import ComposableArchitecture

struct ContentView: View {
    
    let store: StoreOf<AppReducer>
    
    var body: some View {
        WithViewStore(store, observe: { $0 }) { viewStore in
            VStack(spacing: 20) {
                
                Text("\(viewStore.receivedMessage.message.first?.key ?? "No Keys")")
                Text("\(viewStore.receivedMessage.message.first?.value as? String ?? "No Value")")
                
                Button("Tap", action: {
                    
                    viewStore.send(.sendMessage(["Tapped":"TappedValue: \(Int.random(in: 1...100))"]))
                    
                })
                
            }
            .onAppear() {
                viewStore.send(.receiveMessage)
            }
            .padding()
        }
    }
}

the viewStore.send(.sendMessage) seems to be working fine.
However,it is not while receiving message.

The message could be received only once, then the rest of the message from companion/counterpart, seems to be neglected.

I would say that I may have done something wrong while binding the received value from delegate, but I have no idea how can I fix it to make it async and fit it to be implemented in client. It would be great I could get any reference, or advice. Thanks ahead.🙏🙏