Messenger - send & receive messages

• Add MessengerRegisterMessageListener function
• Add MessengerListenForMessages function
• Add MessengerSendMessage function

Sources/XXMessengerClient/Messenger/Functions/MessengerSendMessage.swift

+import Foundation
+import XCTestDynamicOverlay
+import XXClient
+
+public struct MessengerSendMessage {
+  public struct DeliveryReport: Equatable {
+    public enum Result: Equatable {
+      case delivered
+      case notDelivered(timedOut: Bool)
+      case failure(NSError)
+    }
+
+    public init(
+      report: E2ESendReport,
+      result: Result
+    ) {
+      self.report = report
+      self.result = result
+    }
+
+    public var report: E2ESendReport
+    public var result: Result
+  }
+
+  public typealias DeliveryCallback = (DeliveryReport) -> Void
+
+  public enum Error: Swift.Error, Equatable {
+    case notLoaded
+    case notConnected
+  }
+
+  public var run: (Data, Data, DeliveryCallback?) throws -> E2ESendReport
+
+  public func callAsFunction(
+    recipientId: Data,
+    payload: Data,
+    deliveryCallback: DeliveryCallback?
+  ) throws -> E2ESendReport {
+    try run(recipientId, payload, deliveryCallback)
+  }
+}
+
+extension MessengerSendMessage {
+  public static func live(_ env: MessengerEnvironment) -> MessengerSendMessage {
+    MessengerSendMessage { recipientId, payload, deliveryCallback in
+      guard let cMix = env.cMix() else {
+        throw Error.notLoaded
+      }
+      guard let e2e = env.e2e() else {
+        throw Error.notConnected
+      }
+      let report = try e2e.send(
+        messageType: 2,
+        recipientId: recipientId,
+        payload: payload,
+        e2eParams: env.getE2EParams()
+      )
+      if let deliveryCallback = deliveryCallback {
+        do {
+          try cMix.waitForRoundResult(
+            roundList: try report.encode(),
+            timeoutMS: 30_000,
+            callback: .init { result in
+              switch result {
+              case .delivered(_):
+                deliveryCallback(.init(report: report, result: .delivered))
+              case .notDelivered(let timedOut):
+                deliveryCallback(.init(report: report, result: .notDelivered(timedOut: timedOut)))
+              }
+            }
+          )
+        } catch {
+          deliveryCallback(.init(report: report, result: .failure(error as NSError)))
+        }
+      }
+      return report
+    }
+  }
+}
+
+extension MessengerSendMessage {
+  public static let unimplemented = MessengerSendMessage(
+    run: XCTUnimplemented("\(Self.self)")
+  )
+}