Event Kit on Andrew Bancroft

Creating Calendar Events with Event Kit and Swift

Thu, 02 Jun 2016 17:37:15 +0000

Folks have asked more about working with Event Kit and Swift, so the series continues with this guide on how to create calendar events with Event Kit and Swift!

Previous guides in the series include the following:

Previous Guides

Demo

Here’s what we’re going for by the end of this:

As with my other guides, I’ve included a working project on GitHub for you to peruse and tinker with:

Resources

Event Tracker – Create Events

Code Example

The majority of the work to create an event happens in the example project’s AddEventViewController.swift file, so that’s where I’ll spend my time in this guide. First, let’s put the relevant code before us:

 1class AddEventViewController: UIViewController {
 2
 3    var calendar: EKCalendar! // Intended to be set in parent controller's prepareForSegue event
 4
 5    @IBOutlet weak var eventNameTextField: UITextField!
 6    @IBOutlet weak var eventStartDatePicker: UIDatePicker!
 7    @IBOutlet weak var eventEndDatePicker: UIDatePicker!
 8
 9    // ...
10
11    @IBAction func addEventButtonTapped(sender: UIBarButtonItem) {
12        // Create an Event Store instance
13        let eventStore = EKEventStore();
14        
15        // Use Event Store to create a new calendar instance
16        if let calendarForEvent = eventStore.calendarWithIdentifier(self.calendar.calendarIdentifier)
17        {
18            let newEvent = EKEvent(eventStore: eventStore)
19            
20            newEvent.calendar = calendarForEvent
21            newEvent.title = self.eventNameTextField.text ?? "Some Event Name"
22            newEvent.startDate = self.eventStartDatePicker.date
23            newEvent.endDate = self.eventEndDatePicker.date
24            
25            // Save the calendar using the Event Store instance
26            
27            do {
28                try eventStore.saveEvent(newEvent, span: .ThisEvent, commit: true)
29                delegate?.eventDidAdd()
30                
31                self.dismissViewControllerAnimated(true, completion: nil)
32            } catch {
33                let alert = UIAlertController(title: "Event could not save", message: (error as NSError).localizedDescription, preferredStyle: .Alert)
34                let OKAction = UIAlertAction(title: "OK", style: .Default, handler: nil)
35                alert.addAction(OKAction)
36                
37                self.presentViewController(alert, animated: true, completion: nil)
38            }
39        }
40     }
41
42     // ...
43}

Code Walkthrough

The general outline of the code is this:

Create an instance of EKEventStore – this will let you create EKEvents and save them.

1let newEvent = EKEvent(eventStore: eventStore)

Pull an EKCalendar instance from the Event Store – this will let you associate an event with a calendar.

1if let calendarForEvent = eventStore.calendarWithIdentifier(self.calendar.calendarIdentifier) { 
2// ... 
3}

Create a new EKEvent instance and set its properties.

1let newEvent = EKEvent(eventStore: eventStore)
2            
3newEvent.calendar = calendarForEvent
4newEvent.title = self.eventNameTextField.text ?? "Some Event Name"
5newEvent.startDate = self.eventStartDatePicker.date
6newEvent.endDate = self.eventEndDatePicker.date

Attempt to save the event with the EKEventStore instance that was created first.

 1do {
 2    try eventStore.saveEvent(newEvent, span: .ThisEvent, commit: true)
 3    delegate?.eventDidAdd()
 4    
 5    self.dismissViewControllerAnimated(true, completion: nil)
 6} catch {
 7    let alert = UIAlertController(title: "Event could not save", message: (error as NSError).localizedDescription, preferredStyle: .Alert)
 8    let OKAction = UIAlertAction(title: "OK", style: .Default, handler: nil)
 9    alert.addAction(OKAction)
10    
11    self.presentViewController(alert, animated: true, completion: nil)
12}

Gotchas

As I was working through this example, I was initially running into trouble when associating my newEvent with the calendar that was passed into AddEventViewController from the parent controller’s prepareForSegue method.

It turns out that if you retrieve a calendar from one EKEventStore instance, say, in the previous view controller, and attempt to assign it to an EKEvent that is associated with a different EKEventStore instance, things become really unhappy when it comes time to save the event.

