AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Swift：JKEKEvent日历事件和提醒事件的基本使用

2022-05-23 641
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： Swift：JKEKEvent日历事件和提醒事件的基本使用

JKSwiftExtension，测试用例在 JKEKEventViewController 里面

目录：


  • 1、日历基本的使用
  • 根据时间段获取日历事件
  • 添加日历事件
  • 修改日历事件
  • 删除日历事件
  • 2、提醒事件的基本的使用
  • 查询出所有提醒事件
  • 添加提醒事件
  • 修改提醒事件
  • 移除提醒事件


一、日历基本的使用

import EventKit
public class JKEKEvent: NSObject {}
// MARK:- 一、日历基本的使用
public extension JKEKEvent {
    // MARK: 1.1、根据时间段获取日历事件
    /// 根据时间段获取日历事件
    /// - Parameters:
    ///   - startDate: 开始时间
    ///   - endDate: 结束时间
    ///   - eventsClosure: 事件闭包
    static func selectCalendarsEvents(startDate: Date, endDate: Date, eventsClosure: @escaping (([EKEvent]) -> Void)) {
        let eventStore = EKEventStore()
        // 请求日历事件
        eventStore.requestAccess(to: .event, completion: {
        granted, error in
            if (granted) && (error == nil) {
                // 获取本地日历（剔除节假日，生日等其他系统日历）
                let calendars = eventStore.calendars(for: .event).filter({
                (calender) -> Bool in
                    return calender.type == .local || calender.type == .calDAV
                })
                let predicate = eventStore.predicateForEvents(withStart: startDate, end: endDate, calendars: calendars)
                let eV = eventStore.events(matching: predicate)
                // 重新刷新表格数据
                DispatchQueue.main.async {
                    eventsClosure(eV)
                }
            } else {
                DispatchQueue.main.async {
                    eventsClosure([])
                }
            }
        })
    }
    // MARK: 1.2、添加日历事件
    /// 添加日历事件
    /// - Parameters:
    ///   - title: 提醒的标题
    ///   - startDate: 开始时间
    ///   - endDate: 结束时间
    ///   - notes: 备注
    ///   - eventsClosure: 事件闭包
    static func addCalendarsEvents(title: String, startDate: Date, endDate: Date, notes: String, eventsClosure: @escaping ((Bool, String?) -> Void)) {
        let eventStore = EKEventStore()
        eventStore.requestAccess(to: .event, completion: {
        granted, error in
            if (granted) && (error == nil) {
                let event: EKEvent = EKEvent(eventStore: eventStore)
                event.title = title
                event.startDate = startDate
                event.endDate = endDate
                event.notes = notes
                event.calendar = eventStore.defaultCalendarForNewEvents
                do {
                    try eventStore.save(event, span: .thisEvent)
                    DispatchQueue.main.async {
                        eventsClosure(true, event.calendarItemIdentifier)
                    }
                } catch {
                    DispatchQueue.main.async {
                        eventsClosure(false, nil)
                    }
                }
            } else {
                DispatchQueue.main.async {
                    eventsClosure(false, nil)
                }
            }
        })
    }
    // MARK: 1.3、修改日历事件
    /// 修改日历事件
    /// - Parameters:
    ///   - eventIdentifier: 唯一标识符区分某个事件
    ///   - title: 提醒的标题
    ///   - startDate: 开始时间
    ///   - endDate: 结束时间
    ///   - notes: 备注
    ///   - eventsClosure: 事件闭包
    static func updateCalendarsEvents(eventIdentifier: String, title: String, startDate: Date, endDate: Date, notes: String, eventsClosure: @escaping ((Bool) -> Void)) {
        let eventStore = EKEventStore()
        // 请求日历事件
        eventStore.requestAccess(to: .event, completion: {
        granted, error in
            if (granted) && (error == nil) {
                // 获取本地日历（剔除节假日，生日等其他系统日历）
                let calendars = eventStore.calendars(for: .event).filter({
                (calender) -> Bool in
                    return calender.type == .local || calender.type == .calDAV
                })
                let predicate = eventStore.predicateForEvents(withStart: startDate, end: endDate, calendars: calendars)
                let events = eventStore.events(matching: predicate)
                let eventArray = events.filter { $0.calendarItemIdentifier == eventIdentifier }
                guard eventArray.count > 0 else {
                    DispatchQueue.main.async {
                        eventsClosure(false)
                    }
                    return
                }
                let event = eventArray[0]
                event.title = title
                event.startDate = startDate
                event.endDate = endDate
                event.notes = notes
                event.calendar = eventStore.defaultCalendarForNewEvents
                do {
                   try eventStore.save(event, span: .thisEvent)
                    DispatchQueue.main.async {
                        eventsClosure(true)
                    }
                } catch {
                    DispatchQueue.main.async {
                        eventsClosure(false)
                    }
                }
            } else {
                DispatchQueue.main.async {
                    eventsClosure(false)
                }
            }
        })
    }
    // MARK: 1.4、删除日历事件
    /// 删除日历事件
    /// - Parameters:
    ///   - eventIdentifier: 唯一标识符区分某个事件
    ///   - eventsClosure: 事件闭包
    static func removeCalendarsEvent(eventIdentifier: String, eventsClosure: @escaping ((Bool) -> Void)) {
        let eventStore = EKEventStore()
        // 请求日历事件
        eventStore.requestAccess(to: .event, completion: {
        granted, error in
            if (granted) && (error == nil) {
                // 获取本地日历（剔除节假日，生日等其他系统日历）
                let calendars = eventStore.calendars(for: .event).filter({
                (calender) -> Bool in
                    return calender.type == .local || calender.type == .calDAV
                })
                // 获取当前年
                let com = Calendar.current.dateComponents([.year], from: Date())
                let currentYear = com.year!
                var events: [EKEvent] = []
                // 获取所有的事件（前后20年）
                for i in -20...20 {
                    let startDate = startOfMonth(year: currentYear + i, month:1)
                    let endDate = endOfMonth(year: currentYear + i, month: 12, returnEndTime: true)
                    let predicate = eventStore.predicateForEvents(
                    withStart: startDate, end: endDate, calendars: calendars)
                    let eV = eventStore.events(matching: predicate)
                    events.append(eV)
                }
                let event = events.filter { return $0.calendarItemIdentifier == eventIdentifier }
                guard event.count > 0 else {
                    DispatchQueue.main.async {
                        eventsClosure(false)
                    }
                    return
                }
                do {
                    try eventStore.remove(event[0], span: .thisEvent, commit: true)
                    DispatchQueue.main.async {
                        eventsClosure(true)
                    }
                } catch {
                    DispatchQueue.main.async {
                        eventsClosure(false)
                    }
                }
            } else {
                DispatchQueue.main.async {
                    eventsClosure(false)
                }
            }
        })
    }
}


