Day 12 · 1부 · .task 수명과 로딩 상태

import UIKit

final class PhotosViewController: UIViewController {
    private var loadTask: Task<Void, Never>?

    override func viewDidAppear(_ animated: Bool) {
        super.viewDidAppear(animated)
        loadTask = Task { await self.load() }
    }

    override func viewDidDisappear(_ animated: Bool) {
        super.viewDidDisappear(animated)
        loadTask?.cancel()          // 빠뜨리면 화면이 사라져도 계속 돈다
    }

    private func load() async { }
}

struct TickerWrong: View {
    @State private var price = 0.0

    var body: some View {
        Text(price, format: .number)
            .onAppear {
                Task {
                    for await value in PriceFeed.stream() {
                        price = value          // 뷰가 사라진 뒤에도 계속 돈다
                    }
                }
            }
    }
}

struct Ticker: View {
    @State private var price = 0.0

    var body: some View {
        Text(price, format: .number)
            .task {
                for await value in PriceFeed.stream() {
                    price = value
                }
            }
    }
}

enum PriceFeed {
    static func stream() -> AsyncStream<Double> {
        AsyncStream { continuation in
            let producer = Task {
                while !Task.isCancelled {
                    continuation.yield(Double.random(in: 90...110))
                    try? await Task.sleep(for: .seconds(1))
                }
                continuation.finish()
            }
            continuation.onTermination = { _ in producer.cancel() }  // 소비자가 끝나면 생산도 멈춤
        }
    }
}

struct ReportView: View {
    @State private var pages: [String] = []
    @State private var errorMessage: String?

    var body: some View {
        List(pages, id: \.self) { Text($0) }
            .overlay { if let errorMessage { Text(errorMessage) } }
            .task {
                do {
                    for index in 1...20 {
                        try Task.checkCancellation()           // 취소됐으면 여기서 throw
                        try await Task.sleep(for: .milliseconds(200))
                        pages.append("Page \(index)")
                    }
                } catch is CancellationError {
                    // 화면을 떠나서 취소됨 — 오류 문구를 띄우지 않는다
                } catch {
                    errorMessage = error.localizedDescription
                }
            }
    }
}

struct SearchScreen: View {
    @State private var query = ""
    @State private var results: [String] = []

    var body: some View {
        NavigationStack {
            List(results, id: \.self) { Text($0) }
                .searchable(text: $query)
                .task(id: query) {
                    guard !query.isEmpty else { results = []; return }
                    do {
                        try await Task.sleep(for: .milliseconds(300))  // 디바운스
                        results = await SearchAPI.search(query)
                    } catch {
                        // 새 글자가 들어와 취소됨 — 아무것도 하지 않는다
                    }
                }
                .navigationTitle("검색")
        }
    }
}

enum SearchAPI {
    static func search(_ query: String) async -> [String] {
        ["\(query)ift", "\(query)iftUI", "\(query)ift Testing"]
    }
}

struct SearchScreenWrong: View {
    @State private var query = ""
    @State private var results: [String] = []

    var body: some View {
        List(results, id: \.self) { Text($0) }
            .searchable(text: $query)
            .onChange(of: query) { _, newValue in
                Task {
                    results = await SearchAPI.search(newValue)  // 응답 순서 = 요청 순서라는 보장 없음
                }
            }
    }
}

@Observable
final class ProfileModelWrong {
    var isLoading = false
    var errorMessage: String?
    var profile: Profile?
    // isLoading == true && errorMessage != nil 인 순간이 생길 수 있다
}

enum LoadState<Value> {
    case idle
    case loading
    case loaded(Value)
    case failed(String)
}

struct Profile { let name: String }

struct ProfileAPI {                              // 네트워크 대신 1초 지연
    func fetch() async throws -> Profile {
        try await Task.sleep(for: .seconds(1))
        return Profile(name: "Taylor")
    }
}

@MainActor
@Observable
final class ProfileModel {
    private(set) var state: LoadState<Profile> = .idle
    private let api = ProfileAPI()

    func load() async {
        if case .loading = state { return }    // 이미 로딩 중이면 무시
        state = .loading
        do {
            state = .loaded(try await api.fetch())
        } catch is CancellationError {
            state = .idle                       // 취소는 실패가 아니다
        } catch {
            state = .failed(error.localizedDescription)
        }
    }
}

struct ProfileScreen: View {
    @State private var model = ProfileModel()

    var body: some View {
        Group {
            switch model.state {
            case .idle, .loading:
                ProgressView()
            case .loaded(let profile):
                Text(profile.name).font(.title)
            case .failed(let message):
                ContentUnavailableView {
                    Label("불러오지 못했다", systemImage: "wifi.exclamationmark")
                } description: {
                    Text(message)
                } actions: {
                    Button("다시 시도") { Task { await model.load() } }
                }
            }
        }
        .task { await model.load() }
    }
}

struct SaveButton: View {
    @State private var isSaving = false
    let save: () async -> Void

    var body: some View {
        Button {
            isSaving = true                 // ① 탭한 그 프레임에 반영
            Task {
                await save()                // ② 비동기 작업
                isSaving = false            // ③ 끝나면 다시 동기 변경
            }
        } label: {
            Text("저장")
                .opacity(isSaving ? 0 : 1)                // 버튼 크기 유지
                .overlay { if isSaving { ProgressView() } }
        }
        .disabled(isSaving)
    }
}