Last reply continued:
I adjusted your code a bit where you check the deleted objectIDs inside a Notification userInfo, because my notification used the key deleted -- so I had to use NSManagedObjectContext.NotificationKey.deletedObjects.
I wrote an extension of Notification for reusing the check in my second and third View. This is the code of the Notification extension:
import CoreData
extension Notification {
		/*Returns whether this notification is about the deletion of the given `NSManagedObject` instance*/
		func isDeletion(of managedObject: NSManagedObject) -> Bool {
				guard let deletedObjectIDs = self.deletedObjectIDs
				else {
						return false
				}
				return deletedObjectIDs.contains(managedObject.objectID)
		}
		private var deletedObjectIDs: [NSManagedObjectID]? {
				guard let deletedObjects =
								self.userInfo?[NSManagedObjectContext.NotificationKey.deletedObjects.rawValue]
								as? Set<NSManagedObject>,
							deletedObjects.count > 0
				else {
						return .none
				}
				return deletedObjects.map(\.objectID)
		}
}
What I expect to happen:
If a user navigates from View 1 to View 3 and taps on the Button "DELETE this Item", I want that my Detail-Views get dismissed. I want that View 3 and View 2 get dismissed. I want to return to my first view. This should also work when a user has open View 3 from Tab 1 and Tab 2.
What actually happens:
Dismissing my View 2 and View 3 manually by clicking on the "Dismiss" button works fine. Also the "Reset" Button on View 3 works in a way that View 3 and View 2 are dismissed and I turn back to View 1.
However, as soon as I invoke the delete and save Core Data operation, my Views are not dismissed. Instead, just my View 3 gets dismissed and I am stuck at View 2, where I even cannot manually dismiss the View 2 with the "Dismiss" Button. View 2 cannot access attributes of the deleted NSManagedObject, so instead my fallback values are used.
I also tried to use the environment variable @Environment(\.presentationMode) var presentationMode and presentationMode.wrappedValue.dismiss() instead of Bindings between my Views, but that resulted in the same unwanted behavior.
I would like that all my Child-Detail-Views get dismissed on Deletion resp. firing of Notification. It does not make sense to display View 2 if it is not possible, due to the deletion of my persistence object.
I hope that someone can help me with this issue. I am really stuck here, and I just want to get it to work as I expect it.
Thank you so much for your help! 🙏🏻☺️
Best,
Bernhard
bernhard-st
Users receive reputation points by contributing quality content to the forums.
Posts include post and replies published on the forums.
Post authors can mark replies as Accepted to indicate successful solutions.
Apple Developer Forums admins can mark replies as Apple Recommended to indicate an approved solution
Post
Replies
Boosts
Views
Activity
Last reply continued:
This is the code of View2:
import SwiftUI
struct View2: View {
		@Environment(\.managedObjectContext) var moc
		@ObservedObject var item: Item
		@Binding var isView2Presented: Bool
		
		var body: some View {
				List {
						Text("Item name: \(item.name ?? "item name unknown")")
						View2_Row(item: item)
						Button(action: { isView2Presented = false }, label: {Text("Dismiss")})
				}
				.listStyle(InsetGroupedListStyle())
				.navigationTitle("View 2")
				.onReceive(NotificationCenter.default.publisher(for: Notification.Name(rawValue: "Reset"))) { _ in
						print("\(Self.self) inside reset notification closure")
						self.isView2Presented = false
				}
				.onReceive(NotificationCenter.default.publisher(for: .NSManagedObjectContextDidSave, object: self.moc),
									 perform: dismissIfObjectIsDeleted(_:))
		}
		
		private func dismissIfObjectIsDeleted(_ notification: Notification) {
				if notification.isDeletion(of: self.item) {
						print("\(Self.self) dismissIfObjectIsDeleted Dismiss view after deletion of Item")
						isView2Presented = false
				}
		}
}
struct View2_Row : View {
		@ObservedObject var item: Item
		@State private var isView3Presented: Bool = false
				
		var body: some View {
				NavigationLink("View 3",
											 destination: View3(item: item,
																					isView3Presented: $isView3Presented),
											 isActive: $isView3Presented)
				.isDetailLink(false)
		}
}
In View2 I display one NavigationLink to my View3 and also pass a Binding and the persistent Item instance. This View also listens to my custom Notification named Reset and for .NSManagedObjectContextDidSave and executes a closure when triggered onReceive. On receipt of a notification I want to dismiss the View2, such that View1 is displayed. This is the code of View3:
import SwiftUI
struct View3: View {
		@Environment(\.managedObjectContext) var moc
		@ObservedObject var item: Item
		