二、提醒事件的基本的使用

public extension JKEKEvent {
    // MARK: 2.1、查询出所有提醒事件
    static func selectReminder(remindersClosure: @escaping (([EKReminder]?) -> Void)) {
        // 在取得提醒之前，需要先获取授权
        let eventStore = EKEventStore()
        eventStore.requestAccess(to: .reminder) {
            (granted: Bool, error: Error?) in
            if (granted) && (error == nil) {
                // 获取授权后，我们可以得到所有的提醒事项
                let predicate = eventStore.predicateForReminders(in: nil)
                eventStore.fetchReminders(matching: predicate, completion: {
                    (reminders: [EKReminder]?) -> Void in
                    DispatchQueue.main.async {
                        remindersClosure(reminders)
                    }
                })
            } else {
                DispatchQueue.main.async {
                    remindersClosure(nil)
                }
            }
        }
    }
    // MARK: 2.2、添加提醒事件
    /// 添加提醒事件
    /// - Parameters:
    ///   - title: 提醒的标题
    ///   - startDate: 开始时间
    ///   - endDate: 结束时间
    ///   - notes: 备注
    ///   - eventsClosure: 事件闭包
    static func addReminder(title: String, startDate: Date, endDate: Date, notes: String, eventsClosure: @escaping ((Bool, String?) -> Void)) {
        let eventStore = EKEventStore()
        // 获取"提醒"的访问授权
        eventStore.requestAccess(to: .reminder) {(granted, error) in
            if (granted) && (error == nil) {
                // 创建提醒条目
                let reminder = EKReminder(eventStore: eventStore)
                reminder.title = title
                reminder.notes = notes
                reminder.startDateComponents = dateComponentFrom(date: startDate)
                reminder.dueDateComponents = dateComponentFrom(date: endDate)
                reminder.calendar = eventStore.defaultCalendarForNewReminders()
                // 保存提醒事项
                do {
                    try eventStore.save(reminder, commit: true)
                    DispatchQueue.main.async {
                        eventsClosure(true, reminder.calendarItemIdentifier)
                    }
                } catch {
                    DispatchQueue.main.async {
                        eventsClosure(false, nil)
                    }
                }
            } else {
                DispatchQueue.main.async {
                    eventsClosure(false, nil)
                }
            }
        }
    }
    // MARK: 2.3、修改提醒事件
    /// 修改提醒事件
    /// - Parameters:
    ///   - eventIdentifier: 唯一标识符区分某个事件
    ///   - title: 提醒的标题
    ///   - startDate: 开始时间
    ///   - endDate: 结束时间
    ///   - notes: 备注
    ///   - eventsClosure: 事件闭包
    static func updateEvent(eventIdentifier: String, title: String, startDate: Date, endDate: Date, notes: String, eventsClosure: @escaping ((Bool) -> Void)) {
        let eventStore = EKEventStore()
        // 获取"提醒"的访问授权
        eventStore.requestAccess(to: .reminder) {(granted, error) in
            if (granted) && (error == nil) {
                // 获取授权后，我们可以得到所有的提醒事项
                let predicate = eventStore.predicateForReminders(in: nil)
                eventStore.fetchReminders(matching: predicate, completion: {
                    (reminders: [EKReminder]?) -> Void in
                    guard let weakReminders = reminders else {
                        DispatchQueue.main.async {
                            eventsClosure(false)
                        }
                        return
                    }
                    let weakReminder = weakReminders.filter { $0.calendarItemIdentifier == eventIdentifier }
                    guard weakReminder.count > 0 else {
                        DispatchQueue.main.async {
                            eventsClosure(false)
                        }
                        return
                    }
                    let reminder = weakReminder[0]
                    reminder.title = title
                    reminder.notes = notes
                    reminder.startDateComponents = dateComponentFrom(date: startDate)
                    reminder.dueDateComponents = dateComponentFrom(date: endDate)
                    reminder.calendar = eventStore.defaultCalendarForNewReminders()
                    // 修改提醒事项
                    do {
                        try eventStore.save(reminder, commit: true)
                        DispatchQueue.main.async {
                            eventsClosure(true)
                        }
                    } catch {
                        DispatchQueue.main.async {
                            eventsClosure(false)
                        }
                    }
                })
            }
        }
    }
    // MARK: 2.4、移除提醒事件
    /// 移除提醒事件
    /// - Parameters:
    ///   - eventIdentifier: 唯一标识符区分某个事件
    ///   - title: 提醒的标题
    ///   - startDate: 开始时间
    ///   - endDate: 结束时间
    ///   - notes: 备注
    ///   - eventsClosure: 事件闭包
    static func removeEvent(eventIdentifier: String, eventsClosure: @escaping ((Bool) -> Void)) {
        let eventStore = EKEventStore()
        // 获取"提醒"的访问授权
        eventStore.requestAccess(to: .reminder) {(granted, error) in
            if (granted) && (error == nil) {
                // 获取授权后，我们可以得到所有的提醒事项
                let predicate = eventStore.predicateForReminders(in: nil)
                eventStore.fetchReminders(matching: predicate, completion: {
                    (reminders: [EKReminder]?) -> Void in
                    guard let weakReminders = reminders else {
                        DispatchQueue.main.async {
                            eventsClosure(false)
                        }
                        return
                    }
                    let reminderArray = weakReminders.filter { $0.calendarItemIdentifier == eventIdentifier }
                    guard reminderArray.count > 0 else {
                        DispatchQueue.main.async {
                            eventsClosure(false)
                        }
                        return
                    }
                    // 移除提醒事项
                    do {
                        try eventStore.remove(reminderArray[0], commit: true)
                        DispatchQueue.main.async {
                            eventsClosure(true)
                        }
                    } catch {
                        DispatchQueue.main.async {
                            eventsClosure(false)
                        }
                    }
                })
            }
        }
    }
}
// MARK:- private
private extension JKEKEvent {
    /// 根据NSDate获取对应的DateComponents对象
    static func dateComponentFrom(date: Date) -> DateComponents {
        let cal = Calendar.current
        let dateComponents = cal.dateComponents([.minute, .hour, .day, .month, .year], from: date)
        return dateComponents
    }
    /// 指定年月的开始日期
    static func startOfMonth(year: Int, month: Int) -> Date {
        let calendar = Calendar.current
        var startComps = DateComponents()
        startComps.day = 1
        startComps.month = month
        startComps.year = year
        let startDate = calendar.date(from: startComps)!
        return startDate
    }
    /// 指定年月的结束日期
    static func endOfMonth(year: Int, month: Int, returnEndTime: Bool = false) -> Date {
        let calendar = Calendar.current
        var components = DateComponents()
        components.month = 1
        if returnEndTime {
            components.second = -1
        } else {
            components.day = -1
        }
        let tem = startOfMonth(year: year, month:month)
        let endOfYear =  calendar.date(byAdding: components, to: tem)!
        return endOfYear
    }
}


