iOS_EventKit的Calendar和Reminder的使用

private var store: EKEventStore = EKEventStore() // 初始化和释放时间比较长，建议写成单例

// 1.检查授权
store.requestAccess(to: .event) { (granted, error) in
  if granted { // 已授权
    print("已授权")
    self.inquireCalender() // 调用了查询事件方法
  } else { // 未授权：需要request
    print("未授权, 若需使用此功能，需要提醒用户去系统设置页面开启日历权限")
  }
}

// MARK: 查询日历事件
func inquireCalender() {
  // 1.使用谓词
  let calendar = NSCalendar.current
  // 开始时间
  var startComponents = DateComponents()
  startComponents.day = 0
  let startDate:Date = calendar.date(byAdding: startComponents, to: Date()) ?? Date()
  print("onDateAgo: \(startDate)")
  // 结束时间
  var endComponents = DateComponents()
  endComponents.month = 3
  let endDate:Date = calendar.date(byAdding: endComponents, to: Date()) ?? Date()
  print("onDateAgo: \(endDate)")

  // 参数calendars是一个calendar的集合，如果为nil，表示所有用户的calendars
  let predicate = store.predicateForEvents(withStart: startDate, end: endDate, calendars: nil)

  // 该方法为同步方法，最好放在工作线程里做
  let events = store.events(matching: predicate)

  print("events: \(events)")
  self.events = events
  // 刷新tableview展示数据
  DispatchQueue.main.async {
    self.tableView.reloadData()
  }
  // 2.使用identifier获取
  store.event(withIdentifier: "")
}

// MARK: - 创建
@objc private func addCalendar() {
  // 3.创建
  let event = EKEvent(eventStore: store)
  event.title = "私人课"
  event.startDate = Date()
  event.endDate = Date().addingTimeInterval(1000)
  let alarm = EKAlarm(absoluteDate: Date().addingTimeInterval(500))
  event.addAlarm(alarm)
  event.calendar = store.defaultCalendarForNewEvents
  do {
    try store.save(event, span: .futureEvents, commit: true)
  } catch {
    print("save calendar error:\(error)")
  }
  DispatchQueue.main.async { [weak self] in
    self?.inquireCalender() // 重新查询，并刷新列表
  }
}

// 4.删除
let event: EKEvent = events![indexPath.row]
do {
  try store.remove(event, span: .futureEvents, commit: true)
} catch {
  print("remove error: \(error)")
}
DispatchQueue.main.async { [weak self] in
  self?.inquireCalender() // 重新查询，并刷新列表
}

// 5.修改
let event: EKEvent = events![indexPath.row]
event.title = "修改后的 私人课~"
do {
  try store.save(event, span: .futureEvents, commit: true)
} catch {
  print("remove error: \(error)")
}
DispatchQueue.main.async { [weak self] in
  self?.inquireCalender() // 重新查询，并刷新列表
}

// 1.检查授权
store.requestAccess(to: .reminder) { (granted, error) in
  if granted { // 已授权
    print("已授权")
    self.inquireReminder()
  } else { // 未授权：需要request
    print("未授权, 若需使用此功能，需要提醒用户去系统设置页面开启提醒权限")
    // TODO Alert
  }
}

// 1).使用谓词
// starting = nil 表示从最开始查找
// ending = nil 表示查找到最后
// 查找未完成的提醒
var predicate = store.predicateForIncompleteReminders(withDueDateStarting: nil, ending: nil, calendars: nil)

// 查找完成的提醒
predicate = store.predicateForCompletedReminders(withCompletionDateStarting: nil, ending: nil, calendars: nil)

// 查找所有提醒
predicate = store.predicateForReminders(in: nil)

store.fetchReminders(matching: predicate) { [weak self] (reminders) in
  guard (reminders != nil) else {
    return
  }
  self?.reminders = reminders
  DispatchQueue.main.async {
    self?.tableView.reloadData()
  }
  for reminder in reminders! {
    // 与日历事件不同的是，该方法为异步回调，不需要另外开线程
    // 如果想要停止获取的操作，return cancelFetchRequest
    print("reminder: \(reminder)")
    print("alarm: \(reminder.alarms?.first)")
  }
}
// 2).使用identifer查找
store.calendarItem(withIdentifier: "")

let reminder: EKReminder = EKReminder(eventStore: store)
reminder.calendar = store.defaultCalendarForNewReminders()
reminder.title = "提醒你哦~"
let alarm = EKAlarm(absoluteDate: Date(timeIntervalSinceNow: 20))
reminder.addAlarm(alarm)
do {
  try store.save(reminder, commit: true)
} catch {
  print("save reminder error: \(error)")
}
DispatchQueue.main.async {
  self.inquireReminder() // 重新查询，并刷新列表
}

let reminder: EKReminder = reminders![indexPath.row]
reminder.title = "修改后的 提醒你哦~"
do {
  try store.save(reminder, commit: true)
} catch {
  print("remove error: \(error)")
}
DispatchQueue.main.async {
  self.inquireReminder() // 重新查询，并刷新列表
}

let reminder: EKReminder = reminders![indexPath.row]
do {
  try store.remove(reminder, commit: true)
} catch {
  print("remove error: \(error)")
}
DispatchQueue.main.async {
  self.inquireReminder() // 重新查询，并刷新列表
}