Rork Max アプリで通信の切断と復帰に強くする — NWPathMonitor によるオフライン検知と再送設計

import SwiftUI
 
struct OfflineBanner: View {
    @EnvironmentObject var monitor: NetworkMonitor
 
    var body: some View {
        if !monitor.isConnected {
            HStack(spacing: 8) {
                Image(systemName: "wifi.slash")
                Text("オフラインです。変更は接続後に自動で送信します")
                    .font(.footnote)
            }
            .padding(.vertical, 8)
            .frame(maxWidth: .infinity)
            .background(.thinMaterial)
            .transition(.move(edge: .top).combined(with: .opacity))
        }
    }
}

@main
struct MyApp: App {
    @StateObject private var monitor = NetworkMonitor.shared
 
    var body: some Scene {
        WindowGroup {
            ContentView()
                .environmentObject(monitor)
                .safeAreaInset(edge: .top) {
                    OfflineBanner()
                        .environmentObject(monitor)
                        .animation(.easeInOut, value: monitor.isConnected)
                }
        }
    }
}

import Foundation
import Combine
 
actor SendQueue {
    struct Job: Codable, Identifiable {
        let id: UUID
        let endpoint: String
        let payload: Data
    }
 
    private var jobs: [Job] = []
    private var isFlushing = false
 
    func enqueue(_ job: Job) {
        jobs.append(job)
    }
 
    func flush(using send: @Sendable (Job) async throws -> Void) async {
        guard !isFlushing else { return }   // 二重フラッシュ防止
        isFlushing = true
        defer { isFlushing = false }
 
        while let job = jobs.first {
            do {
                try await send(job)
                jobs.removeFirst()          // 成功したものだけ外す
            } catch {
                break                        // 失敗したら残して次の復帰を待つ
            }
        }
    }
}

@MainActor
final class SyncCoordinator: ObservableObject {
    private let queue = SendQueue()
    private var cancellable: AnyCancellable?
    private var wasConnected = true
 
    init(monitor: NetworkMonitor) {
        cancellable = monitor.$isConnected
            .removeDuplicates()
            .sink { [weak self] connected in
                guard let self else { return }
                let recovered = connected && !self.wasConnected
                self.wasConnected = connected
                if recovered {
                    Task { await self.flush() }
                }
            }
    }
 
    func submit(endpoint: String, payload: Data) async {
        await queue.enqueue(.init(id: UUID(), endpoint: endpoint, payload: payload))
    }
 
    private func flush() async {
        await queue.flush { job in
            var request = URLRequest(url: URL(string: job.endpoint)!)
            request.httpMethod = "POST"
            request.httpBody = job.payload
            request.setValue(job.id.uuidString, forHTTPHeaderField: "Idempotency-Key")
            _ = try await URLSession.shared.data(for: request)
        }
    }
}