		@State var isAddViewPresented: Bool = false
		@Binding var isView3Presented: Bool
		var body: some View {
				Group {
						List {
								Text("Item name: \(item.name ?? "item name unknown")")
								
								Button("DELETE this Item") {
										moc.delete(self.item)
										try! moc.save()
										/*adding the next line does not matter:*/
										/*NotificationCenter.default.post(Notification.init(name: Notification.Name(rawValue: "Reset")))*/
								}.foregroundColor(.red)
								
								Button(action: {
										NotificationCenter.default.post(Notification.init(name: Notification.Name(rawValue: "Reset")))
								}, label: {Text("Reset")}).foregroundColor(.green)
								
								Button(action: {isView3Presented = false }, label: {Text("Dismiss")})
						}
				}
				.onReceive(NotificationCenter.default.publisher(for: .NSManagedObjectContextDidSave, object: self.moc),
									 perform: dismissIfObjectIsDeleted(_:))
				.onReceive(NotificationCenter.default.publisher(for: Notification.Name(rawValue: "Reset"))) { _ in
						print("\(Self.self) inside reset notification closure")
						self.isView3Presented = false
				}
				.listStyle(InsetGroupedListStyle())
				.navigationTitle("View 3")
				.toolbar {
						ToolbarItem {
								Button(action: {isAddViewPresented.toggle()}, label: {
										Label("Add", systemImage: "plus.circle.fill")
								})
						}
				}
				.sheet(isPresented: $isAddViewPresented, content: {
						Text("DestinationDummyView")
				})
		}
		
