How do I pass CoreData into UICalendarview - ios

Question

I'm trying to use my CoreData entity 'Item' to show decorations on a calendar (using UIcalendarview in iOS16). I have my view called CalView calling the CalendarHelper struct (where the UICalendarView is coded and setup). It is showing decorations on every day currently, but I want to only show decorations on the days where there is a CoreData entry, and then enable navigation when you click on those days to the detail view. The problem is that I can't figure out how to get the CoreData entity into the CalendarHelper and UICalendarView to use it. It's currently giving me an error stating that I can't pass a FetchedResult in to an expected ObservedResult. But when I change them all to FetchedResult on that function, it gives me an error saying it's expecting a type of Item.
NOTE: I posted this over here as well but I think I messed up that post by deleting the original when I updated it. https://stackoverflow.com/questions/75138925/pass-coredata-into-uicalendarview-to-show-decorations-and-click-on-date-for-deta
CALVIEW:
struct CalView: View {
var body: some View {
ZStack {
VStack {
HStack {
CalendarHelper(interval: DateInterval(start: .distantPast, end: .distantFuture))
}
}
}
}
}
CALENDARHELPER:
struct CalendarHelper: UIViewRepresentable {
#Environment(\.managedObjectContext) private var viewContext
#FetchRequest(
sortDescriptors: SleepSort.default.descriptors,
animation: .default)
private var items: FetchedResults<Item>
let interval: DateInterval
func makeUIView(context: Context) -> UICalendarView {
let calView = UICalendarView()
calView.delegate = context.coordinator
calView.calendar = Calendar(identifier: .gregorian)
calView.availableDateRange = interval
calView.fontDesign = .rounded
let dateSelection = UICalendarSelectionSingleDate(delegate: context.coordinator)
calView.selectionBehavior = dateSelection
calView.wantsDateDecorations = true
return calView
}
func makeCoordinator() -> Coordinator {
Coordinator(parent: self, items: items)
}
func updateUIView(_ uiView: UICalendarView, context: Context) {
}
class Coordinator: NSObject, UICalendarViewDelegate, UICalendarSelectionSingleDateDelegate {
var parent: CalendarHelper
#ObservedObject var items: Item
init(parent: CalendarHelper, items: ObservedObject<Item>) {
self.parent = parent
self._items = items
}
#MainActor
func calendarView(_ calendarView: UICalendarView, decorationFor dateComponents: DateComponents) -> UICalendarView.Decoration? {
let font = UIFont.systemFont(ofSize: 10)
let configuration = UIImage.SymbolConfiguration(font: font)
let image = UIImage(systemName: "star.fill", withConfiguration: configuration)?.withRenderingMode(.alwaysOriginal)
return .image(image)
}
func dateSelection(_ selection: UICalendarSelectionSingleDate,
didSelectDate dateComponents: DateComponents?) {
}
func dateSelection(_ selection: UICalendarSelectionSingleDate,
canSelectDate dateComponents: DateComponents?) -> Bool {
return true
}
}
}

Answer 1

I tested for a while to pass in FetchResults to the coordinator (as SwiftUI #FetchRequest works on a view only), and did not find a solution, but the recommendation to use a standard NSFetchRequest in or from the coordinator. The decorationFor method is called once for each calendar day in the displayed month - this makes the change lagging if that makes 30 NSFetchrequests - so we need to fetch once per month displayed and store the result.
Here is my my calendarView decorationFor method (simplified):
// --------------------------------------------------------------------------
//helper function to compare two dateComponents on day granularity
extension DateComponents {
func sameDate(source: DateComponents) -> Bool {
if let lhs = self.date,
let rhs = source.date,
Calendar.current.startOfDay(for: lhs) == Calendar.current.startOfDay(for: rhs) {
return true
} else {
return false
}
}
}
// -------------------------------------------------------
#MainActor func calendarView(_ calendarView: UICalendarView, decorationFor dateComponents: DateComponents) -> UICalendarView.Decoration? {
//in the coordinator, define:
// private var currentVisibleRange = DateComponents()
// private var result : [YourClass] = []
//check if the requested dateComponents are within the currentVisibleRange
if !currentVisibleRange.sameDate(source: calendarView.visibleDateComponents) {
//here the requested date is not in the currentVisibleRange, so we have to do a new fetch
let myFetch = makeMyFetchRequest(dateComponents) //whatever fetch request you need, based on NSFetchRequest
do {
result = try context.fetch(myFetch)
//result now contains an Array of NSManagedObjects, might need to be sorted, dependent on the underlying data
} catch {
print("Failed to fetch: \(error)")
}
//now we have to store the new range to avoid doing it again for the same range
currentVisibleRange = calendarView.visibleDateComponents
return .customView {
//return any UIView, e.g. a UILabel, or use UIHostingController if you want to return a Swift view
//the view must be a decoration for dateComponents.day
makeMyUILabel(forDay: dateComponents.day)
}
}//calendarView
This works well also on large datasets, one fetch per month displayed is sustainable and shows good performance