Download multiple images into CoreData - ios

Question

I am writing an iOS App in Swift.
In my Home page (HomeLandingViewController.swift), I have to call two APIs parallel which gives me a list of images, and I have to download all those images, and then dump in CoreData. Till this process completes, I have to show some loading animation etc in UI.
FLOW:
Homepage VC loads > Start Animation > Call API 1 and Call API 2 parallel > Receive image arrays from API 1 and API 2 > get DATA of all those images > Dump into Coredata > Notify homepage VC that work is done > Stop Animation
For this purpose, I have made a dedicated class (IconsHelper.swift)
I am using Moya networking library.
The issue is that things are not working as expected. Because things are working asynchronous, the homepage VC is getting notified even before images are downloaded.
My Code Snippets:
IconsHelper.shared.getNewIconsFromServer()
class IconsHelper {
static let shared: IconsHelper = .init()
var group:DispatchGroup?
//Get Icons from API 1 and API 2:
func getNewIconsFromServer() {
group = DispatchGroup()
group?.enter()
let dispatchQueue_amc = DispatchQueue(label: "BackgroundIconsFetch_AMC", qos: .background)
dispatchQueue_amc.async(group: group) {
self.getNewIcons(type: .amcIcons)
}
if group?.hasGroupValue() ?? false {
group?.leave()
Log.b("CMSIcons: Group Leave 1")
}
group?.enter()
let dispatchQueue_bank = DispatchQueue(label: "BackgroundIconsFetch_Bank", qos: .background)
dispatchQueue_bank.async(group: group) {
self.getNewIcons(type: .bankIcons)
}
if group?.hasGroupValue() ?? false {
group?.leave()
Log.b("CMSIcons: Group Leave 2")
}
group?.notify(queue: .global(), execute: {
Log.b("CMSIcons: All icons fetched from server.")
})
}
func getNewIcons(type: CMSIconsTypes) {
let iconsCancellableToken: CancellableToken?
let progressClosure: ProgressBlock = { response in
}
let activityChange: (_ change: NetworkActivityChangeType) -> Void = { (activity) in
}
let cmsCommonRequestType=self.getCmsCommonRequestType(type: type)
iconsCancellableToken = CMSProvider<CMSCommonResponse>.request( .cmsCommonRequest(request: cmsCommonRequestType), success: { (_response) in
Log.b("CMSIcons: Get new icons from server for type: \(type)")
//Set http to https:
var iconsHostname:String=""{
didSet {
if let comps=URLComponents(string: iconsHostname) {
var _comps=comps
_comps.scheme = "https"
if let https = _comps.string {
iconsHostname=https
}
}
}
}
if (_response.data?.properties != nil) {
if _response.status {
let alias = self.getCmsAlias(type: type)
let property = _response.data?.properties.filter {$0.alias?.lowercased()==ValueHelper.getCMSAlias(alias)}.first?.value
if let jsonStr = property {
iconsHostname = _response.data?.hostName ?? ""
if let obj:CMSValuesResponse = CMSValuesResponse.map(JSONString: jsonStr) {
if let fieldsets=obj.fieldsets {
if fieldsets.count > 0 {
for index in 1...fieldsets.count {
let element=fieldsets[index-1]
if let prop = element.properties {
if(prop.count > 0) {
let urlAlias = self.getCmsURLAlias(type: type)
let iconUrl = prop.filter {$0.alias?.lowercased()==ValueHelper.getCMSAlias(urlAlias)}.first?.value
let name = prop.filter {$0.alias?.lowercased()==ValueHelper.getCMSAlias(.iconsNameAlias)}.first?.value
if let iconUrl=iconUrl, let name=name {
if let url = URL(string: iconsHostname+iconUrl) {
DispatchQueue.global().async {
if let data = try? Data(contentsOf: url) {
Log.b("CMSIcons: Icon url \(url.absoluteString) to Data done.")
var databaseDumpObject=CMSIconStructure()
databaseDumpObject.name=name
databaseDumpObject.data=data
self.dumpIconToLocalStorage(object: databaseDumpObject, type: type)
}
}
}
}
}
}
}//Loop ends.
//After success:
self.setFetchIconsDateStamp(type:type)
}
}
}
}
}
}
}, error: { (error) in
}, failure: { (_) in
}, progress: progressClosure, activity: activityChange) as? CancellableToken
}
//Dump icon data into CoreData:
func dumpIconToLocalStorage(object: CMSIconStructure, type: CMSIconsTypes) {
let entityName = self.getEntityName(type: type)
if #available(iOS 10.0, *) {
Log.b("Do CoreData task in background thread")
//Do CoreData task in background thread:
let context = appDelegate().persistentContainer.viewContext
let privateContext: NSManagedObjectContext = {
let moc = NSManagedObjectContext(concurrencyType: .privateQueueConcurrencyType)
moc.parent = context
return moc
}()
//1: Read all offline Icons:
let fetchRequest = NSFetchRequest<NSFetchRequestResult>(entityName: entityName)
fetchRequest.predicate = NSPredicate(format: "name = %#",
argumentArray: [object.name.lowercased()])
do {
let results = try privateContext.fetch(fetchRequest) as? [NSManagedObject]
if results?.count != 0 {
//2: Icon already found in CoreData:
if let icon=results?[0] {
icon.setValue(object.name.lowercased(), forKey: "name") //save lowercased
icon.setValue(object.data, forKey: "data")
}
} else {
//3: Icon not found in CoreData:
let entity = NSEntityDescription.entity(forEntityName: entityName, in: privateContext)
let newIcon = NSManagedObject(entity: entity!, insertInto: privateContext)
newIcon.setValue(object.name.lowercased(), forKey: "name") //save lowercased
newIcon.setValue(object.data, forKey: "data")
}
Log.b("CMSIcons: Icon data saved locally against name: \(object.name)")
} catch {
Log.i("Failed reading CoreData \(entityName.uppercased()). Error: \(error)")
}
privateContext.perform {
// Code in here is now running "in the background" and can safely
// do anything in privateContext.
// This is where you will create your entities and save them.
do {
try privateContext.save()
} catch {
Log.i("Failed reading CoreData \(entityName.uppercased()). Error: \(error)")
}
}
} else {
// Fallback on earlier versions
}
}
}

