How to Fetch Apple Calendar Events and Reminders in Flutter (macOS)

<key>com.apple.security.personal-information.calendars</key>
<true/>
<key>com.apple.security.personal-information.reminders</key>
<true/>

<key>NSCalendarsFullAccessUsageDescription</key>
<string>This app needs access to your calendar.</string>
<key>NSRemindersFullAccessUsageDescription</key>
<string>This app needs access to your reminders.</string>

<!-- For macOS 13 or older -->
<key>NSCalendarsUsageDescription</key>
<string>This app needs access to your calendar.</string>
<key>NSRemindersUsageDescription</key>
<string>This app needs access to your reminders.</string>

import Cocoa
import EventKit

@objc class CalendarBridge: NSObject {

    // Use a single shared EKEventStore for the whole app
    static let store = EKEventStore()

    // MARK: - Permission Requests

    /// Request calendar access permission from the user
    @objc static func requestCalendarPermission(_ result: @escaping (Bool) -> Void) {
        if #available(macOS 14.0, *) {
            store.requestFullAccessToEvents { granted, _ in
                if granted { store.reset() } // Refresh calendars after permission
                DispatchQueue.main.async { result(granted) }
            }
        } else {
            store.requestAccess(to: .event) { granted, _ in
                if granted { store.reset() }
                DispatchQueue.main.async { result(granted) }
            }
        }
    }

    /// Request reminders access permission from the user
    @objc static func requestReminderPermission(_ result: @escaping (Bool) -> Void) {
        if #available(macOS 14.0, *) {
            store.requestFullAccessToReminders { granted, _ in
                if granted { store.reset() }
                DispatchQueue.main.async { result(granted) }
            }
        } else {
            store.requestAccess(to: .reminder) { granted, _ in
                if granted { store.reset() }
                DispatchQueue.main.async { result(granted) }
            }
        }
    }

    // MARK: - Authorization Check

    /// Check if calendar access is already authorized
    @objc static func isCalendarAuthorized() -> Bool {
        switch EKEventStore.authorizationStatus(for: .event) {
        case .authorized, .fullAccess:
            return true
        default:
            return false
        }
    }

    // MARK: - Calendars

    /// Get all available calendars for events
    @objc static func getCalendars() -> [[String: String]] {
        let calendars = store.calendars(for: .event)
        return calendars.map { cal in
            let source = cal.source.sourceType == .local ? "Default" : cal.source.title
            return [
                "id": cal.calendarIdentifier,
                "title": cal.title,
                "sourceType": source,
                "sourceTitle": cal.source.title
            ]
        }
    }

    /// Fetch events from the selected calendar IDs for the next 7 days
    @objc static func fetchEvents(calendarIds: [String], result: @escaping ([[String: Any]]) -> Void) {
        guard isCalendarAuthorized() else {
            result([["error": "permission_denied"]])
            return
        }

        let calendars = store.calendars(for: .event).filter { calendarIds.contains($0.calendarIdentifier) }
        let now = Date()
        let weekAhead = Calendar.current.date(byAdding: .day, value: 7, to: now)!

        let isoFormatter = ISO8601DateFormatter()
        isoFormatter.formatOptions = [.withInternetDateTime]

        var events: [[String: Any]] = []

        for cal in calendars {
            let predicate = store.predicateForEvents(withStart: now, end: weekAhead, calendars: [cal])
            for event in store.events(matching: predicate) {
                events.append([
                    "id": event.eventIdentifier ?? "",
                    "title": event.title ?? "No Title",
                    "start": isoFormatter.string(from: event.startDate),
                    "end": isoFormatter.string(from: event.endDate),
                    "location": event.location ?? "",
                    "notes": event.notes ?? "",
                    "isAllDay": event.isAllDay,
                    "calendarId": event.calendar.calendarIdentifier,
                    "calendarTitle": event.calendar.title
                ])
            }
        }

        result(events)
    }

    // MARK: - Reminders

    /// Get all reminder lists
    @objc static func getReminderLists() -> [[String: String]] {
        store.reset() // Refresh lists after permission granted
        return store.calendars(for: .reminder).map { cal in
            let source = cal.source.sourceType == .local ? "Default" : cal.source.title
            return [
                "id": cal.calendarIdentifier,
                "title": cal.title,
                "sourceType": source
            ]
        }
    }

    /// Fetch all reminders in a specific list
    @objc static func fetchReminders(listId: String, result: @escaping ([[String: Any]]) -> Void) {
        let lists = store.calendars(for: .reminder)
        guard let list = lists.first(where: { $0.calendarIdentifier == listId }) else {
            result([["error": "list_not_found"]])
            return
        }

        let isoFormatter = ISO8601DateFormatter()
        isoFormatter.formatOptions = [.withInternetDateTime]

        let predicate = store.predicateForReminders(in: [list])
        store.fetchReminders(matching: predicate) { reminders in
            let mapped = (reminders ?? []).map { r -> [String: Any] in
                let dueDate = r.dueDateComponents?.date.map { isoFormatter.string(from: $0) } ?? ""
                return [
                    "id": r.calendarItemIdentifier,
                    "title": r.title ?? "No Title",
                    "notes": r.notes ?? "",
                    "completed": r.isCompleted,
                    "dueDate": dueDate,
                    "hasDueDate": r.dueDateComponents != nil,
                    "priority": r.priority
                ]
            }
            result(mapped)
        }
    }
}

