来自URL的图像未加载

Question

我试图让一个屏幕女巫从实时数据库中获取一个图像url，然后从这个url加载图像。问题是，每当我调用带有C的函数时，从数据库中获取url，映像没有加载，全局变量withc保持，url总是默认值。

My函数：

@State var imageURL: String = "none"


func getCurrentUserProfilePictureURL() {
    
    let ref: DatabaseReference = Database.database().reference()
    let userRef = ref.child("users").child(Auth.auth().currentUser?.uid ?? "noid")

    // Get Current Profie Picture URL from Real-Time Database
    userRef.observeSingleEvent(of: .value) { snapshot in
        
        self.imageURL = snapshot.childSnapshot(forPath: "photoUrl").value as! String
        
                    
    } withCancel: { error in
        print("ERROR: \(error.localizedDescription)")
    }
    
                    
}

我的图像视图：

    VStack {
        
        if let imageURLString = imageURLString, let url = URL(string: imageURLString) {
            AsyncImage(url: url) { image in
                image
            } placeholder: {
                placeholder
            }

        } else {
            placeholder
        }
        
    }.onAppear {
        getCurrentUserProfilePictureURL()
    }

我的占位符：

var placeholder : some View {
    Image("user_icon")
        .frame(width: 120, height: 120, alignment: .center)
}

AsyncImage.swift:

//
//  AsyncImage.swift
//  iGrow Goals
//
//  Created by George Sepetadelis on 27/8/21.
//

import Foundation
import SwiftUI
import UIKit
import Combine

struct AsyncImage<Placeholder: View>: View {
    @StateObject private var loader: ImageLoader
    private let placeholder: Placeholder
    private let image: (UIImage) -> Image
    
    init(
        url: URL,
        @ViewBuilder placeholder: () -> Placeholder,
        @ViewBuilder image: @escaping (UIImage) -> Image = Image.init(uiImage:)
    ) {
        self.placeholder = placeholder()
        self.image = image
        _loader = StateObject(wrappedValue: ImageLoader(url: url, cache: Environment(\.imageCache).wrappedValue))
    }
    
    var body: some View {
        content
            .onAppear(perform: loader.load)
    }
    
    private var content: some View {
        Group {
            if loader.image != nil {
                image(loader.image!)
            } else {
                placeholder
            }
        }
    }
}

protocol ImageCache {
    subscript(_ url: URL) -> UIImage? { get set }
}

struct TemporaryImageCache: ImageCache {
    private let cache = NSCache<NSURL, UIImage>()
    
    subscript(_ key: URL) -> UIImage? {
        get { cache.object(forKey: key as NSURL) }
        set { newValue == nil ? cache.removeObject(forKey: key as NSURL) : cache.setObject(newValue!, forKey: key as NSURL) }
    }
}

class ImageLoader: ObservableObject {
    @Published var image: UIImage?
    
    private(set) var isLoading = false
    
    private let url: URL
    private var cache: ImageCache?
    private var cancellable: AnyCancellable?
    
    private static let imageProcessingQueue = DispatchQueue(label: "image-processing")
    
    init(url: URL, cache: ImageCache? = nil) {
        self.url = url
        self.cache = cache
    }
    
    deinit {
        cancel()
    }
    
    func load() {
        guard !isLoading else { return }

        if let image = cache?[url] {
            self.image = image
            return
        }
        
        cancellable = URLSession.shared.dataTaskPublisher(for: url)
            .map { UIImage(data: $0.data) }
            .replaceError(with: nil)
            .handleEvents(receiveSubscription: { [weak self] _ in self?.onStart() },
                          receiveOutput: { [weak self] in self?.cache($0) },
                          receiveCompletion: { [weak self] _ in self?.onFinish() },
                          receiveCancel: { [weak self] in self?.onFinish() })
            .subscribe(on: Self.imageProcessingQueue)
            .receive(on: DispatchQueue.main)
            .sink { [weak self] in self?.image = $0 }
    }
    
    func cancel() {
        cancellable?.cancel()
    }
    
    private func onStart() {
        isLoading = true
    }
    
    private func onFinish() {
        isLoading = false
    }
    
    private func cache(_ image: UIImage?) {
        image.map { cache?[url] = $0 }
    }
}

struct ImageCacheKey: EnvironmentKey {
    static let defaultValue: ImageCache = TemporaryImageCache()
}

extension EnvironmentValues {
    var imageCache: ImageCache {
        get { self[ImageCacheKey.self] }
        set { self[ImageCacheKey.self] = newValue }
    }
}

Answer 1

有几件事应该改变：

1. 你只需要加载你的AsyncImage一旦你有一个有效的网址-现在，你尝试加载从一开始，那里的值只是“无”

1. 您不应该在init中调用getCurrentUserProfilePictureURL，因为SwiftUI View上的init可能会被多次调用，并且不应该用于不应该运行超过一次的重载或代码。相反，使用onAppear.

struct ContentView: View {
    @State private var imageURLString: String? = nil
    
    var placeholder : some View {
        Image("user_icon")
            .frame(width: 120, height: 120, alignment: .center)
    }
    
    var body: some View {
        VStack {
            if let imageURLString = imageURLString, let url = URL(string: imageURLString) {
                AsyncImage(url: url) { image in
                    image
                } placeholder: {
                    placeholder
                }

            } else {
                placeholder
            }
        }.onAppear {
            getCurrentUserProfilePictureURL()
        }
    }
    
    func getCurrentUserProfilePictureURL() {
        
        let ref: DatabaseReference = Database.database().reference()
        let userRef = ref.child("users").child(Auth.auth().currentUser?.uid ?? "noid")

        // Get Current Profie Picture URL from Real-Time Database
        userRef.observeSingleEvent(of: .value) { snapshot in
            self.imageURL = snapshot.childSnapshot(forPath: "photoUrl").value as! String
        } withCancel: { error in
            print("ERROR: \(error.localizedDescription)")
        }
    }
}

在上面的代码中，imageURLString是一个可选的--如果它没有值，则显示占位符图像。一旦它有了一个值(即异步getCurrentUserProfilePictureURL完成时)，它就可以开始加载AsyncImage

基于这些注释，您正在使用某种自定义AsyncImage实现。因此，该部分的代码可能需要看起来更像(猜测，因为我不知道实现是什么样子的--这是基于原始代码的)：

AsyncImage(url: url,
           placeholder: { placeholder },
           image: { Image(uiImage: $0).resizable() })