should restart the app to update coredata(ios) - ios

Question

I have the following coredata code
in my view controller i have a button to update a label
the problem is that i should restart the app or hit the update button twice to see the updated label
it seems the database gets updated but not the ui
my coreDataStack:
import Foundation
import CoreData
class CoreDataStack: NSObject {
static let moduleName = "myModel"
static let sharedInstance = CoreDataStack()
/
lazy var managedObjectModel: NSManagedObjectModel = {
let modelURL = Bundle.main.url(forResource:
CoreDataStack.moduleName, withExtension: "momd")!
return NSManagedObjectModel(contentsOf: modelURL)!
}()
lazy var applicationDocumentsDirectory: URL = {
/
return NSPersistentContainer.defaultDirectoryURL()
}()
lazy var persistentStoreCoordinator: NSPersistentStoreCoordinator = {
let coordinator = NSPersistentStoreCoordinator(managedObjectModel:
self.managedObjectModel)
let persistentStoreURL =
self.applicationDocumentsDirectory.appendingPathComponent(CoreDataStack.mo
duleName + ".sqlite")
do {
/
try coordinator.addPersistentStore(ofType: NSSQLiteStoreType,
configurationName: nil,
at: persistentStoreURL,
options: [NSMigratePersistentStoresAutomaticallyOption: true,
NSInferMappingModelAutomaticallyOption: false])
} catch {
fatalError("Persistent store error! \(error)")
}
return coordinator
}()
fileprivate lazy var saveManagedObjectContext: NSManagedObjectContext = {
let moc = NSManagedObjectContext(concurrencyType: .privateQueueConcurrencyType)
moc.persistentStoreCoordinator = self.persistentStoreCoordinator
return moc
}()
lazy var managedObjectContext: NSManagedObjectContext = {
let managedObjectContext = NSManagedObjectContext(concurrencyType: .mainQueueConcurrencyType)
managedObjectContext.parent = self.saveManagedObjectContext
return managedObjectContext
}()
func saveMainContext() {
guard managedObjectContext.hasChanges || saveManagedObjectContext.hasChanges else {
return
}
managedObjectContext.performAndWait() {
do {
print("saved data simple")
try self.managedObjectContext.save()
} catch {
fatalError("Error saving main managed object context! \(error)")
}
}
saveManagedObjectContext.perform() {
do {
print("saved data private context")
try self.saveManagedObjectContext.save()
} catch {
fatalError("Error saving private managed object context! \(error)")
}
}
}
func createCoreDataContainerOnFirstLaunch() {
/
let previouslyLaunched = UserDefaults.standard.bool(forKey: "previouslyLaunchedDb2")
if !previouslyLaunched {
UserDefaults.standard.set(true, forKey: "previouslyLaunchedDb2")
/
let directory = NSPersistentContainer.defaultDirectoryURL()
let url = directory.appendingPathComponent(CoreDataStack.moduleName + ".sqlite")
/
/
let seededDatabaseURL = Bundle.main.url(forResource: CoreDataStack.moduleName, withExtension: "sqlite")!
/
_ = try? FileManager.default.removeItem(at: url)
do {
try FileManager.default.copyItem(at: seededDatabaseURL, to: url)
} catch let nserror as NSError {
fatalError("Error: \(nserror.localizedDescription)")
}
/
let seededSHMURL = Bundle.main.url(forResource: CoreDataStack.moduleName, withExtension: "sqlite-shm")!
let shmURL = directory.appendingPathComponent(CoreDataStack.moduleName + ".sqlite-shm")
_ = try? FileManager.default.removeItem(at: shmURL)
do {
try FileManager.default.copyItem(at: seededSHMURL, to: shmURL)
} catch let nserror as NSError {
fatalError("Error: \(nserror.localizedDescription)")
}
/
let seededWALURL = Bundle.main.url(forResource: CoreDataStack.moduleName, withExtension: "sqlite-wal")!
let walURL = directory.appendingPathComponent(CoreDataStack.moduleName + ".sqlite-wal")
_ = try? FileManager.default.removeItem(at: walURL)
do {
try FileManager.default.copyItem(at: seededWALURL, to: walURL)
} catch let nserror as NSError {
fatalError("Error: \(nserror.localizedDescription)")
}
print("Seeded Core Data")
}
}
}
my appDelegate:
var coreDataStack = CoreDataStack()
coreDataStack.createCoreDataContainerOnFirstLaunch()
updateDB.updateDatabase(entityName: "myTable")
my view controller:
var coreDataStack = CoreDataStack()
var MatchList = [Matches]()
override func viewDidLoad() {
super.viewDidLoad()
refreshMatches()
}
#objc func updateMatchDetails() {
DispatchQueue.global(qos: DispatchQoS.QoSClass.background).async {
self.MatchList.removeAll()
self.updateDB.updateDatabase(entityName: "Matches")
DispatchQueue.main.async {
self.refreshMatches()
}
}
func updateDatabase(entityName:String){
Alamofire.request(url, method: .get, parameters: parameters, encoding: URLEncoding(destination: .queryString), headers: nil).responseJSON{ response in
if let jsonObject = response.result.value, let items = jsonObject as? [[String: Any]] {
/
/
guard let entity = NSEntityDescription.entity(forEntityName: entityName, in:(self.dataStack.mainContext)) else {
fatalError(LoaderError.NoEntityDescription.rawValue)
}
self.dataStack.sync(items, inEntityNamed: entity.name!) { result in
print(result ?? "updated \(entityName)")
}
} else if let error = response.error {
print(error as NSError)
} else {
print(LoaderError.UnknownError)
}
}
}
func refreshMatches(){
do{
let request = NSFetchRequest<Matches>(entityName:"Matches")
let result = try
self.coreDataStack.managedObjectContext.fetch(request)
MatchList = result
if result.count >= 1{
for item in MatchList {
let row = item.display!
if row == "True"{
if let index = result.index(of: item) {
print("index:\(index)")
self.matchStatus.text = "match status: " + item.matchStatus!
self.view.setNeedsLayout()
}
}
}
}
}catch{
print("there was an error")
}
}
#IBAction func update(_ sender: Any) {
updateMatchDetails()
}

Answer 1

Your network operation will complete asynchronously, so refreshMatches is called before updateDatabase has updated Core Data. This means you only get the old data.
You need to call refreshMatches from the completion handler of your data sync operation:
func updateDatabase(entityName:String){
Alamofire.request(url, method: .get, parameters: parameters, encoding: URLEncoding(destination: .queryString), headers: nil).responseJSON{ response in
if let jsonObject = response.result.value, let items = jsonObject as? [[String: Any]] {
guard let entity = NSEntityDescription.entity(forEntityName: entityName, in:(self.dataStack.mainContext)) else {
fatalError(LoaderError.NoEntityDescription.rawValue)
}
self.dataStack.sync(items, inEntityNamed: entity.name!) { result in
print(result ?? "updated \(entityName)")
DispatchQueue.main.async {
self.refreshMatches()
}
}
} else if let error = response.error {
print(error as NSError)
} else {
print(LoaderError.UnknownError)
}
}
}