import Cocoa
import FlutterMacOS
import EventKit

@main
class AppDelegate: FlutterAppDelegate {
    private var channel: FlutterMethodChannel?

    override func applicationDidFinishLaunching(_ notification: Notification) {
        let controller = NSApplication.shared.windows.first!.contentViewController as! FlutterViewController
        channel = FlutterMethodChannel(name: "method_macos_native", binaryMessenger: controller.engine.binaryMessenger)

        channel!.setMethodCallHandler { call, result in
            switch call.method {
            case "requestCalendarPermission":
                CalendarBridge.requestCalendarPermission { granted in result(granted) }
            case "requestReminderPermission":
                CalendarBridge.requestReminderPermission { granted in result(granted) }
            case "checkCalendarPermission":
                result(CalendarBridge.isCalendarAuthorized())
            case "getCalendars":
                result(CalendarBridge.getCalendars())
            case "fetchCalendarEvents":
                let ids = (call.arguments as? [String: Any])?["calendarIds"] as? [String] ?? []
                DispatchQueue.global().async {
                    CalendarBridge.fetchEvents(calendarIds: ids) { events in
                        DispatchQueue.main.async { result(events) }
                    }
                }
            case "getReminderLists":
                DispatchQueue.global().async {
                    let lists = CalendarBridge.getReminderLists()
                    DispatchQueue.main.async { result(lists) }
                }
            case "fetchReminders":
                let listId = (call.arguments as? [String: Any])?["listId"] as? String ?? ""
                DispatchQueue.global().async {
                    CalendarBridge.fetchReminders(listId: listId) { reminders in
                        DispatchQueue.main.async { result(reminders) }
                    }
                }
            default:
                result(FlutterMethodNotImplemented)
            }
        }

        setupCalendarChangeObserver()
        super.applicationDidFinishLaunching(notification)
    }

    private func setupCalendarChangeObserver() {
        NotificationCenter.default.addObserver(forName: .EKEventStoreChanged,
                                               object: CalendarBridge.store,
                                               queue: .main) { [weak self] _ in
            self?.channel?.invokeMethod("onCalendarChanged", arguments: nil)
        }
    }
}

import 'dart:io';
import 'package:flutter/services.dart';

class CalendarService {
  static const MethodChannel _channel = MethodChannel('method_macos_native');

  static Future<bool> requestCalendarPermission() async { ... }
  static Future<bool> requestReminderPermission() async { ... }
  static Future<List<Map<String, dynamic>>> getCalendars() async { ... }
  static Future<List<Map<String, dynamic>>> fetchEvents(List<String> calendarIds) async { ... }
  static Future<List<Map<String, dynamic>>> getReminderLists() async { ... }
  static Future<List<Map<String, dynamic>>> fetchReminders(String listId) async { ... }
}

Future<void> loadCalendar() async {
  final granted = await CalendarService.requestCalendarPermission();
  if (!granted) return;
  final calendars = await CalendarService.getCalendars();
  final ids = calendars.map((c) => c['id'] as String).toList();
  final events = await CalendarService.fetchEvents(ids);
  events.forEach((e) => print('${e['title']} @ ${e['start']}'));
}

Future<void> loadReminders() async {
  if (!await CalendarService.requestReminderPermission()) return;
  final lists = await CalendarService.getReminderLists();
  for (final list in lists) {
    final reminders = await CalendarService.fetchReminders(list['id'] as String);
    print('${list['title']}: ${reminders.length} reminders');
  }
}

final lists = await CalendarService.getReminderLists();
for (final list in lists) {
  final all = await CalendarService.fetchReminders(list['id'] as String);
  final open = all.where((r) => r['completed'] != true).toList();
  print('- ${list['title']} (${open.length} open) -');
}

void listenForCalendarChanges(VoidCallback onChanged) {
  const channel = MethodChannel('method_macos_native');
  channel.setMethodCallHandler((call) async {
    if (call.method == 'onCalendarChanged') onChanged();
  });
}