Containers —How Data Access Is Organized

The data management and data access in iCloud have a similar feel to how we access data locally on the device in that each application has its own sandbox in the cloud. This sandbox is called a Containerand contains the data that an app might need to store in the cloud. One significant difference, however, is that, unlike with local storage, several apps can share a storage container in the cloud, as long as they are all associated with the same development account.

Programmatically containers are represented by the CKContainer class, which is part of the CloudKit framework. Every app that uses iCloud has a designated default container object, which you can obtain by calling CKContainer.defaultContainer()(Listing 13-12).

Listing 13-12. Obtaining a Reference to the Default Container

let container = CKContainer.defaultContainer()

Figure 13-2 illustrates the structure of a container. It consists of several databases: a public one and multiple private ones. The public database is application-centric and is available to all users of the app, whereas each private database is associated with only one user and is only accessible to that user.

Figure 13-2. CloudKit Container structure

When an app is installed on a user’s device, it can only see and access two databases: the public one and the private database for the user. CKContainer has helper methods, which allow us to talk to each database: publicCloudDatabase and privateCloudDatabase. Each of these methods returns a reference to a CKDatabase object (Listing 13-13).

Listing 13-13. Obtaining References to the Public and the Private Database

let publicDatabase = container.publicCloudDatabase
let privateDatabase = container.privateCloudDatabase                                                

Be aware that you cannot delete a container. Once a container is created it will stay in iCloud forever, or at least until Apple decides to change how its cloud works. In other words, do not run around and create new containers without a good reason.

Next we will have a look at how data is represented inside a container’s database.

Records —How Data Is Represented

Data in the CloudKit databases is organized as records. A record is very similar to a key-value pair, where the value can take a variety of types: number, array, date, and time; location; binary blob; and many more. The key part of the pair is of type String, which consists of alphanumeric characters and starts with a letter.

The class that helps you work with records is called CKRecord. CKRecord instances have a property, called recordType, which serves as metadata: it holds a string with a custom description of the record’s data. This gives us a way of querying iCloud for records that match this description. This is helpful if we want to query iCloud for certain record types only. You can give any valid string name as a record type. When a record is created in the cloud it automatically gets some additional metadata fields that store information about when the record was created, which user created it, when it was last updated, and who made the update. You can use this metadata to narrow your searches in the database.

Let us see how we can create a record and fill it in with data Listing 13-14). An instance of the CKRecord class is created by calling its default initializer and passing a string to describe the record type. To add a key-value pair we call the setObject(_:forKey:) method of the instance. The listing also shows you a shortcut alternative: instead of calling setObject(_:forKey:) you can put the key name in square brackets, [], and use the assignment operator.

Listing 13-14. Creating a CKRecord Instance and Populating It with Data

let record = CKRecord(recordType: "Person")
record.setObject("Julius Marx", forKey: "name")
record["age"] = 30
record["nickname"] = "Groucho"

Each record has a unique ID, which is automatically assigned to it by the CloudKit framework at the time of initialization. You can set an ID yourself by using the initWithRecordType:recordID: initializer of the CKRecord class. When a record is received by the iCloud server its ID gets checked for uniqueness and if it is not unique the server throws an error.

Records can be organized in groups, called zones, which are represented by the CKRecordZone class. Every container has a default zone, which is used if you don’t explicitly define one. Grouping records lets you define custom business logic and perform transactional operations on records in a zone. We won’t use zones in this tutorial, but it’s good to be aware of them, as they can be invaluable when it comes to segmenting big data.

Defining Relationships Between Records

Imagine we have to create a music player application that will help users play their favorite songs of their favorite bands. We can design the underlying data model as records, which will represent a band, an album, or a song. In other words, each CKRecord in our model will have its recordType set to Bands, Albums, or Songs. If we had the record for a song, it would be useful to be able to work out what album it was released on and which band recorded it. To do that we will need to set relationships between the song, album, and band records.

In CloudKit relationships between records are managed by instances of the CKReference class. A CKReference object creates a many-to-one relationship between records in CloudKit’s database. Records that refer to another record, which we will call the target record, need to contain a reference object, which in turn contains information about the target. Both the target and the referring records need to be in the same zone of the same database.