Specifically, you’ll get an error that says “Thread 1: signal SIGKILL” followed by “Thread 1: EXC_BAD_ACCESS”:

The fix for this was easy, once I figured out what was going on: Simply re-retrieve a calendar instance using an appropriate calendarIdentifier from the EKEventStore instance you’re using to save the EKEvent with:

1if let calendarForEvent = eventStore.calendarWithIdentifier((self.calendar.calendarIdentifier))
2{
3    let newEvent = EKEvent(eventStore: eventStore)
4    
5    newEvent.calendar = calendarForEvent
6    
7    // ...
8}

Wrapping up

My focus in this guide was to demonstrate how to create and save and event to a user’s calendar. I intentionally left out a lot of the navigation aspects and prepareForSegue calls in order to highlight the event creation process itself. Be sure to check out the accompanying Xcode project on GitHub for full details on the flow of the application.

Creating Calendars with Event Kit and Swift

Wed, 17 Jun 2015 17:46:29 +0000

Updated on April 19, 2016 – Swift 2.1 | Added example project

Apple’s Event Kit framework empowers developers to interact with an iOS device’s calendar database. Not only can we read calendars and events from the database, we can also create calendars.

In a previous article, we looked at how to handle asking the user for permission to access their calendars. Now my goal is to show you how to create local calendars on the user’s device programmatically with Swift using the Event Kit framework.

Here’s a demo of what we’re going for by the time I’m finished with this article:

If you’d like to tinker with the code for yourself, you can download the example project:

Resources

Event Tracker – Create Calendar

Import EventKit

Step 1 in this whole process will be to import EventKit at the top of your Swift file:

1import UIKit
2import EventKit
3
4// ...

Importing EventKit gives us access to everything we need to work with calendars.

General outline for creating a local calendar

Now, we’ll proceed with creating a local calendar on the user’s device. It’s important to note that there are other kinds of calendars that you can create. For example, you can create calendars that sync with iCloud. For now though, we’re going to narrow the focus down to just creating the calendar on the user’s local device.

Here’s the general outline (and then some code):

Create an EKEventStore instance
Create a new EKCalendar instance using that event store instance
Configure the new calendar’s title
Wire up the new calendar’s source
- Obtain a list of the available sources from the event store instance
- Filter that list down to the EKSourceTypeLocal source type
- Assign it to the calendar’s source property
Save the calendar using the event store instance
Handle any problems that might have occurred

Code example

That’s the general outline… Now for the code!

 1// Create an Event Store instance
 2let eventStore = EKEventStore();
 3
 4// Use Event Store to create a new calendar instance
 5// Configure its title
 6let newCalendar = EKCalendar(forEntityType: .Event, eventStore: eventStore)
 7
 8// Probably want to prevent someone from saving a calendar
 9// if they don't type in a name...
10newCalendar.title = "Some Calendar Name"
11
12// Access list of available sources from the Event Store
13let sourcesInEventStore = eventStore.sources 
14
15// Filter the available sources and select the "Local" source to assign to the new calendar's
16// source property
17newCalendar.source = sourcesInEventStore.filter{
18    (source: EKSource) -> Bool in
19    source.sourceType.rawValue == EKSourceType.Local.rawValue
20}.first!
21
22// Save the calendar using the Event Store instance
23do {
24    try eventStore.saveCalendar(newCalendar, commit: true)
25    NSUserDefaults.standardUserDefaults().setObject(newCalendar.calendarIdentifier, forKey: "EventTrackerPrimaryCalendar")
26} catch {
27    let alert = UIAlertController(title: "Calendar could not save", message: (error as NSError).localizedDescription, preferredStyle: .Alert)
28    let OKAction = UIAlertAction(title: "OK", style: .Default, handler: nil)
29    alert.addAction(OKAction)
30    
31    self.presentViewController(alert, animated: true, completion: nil)
32}

The most confusing part of the code above for me was obtaining the right source to assign to the new calendar’s source property. Let’s unpack that for a second…

Obtaining and assigning the calendar’s source

