Eventkit

import EventKit
let eventStore = EKEventStore()

func createEvent(    title: String,    startDate: Date,    endDate: Date,    calendar: EKCalendar? = nil) throws {    let event = EKEvent(eventStore: eventStore)    event.title = title    event.startDate = startDate    event.endDate = endDate    event.calendar = calendar ?? eventStore.defaultCalendarForNewEvents
    try eventStore.save(event, span: .thisEvent)}

// List writable calendarslet calendars = eventStore.calendars(for: .event)    .filter { $0.allowsContentModifications }
// Use the first writable calendar, or the defaultlet targetCalendar = calendars.first ?? eventStore.defaultCalendarForNewEventsevent.calendar = targetCalendar

import CoreLocation
let location = EKStructuredLocation(title: "Apple Park")location.geoLocation = CLLocation(latitude: 37.3349, longitude: -122.0090)event.structuredLocation = location

func fetchEvents(from start: Date, to end: Date) -> [EKEvent] {    let predicate = eventStore.predicateForEvents(        withStart: start,        end: end,        calendars: nil  // nil = all calendars    )    return eventStore.events(matching: predicate)        .sorted { $0.startDate < $1.startDate }}

if let event = eventStore.event(withIdentifier: savedEventID) {    print(event.title ?? "No title")}

func createReminder(title: String, dueDate: Date) throws {    let reminder = EKReminder(eventStore: eventStore)    reminder.title = title    reminder.calendar = eventStore.defaultCalendarForNewReminders()
    let dueDateComponents = Calendar.current.dateComponents(        [.year, .month, .day, .hour, .minute],        from: dueDate    )    reminder.dueDateComponents = dueDateComponents
    try eventStore.save(reminder, commit: true)}

func fetchIncompleteReminders() async -> [EKReminder] {    let predicate = eventStore.predicateForIncompleteReminders(        withDueDateStarting: nil,        ending: nil,        calendars: nil    )
    return await withCheckedContinuation { continuation in        eventStore.fetchReminders(matching: predicate) { reminders in            continuation.resume(returning: reminders ?? [])        }    }}

func completeReminder(_ reminder: EKReminder) throws {    reminder.isCompleted = true    try eventStore.save(reminder, commit: true)}

// Every week, indefinitelylet weeklyRule = EKRecurrenceRule(    recurrenceWith: .weekly,    interval: 1,    end: nil)event.addRecurrenceRule(weeklyRule)
// Every 2 weeks, ending after 10 occurrenceslet biweeklyRule = EKRecurrenceRule(    recurrenceWith: .weekly,    interval: 2,    end: EKRecurrenceEnd(occurrenceCount: 10))
// Monthly, ending on a specific datelet monthlyRule = EKRecurrenceRule(    recurrenceWith: .monthly,    interval: 1,    end: EKRecurrenceEnd(end: endDate))

// Every Monday and Wednesdaylet days = [    EKRecurrenceDayOfWeek(.monday),    EKRecurrenceDayOfWeek(.wednesday)]
let complexRule = EKRecurrenceRule(    recurrenceWith: .weekly,    interval: 1,    daysOfTheWeek: days,    daysOfTheMonth: nil,    monthsOfTheYear: nil,    weeksOfTheYear: nil,    daysOfTheYear: nil,    setPositions: nil,    end: nil)event.addRecurrenceRule(complexRule)

// Change only this occurrencetry eventStore.save(event, span: .thisEvent)
// Change this and all future occurrencestry eventStore.save(event, span: .futureEvents)

// 15 minutes beforelet alarm = EKAlarm(relativeOffset: -15 * 60)event.addAlarm(alarm)
// At an absolute datelet absoluteAlarm = EKAlarm(absoluteDate: alertDate)event.addAlarm(absoluteAlarm)

import EventKitUI
class EventEditorCoordinator: NSObject, EKEventEditViewDelegate {    let eventStore = EKEventStore()
    func presentEditor(from viewController: UIViewController) {        let editor = EKEventEditViewController()        editor.eventStore = eventStore        editor.editViewDelegate = self        viewController.present(editor, animated: true)    }
    func eventEditViewController(        _ controller: EKEventEditViewController,        didCompleteWith action: EKEventEditViewAction    ) {        switch action {        case .saved:            // Event saved            break        case .canceled:            break        case .deleted:            break        @unknown default:            break        }        controller.dismiss(animated: true)    }}

import EventKitUI
let viewer = EKEventViewController()viewer.event = existingEventviewer.allowsEditing = truenavigationController?.pushViewController(viewer, animated: true)

let chooser = EKCalendarChooser(    selectionStyle: .multiple,    displayStyle: .allCalendars,    entityType: .event,    eventStore: eventStore)chooser.showsDoneButton = truechooser.showsCancelButton = truechooser.delegate = selfpresent(UINavigationController(rootViewController: chooser), animated: true)

NotificationCenter.default.addObserver(    forName: .EKEventStoreChanged,    object: eventStore,    queue: .main) { [weak self] _ in    self?.refreshEvents()}

// WRONG: Legacy request API on current systemseventStore.requestAccess(to: .event) { granted, error in }
// CORRECT: Use the granular async methodslet granted = try await eventStore.requestFullAccessToEvents()

// WRONG: No check -- will throw if calendar is read-onlyevent.calendar = someCalendartry eventStore.save(event, span: .thisEvent)
// CORRECT: Verify the calendar allows modificationsguard someCalendar.allowsContentModifications else {    event.calendar = eventStore.defaultCalendarForNewEvents    return}event.calendar = someCalendartry eventStore.save(event, span: .thisEvent)

// WRONG: Event appears at wrong time for traveling usersevent.startDate = Date()event.endDate = Date().addingTimeInterval(3600)
// CORRECT: Set the timezone explicitly for location-specific eventsevent.timeZone = TimeZone(identifier: "America/New_York")event.startDate = startDateevent.endDate = endDate

// WRONG: Changes never persistedtry eventStore.save(event1, span: .thisEvent, commit: false)try eventStore.save(event2, span: .thisEvent, commit: false)// Missing commit!
// CORRECT: Commit after batchingtry eventStore.save(event1, span: .thisEvent, commit: false)try eventStore.save(event2, span: .thisEvent, commit: false)try eventStore.commit()

// WRONG: Event fetched from storeA, saved to storeBlet event = storeA.event(withIdentifier: id)!try storeB.save(event, span: .thisEvent) // Undefined behavior
// CORRECT: Use the same store throughoutlet event = eventStore.event(withIdentifier: id)!try eventStore.save(event, span: .thisEvent)