文章标签：
测试技术
Swift
关键词：
Swift事件
Swift日历
JoanKing
目录
相关文章
光明顶阳顶天
|
2月前
|
Swift UED
Swift 中使用闭包处理事件
【10月更文挑战第20天】使用闭包来处理事件在 Swift 编程中是一种非常常见和有效的方式。它提供了简洁、灵活和高效的解决方案，使我们能够更轻松地实现各种交互功能。通过深入理解闭包的原理和应用方法，我们可以更好地利用闭包来处理各种事件，提升应用的用户体验和开发效率。
光明顶阳顶天
34 2
QianChia
|
iOS开发
iOS - Swift NSCalendar 日历
前言 public class NSCalendar : NSObject, NSCopying, NSSecureCoding NSCalendar 对世界上现存的常用的历法进行了封装，既提供了不同历法的时间信息，又支持日历的计算。
QianChia
1640 0
cwift-tal
|
Android开发 Swift
swift UI专项训练25 网址输入完毕事件
   首先我们运行一下上一话中写好的程序看看有什么问题。 我们发现点击return是没有反应的，这是因为我们之前设置了文本框为这个界面的第一反应者，我们要得到键盘的返回必须对键盘做一些操作。
cwift-tal
884 0
cwift-tal
|
Android开发 Swift
swift UI专项训练24 构建函数和侦测网页载入事件
     构建一个方法用来载入网页的请求： func loadurl(url:String ,web:UIWebView){ let aurl = NSURL(string: ur...
cwift-tal
796 0
众所周知
|
7月前
|
安全 编译器 Swift
IOS开发基础知识： 对比 Swift 和 Objective-C 的优缺点。
IOS开发基础知识： 对比 Swift 和 Objective-C 的优缺点。
众所周知
410 2
Ant.Dream
|
5月前
|
Unix 调度 Swift
苹果iOS新手开发之Swift 中获取时间戳有哪些方式？
在Swift中获取时间戳有四种常见方式：1) 使用`Date`对象获取秒级或毫秒级时间戳；2) 通过`CFAbsoluteTimeGetCurrent`获取Core Foundation的秒数，需转换为Unix时间戳；3) 使用`DispatchTime.now()`获取纳秒级精度的调度时间点；4) `ProcessInfo`提供设备启动后的秒数，不表示绝对时间。不同方法适用于不同的精度和场景需求。
Ant.Dream
157 3
东方睿赢
|
10天前
|
安全 Swift iOS开发
Swift 与 UIKit 在 iOS 应用界面开发中的关键技术和实践方法
本文深入探讨了 Swift 与 UIKit 在 iOS 应用界面开发中的关键技术和实践方法。Swift 以其简洁、高效和类型安全的特点，结合 UIKit 丰富的组件和功能，为开发者提供了强大的工具。文章从 Swift 的语法优势、类型安全、编程模型以及与 UIKit 的集成，到 UIKit 的主要组件和功能，再到构建界面的实践技巧和实际案例分析，全面介绍了如何利用这些技术创建高质量的用户界面。
东方睿赢
20 2
众所周知
|
26天前
|
Swift iOS开发 UED
如何使用Swift和UIKit在iOS应用中实现自定义按钮动画
本文通过一个具体案例，介绍如何使用Swift和UIKit在iOS应用中实现自定义按钮动画。当用户点击按钮时，按钮将从圆形变为椭圆形，颜色从蓝色渐变到绿色；释放按钮时，动画以相反方式恢复。通过UIView的动画方法和弹簧动画效果，实现平滑自然的过渡。
众所周知
48 1
龙大吉
|
2月前
|
Swift iOS开发 UED
如何使用Swift和UIKit在iOS应用中实现自定义按钮动画
【10月更文挑战第18天】本文通过一个具体案例，介绍如何使用Swift和UIKit在iOS应用中实现自定义按钮动画。当用户按下按钮时，按钮将从圆形变为椭圆形并从蓝色渐变为绿色；释放按钮时，动画恢复原状。通过UIView的动画方法和弹簧动画效果，实现平滑自然的动画过渡。
龙大吉
50 5
1941623231718325
|
4月前
|
存储 移动开发 Swift
使用Swift进行iOS应用开发：探索现代移动开发的魅力
【8月更文挑战第12天】使用Swift进行iOS应用开发，不仅能够享受到Swift语言带来的简洁、快速、安全的编程体验，还能够充分利用iOS平台提供的丰富资源和强大功能。然而，iOS应用开发并非易事，需要开发者具备扎实的编程基础、丰富的实践经验和不断学习的精神。希望本文能够为您的iOS应用开发之旅提供一些有益的参考和帮助。
1941623231718325
45 2