The eventStore instance gives us the ability to query for a listing of its relevant calendar source types. But why are we going to the event store just to get a list of all the sources so that we can filter it down to just the one we want? Well, because this is the only way to get EKSource instances! Take a look at this quote from the Apple Documentation:

You do not create instances of EKSource. You retrieve EKSource objects from an EKEventStore object. Use the sources property to get all the EKSource objects for an event store, and use the methods in this class to access properties of the source object. (emphasis added)

So that answers the question of why we query the event store for that list of source types. But now, how do we narrow that list down to the one we want? That’s where the call to filter comes in…

First let’s isolate that code segment from the rest so it’s clear what we’re analyzing:

1newCalendar.source = sourcesInEventStore.filter{
2    (source: EKSource) -> Bool in
3    source.sourceType.rawValue == EKSourceType.Local.rawValue
4}.first!

The goal of this code is to take the list of sources in the event store, and filter them so that only the one matching the value of EKSourceTypeLocal is returned. This is easily accomplished using the filter function on the array of EKSources that’s returned by the event store.

But filter also returns an array, so to get the single source we’re looking for, we’ll simply grab the first element out of the array filter returns, and assign it to the new calendar’s source property. There are no duplicated EKSourceTypes in the list returned by the event store, so our filter expression should only return one match wrapped in an array.

That’s it for configuring the calendar. The remainder of the code uses the event store instance to save the calendar, and handle any errors that might occur with the save process.

Saving the calendar identifier

One last thing to note is that if you’re creating a calendar for your app to store events in, you probably want to stash the calendar’s identifier value somewhere, so that you can query the event store for the calendar directly, at a later point in time.

Using NSUserDefaults.standardUserDefaults() is a convenient way to store this calendar identifier value. The code to pay attention to is highlighted in this snippet:

 1// ...
 2
 3// Save the calendar using the Event Store instance
 4do {
 5    try eventStore.saveCalendar(newCalendar, commit: true)
 6    NSUserDefaults.standardUserDefaults().setObject(newCalendar.calendarIdentifier, forKey: "EventTrackerPrimaryCalendar")
 7} catch {
 8    let alert = UIAlertController(title: "Calendar could not save", message: (error as NSError).localizedDescription, preferredStyle: .Alert)
 9    let OKAction = UIAlertAction(title: "OK", style: .Default, handler: nil)
10    alert.addAction(OKAction)
11    
12    self.presentViewController(alert, animated: true, completion: nil)
13}

So assuming that the calendar was saved successfully without error, we’ll simply access the standard user defaults, and insert a new object (our calendar’s identifier) for a key that we’ll use to retrieve the identifier again later.

Wrapping up

Having the ability to create a calendar for an iOS application using Event Kit is a powerful thing if you’re wanting to take advantage of some of the built-in event-related features of the iOS platform. In this article we saw how to create a calendar using Event Kit and Swift. Additionally we analyzed some of the less-than-intuitive pieces of accessing the event store for a list of sources. We concluded by saving the new calendar’s identifier to NSUserDefaults so that we could easily retrieve the calendar from the event store at a later time.

Beginner’s Guide to Event Kit in Swift – Requesting Permission

Thu, 14 May 2015 20:37:52 +0000

Updated on October 26, 2016 – Swift 3.0

EventKit provides a set of classes for accessing and manipulating a user’s calendar events and reminders. In the tutorial that follows, my goal is to walk you through the first steps of setting up an app that utilizes EventKit. I will demonstrate how to request permission to the user’s calendar and show a couple of examples for how to handle the user’s response (for when they grant access, or deny it).

Note: Code in the main article below is written in Swift 3.0, but code examples for Swift 2.3 are found in the example project.

Example scenario

Let’s start by proposing a basic scenario to serve as this tutorial’s example.

Suppose that we’re building an app that, for now, has a single View Controller. We’d like this View Controller to display a list of calendars if the user grants us permission to do so. If they deny permission, we’d like to show a message to them that indicates that our app can’t function without this permission, and we’ll allow them to click a button to grant us permission in the Settings of their device.

I’ve created such an app as an example – jump over to GitHub to grab the code and explore. Read on for an explanation of some of the finer points of the setup and code.

Resources

Example Xcode Project (Swift 2.3 | Swift 3.0)