Listing 13-15 illustrates how references between records are created, using the example from the start of this section: we see how to create references from a song record to its respective band and album records.

Listing 13-15. Creating a Reference Between Two CKRecords

let band = CKRecord(recordType: "Bands")
band["name"] = "Scorpions"

let album = CKRecord(recordType: "Albums")
album["name"] = "Crazy World"

let song = CKRecord(recordType: "Songs")
song["name"] = "Wind of Change"

let referenceBand = CKReference(recordID: band.recordID,
    action: .DeleteSelf)
let referenceAlbum = CKReference(recordID: album.recordID,
    action: .DeleteSelf)

song["inAlbum"] = referenceAlbum
song["byBand"] = referenceBand

You probably noticed a parameter called action, which we set when initializing CKReference. This is a property of the CKReference class, which defines what action needs to be taken when the target of the reference is deleted. We can choose between these two:

• CKReferenceActionDeleteSelf—deleting the target record deletes any records that contain that reference in one of their fields.

• CKReferenceActionNone—no action is taken.

Assets—Storing Unstructured Data

Storing strings and numbers in the cloud is good, but how do we go about storing a large document like an image or a video file? To create such a record in the database, its value needs to be of type CKAsset. This class represents data stored in, typically, large files.

Listing 13-16 builds on the band-album example we used earlier and stores the album cover as an asset.

Listing 13-16. Creating an Asset from an Image File

let albumCoverAsset = CKAsset(fileURL: coverImageURL)
album["coverImageAsset"] = albumCoverAsset

Saving and Deleting Records from the Cloud

CKRecord instances live in the application’s memory and get deleted when the app closes. To persist a record to iCloud, we need to ask the database to which it belongs to save it on the server. For that purpose CKDatabase has a convenience method, called saveRecord(_:completionHandler:). Have a look at Listing 13-17 for how to use it. saveRecord’s first argument is the record we want to persist and its second argument is a callback, also known as completion handler, which will be executed when the saving operation finishes. The callback’s signature is (CKRecord?, NSError?): in it we get passed the record we tried to persist and an error object, which is set to nil if the saving was successful or contains information on what went wrong otherwise.

Listing 13-17. Save a CKRecord in the Server’s Database

let privateDatabase = CKContainer.defaultContainer().privateCloudDatabase
let band = CKRecord(recordType: "Bands")
band["name"] = "Scorpions"

privateDatabase.saveRecord(band) { (record, error) -> Void in
    //Handle success or error response from the server
}

saveRecord(_:completionHandler:) is used for updating existing records in the database, as well as for persisting them for the first time.

To delete a record from the server we call CKDatabase’s deleteRecordWithID(_:completionHandler:) method, which looks very similar to the method we used for saving: we pass in the record we want to delete and a callback function as arguments. The callback gets executed when the deletion is complete; it receives a reference to the record that we tried to delete and optional error information. We can see this in Listing 13-18.

Listing 13-18. Deleting a Record from the Cloud

privateDatabase.deleteRecordWithID(band.recordID)
    {(recordID, error) -> Void in }

Note that saving and deleting are performed asynchronously over the network. As it is not in our control how long a response from the server may take, it is usually a good idea to notify the user with an activity indicator that a potentially lengthy operation is taking place.

Retrieving Records from the Cloud

To get records from the cloud we need to perform a query, using CKQuery—another helper class from the CloudKit framework. Initializing a CKQuery instance takes the already familiar recordType and an instance of NSPredicate. NSPredicate is a powerful class that helps us specify how data should be retrieved from the database. It has its own query language, similar to using the WHERE clause in the structured query language (SQL) for those of you familiar with SQL.

Apart from narrowing down and filtering the data we fetch from the database, we can have the retrieved records sorted, using CKQuery’s property sortDescriptors, which is an array of NSSortDescriptor objects.

