WidgetKit with Data from CoreData

A couple of articles that I have read suggest that I get CoreData records from my DataManager like the following. It's kind of redundant as it accesses DataManager inside the TimelineProvider struct and also inside the Widget struct. That's why I wonder if this is the right approach.

import WidgetKit
import SwiftUI
import CoreData

struct Provider: TimelineProvider {
    func placeholder(in context: Context) -> SimpleEntry {
        ...
    }

    func getSnapshot(in context: Context, completion: @escaping (SimpleEntry) -> ()) {
        ...
    }

    func getTimeline(in context: Context, completion: @escaping (Timeline<Entry>) -> ()) {
        let manager = CloudDataManager()
        var records: [Little] = []
        let request = NSFetchRequest<Little>(entityName: "Little")
        do {
            records = try manager.context.fetch(request)
            records.sort { lhs, rhs in
                lhs.trashDate! < rhs.trashDate!
            }
            
        } catch {
            print("Fetch error for CloudDataManager: \(error.localizedDescription)")
        }
        
        var items: [Item] = []
        for record in records {
            let item = Item(trashDate: record.trashDate ?? Date.now, imageSelection: Int(record.imageSelection))
            items.append(item)
        }
        
        let entry = Timeline(entries: [SimpleEntry(date: Date(), items: items)], policy: .atEnd)
        completion(entry)
    }
}

struct SimpleEntry: TimelineEntry {
    let date: Date
    let items: [Item]
}

struct LittleGuyEntryView : View {
    var entry: Provider.Entry

    var body: some View {
        ZStack {
            ContainerRelativeShape()
                .fill(.widgetBackground)
            VStack {
                if entry.items.count > 0 {
                    ForEach(entry.items, id: \.id) { item in
                        ...
                    }
                }
            }
            .padding()
        }
    }
}

struct LittleGuy: Widget {
    let manager = DataManager()
    let kind: String = "App name"

    var body: some WidgetConfiguration {
        StaticConfiguration(kind: kind, provider: Provider()) { entry in
            LittleTrashEntryView(entry: entry)
                .environment(\.managedObjectContext, manager.context)
                .containerBackground(.fill.tertiary, for: .widget)
        }
        .contentMarginsDisabled()
        .supportedFamilies([.systemSmall])
    }
}

As widgets and the main iOS app are on the same device, they can use the same CoreData stack.

I have a CoreData class with methods to access the stack in the Widget target. It's instantiated in the WigetExtensionBundle as a global let so it's available everywhere.

Whenever I need to get data from CoreData I can just call something like coredata.shared.getMyData().