Storyboard setup

One of the first things you’ll deal with in EventKit is the need to set yourself up with a UI to handle the different responses that the user can give you on that first application launch when you ask, “Can we access your calendar?”. We’ll get to the particulars of how request that permission shortly. But first, let’s dissect how we might arrange a Storyboard with some views that do the right thing for a given response to that permission prompt.

The user can either grant permission, or deny permission to interact with their calendar or reminders. We need to be prepared for either scenario.

Tableview for the calendar list for when access is granted

I’m feeling optimistic today, so let’s begin with the case where the user grants us permission to their calendar from the get-go.

When the user grants us permission, we’d like to list out their calendars inside a table view. We’ll worry with setting up the data source later in the tutorial. For now, we’ll drag over a table view from the Utilities pane.

To get the table view to fill the whole screen, I do a couple of things. Usually, when you drag one out from the Utilities pane, the table view will fill the whole scene in the Storyboard. From that layout, I drag the top edge down until it “snaps” to the line where I’d expect the bottom of the status bar to be positioned. Then I set the following constraints:

Center X
Center Y
Equal width to Superview
Top space to Top Layout Guide for height.

I’ve created a short screencast on setting up a table view if you’d like a complete walkthrough:

Resources

Here’s a detailed view of the constraints, along with a visual of what the Storyboard Scene looks like with the table view installed:

As a final note, I’ve set the hidden property of the table view to true in the Storyboard. I’ll toggle the table’s visibility based on the user’s granting or denying of the calendar access later, but I thought it was worth pointing out that the initial state of my table view in the example is hidden.

“Need permission” view for when access is denied

There will be times when a user denies access to the calendar before realizing that doing so essentially stops all the functionality provided by your app. If your entire app, or even just a portion of it requires access to function, you need a way to inform the user of this, and provide them a way to navigate to settings and grant access manually if possible.

The way I did this in the sample project was to organize a new View onto the Storyboard Scene which contains a label with some instructions, and a button that takes the user to the Settings page for our app when they tap on it.

Once again, some constraints are involved in getting things to appear correctly at run-time. I won’t go into the details of this here, since it’s likely that every implementation of this will be slightly different.

One thing I will point out though, is that the View’s alpha has been set to 0 so that I can perform a nice fade in transition if the user denies access. Here’s a look at the Scene with the invisible “NeedPermissionsView” installed:

The role of the Event Store

At the heart of EventKit is the EKEventStore. EKEventStore is the central “thing”. Creating an instance of EKEventStore provides developers with an API for performing various read/write operations on the user’s calendars and reminder lists.

A View Controller that interacts with the calendar should hold a reference to an EKEventStore instance. It’s easy to create one – here’s an example:

1class ViewController: UIViewController, UITableViewDataSource, UITableViewDelegate {
2
3    let eventStore = EKEventStore()
4
5    // ...    
6}

Checking for calendar authorization

Once we have a reference to an EKEventStore instance, we can use it to do things like check whether or not the user has granted us permission to use their calendar. From there, we can make decisions about whether or not we need to request permission, and subsequently figure out which view to show (the table view or the need permission view).