Performing a query on the server is an asynchronous operation and, like the rest of the server-side calls we have made so far, requires that we implement a completion handler function that will be called once the query returns a result. We pass this completion handler to CKDatabase’s performQuery(_:inZoneWithID:completionHandler:) method.

In Listing 13-19 you can see an example of a query that retrieves all records of type Bands from the server and sorts them by their name in ascending order. The result comes as an array of CKRecord objects, which is the first parameter of the completion handler closure we pass to privateDatabase.performQuery.

Listing 13-19. Retrieve a List of Records from the Server

let fetchQuery  = CKQuery(recordType: "Bands",
                         predicate: NSPredicate(format: "TRUEPREDICATE"))

fetchQuery.sortDescriptors = [ NSSortDescriptor(key: "name",
                                ascending: true) ]

privateDatabase.performQuery(fetchQuery, inZoneWithID: nil) {
                                (records, error) -> Void in }

Common Error Messages

As you can see, all network operations we have done so far return their results in callback functions, which take optional NSError parameters. It’s a good idea always to check if the error passed to the callback is nil and if it isn’t, to inspect its error code. You can find a complete list of error codes in the definition of CKErrorCode. Following are some of the most common ones with suggestions about how to deal with them:

• .BadContainer or .MissingEntitlement. Check if you have specified a container in the iCloud entitlements section of your app matching the CKContainer object. Make sure that the container exists on the CloudKit Dashboard web site.

• .NotAuthenticated or .PermissionFailure. You might not have entered your iCloud credentials in the settings of your device yet. Go to device Settings > iCloud and see if an account has been assigned. Another reason to get one of these errors could be that iCloud is disabled on the device. Enable it in Settings ➤ iCloud.

• .UnknownItem. This usually means that you have requested a record type that doesn’t exist on the server. Make sure you haven’t made a typo when specifying the string for recordType and check the CloudKit Dashboard web site to make sure the string matches the records that are there.

I keep mentioning the CloudKit Dashboard but haven’t told you what it is yet. This is a web-based admin panel that helps you manage data on the iCloud server. The rest of this chapter provides a more in-depth look at it.

Preparation: Setting Up the App

First things first. Before we start coding, we need to perform several mandatory steps to enable CloudKit in our application.

Start by creating a new Single View Application project in Xcode and name it CloudKitDemo. Select the project in the Project Navigator and select the app from the list of targets. Open the General tab and set Team to the correct iOS development account (Figure 13-3).

Figure 13-3. Select an account in Team: it will need to be a member of Apple’s iOS Development Program

Next, open the Capabilities tab and find the iCloud setting. Toggle the switch to enable iCloud (Figure 13-4). This will add all the necessary entitlements to your application. It may take a few minutes for Xcode to create an app ID and authorize it to use iCloud. Note that this step will generate an error if the team/Apple ID you selected in the previous step is not a member of Apple’s iOS Development Program.

Figure 13-4. Enable iCloud usage for the app target

Tick the Key-value storage and CloudKit checkboxes (Figure 13-5). In this tutorial we will not share database containers with other apps, so leave the Use default container option checked.

Figure 13-5. The applciation's iCloud settings

At the bottom of the settings you will see a button that says CloudKit Dashboard. Click it to go to the CloudKit Dashboard admin web page—it will load in a browser. Log in with your Apple ID.

CloudKit Dashboard —Registering Record Type

The CloudKit Dashboard is the place where you can administer the app’s back end in the cloud. It lets you manage database containers, zones, and record types; monitor data usage and data traffic; and get information about users.

Before we can store and fetch records from iCloud we need to create a new Record Type. Open the CloudKit Dashboard page and select Record Types from the menu on the left as shown on Figure 13-6. Create a new record type by clicking the + button at the top of the page. Name the new record type ShoppingItem. Next you need to add fields to the record and specify their data type. Let us add a field of type String and name it “name.” Finally, click the Save button at the bottom of the page to persist the changes.

Figure 13-6. Create a new Record Type

Linking the Device with an iCloud Account

For our users to be able to use this application they should be logged in with their iCloud account on the device. You have to do the same in order to test the app whether on a device or in a simulator.

