iOS 5 for developers: What you need to know
Wow Apple has added a TON of new features for developers in iOS 5. Make sure you read this article if you are an iPhone / iPad developer to get the skinny on what is coming. This article summarizes the key developer-related features introduced in iOS 5.0. This version of the operating system runs on current iOS-based devices. In addition to describing the key new features, this article lists the documents that describe those features in more detail.iCloud Storage APIs The iCloud storage APIs let your application write user documents and data to a central location and access those items from all of a user’s computers and iOS devices. Making a user’s documents ubiquitous using iCloud means that a user can view or edit those documents from any device without having to sync or transfer files explicitly. Storing documents in a user’s iCloud account also provides a layer of security for that user. Even if a user loses a device, the documents on that device are not lost if they are in iCloud storage. There are two ways that applications can take advantage of iCloud storage, each of which has a different intended usage:
- iCloud document storage—Use this feature to store user documents and data in the user’s iCloud account.
- iCloud key-value data storage—Use this feature to share small amounts of data among instances of your application.
The summary for using the iCloud storage APIs in your application is as follows:
- Use the iOS Provisioning Portal to enable iCloud storage for your iOS application.Enabling this feature requires that you have an updated provisioning profile on your development systems. Xcode 4 handles this step for you automatically.
- Add an Entitlements file to your application and use it to configure the iCloud features your application uses
- Implement iCloud document storage as follows:
- Use the
UIDocumentclass to read and write the contents of your user documents; alternatively, incorporate support for file presenters and file coordinators into the custom classes that you use to manage user documents. The iCloud service uses the file coordination mechanism to notify your application when a document changes. (The
UIDocumentclass implements support for file presenters and file coordinators for you and is recommended.)
- Use the
NSFileManagerclass to move the appropriate documents to the user’s iCloud storage. It is recommended that you give users the option to move documents to iCloud
- Use the
NSMetadataQueryinterfaces to search for documents in a user’s iCloud storage;
- Be prepared to handle version conflicts that might arise when two devices try to update a document at the same time;
- Use the
- To implement iCloud key-value data storage, use the
NSUbiquitousKeyValueStoreclass to read and write keys and values.
Figure 1 Pushing document changes to iCloud
From an implementation perspective, the easiest way to manage documents in iCloud is to use the
UIDocumentclass. This class does most of the heavy lifting required to read and write files that are stored in iCloud. Specifically, the
UIDocumentclass handles the creation and use of file coordinators to modify the document. This class also seamlessly integrates document changes coming from other devices. The class even helps handle the potential conflicts that can arise when two devices do manage to update the same file in conflicting ways. You are not required to use the
UIDocumentclass to manage your application’s documents, but using it requires less effort on your part. Important: Applications that store documents to iCloud must specify one or more containers in which to store those documents. You specify which containers your application supports using the
UIDocumentclass). Moving a Document to iCloud Storage To move a document to iCloud storage:
- Create and save the file locally in your application sandbox.
- If you are not using the
UIDocumentclass to manage your file, create a file presenter to be responsible for it.
- Create an
NSURLobject that specifies the destination of the file in a user’s iCloud storage.You must put files in one of the container directories associated with your application. Call the
NSFileManagerto get the root URL for the directory, and then append any additional directory and filenames to that URL. (Applications may put documents in any container directory for which they have the appropriate entitlement.
- Call the
NSFileManagerto move the file to the specified destination in iCloud.
Documentssubdirectory and use that directory for storing user documents. In iCloud, the contents of the
Documentsdirectory are made visible to the user so that individual documents can be deleted. Everything outside of the
Documentsdirectory is grouped together and treated as a single entity that a user can keep or delete. You create subdirectories in a user’s iCloud storage using the methods of the
NSFileManagerclass just as you would any directory. After you move a document to iCloud, it is not necessary to save a URL to the document’s location persistently. If you manage a document using a
UIDocumentobject, that object automatically updates its local data structures with the document’s new URL. However, it does not save that URL to disk, and neither should your custom file presenters. Instead, because documents can move while in a user’s iCloud storage, you should use an
NSMetadataQueryobject to search for documents. Searching guarantees that your application has the correct URL for accessing the document.
Searching for Documents in iCloudTo locate documents in iCloud storage, your application must search using an
NSMetadataQueryobject. Searching is a guaranteed way to locate documents both in a user’s iCloud storage and in your application sandbox. You should always use query objects instead of saving URLs persistently because the user can delete files from iCloud storage when your application is not running. Using a query to search is the only way to ensure an accurate list of documents. In iOS 5.0, the
NSMetadataQueryclass supports the following search scopes for your documents:
- Use the
NSMetadataQueryUbiquitousDocumentsScopeconstant to search for documents in iCloud that reside somewhere inside a
Documentsdirectory. (For any given container directory, put documents that the user is allowed to access inside a
- Use the
NSMetadataQueryUbiquitousDataScopeconstant to search for documents in iCloud that reside anywhere other than in a
Documentsdirectory. (For any given container directory, use this scope to store user-related data files that your application needs to share but that are not files you want the user to manipulate directly.)
- Use the
NSMetadataQueryLocalDocumentsScopeconstant to search the
Documentsdirectory in your application’s sandbox.
NSMetadataQueryobject and do the following:
- Set the search scope of the query to an appropriate value (or values).
- Add a predicate to narrow the search results. To search for all files, specify a predicate with the format
NSMetadataItemFSNameKey == *.
- Register for the query notifications and configure any other query parameters you care about, such as sort descriptors, notification intervals, and so on.The
NSMetadataQueryobject uses notifications to deliver query results. At a minimum, you should register for the
NSMetadataQueryDidUpdateNotificationnotification, but you might want to register for others in order to detect the beginning and end of the results-gathering process.
- Call the
startQuerymethod of the query object.
- Run the current run loop so that the query object can generate the results.If you started the query on your application’s main thread, simply return and let the main thread continue processing events. If you started the query on a secondary thread, you must configure and execute a run loop explicitly.
- Process the results in your notification-handler methods.When processing results, always disable updates first. Doing so prevents the query object from modifying the result list while you are using it. When you are done processing the results, reenable updates again to allow new updates to arrive.
- When you are ready to stop the search, call the
stopQuerymethod of the query object.
NSFileCoordinatorclass. The job of a file coordinator is to coordinate the reads and writes performed by your application and the sync daemon on the same document. For example, your application and the daemon may both read the document at the same time but only one may write to the file at any single time. Also, if one process is reading the document, the other process is prevented from writing to the document until the reader is finished. In addition to coordinating operations, file coordinators also work with file presenters to notify applications when changes are about to occur. Afile presenter is any object that conforms to the
NSFilePresenterprotocol and takes responsibility for managing a specific file (or directory of files) in an application. The job of a file presenter is to protect the integrity of its own data structures. It does this by listening for messages from other file coordinators and using those messages to update its internal data structures. In most cases, a file presenter may not have to do anything. However, if a file coordinator declares that it is about to move a file to a new URL, the file presenter would need to replace its old URL with the new one provided to it by the file coordinator. The
UIDocumentclass is an example of a file presenter that tracks changes to its underlying file or file package. Here is a checklist of the things your application must do to work with documents in iCloud:
- Manage each document in iCloud using a file presenter. The recommended way to do this is to use the
UIDocumentclass, but you may define custom file presenters if you prefer. You can use a single file presenter to manage a file package or a directory of files.
- After creating a file presenter, register it by calling the
addFilePresenter:class method of
NSFileCoordinator. Registration is essential. The system can notify only registered presenter objects.
- Before deleting a file presenter, unregister it by calling the
- Create an instance of the
NSFileCoordinatorclass and initialize it with the file presenter object that is about to perform the file operation.
- Use the methods of the
NSFileCoordinatorobject to read or write the file:
- To read all or part of a single file, use the
- To write to a file or delete it, call the
- To perform a sequence of read or write operations, use the
- To write to multiple files, or to move a file to a new location, use the
- To read all or part of a single file, use the
- When you are done with the operations, release the file coordinator object.
NSFileVersionclass. To resolve conflicts:
- Get the current file version using the
currentVersionOfItemAtURL:class method of
- Get an array of conflict versions using the
unresolvedConflictVersionsOfItemAtURL:class method of
- For each conflict version object, perform whatever actions are needed to resolve the conflict. Options include:
- Merging the conflict versions with the current file automatically, if it is practical to do so.
- Ignoring the conflict versions, if doing so does not result in any data loss.
- Prompting the user to select which version (current or conflict) to keep. This should always be your last option.
- Update the current file as needed.
- If the current file version remains the winner, you do not need to update the current file.
- If a conflict version is chosen as the winner, use a coordinated write operation to overwrite the contents of the current file with the contents of the conflict version.
- If the user chooses to save the conflict version under a different name, create the new file with the contents of the conflict version.
- Set the
resolvedproperty of the conflict version objects to
YES.Setting this property to
YEScauses the conflict version objects (and their corresponding files) to be removed from the user’s iCloud storage.
Storing Key-Value Data in iCloudAn application can use the
NSUbiquitousKeyValueStoreclass to share small amounts of data with other instances of itself running on other computers and iOS devices. This class provides a similar service as the
NSUserDefaultsclass in that it allows you to save simple data types (numbers, strings, dates, arrays, and so on) persistently and retrieve that data later. The main difference is that the
NSUbiquitousKeyValueStoreclass writes that data to the user’s iCloud storage so that it can be retrieved by the application running on different iOS devices or computers.
Important: Applications that use theThe amount of available space in a single key-value store is limited to 64 KB and the data for a single key cannot exceed 4 KB. Thus, you can use this storage to record small details about your application but should not use it to store user documents or other large data archives. Instead, you should use the information in the key-value store to improve the user experience for your application. For example, a magazine application might store the current issue and page number that the user is reading. That way, if the user opens the application on another device, the version of your application on that device can open to the same issue and page as the previous device. The
NSUbiquitousKeyValueStoreclass must also request the
com.apple.developer.ubiquity-kvstore-identifierentitlement. If you configure multiple applications with the same value for this entitlement, all of them share the same key-value data. For more information about configuring iCloud entitlements, see “Requesting Entitlements for iCloud Storage.”
NSUbiquitousKeyValueStoreclass should not be used as a replacement or supplement for the
NSUserDefaultsclass. An application should always write all of its configuration data to disk using the
NSUserDefaultsclass. It should then write the data it intends to share to the key-value data store using the
NSUbiquitousKeyValueStoreclass. This guarantees that your application always has a valid copy of the data available locally.
Requesting Entitlements for iCloud StorageTo protect the data each application creates, applications must request specific entitlements at build time in order to use iCloud storage. These entitlements are tied to the application’s provisioning profile and are used to differentiate your application’s documents and data from that of other applications. There are two entitlements an application can request, depending on which iCloud features it uses:
- To use iCloud document storage, request the
com.apple.developer.ubiquity-container-identifiersentitlement. The value of this key is an array of container identifier strings. (The first string in the array must not contain any wildcard characters.)
- To use the iCloud key-value data store, request the
com.apple.developer.ubiquity-kvstore-identifierentitlement. The value of this key is a single container identifier string.
.<CUSTOM_STRING>, where <TEAM_ID> is the unique ten-character identifier associated with your developer account. The contents of <CUSTOM_STRING> are at your discretion, but it is recommended that you use a reverse-DNS string similar to your application’s bundle identifier. In practice, the string can be anything that makes sense to your development team. You can even use the same container identifier string for multiple applications if you want them to share the same storage space. Applications using iCloud document storage can specify multiple containers for storing documents and data. The value of the
com.apple.developer.ubiquity-container-identifierskey is an array of strings. The first string in this array must be the main container identifier to associate with your application. If your company develops multiple applications, though, you can include additional container identifiers for your other applications. An application that supports multiple containers may read and write the documents and data in all of those containers, and searches always return a merged set of results. Listing 1 shows the XML from an entitlements file that requests the keys for an iPad application. In this example, the iPad application can read and write its own documents (which it stores in the container directory identified using the
A1B2C3D4E5.com.example.MyApp.ipad) and it can read and write files from the iPhone version of the same application (which may or may not use a different file format). Listing 1 iCloud keys in the
Note: The strings you specify in your entitlements property-list file are also the strings you pass to the
URLForUbiquityContainerIdentifier:method when requesting the location of a directory in the user’s iCloud storage.
Using iCloud Storage ResponsiblyApplications that take advantage of iCloud storage features should act responsibly when storing data in there. The space available in each user’s account is limited and is shared by all applications. In addition, users can see how much space is consumed by a given application and choose to delete documents and data associated with your application. For these reasons, it is in your application’s interest to be responsible about what files you store. Here are some tips to help you manage documents appropriately:
- Rather than storing all documents, let a user choose which documents to store in an iCloud account. If a user creates a large number of documents, storing all of those documents in iCloud could overwhelm that user’s available space. Providing a way for a user to designate which documents to store in iCloud gives that user more flexibility in deciding how best to use the available space.
- Remember that deleting a document removes it from a user’s iCloud account and from all of that user’s computers and devices. Make sure that users are aware of this fact and confirm any delete operations. For your application to refresh the local copy of a document, use the
- When storing documents in iCloud, place them in a
Documentsdirectory whenever possible. Documents inside a
Documentsdirectory can be deleted individually by the user to free up space. However, everything outside that directory is treated as data and must be deleted all at once.
- Never store caches or other files that are private to your application in a user’s iCloud storage. A user’s iCloud account should be used only for storing user data and content that cannot be re-created by your application.
iCloud BackupUsers can now opt to have their applications and application data backed up directly to their iCloud account, making it easier to restore applications to their most recent state. Having data backed up in iCloud makes it easy for a user to reinstall that data to a new or existing iOS device. However, because the amount of space in a user’s iCloud account is limited, applications should be even more selective about where they store files. The placement of files in your application’s home directory determines what gets backed up and what does not. Anything that would be backed up to a user’s computer is also backed up wirelessly to iCloud. Thus, everything in the
Documentsdirectory and most (but not all) of your application’s
Librarydirectory. To minimize the amount of data stored in the user’s iCloud account, developers are encouraged to put more files in the
Library/Cachesdirectory, especially if those files can be easily re-created or obtained in another way.
Note:Any documents that your application stores explicitly in iCloud (using the iCloud storage APIs) are not backed up with your application. (Those documents are already stored in the user’s iCloud account and therefore do not need to be backed up separately.) For information about how to store user documents in iCloud, see “Storing and Using Documents in iCloud.”
Automatic Reference CountingAutomatic Reference Counting (ARC) is a compiler-level feature that simplifies the process of managing the lifetimes of Objective-C objects. Instead of you having to remember when to retain or release an object, ARC evaluates the lifetime requirements of your objects and automatically inserts the appropriate method calls at compile time.
To be able to deliver these features, ARC imposes some restrictions—primarily enforcing some best practices and disallowing some other practices:
- Do not call the
deallocmethods in your code.In addition, you cannot implement custom
releasemethods.Because you do not call the
releasemethod, there is often no need to implement a custom
deallocmethod—the compiler synthesizes all that is required to relinquish ownership of instance variables. You can provide a custom implementation of
deallocif you need to manage other resources.
- Do not store object pointers in C structures.Store object pointers in other objects instead of in structures.
- Do not directly cast between object and nonobject types (for example, between
void*).You must use special functions or casts that tell the compiler about an object’s lifetime. You use these to cast between Objective-C objects and Core Foundation objects.
- You cannot use
NSAutoreleasePoolobjects.Instead, you must use a new
@autoreleasepoolkeyword to mark the start of an autorelease block, and the
@endkeyword to mark the end of it.
nilif the object to which it points is deallocated. There are qualifiers for variables, and new
strongdeclared property attributes, as illustrated in the following examples:
// The following declaration is a synonym for: @property(retain) MyClass *myObject;
@property(strong) MyClass *myObject;
// The following declaration is similar to "@property(assign) MyOtherClass *delegate;"
// except that if the MyOtherClass instance is deallocated,
// the property value is set to nil instead of remaining as a dangling pointer
@property(weak) MyOtherClass *delegate;
StoryboardsStoryboards are the new way to define your application’s user interface. In the past, you used nib files to define your user interface one view controller at a time. A storyboard file captures your entire user interface in one place and lets you define both the individual view controllers and the transitions between those view controllers. As a result, storyboards capture the flow of your overall user interface in addition to the content you present. If you are creating new applications, the Xcode templates come preconfigured to use storyboards. For other applications, the process for using storyboards is as follows:
- Configure your application’s
Info.plistfile to use storyboards:
- Add the
UIMainStoryboardFilekey and set its value to the name of your storyboard file.
- Remove the existing
NSMainNibFilekey. (Storyboards replace the main nib file.)
- Add the
- Create and configure the storyboard file in Xcode; see “Creating Storyboard Files.”
- Update your view controllers to handle storyboard transitions; see “Preparing to Transition to a New View Controller.”
- If you ever need to present a view controller manually (perhaps to support motion-related events), use the storyboard classes to retrieve and present the appropriate view controller; see “Presenting Storyboard View Controllers Programmatically.”
Info.plistfile. UIKit handles the rest.
Creating Storyboard FilesYou use Interface Builder to create storyboard files for your application. Most applications need only one storyboard file, but you can create multiple storyboard files if you want. Every storyboard file has a view controller known as the initial view controller. This view controller represents the entry point into the storyboard. For example, in your application’s main storyboard file, the initial view controller would be the first view controller presented by your application. Each view controller in a storyboard file manages a single scene. For iPhone applications, a scene manages one screen’s worth of content, but for iPad applications the content from multiple scenes can be on screen simultaneously. To add new scenes to your storyboard file, drag a view controller from the library to the storyboard canvas. You can then add controls and views to the view controller’s view just as you would for a nib file. And as before, you can configure outlets and actions between your view controller and its views. When you want to transition from one view controller to another, Control-click a button, table view cell, or other trigger object in one view controller, and drag to the view controller for a different scene. Dragging between view controllers creates a segue, which appears in Interface Builder as a configurable object. Segues support all of the same types of transitions available in UIKit, such as modal transitions and navigation transitions. You can also define custom transitions and transitions that replace one view controller with another. Preparing to Transition to a New View Controller Whenever a user triggers a segue in the current scene, the storyboard runtime calls the
prepareForSegue:sender:method of the current view controller. This method gives the current view controller an opportunity to pass any needed data to the view controller that is about to be displayed. When implementing your view controller classes, you should override this method and use it to handle these transitions. Presenting Storyboard View Controllers Programmatically Although the storyboard runtime usually handles transitions between view controllers, you can also trigger segues programmatically from your code. You might do so when setting up the segue in Interface Builder is not possible, such as when using accelerometer events to trigger the transition. There are several options for transitioning to a new view controller:
- If a storyboard file contains an existing segue between the current view controller and the destination view controller (perhaps triggered by some other control in the view controller), you can trigger that segue programmatically using the
- If there is no segue between the view controllers but the destination view controller is defined in the storyboard file, first load the view controller programmatically using the
UIStoryboard. Then present the view controller using any of the existing programmatic means, such as by pushing it on a navigation stack.
- If the destination view controller is not in the storyboard file, create it programmatically and present it as described in View Controller Programming Guide for iOS.
Newsstand SupportNewsstand provides a central place for users to read magazines and newspapers. Publishers who want to deliver their magazine and newspaper content through Newsstand can create their own iOS applications using the Newsstand Kit framework (
NewsstandKit.framework), although doing so is not required. A big advantage of the Newsstand Kit framework, however, is that you can use it to initiate background downloads of new magazine and newspaper issues. After you start a download, the system handles the download operation and notifies your application when the new content is available. Unlike other iOS applications, Newsstand applications appears only in Newsstand itself, not in a user’s Home screen. And instead of displaying an application icon, the application typically displays the cover of their most recent issue, with some additional adornments provided by Newsstand. When the user taps that cover art, your application launches normally to present the current issue or any back issues that were downloaded and are still available.
Note: Newsstand applications must include theCreating an application that uses Newsstand Kit requires some interplay between the actual application and the content servers that you manage. Your servers are responsible for notifying the application when new content is available, typically using a push notification. If your Newsstand application includes the
UINewsstandAppkey in their
Info.plistfile to indicate that they support Newsstand. For more information about this key, see Information Property List Key Reference.
UIBackgroundModeskey with the
newsstand-contentvalue in its
Info.plistfile, your Newsstand application is launched in the background so that it can start downloading the latest issue. The download process itself is managed by the system, which notifies your application when the content is fully downloaded and available. When your server is alerting your application of a new issue, that server should include the
content-availableproperty (with a value of
1) in the JSON payload. This property tells the system that it should launch your application so that it can begin downloading the new issue. Applications are launched and alerted to new issues once in a 24-hour period at most, although if your application is running when the notification arrives, it can begin downloading the content immediately. In addition to your server providing content for each new issue, it should also provide cover art to present in Newsstand when that issue is available. This cover art is displayed in place of the application’s default icon, which is specified by the Newsstand-specific icons in the
CFBundleIconskey of your application’s
Info.plistfile. Cover art gives users a more visual cue that a new issue is available. Your application can also add a badge to new issues. AirPlay Improvements AirPlay lets users stream audio and video from an iOS-based device to AirPlay–enabled devices such as televisions and audio systems. In iOS 5, developers can now use AirPlay to present application content on a nearby Apple TV 2. Users can now mirror the content of an iPad 2 to an Apple TV using AirPlay for any application. And developers who want to display different content (instead of mirroring) can assign a new window object to any
UIScreenobjects connected to an iPad 2 via AirPlay. In addition, you can now take advantage of AirPlay in the following ways:
- Applications that use AV Foundation can now use the
AVPlayerclass to stream audio and video content over AirPlay; see AV Foundation Framework Reference.
- The Media Player framework includes support for displaying “Now Playing” information in several locations, including as part of the content delivered over AirPlay; see MPNowPlayingInfoCenter Class Reference.
UIWebViewclass now supports the presentation of multimedia content over AirPlay. This support is enabled by default, but you can opt out of it if you want to.
New FrameworksIn iOS 5.0, there are several new frameworks you should investigate.
GLKit FrameworkThe GLKit framework (
GLKit.framework) contains a set of Objective-C based utility classes that simplify the effort required to create an OpenGL ES 2.0 application. GLKit provides support for four key areas of application development:
GLKViewControllerclasses provide a standard implementation of an OpenGL ES–enabled view and associated rendering loop. The view manages the underlying framebuffer object on behalf of the application; your application just draws to it.
GLKTextureLoaderclass provides image conversion and loading routines to your application, allowing it to automatically load texture images into your context. It can load textures synchronously or asynchronously. When loading textures asynchronously, your application provides a completion handler block to be called when the texture is loaded into your context.
- The GLKit framework provides implementations of vector, matrix, and quaternions as well as a matrix stack operation to provides the same functionality found in OpenGL ES 1.1.
GLKReflectionMapEffectclasses provide precreated, configurable graphics shaders that implement commonly used graphics operations. In particular, the
GLKBaseEffectclass implements the lighting and material model found in the OpenGL ES 1.1 specification, simplifying the effort required to migrate an application from OpenGL ES 1.1 to OpenGL ES 2.0.
CoreImage.framework) provides a powerful set of built-in filters for manipulating video and still images. You can use the built-in filters for everything from simple operations (like touching up and correcting photos) to more advanced operations (like face and feature detection). The advantage of using these filters is that they operate in a nondestructive manner so that your original images are never changed directly. In addition, Core Image takes advantage of the available CPU and GPU processing power to ensure that operations are fast and efficient. The
CIImageclass provides access to a standard set of filters that you can use to improve the quality of a photograph. To create other types of filters, you can create and configure a
CIFilterobject for the appropriate filter type. Twitter Framework The Twitter framework (
Twitter.framework) provides support for sending Twitter requests on behalf of the user and for composing and sending tweets. For requests, the framework handles the user authentication part of the request for you and provides a template for creating the HTTP portion of the request. (Refer to the Twitter API for populating the content of the request.) The composition of tweets is accomplished using the
TWTweetComposeViewControllerclass, which is a view controller that you post with your proposed tweet content. This class gives the user a chance to edit or modify the tweet before sending it. Users control whether an application is allowed to communicate with Twitter on their behalf using Settings. The Twitter framework also works in conjunction with the Accounts framework (
Accounts.framework) to access the user’s account. Accounts Framework The Accounts framework (
Accounts.framework) provides a single sign-on model for certain user accounts. Single sign-on improves the user experience, because applications no longer need to prompt a user separately for login information related to an account. It also simplifies the development model for you by managing the account authorization process for your application. In iOS 5.0, applications can use this framework in conjunction with the Twitter framework to access a user’s Twitter account. Generic Security Services Framework The Generic Security Services framework (
GSS.framework) provides a standard set of security-related services to iOS applications. The basic interfaces of this framework are specified in IETF RFC 2743 and RFC 4401. In addition to offering the standard interfaces, iOS includes some additions for managing credentials that are not specified by the standard but that are required by many applications. Application Design-Level Improvements The following sections describe new capabilities that you can incorporate into the model, view, and controller layers of your application.
Document SupportCocoa Touch now includes a
UIDocumentclass for managing the data associated with user documents. If you are implementing a document-based application, this class reduces the amount of work you must do to manage your document data. In addition to providing a container for all of your document-related data, the
UIDocumentclass provides built-in support for a number of features:
- Asynchronous reading and writing of data on a background queue, allowing your application to remain responsive to users while reading and writing operations occur.
- Support for coordinated reading and writing of documents, which is required for documents in iCloud storage.
- Safe saving of document data by writing data first to a temporary file and then replacing the current document file with it.
- Support for resolving conflicts between different versions of your document if a conflict occurs.
- Automatic saving of document data at opportune moments.
- Support for flat file and package file representations on disk.
- For applications that use Core Data to manage their content, there is also a
UIManagedDocumentsubclass to manage interactions with documents in the database.
Data Protection ImprovementsIntroduced in iOS 4.0, data protection lets you store application and user data files on disk in an encrypted format so that they can be accessed only when a user’s device is unlocked. In iOS 5.0, you now have more flexibility regarding when your application can access protected files.
- Using the
NSFileProtectionCompleteUnlessOpenoption, your application can access a file while the device is unlocked and, if you keep the file open, continue to access that file after the user locks the device.
- Using the
NSFileProtectionCompleteUntilFirstUserAuthenticationoption, your application cannot access the file while the device is booting or until the user unlocks the device. After the user unlocks the device for the first time, you can access the file even if the user subsequently locks the device again.
Custom Appearance for UIKit ControlsYou can now customize the appearance of many UIKit views and controls to give your application a unique look and feel. For example, you might use these customizations to make the standard system controls match the branding for the rest of your application. UIKit supports the following customizations:
- You can set the tint color, background image, and title position properties (among other) on a wide variety of objects, including toolbars, navigation bars, search bars, buttons, sliders, and some other controls.
- You can set attributes of some objects directly, or you can set the default attributes to use for a class using an appearance proxy.An appearance proxy is an object you use to modify the default appearance of visual objects such as views and bar items. Classes that adopt the
UIAppearanceprotocol support the use of an appearance proxy. To modify the default appearance of such a class, retrieve its proxy object using the
appearanceclass method and call the returned object’s methods to set new default values. A proxy object implements those methods and properties from its proxied class that are tagged with the
UI_APPEARANCE_SELECTORmacro. For example, you can use a proxy object to change the default tint color (through the
trackTintColorproperties) of the
UIProgressViewclass.If you want to set a different default appearance based on how a given object is used in your application, you can do so using the proxy object returned by the
appearanceWhenContainedIn:method instead. For example, you use this proxy object to set specific default values for a button only when it is contained inside a navigation bar.Any changes you make with a proxy object are applied, at view layout time, to all instances of the class that exist or that are subsequently created. However, you can still override the proxy defaults later using the methods and properties of a given instance.
UIViewControllerclass now allows you to define your own custom container view controllers and present content in new and interesting ways. Examples of existing container view controllers include
UISplitViewController. These view controllers mix custom content with content provided by one or more separate view controller objects to create a unique presentation for application content. Container view controllers act as a parent for their contained view controllers, forwarding important messages about rotations and other relevant events to their children. Settings Applications that deliver custom preferences can now use a new radio group element. This element is similar to the multivalue element for selecting one item from a list of choices. The difference is that the radio group element displays its choices inline with your preferences instead of on a separate page. Xcode Tools The following sections describe the improvements to the Xcode tools and the support for developing iOS applications. For detailed information about the features available in Xcode 4.2, see Xcode New Features User Guide.
Xcode ImprovementsXcode 4.2 adds support for many features that are available in iOS 5.0.
- The LLVM compiler supports Automatic Reference Counting (ARC), and Xcode includes a menu item to convert targets to use ARC. (For more information about ARC and about how to use it in your applications, see “Automatic Reference Counting.”)
- The Interface Builder user interface provides support for creating storyboard files for your iOS applications. (For more information about using storyboards in your iOS applications, see “Storyboards.”)
- In iOS Simulator, you can now simulate different locations for applications using the Core Location framework.
- You can download your application data from an iOS device and automatically restore that data when debugging or testing in iOS simulator or on a device.
OpenGL ES DebuggingThe debugging experience in Xcode has been updated to include a new workflow for debugging OpenGL ES applications. You can now use Xcode to do the following for your OpenGL ES applications:
- Introspect OpenGL ES state information and objects such as view textures, shaders, and so on.
- Set breakpoints on OpenGL ES errors, set conditional OpenGL ES entry point breakpoints, break on frame boundaries, and so on.
UI Automation EnhancementsThe Automation instrument now includes a script editor and the ability to capture (record) actions into your script as you perform them on a device. There are also enhancements to the objects that you use in the Automation instrument to automate UI testing:
UIATargetobject can now simulate rotate gestures and location changes.
UIAHostobject supports executing a task from the Instruments application itself.
UIAElementobject can now simulate a rotate gesture centered on the element.
- Several functions that were previously available only in
UIAPopoverwere moved to
UIAElementbecause they are common to all element objects.
UIAKeyboardobject now supports performing a sequence of keyboard taps to simulate the typing of a string.
- System Trace for iOS—Uses several instruments to profile aspects of Mac OS X or iOS that could be affecting application performance, such as system calls, thread scheduling, and VM operations.
- Network Connections instrument—Inspect how your application is using TCP/IP and UDP/IP connections. With this instrument it is possible to see how much data is flowing through each connection and for each application. You can also use it to display interesting statistics, such as round trip times and retransmission request information.
- Network Activity (located in Energy Diagnostics)—Helps bridge the gap between networking (cellular and WiFi) and energy usage. You use it to display device-wide data flow through each network interface alongside energy usage level data that is taken directly from the battery.
UIKitThe UIKit framework includes the following enhancements:
UIViewControllerclass can now be used to create custom container view controllers; see “Container View Controller Support.”
- The UIKit framework provides support for loading and using storyboards; see “Storyboards.”
- Bars and bar button items can now be tinted and customized for your application; see “Custom Appearance for UIKit Controls.”
UIPageViewControllerclass is a new container view controller for creating page-turn transitions between view controllers.
UIReferenceLibraryViewControllerclass adds support for presenting a custom dictionary service to the user.
UIImagePickerControllerclass supports new options for specifying the quality of video recordings.
UIStepperclass is a new control for incrementing a floating-point value value up or down within a configurable range.
- View-based animations now support cross-dissolve, flip-from-top, and flip-from-bottom animations; see UIView Class Reference.
UIApplicationclass now reports the language directionality of the running application.
exclusiveTouchproperty of the
UIControlclass now defaults to
UITableViewclass adds support for automatic row animations, moving rows and sections, multiselection, and copy and paste behaviors for cells.
UIScreenclass lets you specify overscan compensation behaviors for video delivered over AirPlay or through an attached HDMI cable. You can also programmatically set a screen’s brightness.
UIScrollViewclass now exposes its gesture recognizers so that you can configure them more precisely for your application.
UISegmentedControlclass now supports proportional segment widths.
UIAlertViewclass now supports password-style text entry and special configurations for entering text securely.
UIColorclass includes support for Core Image and new methods to retrieve individual color values.
UIImageclass includes support for Core Image, support for stretching an image by tiling part of its content, and support for looping animations.
UITextInputTraitsprotocol adds support for a Twitter-specific keyboard and separate spell-checking behavior.
UIAccessibilityprotocol includes new interfaces that define the activation point within an element and indicate whether an element is modal or contains hidden elements. There are also new notifications that inform you of changes in system-provided accessibility features, such as zoom, audio status, and closed captioning.
UIAccessibilityReadingContentprotocol allows you to provide a continuous, page-turning reading experience to VoiceOver users.
UIAccessibilityIdentificationprotocol allows you to uniquely identify elements in your app so that you can refer to them in automation scripts.
UIWebViewclass automatically supports the presentation of multimedia content over AirPlay. You can opt out of this behavior by changing the value in the
mediaPlaybackAllowsAirPlayproperty of the class. This class also exposes a
scrollViewproperty so that you can access the scrolling properties of your web interfaces.
- You can get notifications about source state changes and changes regarding the number of audio buffers that have been processed.
- The Apple Spatial Audio extension in iOS 5.0 adds three audio effects that are especially useful for games: reverberation, obstruction effects, and occlusion effects.
Media PlayerThe Media Player framework includes the following enhancements:
- There is now support for displaying “Now Playing” information in the lock screen and multitasking controls. This information can also be displayed on an Apple TV and with content delivered via AirPlay.
- You can detect whether video is being streamed to an AirPlay device using the
airPlayVideoActiveproperty of the
- Applications can now use the framework to play content from iTunes University.
Note:If you are currently using Map Kit for geocoding, you should switch to using the Core Location framework for that feature; see “Core Location.”
iAdThe iAd framework provides new callback methods for developers who use multiple add networks and want to be notified when a new ad is available. The
bannerViewWillLoadAd:method (defined in the
ADBannerViewDelegateprotocol) is called when a banner has confirmed that an ad is available but before the ad is fully downloaded and ready to be presented. The
interstitialAdWillLoad:method (defined in the
ADInterstitialAdDelegateprotocol) offers similar behavior for interstitial ads. Game Kit The Game Kit framework and Game Center now have the following features:
GKTurnBasedMatchclass provides support for turn-based gaming, which allows games to create persistent matches whose state is stored in iCloud. Your game manages the state information for the match and determines which player must act to advance the state of the match.
- Your game can now adjust the default leaderboard (implemented by the
GKLeaderboardclass) shown to each player. If your game does not change the default leaderboard for a player, that player sees the leaderboard configured for your application in iTunes Connect.
GKNotificationBannerclass implements a customizable banner similar to the banner shown to players when they log in to Game Center. Your game may use this banner to display messages to the player.
- When your game reports an achievement, it can automatically display a banner to the player using the
GKMatchmakerViewControllerobject can now add players to an existing match in addition to creating a new match.
GKMatchDelegateprotocol now includes a method to reconnect devices when a two-player match is disconnected.
NSFileManagerclass includes new methods for moving a file to a user’s iCloud storage.
- The new
NSFilePresenterprotocol implement now locking support and notifications when manipulating documents in iCloud.
- The new
NSFileVersionclass reports and manages conflicts between different versions of a file in iCloud.
NSURLclass includes new methods and constants to support syncing items to a user’s iCloud storage.
- The new
NSMetadataQueryclass supports attributes for items synced to a user’s iCloud storage. Several other metadata-related classes were also added, including
- The new
NSJSONSerializationclass is a new class that supports back-and-forth conversions between JSON data and Foundation types.
- The new
NSLinguisticTaggerclass is a new class lets you break down a sentence into its grammatical components, allowing the determination of nouns, verbs, adverbs, and so on. This tagging works fully for English and the class also provides a method to find out what capabilities are available for other languages.
- This framework now includes the
NSFileWrapperclass for managing file packages—that is, files implemented as an opaque directory.
- The new
NSOrderedSetcollection class offers the semantics of sets, whereby each element occurs at most once in the collection, but where elements are in a specific order.
- Most delegate methods are now declared using formal protocols instead of as categories on
- The class hierarchy has been restructured. There is now a common base class called
EKObjectand portions of the
EKEventclass have been moved into a new base class called
- With the
EKEventStoreclass, you can now create and delete calendars programmatically, fetch calendars based on their identifier, save and remove events in batches, and trigger a programmatic refresh of calendar data.
- The new
EKSourceclass represents the source for creating new calendars and events.
EKCalendarclass now provides access to a calendar’s UUID, source, and other attributes.
EKCalendarChooserclass, which provides a standard way for selecting from the user’s iCal calendars. Core Motion The Core Motion framework now supports reporting heading information and magnetometer data for devices that have the corresponding hardware. Core Location The Core Location framework (
CoreLocation.framework) now includes support for both forward and reverse geocoding location data. This support allows you to convert back and forth between a set of map coordinates and information about the street, city, country (and so on) at that coordinate. Core Graphics The Core Graphics framework (
CoreGraphics.framework) includes some new interfaces to support the creation of paths. Specifically, there are new interfaces for creating paths with an ellipse or rectangle and for adding arcs to existing paths. Core Data The Core Data framework includes the following enhancements:
- Core Data provides integration with the iOS document architecture and iCloud storage. The
UIManagedDocumentclass is a concrete subclass of
UIDocumentthat uses a Core Data persistent store for document data storage.
- For applications built for iOS 5.0 or later, persistent stores now store data by default in an encrypted format on disk. The default protection level prevents access to the data until after the user unlocks the device for the first time. You can change the protection level by assigning a custom value to the
NSPersistentStoreFileProtectionKeykey when configuring your persistent stores. For additional information about the data protection that are new in iOS 5.0, see “Data Protection Improvements.”
- Core Data formalizes the concurrency model for the
NSManagedObjectContextclass with new options. When you create a context, you can specify the concurrency pattern to use with it: thread confinement, a private dispatch queue, or the main dispatch queue. The
NSConfinementConcurrencyTypeoption provides the same behavior that was present on versions of iOS prior to 5.0 and is the default. When sending messages to a context created with a queue association, you must use the
performBlockAndWait:method if your code is not already executing on that queue (for the main queue type) or within the scope of a
performBlock...invocation (for the private queue type). Within the blocks passed to those methods, you can use the methods of
performBlockAndWait:method supports API reentrancy. The
performBlock:method includes an autorelease pool and calls the
processPendingChangesmethod upon completion.
- You can create nested managed object contexts, in which the parent object store of a context is another managed object context rather than the persistent store coordinator. This means that fetch and save operations are mediated by the parent context instead of by a coordinator. This pattern has a number of usage scenarios, including performing background operations on a second thread or queue and managing discardable edits, such as in an inspector window or viewNested contexts make it more important than ever that you adopt the “pass the baton” approach of accessing a context (by passing a context from one view controller to the next) rather than retrieving it directly from the application delegate.
- Managed objects support two significant new features: ordered relationships, and external storage for attribute values. If you specify that the value of a managed object attribute may be stored as an external record, Core Data heuristically decides on a per-value basis whether it should save the data directly in the database or store a URI to a separate file that it manages for you.
- There are two new classes,
NSIncrementalStoreNode, that you can use to implement support for nonatomic persistent stores. The store does not have to be a relational database—for example, you could use a web service as the back end.
- Audio-session routing information is now specified using dictionary keys. There are also new modes for managing your application’s audio behavior:
- Voice chat mode optimizes the system for two-way voice conversation.
- Video recording mode configures the device for video capture.
- Measurement mode disables automatic compression and limiting for audio input.
- Default mode provides iOS 4.3.3 behavior.
- Core Audio adds seven new audio units for handling advanced audio processing features in your application, such as reverb, adjustable equalization, and time compression and stretching. The new Sampler unit lets you create music instruments, for which you can provide your own sounds. The new AUFilePlayer unit lets you play sound files and feed them directly to other audio units.
- The 3D Mixer audio unit is enhanced in iOS 5.0 to provide reverb and other effects useful in game audio.
- You can automate audio unit parameters in an audio processing graph, which lets you build a music mixer that remembers fader positions and changes.
- You can now use the advanced features of Apple Core Audio Format files in iOS. For example, you might create new voices for the Sampler audio unit.
- There is now programmatic support for adjusting the audio input gain.
- Core Audio now supports 32-bit floating-point audio data for applications that need to provide high quality audio.
- There is automatic support for playing audio and video content over AirPlay. Applications can opt out of transmitting video over AirPlay using the
allowsAirPlayVideoproperty of the
- New properties on the
AVPlayerItemclass indicate whether the item supports fast-forwarding or rewinding of the content.
- Support for accessing photo streams
- Support for creating new albums in the user’s photo library
- Support for adding assets to albums
- The ability to get an aspect ratio thumbnail for an asset
- The ability to modify saved assets
Security.framework) now includes the Secure Transport interfaces, which are Apple’s implementation of the SSL/TLS protocols. You can use these interfaces to configure and manage SSL sessions, manage ciphers, and manage certificates.