Where we check for calendar authorization is important. My recommendation is to check each time the view appears (ie, in viewWillAppear(), because it’s completely possible that the user could grant access at first, switch to settings, and deny access. Our app would need to respond appropriately.

In the example project provided with this article, I’ve created a function named checkCalendarAuthorizationStatus(). Here a peek at what it does:

 1class ViewController: UIViewController, UITableViewDataSource, UITableViewDelegate {
 2
 3    // ...
 4    
 5    override func viewWillAppear(animated: Bool) {
 6        checkCalendarAuthorizationStatus()
 7    }
 8    
 9    func checkCalendarAuthorizationStatus() {
10        let status = EKEventStore.authorizationStatus(for: EKEntityType.event)
11        
12        switch (status) {
13        case EKAuthorizationStatus.notDetermined:
14            // This happens on first-run
15            requestAccessToCalendar()
16        case EKAuthorizationStatus.authorized:
17            // Things are in line with being able to show the calendars in the table view
18            loadCalendars()
19            refreshTableView()
20        case EKAuthorizationStatus.restricted, EKAuthorizationStatus.denied:
21            // We need to help them give us permission
22            needPermissionView.fadeIn()
23        }
24    }
25
26    // ...
27}

The key function here is EKEventStore's authorizationStatus(for:) function. Passing in EKEntityType.event is what corresponds to the user’s calendar. If we wanted to check for access to their reminders, we’d use EKEntityTypeReminder.

The possible EKAuthorizationStatus enumeration values are simply switched over – the logic to be performed is encapsulated in separate functions for ease of readability.

Let’s step through each of those functions one by one…

Update Info.plist for iOS 10 support

Apple now requires us to have a key/value pair in Info.plist that provides a description to the user as to why our apps need access to their calendar.

To set this value, open your Info.plist file, and add a new key for “Privacy – Calendars Usage Description”:

The value that you provide for this plist key ends up being displayed in the alert that’s displayed when you request access.

Requesting access to calendars

As the title of this tutorial suggests, all things start here. Whenever our application loads and we call authorizationStatus(for:), the status that will be returned is notDetermined. It’s at this point that we’d like to request access to the calendar.

To do so, let’s dissect the requestAccessToCalendar function:

 1class ViewController: UIViewController, UITableViewDataSource, UITableViewDelegate {
 2
 3   // ...
 4   
 5    func requestAccessToCalendar() {
 6        eventStore.requestAccess(to: EKEntityType.event, completion: {
 7            (accessGranted: Bool, error: Error?) in
 8            
 9            if accessGranted == true {
10                DispatchQueue.main.async(execute: {
11                    self.loadCalendars()
12                    self.refreshTableView()
13                })
14            } else {
15                DispatchQueue.main.async(execute: {
16                    self.needPermissionView.fadeIn()
17                })
18            }
19        })
20    }
21
22    // ...
23}

Our EKEventStore instance provides a function called requestAccess(to:). Once again, passing in EKEntityType.event is what signals that we’re requesting access to the calendar. The rest of the interesting parts are found in the completion closure that we provide.

There are three main things to note with this portion of the implementation:

The two parameters that are passed in to the closure is a Bool indicating access was granted (true) or denied (false). The second is an NSError.
We need to call dispatch_async() and indicate that we want to jump back over to the main queue to execute our UI refreshes.
self.needPermissionView.fadeIn() utilizes a UIView extension from my post, Fade In / Out Animations as Class Extensions in Swift.

Access granted! Load calendars and refresh table view

When access is granted, we can call the eventStore instance’s calendarsForEntityType function and pass it EKEntityType.event to grab an array of the user’s calendars to display in our table view. Here’s a look:

 1class ViewController: UIViewController, UITableViewDataSource, UITableViewDelegate {
 2
 3    // ...
 4
 5    var calendars: [EKCalendar]?
 6
 7    // ...
 8    
 9    func loadCalendars() {
10        self.calendars = eventStore.calendars(for: EKEntityType.event)
11    }
12    
13    func refreshTableView() {
14        calendarsTableView.isHidden = false
15        calendarsTableView.reloadData()
16    }
17
18    // ...
19}

Access denied – Show needs permission view

When access is denied, we need to unveil the “Needs Permission View” we created in our Storyboard Scene.

Recall that in that view, there’s a button to direct the user to the Settings page for our app so that they can easily grant access to the calendar from there. That button is wired up to an IBAction. Here’s an example implementation of that IBAction:

 1class ViewController: UIViewController, UITableViewDataSource, UITableViewDelegate {
 2
 3    // ...
 4
 5    @IBAction func goToSettingsButtonTapped(_ sender: UIButton) {
 6        let openSettingsUrl = URL(string: UIApplicationOpenSettingsURLString)
 7        UIApplication.shared.openURL(openSettingsUrl!)
 8    }
 9
10    // ...
11}

Wrapping up

That pretty much completes the setup process for working with Event Kit! The remaining cases for the checkCalendarAuthorizationStatus() function simply re-use the functions I just dissected when exploring the requesting permission process.

I encourage you to head over to GitHub and dive into the code for yourself as you get started with utilizing Event Kit in your app!