On your iOS device open Settings ➤ iCloud and make sure iCloud Drive is turned on (Figure 13-7). Then, if the account field is empty, fill in your or your Apple ID credentials to log in to iCloud.

Figure 13-7. Log in to iCloud on a device or in a simulator

Using the CloudKit Framework: Making a Cloud Data Manager

With the project and the new record type set up, it is time to start coding with the CloudKit framework. For clarity we will split the application’s code into two layers. One layer will manage shopping list items and will communicate with the iCloud back end and other layer will take care of the user interface.

In this section we will create a class which will be responsible for

• storing all shopping list items and providing access to their names.

• adding an item to the list and sending it to the cloud.

• deleting an item from the list and syncing with the cloud.

• notifying the UI of the application whenever a response from the server arrives.

From Xcode’s main menu select File ➤ New ➤ File and click Swift fil e to add a new source code file to the project. Name the file CloudDataManager.swift and click on its name in Project navigator to open it. Listing 13-20 shows the CloudDataManager class definition with all the methods stubbed out. We will add functionality to them in a minute. Note that in order to use CloudKit’s API, we need to import the CloudKit framework at the top of the file.

Listing 13-20. CloudDataManager Class

import Foundation
import CloudKit

class CloudDataManager {
    //Shopping list items array
    var dataItems : [CKRecord]

    //Record Type of the items
    let recordType = "ShoppingItem"

    //Default initializer
    init() {
        //Create an empty array of shopping items
        dataItems = []
    }

    //Get item's name at a given index in the items array
    func getItemName( atIndex index : Int ) -> String {
        return dataItems[index]["name"] as! String
    }

    //Get the number of shopping items
    func getItemsCount() -> Int {
        return dataItems.count
    }

    //Get all ShoppingItem records from the server and load them into the list
    func fetchCloudItems( callback callback: (NSError?) -> Void ) {
        //Code of the method goes here
    }

    //Add a new shopping item to the list and sync with iCloud
    func addItem( itemName item : String, callback: (NSError?) -> Void ) {
        //Code of the method goes here
    }

    //Remove an existing shopping item from the list and sync with iCloud
    func removeItem( atIndex index : Int, callback: (NSError?) -> Void) {
        //Code of the method goes here
    }
}

In this class dataItems property is an array that stores the local cache for the shopping list items. There are two sets of methods in the class. The first set includes getItemName(:atIndex) and getItemsCount(), which act as a façade for dataItems. They are used to query the local cache and do not perform any network operations, so they are fast and synchronous.

The next three methods, fetchCloudItems(:callback), addItem(:itemName:callback), and removeItem(:atIndex:callback) perform asynchronous network operations and are potentially slow. Because of this, each of the methods takes a callback function as an argument, which is executed when the respective network operation is complete. We will later implement these callbacks to update the app’s user interface.

We have the skeleton of the CloudDataManager class. Let us now focus on implementing its logic in each of the methods’ stubs (Listing 13-21).

We will start with fetchCloudItems(:callback). This method is called when the app launches: its purpose is to get all previously entered shopping items from the server if there are any. For that purpose we will create a query for retrieving all records of type ShoppingItem: this will be done with the help of an NSPredicate instance. In Listing 13-21 we set the NSPredicate’s filter to TRUEPREDICATE, which means “iterate through all records and fetch each one.” The next step is to get the records sorted. Sorting will be performed on the records’ “name” field in ascending order. The result of the query is returned in the records argument of the completion handler, implemented as a closure in this case.

In the completion handler we are going to update the local cache and signal the UI to show the updated shopping list. The logic of the code inside the closure is fairly simple: if the result contains any records, they are copied into the local list of items. Finally, the code calls the callback argument to communicate the changes with the UI. This is a pattern we will follow when implementing the rest of the methods that involve waiting for a response from the server.

Listing 13-21. Implementation of fetchCloudItems Method

