crossmate

EngagementDebugView.swift (7923B)

---

 import Foundation
 import SwiftUI
 import UIKit
 
 struct EngagementDebugView: View {
     @Environment(\.engagementHost) private var host
 
     @State private var engagementID = UUID()
     @State private var localSignalJSON = ""
     @State private var remoteSignalJSON = ""
     @State private var outboundMessage = "hello from Crossmate"
     @State private var events: [String] = []
     @State private var isBusy = false
 
     private let encoder: JSONEncoder = {
         let encoder = JSONEncoder()
         encoder.outputFormatting = [.prettyPrinted, .sortedKeys]
         return encoder
     }()
 
     var body: some View {
         List {
             Section("Engagement ID") {
                 Text(engagementID.uuidString)
                     .font(.caption.monospaced())
                     .textSelection(.enabled)
 
                 Button("New Engagement ID") {
                     engagementID = UUID()
                     localSignalJSON = ""
                     remoteSignalJSON = ""
                     appendEvent("New engagement ID")
                 }
                 .disabled(isBusy)
             }
 
             Section("Local Signal") {
                 debugTextEditor(text: $localSignalJSON, minHeight: 150)
 
                 Button("Create Offer") {
                     Task { await createOffer() }
                 }
                 .disabled(isBusy || host == nil)
 
                 Button("Copy Local Signal") {
                     UIPasteboard.general.string = localSignalJSON
                 }
                 .disabled(localSignalJSON.isEmpty)
             }
 
             Section("Remote Signal") {
                 debugTextEditor(text: $remoteSignalJSON, minHeight: 150)
 
                 Button("Paste Remote Signal") {
                     remoteSignalJSON = UIPasteboard.general.string ?? ""
                 }
 
                 Button("Accept Offer and Create Reply") {
                     Task { await acceptOfferAndReply() }
                 }
                 .disabled(isBusy || host == nil || remoteSignalJSON.isEmpty)
 
                 Button("Accept Reply") {
                     Task { await acceptReply() }
                 }
                 .disabled(isBusy || host == nil || remoteSignalJSON.isEmpty)
             }
 
             Section("Data Channel") {
                 TextField("Message", text: $outboundMessage)
                     .textInputAutocapitalization(.never)
                     .autocorrectionDisabled()
 
                 Button("Send Message") {
                     sendMessage()
                 }
                 .disabled(host == nil || outboundMessage.isEmpty)
 
                 Button("Teardown") {
                     host?.teardown(engagementID: engagementID)
                     appendEvent("Teardown requested")
                 }
                 .disabled(host == nil)
             }
 
             Section("Events") {
                 if events.isEmpty {
                     Text("No engagement events yet.")
                         .foregroundStyle(.secondary)
                 } else {
                     ForEach(events.indices.reversed(), id: \.self) { index in
                         Text(events[index])
                             .font(.caption.monospaced())
                             .textSelection(.enabled)
                     }
                 }
             }
         }
         .navigationTitle("WebRTC Host Test")
         .navigationBarTitleDisplayMode(.inline)
         .onAppear {
             host?.onEvent = { event in
                 handle(event)
             }
         }
         .onDisappear {
             host?.teardown(engagementID: engagementID)
         }
     }
 
     @ViewBuilder
     private func debugTextEditor(text: Binding<String>, minHeight: CGFloat) -> some View {
         TextEditor(text: text)
             .font(.caption.monospaced())
             .textInputAutocapitalization(.never)
             .autocorrectionDisabled()
             .frame(minHeight: minHeight)
     }
 
     private func createOffer() async {
         guard let host else { return }
         await run("create offer") {
             let signal = try await host.createOffer(engagementID: engagementID)
             localSignalJSON = try encode(signal)
         }
     }
 
     private func acceptOfferAndReply() async {
         guard let host else { return }
         await run("accept offer") {
             let offer = try decodeSignal(remoteSignalJSON)
             let reply = try await host.acceptOfferAndReply(
                 engagementID: engagementID,
                 signal: offer
             )
             localSignalJSON = try encode(reply)
         }
     }
 
     private func acceptReply() async {
         guard let host else { return }
         await run("accept reply") {
             let reply = try decodeSignal(remoteSignalJSON)
             try await host.acceptReply(engagementID: engagementID, signal: reply)
         }
     }
 
     private func sendMessage() {
         guard let data = outboundMessage.data(using: .utf8) else { return }
         do {
             try host?.send(engagementID: engagementID, message: data)
             appendEvent("Sent message: \(outboundMessage)")
         } catch {
             appendEvent("Send failed: \(error.localizedDescription)")
         }
     }
 
     private func run(_ label: String, operation: () async throws -> Void) async {
         guard !isBusy else { return }
         isBusy = true
         appendEvent("Starting \(label)")
         defer { isBusy = false }
 
         do {
             try await operation()
             appendEvent("Finished \(label)")
         } catch {
             appendEvent("\(label) failed: \(error.localizedDescription)")
         }
     }
 
     private func handle(_ event: EngagementHost.Event) {
         switch event {
         case .signal(let id, let signal):
             guard id == engagementID else { return }
             if let json = try? encode(signal) {
                 localSignalJSON = json
             }
             appendEvent("Signal generated")
         case .channelOpen(let id):
             guard id == engagementID else { return }
             appendEvent("Channel open")
         case .channelMessage(let id, let message):
             guard id == engagementID else { return }
             let text = String(data: message, encoding: .utf8)
                 ?? message.base64EncodedString()
             appendEvent("Received message: \(text)")
         case .channelClose(let id):
             guard id == engagementID else { return }
             appendEvent("Channel closed")
         case .error(let id, let message):
             guard id == nil || id == engagementID else { return }
             appendEvent("Error: \(message)")
         }
     }
 
     private func encode(_ signal: EngagementHost.Signal) throws -> String {
         let data = try encoder.encode(signal)
         guard let string = String(data: data, encoding: .utf8) else {
             throw EngagementDebugError.invalidUTF8
         }
         return string
     }
 
     private func decodeSignal(_ string: String) throws -> EngagementHost.Signal {
         guard let data = string.data(using: .utf8) else {
             throw EngagementDebugError.invalidUTF8
         }
         return try JSONDecoder().decode(EngagementHost.Signal.self, from: data)
     }
 
     private func appendEvent(_ message: String) {
         let time = Self.eventTimeFormatter.string(from: Date())
         events.append("\(time) \(message)")
         if events.count > 100 {
             events.removeFirst(events.count - 100)
         }
     }
 
     private static let eventTimeFormatter: DateFormatter = {
         let formatter = DateFormatter()
         formatter.dateStyle = .none
         formatter.timeStyle = .medium
         return formatter
     }()
 }
 
 private enum EngagementDebugError: LocalizedError {
     case invalidUTF8
 
     var errorDescription: String? {
         switch self {
         case .invalidUTF8:
             "The signal could not be encoded as UTF-8."
         }
     }
 }