问SwiftUI:从异步模型发布更改

EN

var body: some Scene {
    WindowGroup {
        ContentView(asyncmethod: myAsyncViewModel())
    }
}

import SwiftUI

struct ContentView: View {
    @State private var isLoaderPresented = false
    @State private var isTopMessagePresented = false

    @ObservedObject var asyncmethod: myAsyncViewModel

    var body: some View {
        VStack {
            Spacer()
            Button( action: {
                    Task {
                        isTopMessagePresented = true
                        let response = await asyncmethod.thisMethodTakesTime()
                        // Want to return a string or object so I know what happens.
                        print("Response Loader: \(response ?? "no response")")
                        isTopMessagePresented = false
                    }
                },
                label: { Text("Run Top Banner Code") }
            )
            Spacer()
        }
        .foregroundColor(.black)
        .popup(isPresented: isTopMessagePresented, alignment: .top, direction: .top, content: {
            Snackbar(showForm: $isTopMessagePresented, asyncmethod: asyncmethod)
        })
    }
}

struct Snackbar: View {
    @Binding var showForm: Bool
    
    @ObservedObject var asyncmethod: myAsyncViewModel

    var body: some View {
        VStack {
            HStack() {
                Image(systemName: asyncmethod.imageName)
                    .resizable()
                    .aspectRatio(contentMode: ContentMode.fill)
                    .frame(width: 40, height: 40)
                Spacer()
                VStack(alignment: .center, spacing: 4) {
                    Text(asyncmethod.title)
                        .foregroundColor(.black)
                        .font(.headline)
                    
                    Text(asyncmethod.subTitle)
                        .font(.body)
                        .foregroundColor(.black)
                        .frame(maxWidth: .infinity)
                }
            }
            .frame(minWidth: 200)
        }
        .padding(15)
        .frame(maxWidth: .infinity, idealHeight: 100)
        .background(Color.black.opacity(0.1))
    }

}

import Foundation

class myAsyncViewModel:  ObservableObject  {
    @Published var imageName: String = "questionmark"
    @Published var title: String = "title"
    @Published var subTitle: String = "subtitle"
    
    func thisMethodTakesTime() async -> String? {
        print("In method: \(imageName), \(title), \(subTitle)")
        title = "MY METHOD"
        subTitle = "Starting out!"
        print("In method. Starting \(title)")
        subTitle = "This is the message"
        print("Sleeping")
        try? await Task.sleep(nanoseconds: 1_000_000_000)
        subTitle = "Between"
        try? await Task.sleep(nanoseconds: 1_000_000_000)
        print("After sleep. Ending")
        subTitle = "About to return. Success!"
        print("In method: \(imageName), \(title), \(subTitle)")
        return "RETURN RESULT"
    }
    
}

import SwiftUI

struct Popup<T: View>: ViewModifier {
    let popup: T
    let isPresented: Bool
    let alignment: Alignment
    let direction: Direction

    // 1.
    init(isPresented: Bool, alignment: Alignment, direction: Direction, @ViewBuilder content: () -> T) {
        self.isPresented = isPresented
        self.alignment = alignment
        self.direction = direction
        popup = content()
    }

    // 2.
    func body(content: Content) -> some View {
        content
            .overlay(popupContent())
    }

    // 3.
    @ViewBuilder private func popupContent() -> some View {
        GeometryReader { geometry in
            if isPresented {
                withAnimation {
                    popup
                        .transition(.offset(x: 0, y: direction.offset(popupFrame: geometry.frame(in: .global))))
                        .frame(width: geometry.size.width, height: geometry.size.height, alignment: alignment)
                }
            }
        }
    }
}

extension Popup {
    enum Direction {
        case top, bottom

        func offset(popupFrame: CGRect) -> CGFloat {
            switch self {
            case .top:
                let aboveScreenEdge = -popupFrame.maxY
                return aboveScreenEdge
            case .bottom:
                let belowScreenEdge = UIScreen.main.bounds.height - popupFrame.minY
                return belowScreenEdge
            }
        }
    }
}

private extension GeometryProxy {
    var belowScreenEdge: CGFloat {
        UIScreen.main.bounds.height - frame(in: .global).minY
    }
}

extension View {
    func popup<T: View>(
        isPresented: Bool,
        alignment: Alignment = .center,
        direction: Popup<T>.Direction = .bottom,
        @ViewBuilder content: () -> T
    ) -> some View {
        return modifier(Popup(isPresented: isPresented, alignment: alignment, direction: direction, content: content))
    }
}