func fetchCloudItems( callback callback: (NSError?) -> Void ) {
    //Get a reference of the user's iCloud database
    let privateDatabase = CKContainer.defaultContainer().privateCloudDatabase

    //Construct a query to get all the records of type "ShoppingItem"
    let fetchQuery  = CKQuery(recordType: self.recordType,
                    predicate: NSPredicate(format: "TRUEPREDICATE"))

    //Sort fetched records by their name in ascending order
    fetchQuery.sortDescriptors = [ NSSortDescriptor(key: "name",
                                    ascending: true) ]

    //Send the query to iCloud
    privateDatabase.performQuery(fetchQuery, inZoneWithID: nil) {
        (records, error) -> Void in
        //Move the result records into the dataItems array
        if records!.count > 0 {
            for record in records! {
                self.dataItems.append( record )
            }
        }

        //Tell the UI to update itself
        callback(error)
    }
}                                                                                            

Next to implement is the addItem(:itemName:callback) method (Listing 13-22). This method is called every time the user adds an item to the shopping list and a new CKRecord instance needs to be created for it. Once this is done the new record is persisted to the cloud by the saveRecord call. We only add the new record to the local cache if saving it to the server was successful—we are notified about this in the completion handler we supply to saveRecord.

Listing 13-22. Implementation of addItem Method

func addItem( itemName item : String, callback: (NSError?) -> Void ) {
    //Get a reference of the user's iCloud database
    let privateDatabase = CKContainer.defaultContainer().privateCloudDatabase

    //Create a record of of type "ShoppingItem" and set its name
    let localRecord = CKRecord(recordType: self.recordType)
    localRecord["name"] = item

    //Ask iCloud to store the record
    privateDatabase.saveRecord(localRecord) { (record, error) -> Void in
        //If the response is ok add this record to the local list
        if let record = record {
            self.dataItems.append( record )
        }

        //Tell the UI to update itself
        callback( error )
    }
}

We will complete the CloudDataManager class with the implementation of the removeItem(:atIndex:callback) method (Listing 13-23). We ask the server to delete a record by calling deleteRecordWithID and passing the record’s unique ID, which we can work out from the record’s recordID property. The completion handler we supply follows a familiar pattern: if the deletion is successful, the local cache is updated and changes are reflected in the user interface.

Listing 13-23. Implementation of removeItemAtIndex Method

func removeItem( atIndex index : Int, callback: (NSError?) -> Void) {
    //Get a reference of the user's iCloud database
    let privateDatabase = CKContainer.defaultContainer().privateCloudDatabase

    //Get a record by its index in the local list
    let record = dataItems[ index ]

    privateDatabase.deleteRecordWithID(record.recordID) {
     (recordID, error) -> Void in
        //Get the local index of the record that should be removed
        let recordIndex = self.dataItems.indexOf(record)
        //Remove the underlying record
        self.dataItems.removeAtIndex(recordIndex!)

        //Tell the UI to update itself
        callback( error )
    }
}                                                                                                                      

Preparing the User Interface

We will use a Table View component to display the shopping list on the screen and two buttons that will let the user add and delete items.

In Xcode open the Main.storyboard file and make it look like the screenshot in Figure 13-8: first find a Navigation bar component in the Object library and drag it to the top of the scene. Then drag two Bar Button item components on top of it—place one on the left and one on the right. Select the left button and in the Attributes inspector select Edit from the System Item drop-down. This will change the caption of the button to Edit. Set System Item for the right button to Add and its caption will change into a big plus sign. These two buttons will let the user add and delete items from the list.

Figure 13-8. CloudKitDemo application user interface

To finish building the UI drag and drop a Table view component under the Navigation and add constraints to it to take the remaining portion of the screen. Create a prototype cell and set its Identifier property to ShoppingItemCell.

Drag the table view into the definition of the ViewController class in ViewController.swift to create an outlet. Name the outlet tableView (Listing 13-24).

Listing 13-24. Create an Outlet for the Table View

@IBOutlet weak var tableView: UITableView!

Creating Table View Data Source and Delegate

The table view needs to get its data from an object that conforms to the UITableViewDataSource protocol. To keep things simple, we will make the ViewController class our data source. To talk to the table view, we will also make it conform to the UITableViewDelegateprotocol (Listing 13-25).