Answer 1

It is generally not recommended to store images as binary data in a Core Data persisted store. In stead, write the images to a local directory and store the local URL in core data instead. Here's an example workflow that might simplify some of your issues that you are experiencing using this recommended approach:
class IconsHelper {
let container: NSPersistentContainer
let provider: CMSProvider<CMSCommonResponse>
private let queue: DispatchQueue = DispatchQueue(label: "IconsHelper", qos: .userInitiated)
let documentsDirectory: URL = {
let searchPath = NSSearchPathForDirectoriesInDomains(.documentDirectory, .userDomainMask, true)
guard let path = searchPath.last else {
preconditionFailure("Unable to locate users documents directory.")
}
return URL(fileURLWithPath: path)
}()
init(container: NSPersistentContainer, provider: CMSProvider<CMSCommonResponse>) {
self.container = container
self.provider = provider
}
enum Icon: String, Hashable {
case amc
case bank
}
func getIcons(_ icons: Set<Icon>, dispatchQueue: DispatchQueue = .main, completion: #escaping ([Icon: URL]) -> Void) {
queue.async {
var results: [Icon: URL] = [:]
guard icons.count > 0 else {
dispatchQueue.async {
completion(results)
}
return
}
let numberOfIcons = icons.count
var completedIcons: Int = 0
for icon in icons {
let request = [""] // Create request for the icon
self.provider.request(request) { (result) in
switch result {
case .failure(let error):
// Do something with the error
print(error)
completedIcons += 1
case .success(let response):
// Extract information from the response for the icon
let imageData: Data = Data() // the image
let localURL = self.documentsDirectory.appendingPathComponent(icon.rawValue + ".png")
do {
try imageData.write(to: localURL)
try self.storeURL(localURL, forIcon: icon)
results[icon] = localURL
} catch {
print(error)
}
completedIcons += 1
if completedIcons == numberOfIcons {
dispatchQueue.async {
completion(results)
}
}
}
}
}
}
}
func storeURL(_ url: URL, forIcon icon: Icon) throws {
// Write the local URL for the specific icon to your Core Data Container.
let context = container.newBackgroundContext()
// Locate & modify, or create CMSIconStructure using the context above.
try context.save()
}
}
Then in your homepage view controller:
// Display Animation
let helper: IconsHelper = IconsHelper.init(container: /* NSPersistentContainer */, provider: /* API Provider */)
helper.getIcons([.amc, .bank]) { (results) in
// Process Results
// Hide Animation
}
The general design here to have a single call that will handle the downloading & processing of the images, then respond with the results after all of the networking calls & core data interactions have finished.
In the example, you initialize your IconsHelper with a reference to the CoreData NSPersistentContainer, and your networking instance. Does this approach help to clarify why your example code doesn't work the way you're expecting?