Got this error: nw_protocol_get_quic_image_block_invoke dlopen libquic failed

Question

I was trying to connect my API data to view it in the cell but it seems that I can't get my response and it's always == nil The code below describes the Country.SWIFT // Model.SWIFT // Response.SWIFT which is showing how can I get my JSON response using Codable and CountryCell.SWIFT is showing how I used it to call the API The link to the API image:

Country.SWIFT

struct Country: Decodable {
    
    var CountryName = ""
    var CountryImage = ""
    var objectId = ""


// MARK: - Coding Keys
enum CodingKeys: String, CodingKey {
    case CountryName = "CountryName"
    case CountryImage = "CountryImage"
    case objectId = "objectId"
}

//MARK: - Json Decoder

init(from decoder: Decoder) throws {
    
    let container = try decoder.container(keyedBy: CodingKeys.self)
    // Parsing our attributes
    self.CountryName = try container.decode(String.self, forKey: .CountryName)
    self.CountryImage = try container.decode(String.self, forKey: .CountryImage)
    self.objectId = try container.decode(String.self, forKey: .objectId)

}

}]

Model.SWIFT

protocol ModelDelegate {
    
    func countriesFetched (_ countries: [Country])
    
}

class Model {
    
    //MARK: - Vars
    var delegate: ModelDelegate?
    
    // MARK: - Get Countries
    func getCountries () {
        // URL Object
        let url = URL(string: Constants.API_URL)
        guard url != nil else {return}
        
        // URL Session object
        let session = URLSession.shared
        
        //Data Task from URLSession object
        
        let dataTask = session.dataTask(with: url!) { (data, response, error) in
            
            if error != nil || data == nil {
                print(error!.localizedDescription)
                return
            }
            print(data!)
            
            do {
                let decoder = JSONDecoder()
                let response = try decoder.decode(Response.self, from: data!)
                
                if response.items != nil {
                    
                    DispatchQueue.main.async {
                        self.delegate?.countriesFetched(response.items!)
                    }
                  
                }
            }
            catch {
                
            }
        }
        
        // start data task
        dataTask.resume()
    }
}

Response.SWIFT

 struct Response: Decodable {

    var items: [Country]? = []
    init(from decoder: Decoder) throws {
        var itemsContrainer = try decoder.unkeyedContainer()
        self.items = try itemsContrainer.decode([Country].self)
        
    }
    
    
}

CountryCell.SWIFT

class CountryCell: UICollectionViewCell {
    
    //MARK: - Vars
    var country: Country?
    
    //MARK: - Outlets
    @IBOutlet weak var imageViewCountryOutlet: UIImageView!
    @IBOutlet weak var lblCountryNameOutlet: UILabel!
    
    //MARK: - Creating Cell

    func generateCell (_ myCountry: Country) {
        self.country = myCountry
        
        guard self.country != nil else {  return }
        lblCountryNameOutlet.text = country!.CountryName
        
        guard self.country!.CountryImage != "" else {return}
        
        let url = URL(string: self.country!.CountryImage)
        
        guard url != nil else {return}
  
        let session = URLSession.shared
        
        let dataTask = session.dataTask(with: url!) { (data, response, error) in
            
            if error == nil || data != nil {
                if url!.absoluteString != self.country!.CountryImage {
                    
                    return
                }

                let image = UIImage(data: data!)

                DispatchQueue.main.async {
                    self.imageViewCountryOutlet.image = image
                    
                }
            }
            
        }

        dataTask.resume()
        
    }
}

Answer 1

There is no need for the wrapping Response type, decode the list of countries directly:

let decoder = JSONDecoder()
let items = try decoder.decode([Country].self, from: data!)

In your code, when you ask in Response for unkeyedContainer, the expected JSON structure would need additional nested array.

Check decoding errors in the catch block with

do {
...
}
catch {
    print(error)
}