Listing 13-25. Conform to UITableViewDelegate and UITableViewDataSource Protocols

class ViewController: UIViewController, UITableViewDelegate,
    UITableViewDataSource {

    //The rest of the code goes here
}

Conforming to these two protocols requires implementation of these two methods in the ViewController class: tableView(_:numberOfRowsInSection:) and tableView(_:cellForRowAtIndexPath). We will just stub them out as shown in Listing 13-26.

Listing 13-26. Implement UITableViewDelegate and UITableViewDataSource Protocols' Methods

class ViewController: UIViewController, UITableViewDelegate,
    UITableViewDataSource {

    //The rest of the code goes here

    func tableView(tableView: UITableView,
        numberOfRowsInSection section: Int) -> Int {
        return 0
    }

    func tableView(tableView: UITableView,
        cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell {
        return UITableViewCell()
    }
}

Populating the Table View with Data

We are finally ready to fill the table view with data. First we need an instance of the CloudDataManager class, which will provide shopping items data: we will make this a property of the ViewController class, called cloudDataManager. The next step is to set the table view’s data source and delegate properties to the ViewController class instance. We will do this in the viewDidLoad() method of ViewController (Listing 13-27).

Listing 13-27. Instantiate CloudDataManager and Fetch Shopping Items from the Server

class ViewController: UIViewController, UITableViewDelegate,
    UITableViewDataSource {

    //Reference to the table view
    @IBOutlet weak var tableView: UITableView!

    //A reference to the data manager class
    let cloudDataManager = CloudDataManager()

    override func viewDidLoad() {
        super.viewDidLoad()

        //Set table view datasource and delegate
        tableView.delegate = self
        tableView.dataSource = self

        //Get all shopping list items from the server
        cloudDataManager.fetchCloudItems( callback: dataChanged )
    }

    //The rest of the code goes here
}

There is a method called dataChanged, which we haven’t implemented yet. This method will be used as a callback for the CloudDataManager methods and will notify the UI to update itself when there is a response from the server.

Its implementation is pretty straightforward : if there was an error, we will print out information about in Xcode’s console; otherwise we will update the table view (Listing 13-28). In iOS we are allowed to access the UI only on the main thread and we need do make sure the all related calls happen there. To execute a code block on the main thread we wrap it in a dispatch_async(dispatch_get_main_queue(),{() -> Void}) call. This function tells iOS to execute the code block nested inside on a specific thread of the app. dispatch_get_main_queue makes sure that the chosen thread is the main one.

Listing 13-28. Update the Table View Using a Callback Method

func dataChanged( error : NSError? ) {
    if let error = error {
        //If there is an error message print it in the console
        print(error)
    }
    else {
        //When there is a response do the logic in the main thread
        dispatch_async(dispatch_get_main_queue(), { å
         [weak self] () -> Void in
            //Refresh data in the table view
            self!.tableView.reloadData();
        })
    }
}

Now let us populate the shopping items in the table view. First we need to provide the number of items so the table can ask the data source to construct the appropriate number of rows in the table. The number of rows is set in the tableView(_:numberOfRowsInSection:) method (Listing 13-29).

Listing 13-29. Set Table View Rows Number

func tableView(tableView: UITableView,
    numberOfRowsInSection section: Int) -> Int
{
    //Return shopping items number
    return cloudDataManager.getItemsCount()
}

The tableView(_:cellForRowAtIndexPath:) call gives us access to update a single cell in the table: we will fill in the new cells with the names of the items in the shopping list, as shown in Listing 13-30.

Listing 13-30. Create a Cell and Set Its Label

func tableView(tableView: UITableView,
    cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell {
    //Create a new table cell for the row
    let cell = tableView.dequeueReusableCellWithIdentifier(
                            "ShoppingItemCell", forIndexPath: indexPath)

    //Set the cell's label to be the name of the corresponding shopping item
    cell.textLabel?.text = cloudDataManager.getItemName(
                                                atIndex: indexPath.row)

    return cell
}

Run the app and you will see an empty table (Figure 13-9). In the next section we will implement how items are added, so we can create our first shopping list.

Figure 13-9. Empty table view

Adding New Items

Open Main.storyboard and ViewController.swift in the Assistant editor and create an Action handler for the plus button. Name this Action didTapAdd (Listing 13-31).

Listing 13-31. Add an Action Handler for Adding New Items

@IBAction func didTapAdd(sender: UIBarButtonItem) {
}

We will show an alert dialog to the user to type the new item’s name. Listing 13-32 shows you how to create an alert dialog with a text field and two buttons: Cancel and Add.

Listing 13-32. Add Item Dialog Implementation

@IBAction func didTapAdd(sender: UIBarButtonItem) {
    //Create an allert controller dialog for adding new item
    let alertController = UIAlertController(title: "New Item",
        message: "Tap in new item", preferredStyle: UIAlertControllerStyle.Alert)

    //Add a text field component to the dialog
    alertController.addTextFieldWithConfigurationHandler {
        (UITextField) -> Void in }

    //Add a Cancel button to dismiss the dialog
    alertController.addAction(UIAlertAction(title: "Cancel",
    style: UIAlertActionStyle.Default, handler: {
        (action : UIAlertAction) -> Void in
    }))

    //Add an Add button to add new item
    alertController.addAction(UIAlertAction(title: "Add",
    style: UIAlertActionStyle.Default, handler: {
        (action : UIAlertAction) -> Void in

        //Get the item's name from dialog's text field
        let itemName = (alertController.textFields![0] as UITextField).text

        //Ask data manager to create new shopping item with the given name
        self.cloudDataManager.addItem( itemName: itemName!,
            callback: self.dataChanged)                                                                                                                      
    }))

    //Show this dialog on the screen
    self.presentViewController(alertController, animated: true,
        completion: nil)
}

Run the application and tap the + button. You should see the dialog prompting you to create a new item (Figure 13-10).

Figure 13-10. Add new item dialog

Deleting Items from the Table View

While adding a new item required us to write only one new method, deleting an item will require more work. We will add several new methods, but they will all be one-liners, I promise.

First create an Action handler for the Edit button in ViewController.swift. Name the Action didTapEdit. Inside this method we will toggle the tableView.editing property to true or false (Listing 13-33). Changing this property notifies the table that we want to edit its rows and causes each row to show a delete button.

Listing 13-33. Edit Button Action

@IBAction func didTapEdit(sender: UIBarButtonItem) {
    //Toggle table view edit mode
    tableView.editing = !tableView.editing
}

When the table view is in edit mode it will ask the data source to verify if a given row can be edited. This would require implementing a method called UITableViewDataSource tableView(_:canEditRowAtIndexPath). Since all of our shopping items can be deleted we will always return true (Listing 13-34).

Listing 13-34. A Method That Checks If a Given Row in the Table Can Be Edited

func tableView(tableView: UITableView,
    canEditRowAtIndexPath indexPath: NSIndexPath) -> Bool {

    //We can edit all the rows
    return true
}                                                                                                                      

When the user taps the delete button next to a row, the table view asks the data source to commit the deletion of the row. This is done inside the tableView(_: commitEditingStyle: forRowAtIndexPath) method (Listing 13-35). This method is used for committing any editing operations, so before proceeding further we will need to make sure that we are committing a deletion: the value of the editingStyle argument needs to be .Delete. Finally, we ask cloudDataManager to delete the corresponding shopping item.

Listing 13-35. A Method for Deleting a Row

func tableView(tableView: UITableView,
    commitEditingStyle editingStyle: UITableViewCellEditingStyle,
        forRowAtIndexPath indexPath: NSIndexPath) {

    if UITableViewCellEditingStyle.Delete == editingStyle {
        //Ask the data manager to delete the coresponding shopping item
        cloudDataManager.removeItem( atIndex: indexPath.row,
            callback: dataChanged)
    }
}

The app is now complete. Run it, tap Edit, and delete a row to see it vanish from the table view and from the iCloud servers (Figure 13-11).

Figure 13-11. Deleting an item from the list