In my timeline method (not getTimeline as I'm using AppIntentTimelineProvider) I just call coredata.shared.getMyData().

Your DataManager class is my CoreData class, and in my case I'm creating one global instance of it, while you're doing this everywhere: let manager = DataManager().

With a global you can access it anywhere. The timeline() method just grabs my data with something like coredata.getMyData(), or in your case manager.fetchRecords().

You seem to be writing your fetchRecords() method to get your data inside the getTimeline() method, i.e.:

let request = NSFetchRequest<Little>(entityName: "Little")
        do {
            records = try manager.context.fetch(request)
...

That should be put into your DataManager() class.

Also, use a predicate to sort your data in the call to CoreData, rather than sorting the records once you have them:

records.sort { lhs, rhs in ... // <-- remove this

Thanks for the tip, darkpaw. But I'm afraid you misunderstand my question. It's underlined. Do I have to let the widget pull data directly from CoreData data manager (DataManager)? In other words, is there any way I could use my existing view model (ViewModel) to deliver data to the widget?

You seem to be writing your fetchRecords() method to get your data inside the getTimeline() method, i.e.:

That should be put into your DataManager() class.

Okay. Thanks. I have done all dirty work through my view model (ViewModel) including the data sorting. That's why I want to know if I need to do it with the data manager, again, just for the widget. That's what I mean by 'redundant' or superfluous.

Well, I'm terribly sorry if I misunderstood your question, but it's quite difficult to make sense of what your question actually was given you posted:

1. A DataManager class that just creates a connection to Core Data.
2. A ViewModel class with a fetchRecords method that uses an instance of your DataManager class.
3. Your TimelineProvider showing the same code from your fetchRecords method inside your getTimeline method. (As in, why the duplication?)

If your question was the underlined question, "how should my widget get data from CoreData?" then I already answered it by explaing how I do it in my working widgets.

You can use any method you want to get data into your widget, whether you pull it directly from the DataManager (via Core Data) or your ViewModel (which has already pulled it from Core Data).

Have you tried both methods? Did one or both of them work? Which one has the simpler code? Go with that one.

Remember, widgets shouldn't be considered actively running code. You tell the timeline provider what data the widget should use and what it should look like at a snapshot in time. The widget isn't sitting there reading your data from Core Data, so how you want to provide the data to it isn't 100% relevant. You only have to be performant in the getSnapshot method because that's used in transient situations like the preview gallery.

Since you haven't responded, other than a comment, and you haven't accepted anything as an answer, here's a little more clarification in case you're still misunderstanding how to do this:

1. Move the fetchRecords method into the DataManager class.
2. Use a predicate to sort the data rather than sorting it after you've retrieved the records. It's faster.
3. Change your ViewModel to something like this:

class ViewModel: ObservableObject {
	let manager = DataManager()
	@Published var records: [Little] = []

	init() {
		records = manager.fetchRecords()
		WidgetCenter.shared.reloadAllTimelines()
	}
}

1. DataManager can be shared between both your iOS target (where ViewModel resides) and your widget target, so change the target membership so it's shared.
2. In your widget target, your getTimeline method would be something like this:

func getTimeline(in context: Context, completion: @escaping (Timeline<Entry>) -> ()) {
	let manager = DataManager()
	var items: [Item] = []
	for record in manager.fetchRecords() {
		let item = Item(trashDate: record.trashDate ?? Date.now, imageSelection: Int(record.imageSelection))
		items.append(item)
	}
	
	let entry = Timeline(entries: [SimpleEntry(date: Date(), items: items)], policy: .atEnd)
	completion(entry)
}

That should show you how to get data from Core Data into your widget.

And, just to answer your other question, no you can't use your ViewModel as it isn't in the widget target, and you cannot call reloadTimelines() from the widget.

If you're still having issues, then I'm sorry, but I've given you all the help I can. You haven't said whether you've attempted anything I've given you.

A solution is not to rely on a Data Manager class and its associates but to use UserDefaults so that Widget's getTimeline method will be called when ContentView submits data to it. By this approach, you can update Widget's View.

import SwiftUI
import WidgetKit

struct ContentView: View {
	var body: some View {
		VStack {
			Button {
				let task0 = TaskItem(id: UUID(), name: "Dish washing", isComplete: false, dueDate: Date.now.addingTimeInterval(86400))
				let task1 = TaskItem(id: UUID(), name: "Bed making", isComplete: false, dueDate: Date.now.addingTimeInterval(86400 * 2))
				saveTasksToWidget(tasks: [task0, task1])
			} label: {
				Image(systemName: "globe")
					.imageScale(.large)
			}
			.tint(.pink)
			.buttonStyle(.borderedProminent)
		}
		.padding()
	}
	
	private func saveTasksToWidget(tasks: [TaskItem]) {
		guard let sharedDefaults = UserDefaults(suiteName: "group.abc") else {
			print("Failed to get shared UserDefaults.")
			return
		}

		do {
			let encoder = JSONEncoder()
			let encodedData = try encoder.encode(tasks)
			sharedDefaults.set(encodedData, forKey: "widgetTasksArray")
			WidgetCenter.shared.reloadAllTimelines()
		} catch {
			print("Error encoding tasks: \(error)")
		}
	}
}

// TaskItem.swift //

import Foundation

struct TaskItem: Codable, Identifiable {
	let id: UUID
	let name: String
	let isComplete: Bool
	let dueDate: Date
	
	static let previewTasks = [
		TaskItem(id: UUID(), name: "Rose", isComplete: false, dueDate: Date.now.addingTimeInterval(86400)),
		TaskItem(id: UUID(), name: "Chrisanthumum", isComplete: true, dueDate: Date.now.addingTimeInterval(86400 * 2)),
		TaskItem(id: UUID(), name: "Garden Dahlia", isComplete: false, dueDate: Date.now.addingTimeInterval(86400 * 3))
	]
}

// CrazyWidget.swift //

import WidgetKit
import SwiftUI

struct SimpleEntry: TimelineEntry {
	let date: Date
	let tasks: [TaskItem]
}

struct Provider: TimelineProvider {
	let appGroupID = "group.abc"
	let dataKey = "widgetTasksArray"
	
	func placeholder(in context: Context) -> SimpleEntry {
		SimpleEntry(date: Date(), tasks: TaskItem.previewTasks)
	}

	func getSnapshot(in context: Context, completion: @escaping (SimpleEntry) -> ()) {
		let currentTasks = loadTasks()
		let entry = SimpleEntry(date: Date(), tasks: currentTasks)
		completion(entry)
	}

	func getTimeline(in context: Context, completion: @escaping (Timeline<Entry>) -> ()) {
		let currentTasks = loadTasks()
		let entry = SimpleEntry(date: Date(), tasks: currentTasks)
		let nextUpdate = Calendar.current.date(byAdding: .minute, value: 1, to: Date())!
		let timeline = Timeline(entries: [entry], policy: .after(nextUpdate))
		completion(timeline)
	}
	
	private func loadTasks() -> [TaskItem] {
		var taskItems: [TaskItem] = []
		if let sharedDefaults = UserDefaults(suiteName: appGroupID), let savedData = sharedDefaults.data(forKey: dataKey) {
			do {
				let decoder = JSONDecoder()
				taskItems = try decoder.decode([TaskItem].self, from: savedData)
			} catch {
				print("Error decoding tasks from App Group: \(error)")
				taskItems = TaskItem.previewTasks // Fallback on decoding failure
			}
		} else {
			taskItems = TaskItem.previewTasks // Fallback on access failure
		}
		return taskItems
	}
}

struct CrazyWidgetEntryView : View {
	var entry: Provider.Entry
	
	var body: some View {
		VStack(alignment: .leading) {
			Text("Pending Tasks")
				.font(.headline)
				.foregroundColor(.blue)
			
			Divider()

			if entry.tasks.isEmpty {
				Text("All clear! No tasks found.")
					.font(.caption)
					.foregroundColor(.secondary)
			} else {
				VStack(alignment: .leading, spacing: 4) {
					ForEach(entry.tasks.prefix(3)) { task in
						HStack {
							Image(systemName: task.isComplete ? "checkmark.circle.fill" : "circle")
								.foregroundColor(task.isComplete ? .green : .orange)
							Text(task.name)
								.font(.caption)
								.strikethrough(task.isComplete)
								.lineLimit(1)
						}
					}
				}
			}
		}
		.padding()
	}
}

struct CrazyWidget: Widget {
	let kind: String = "RailMe"

	var body: some WidgetConfiguration {
		StaticConfiguration(kind: kind, provider: Provider()) { entry in
			CrazyWidgetEntryView(entry: entry)
		}
		.configurationDisplayName("RailMe GGGGG")
		.description("View your current tasks saved from the main app.")
		.supportedFamilies([.systemSmall, .systemMedium])
	}
}

#Preview("Small - Full Data") {
	CrazyWidgetEntryView(entry: SimpleEntry(date: Date(), tasks: TaskItem.previewTasks))
}