		private func dismissIfObjectIsDeleted(_ notification: Notification) {
				if notification.isDeletion(of: self.item) {
						print("\(Self.self) dismissIfObjectIsDeleted Dismiss view after deletion of Item")
						isView3Presented = false
				}
		}
}
My View3 also listens for my custom Reset and for the NSManagedObjectContextDidSave notifications, like View2. On receipt of these notifications I want also that View3 gets dismissed. This View has a "Reset" Button, that fires the Reset Notification. A second button ("DELETE this Item") calls delete on the persistence instance Item and save on the NSManagedObjectContext -- which fires the .NSManagedObjectContextDidSave notification.
@DelawareMathGuy: Thank you for sharing your project. Good to have this well-elaborated project as a reference.
@jjatie: Thank you for the example code with the Notification publisher for obtaining information of a persistence object deletion. It looks really good and seems to be best-suited for my app to handle a View dismiss when I receive a notification after saving the deletion of an object. However, I run into a problem and I hope you can further help me here.
My app has multiple Child-Detail-Views and I want that all Detail-Views are dismissed, if a persistence object was deleted, which these views need. But, I am not able to dismiss all Child-Detail-Views, but only the last one.
I also tried to send my own custom notification independent of the Core-Data delete and save operations -- this has worked. However, if I try to dismiss my Child-Views after deleting my persistence object my Views are not dismissed. :-(
I spent time to build a small example project that shows the problem.
First, I created a new Xcode Project with Core Data enabled. I modified the existing Item entity just a little bit, by adding a name attribute of type String. This is the code of my app @main entry point:
import SwiftUI
import CoreData
@main
struct SwiftUI_CoreData_ExApp: App {
		let persistenceController = PersistenceController.shared
		var body: some Scene {
				WindowGroup {
						TabView {
								View1().tabItem {
										Image(systemName: "1.square.fill")
										Text("Tab 1")
								}
								View1().tabItem {
										Image(systemName: "2.square.fill")
										Text("Tab 2")
								}
						}
						.environment(\.managedObjectContext, persistenceController.container.viewContext)
						.onAppear(perform: {
								let moc = persistenceController.container.viewContext
								/*Create persistence instances in Core Data database for test and reproduction purpose*/
								print("Preparing test data")
								let fetchRequest: NSFetchRequest<NSFetchRequestResult> = NSFetchRequest(entityName: Item.entity().name!)
								let deleteRequest = NSBatchDeleteRequest(fetchRequest: fetchRequest)
								try! moc.execute(deleteRequest)
								for i in 1..<4 {
										let item = Item(context: moc)
										item.name = "Item \(i)"
								}
								try! moc.save()
						})
				}
		}
}
As you can see I have 2 Tabs using the same view View1. For reproduction and test purposes I add 3 Item instances into the Core Data database onAppear, after deleting already existing ones.
My example project consists of 3 views View1, View2, View3.
When clicking on one of the Tabs users start in the first View and can the navigate via NavigationLink to the second View and then to the third View. This is the code of the View1:
import SwiftUI
struct View1: View {
		@FetchRequest(entity: Item.entity(), sortDescriptors: [])
		private var items: FetchedResults<Item>
		
		var body: some View {
				NavigationView {
						List {
								ForEach(self.items, id: \.self) { item in
										View1_Row(item: item)
								}
						}.listStyle(InsetGroupedListStyle())
						.navigationTitle("View 1")
				}
		}
}
struct View1_Row: View {
		@ObservedObject var item: Item
		@State var isView2Presented: Bool = false
		var body: some View {
				NavigationLink(
						destination: View2(item: item, isView2Presented: $isView2Presented),
						isActive: $isView2Presented,
						label: {
								Text("\(item.name ?? "missing item name") - View 2")
						})
						.isDetailLink(false)
		}
}
My View1 fetches all instances of Item with @FetchRequeset and renders a NavigationLink for every persistent object. Note that I pass my View2 the actual persistence instance and a Binding (isView2Presented) whether the View2 should be shown resp. is active.
Well, @jjatie I can see that my DetailView for a persistence entity in Tab2 gets automatically updated, if I change this persistence entity in the DetailView inside Tab1 on save and vice versa. Apparently, it's because @FetchRequest does automatically pull updates if possible.
But I am wondering, how I should handle the situation, where I have open the same DetailView on Tab 1 and Tab 2. User deletes Core Data entity on Tab 1 and switches back to Tab 2.
@DelawareMathGuy pointed out to save the persistent objectID for the current persistent entity in the DetailView and always check .onAppear, if the persistent object still exists with context.object(with: objectId) (where context is an instance of NSManagedObjectContext).
But what about persistentObject.isFault? Would you recommend to use it to check whether the current persistent entity in use for the DetailView still exists? Do you see it as an alternative to query the object by objectID or is this not a best-practice?
Different situation but also related to updating the View on persistent Object change:
But some entities that have relationships to other persistent entities are not automatically updated, if the related entity changed.
I use as workaround to always update my @FetchRequest results, where necessary this workaround in my view:
struct DetailView: View {
@State private var viewAppeared: Bool = false
		var body: some View {
				Group {
						RealDetailView()
						if viewAppeared {
EmptyView()
				}.onAppear {
viewAppeared.toggle()
}
}
This workaround causes my View to update if some persistent entities, that have a relationship to my current persistent object, have changes. I don't know if anybody has a better advice for that… But let me know. :-)
I use @FetchRequest for both of my Tabs, but a bit differently.
In the Tab 1 my View has @FetchRequest that directly fetches instances of MyPersistenceObject:
struct Tab1: View {
		@Environment(\.managedObjectContext) var managedObjectContext
		@FetchRequest(entity: MyPersistenceObject.entity(),
sortDescriptors: [])
var myPersistenceObjects: FetchedResults<MyPersistenceObject>
		...
		ForEach(myPersistenceObjects, id: \.self) { myPersistenceObject in
				 ListViewTab1(myPersistenceObject: myPersistenceObject)
		}
		
Instances of myPersistenceObject are then passed to my ListViewTab1 View (see above).
But, for the Tab 2, I also use @FetchRequest, but I am not directly fetching MyPersistenceObject but Parents of parents of my MyPersistenceObject.
struct Tab2: View {
@FetchRequest(entity: MyPersistenceObjectParentParent.entity(),
sortDescriptors: [])
private var parentParents: FetchedResults<MyPersistenceObjectParentParent>
}
I then have NavigationLinks to a Tab2Child View, which receive one MyPersistenceObjectParentParent instance. This child then inits another FetchRequest in the init with some attribute
struct Tab2Child: View {
@Environment(\.managedObjectContext) var managedObjectContext
@ObservedObject var parentParent: MyPersistenceObjectParentParent
@FetchRequest
var myPersistenceObjectParents: FetchedResults<MyPersistenceObjectParent>
init(parentParent: MyPersistenceObjectParentParent) {
self.parentParent = parentParent
self._myPersistenceObjectParents = FetchRequest(entity: MyPersistenceObjectParent.entity(),
sortDescriptors: [],
predicate: NSPredicate(format: "parentParent = %@", argumentArray: [parentParent]))
}
The view Tab2Child then has two further child views, which get passed one instance of MyPersistenceObjectParent.
The leaf child Detail-View(see above) then gets passed into the the persistent @ObservedObject MyPersistenceObject into the view, because the parent of the child-View uses a ForEach on one instance of the MyPersistenceObjectParent.
struct Detail-View2-Parent: View {
@Environment(\.managedObjectContext) var managedObjectContext
@ObservedObject
var myPersistenceObjectParent: MyPersistenceObjectParent
		var body: some View {
List {
ForEach(myPersistenceObjectParent.myPersistenceObjects, id: \.self) { myPersistenceObject in
DetailView(myPersistenceObject: myPersistenceObject)
}
Sorry, that its not really clearly structured. :(
My question is resolved. I got help on StackOverFlow [1].
In short: The solution is to add ".isDetailLink(false)" to each NavigationLink in my views.
You may see the Apple Documentation on "isDetailLink(_:)" [2].
		NavigationLink(
				destination: View2(types: ["Exams"], presentView2: $presentView2),
				isActive: $presentView2,
				label: {
						Text("View2")
				}).isDetailLink(false)
...
		NavigationLink("View3", destination: View3(presentView3: $presentView3), isActive: $presentView3)
			 .isDetailLink(false)
...
		NavigationLink("View4", destination: View4(presentView4: $presentView4), isActive: $presentView4)
			 .isDetailLink(false)
[1] https://stackoverflow.com/questions/64958493/dismiss-of-swiftui-views-one-after-the-other-programmatically-does-not-work
[2] https://developer.apple.com/documentation/swiftui/navigationlink/isdetaillink(_:)