This article summarizes the developer-related features introduced in iOS 4. This version of the operating system runs on iPhone and iPod touch only and does not run on iPad. In addition to describing the new features, this article lists the documents that describe those features in more detail.
For the latest updates and information, you should also see iOS 4.0 Release Notes. For the list of API differences between the iOS 4 and earlier versions of iOS, see iOS 4.0 API Diffs.
Applications built using iOS SDK 4 or later (and running in iOS 4 and later) are no longer terminated when the user presses the Home button; instead, they now shift to a background execution context. For many applications, this means that the application enters a suspended state of execution shortly after entering the background. Keeping the application in memory avoids the subsequent launch cycle and allows an application to simply reactivate itself, which improves the overall user experience. And suspending the application improves overall system performance by minimizing power usage and giving more execution time to the foreground application.
Although most applications are suspended shortly after moving to the background, applications that need to continue working in the background may do so using one of the following techniques:
An application can request a finite amount of time to complete some important task.
An application can declare itself as supporting specific services that require regular background execution time.
An application can use local notifications to generate user alerts at designated times, whether or not the application is running.
Regardless of whether your application is suspended or continues running in the background, supporting multitasking does require some additional work on your part. Background applications can still be terminated under certain conditions (such as during low-memory conditions), and so applications must be ready to exit at any time. This means that many of the tasks you used to perform at quit time must now be performed when your application moves to the background. This requires implementing some new methods in your application delegate to respond to application state transitions.
For more information on how to handle the new background state transitions, and for information on how to continue running in the background, see iOS App Programming Guide.
The following sections describe the technologies you can use to enhance your application’s user experience.
Local notifications complement the existing push notifications by giving applications an avenue for generating the notifications locally instead of relying on an external server. Background applications can use local notifications as a way to get a user’s attention when important events happen. For example, a navigation application running in the background can use local notifications to alert the user when it is time to make a turn. Applications can also schedule the delivery of local notifications for a future date and time and have those notifications delivered even if the application is not running.
The advantage of local notifications is that they are independent of your application. Once a notification is scheduled, the system manages the delivery of it. Your application does not even have to be running when the notification is delivered.
For more information about using local notifications, see Local and Push Notification Programming Guide.
The Event Kit framework (
EventKit.framework) provides an interface for accessing calendar events on a user’s device. You can use this framework to get existing events and add new events to the user’s calendar. Calendar events can include alarms that you can configure with rules for when they should be delivered. In addition to using Event Kit for creating new events, you can use the view controllers of the Event Kit UI framework (
EventKitUI.framework) to present standard system interfaces for viewing and editing events.
For more information about the classes and methods of these frameworks, see Event Kit Framework Reference and Event Kit UI Framework Reference.
The Core Motion framework (
CoreMotion.framework) provides a single set of interfaces for accessing all motion-based data available on a device. The framework supports accessing both raw and processed accelerometer data using a new set of block-based interfaces. For devices with a built-in gyroscope, you can retrieve the raw gyro data as well as processed data reflecting the attitude and rotation rates of the device. You can use both the accelerometer and gyro-based data for games or other applications that use motion as input or as a way to enhance the overall user experience.
For more information about the classes and methods of this framework, see “Event Delivery: The Responder Chain” in Event Handling Guide for iOS.
Applications that work with sensitive user data can now take advantage of the built-in encryption available on some devices to protect that data. When your application designates a particular file as protected, the system stores that file on-disk in an encrypted format. While the device is locked, the contents of the file are inaccessible to both your application and to any potential intruders. However, when the device is unlocked by the user, a decryption key is created to allow your application to access the file.
Implementing data protection requires you to be considerate in how you create and manage the data you want to protect. Applications must themselves be designed to secure the data at creation time and to be prepared for changes in access to that data when the user locks and unlocks the device.
For more information about how to add data protection to the files of your application, see “App States and Multitasking” in iOS App Programming Guide.
The Core Telephony framework (
CoreTelephony.framework) provides interfaces for interacting with phone-based information on devices that have a cellular radio. Applications can use this framework to get information about a user’s cellular service provider. Applications interested in cellular call events can also be notified when those events occur.
For more information about using the classes and methods of this framework, see Core Telephony Framework Reference.
You can use iAd (
iAd.framework) to deliver banner-based advertisements from your application. Advertisements are incorporated into standard views that you integrate into your user interface and present when you want. The views themselves work with Apple’s ad service to automatically handle all the work associated with loading and presenting the ad content and responding to taps in those ads.
For more information about using iAd in your applications, see iAd Framework Reference.
Graphics and Multimedia
The following sections describe the new graphics and media-related technologies you can incorporate into your applications.
High-Resolution Screen Support
For the most part, applications running on devices with high-resolution screens should work with little or no modifications. The coordinate values you specify during drawing or when manipulating views are all mapped to a logical coordinate system, which is decoupled from the underlying screen resolution. Any content you draw is automatically scaled as needed to support high-resolution screens. For vector-based drawing code, the system frameworks automatically use any extra pixels to improve the crispness of your content. And if you use images in your application, UIKit provides support for loading high-resolution variants of your existing images automatically.
For detailed information about how to support high-resolution screens, see “Supporting High-Resolution Screens In Views” in Drawing and Printing Guide for iOS.
Quick Look Framework
The Quick Look framework (
QuickLook.framework) provides a direct interface for previewing the contents of files your application does not support directly. This framework is intended primarily for applications that download files from the network or that otherwise work with files from unknown sources. After obtaining the file, you use the view controller provided by this framework to display the contents of that file directly in your user interface.
For more information about the classes and methods of this framework, see Quick Look Framework Reference for iOS.
The AV Foundation framework (
AVFoundation.framework) is for applications that need to go beyond the music and movie playback features found in the Media Player framework. Originally introduced in iOS 3.0, this framework has been expanded in iOS 4 to include significant new capabilities, substantially broadening its usage beyond basic audio playback and recording capabilities. Specifically, this framework now includes support for the following features:
Media asset management
Metadata management for media items
Precise synchronization between sounds
An Objective-C interface for determining details about sound files, such as the data format, sample rate, and number of channels
The AV Foundation framework is a single source for recording and playing back audio and video in iOS. This framework also provides much more sophisticated support for handling and managing media items.
For more information about the classes and methods of the AV Foundation framework, see AV Foundation Framework Reference.
The Assets Library framework (
AssetsLibrary.framework) provides a query-based interface for retrieving a user’s photos and videos. Using this framework, you can access the same assets that are nominally managed by the Photos application, including items in the user’s saved photos album and any photos and videos that were imported onto the device. You can also save new photos and videos back to the user’s saved photos album.
For more information about the classes and methods of this framework, see Assets Library Framework Reference.
The Image I/O framework (
ImageIO.framework) provides interfaces for importing and exporting image data and image metadata. This framework is built on top of the Core Graphics data types and functions and supports all of the standard image types available in iOS.
For more information about the functions and data types of this framework, see Image I/O Reference Collection.
The Core Media framework (
CoreMedia.framework) provides the low-level media types used by AV Foundation. Most applications should never need to use this framework, but it is provided for those few developers who need more precise control over the creation and presentation of audio and video content.
For more information about the functions and data types of this framework, see Core Media Framework Reference.
The Core Video framework (
CoreVideo.framework) provides buffer and buffer pool support for Core Media. Most applications should never need to use this framework directly.
The following sections describe the new lower-level technologies and features you can incorporate into your applications.
Block objects are a C-level language construct that you can incorporate into your C and Objective-C code. A block object is essentially an anonymous function and the data that goes with that function, something which in other languages is sometimes called a closure or lambda. Blocks are particularly useful as callbacks or in places where you need a way of easily combining both the code to be executed and the associated data.
In iOS, blocks are commonly used in the following scenarios:
As a replacement for delegates and delegate methods
As a replacement for callback functions
To implement completion handlers for one-time operations
To facilitate performing a task on all the items in a collection
Together with dispatch queues, to perform asynchronous tasks
For an introduction to block objects and how you use them, see A Short Practical Guide to Blocks. For more information about blocks, see Blocks Programming Topics.
Grand Central Dispatch
Grand Central Dispatch (GCD) is a BSD-level technology that you use to manage the execution of tasks in your application. GCD combines an asynchronous programming model with a highly optimized core to provide a convenient (and more efficient) alternative to threading. GCD also provides convenient alternatives for many types of low-level tasks, such as reading and writing file descriptors, implementing timers, monitoring signals and process events, and more.
For more information about how to use GCD in your applications, see Concurrency Programming Guide. For information about specific GCD functions, see Grand Central Dispatch (GCD) Reference.
The Accelerate framework (
Accelerate.framework) contains interfaces for performing math, big-number, and DSP calculations, among others. The advantage of using this framework over writing your own versions of these libraries is that it is optimized for the different hardware configurations present in iOS–based devices. Therefore, you can write your code once and be assured that it runs efficiently on all devices.
For more information about the functions of the Accelerate framework, see Accelerate Framework Reference.
The following sections describe the improvements to the Xcode tools and the support for developing iOS applications.
Xcode 3.2.3 introduces automatic device and provisioning-profile management in the Organizer window. With automatic device provisioning enabled, you can install applications on your device for debugging and testing without having to log in to your team portal to register the device and download a provisioning profile
For more information about using Xcode, see Xcode Overview.
UI Automation API
The following existing frameworks and technologies include additional incremental changes. For a complete list of new interfaces, see iOS 4.0 API Diffs.
UIKit Framework Enhancements
The UIKit framework includes the following enhancements:
Drawing to a graphics context in UIKit is now thread-safe. Specifically:
The routines used to access and manipulate the graphics context can now correctly handle contexts residing on different threads.
String and image drawing is now thread-safe.
Using color and font objects in multiple threads is now safe to do.
UIImagePickerControllerclass includes methods for programmatically starting and stopping video capture. It also includes options for selecting which camera you want to use on a device and for enabling a built-in flash.
UIViewclass includes new block-based methods for implementing animations.
UIWindowclass has a new
rootViewControllerproperty that you can use to change the contents of the window.
Media applications can now receive events related to the controls on an attached set of headphones. You can use these events to control the playback of media-related items.
Several new accessibility interfaces help you make some UI elements more accessible and allow you to customize your application experience specifically for VoiceOver users:
UIAccessibilityActionprotocol makes it easy for VoiceOver users to adjust the value of UI elements, such as pickers and sliders.
UIPickerViewAccessibilityDelegateprotocol enables access to the individual components of a picker.
UIAccessibilityFocusprotocol allows you to find out when VoiceOver is focused on an element, so you can help users avoid making unnecessary taps.
UIAccessibilityTraitStartsMediaSessiontrait allows you to prevent VoiceOver from speaking during a media session that should not be interrupted.
New interfaces in
UIAccessibilityprotocol allow you to specify the language in which labels and hints are spoken, and provide announcements that describe events that don't update application UI in way that would be perceptible to VoiceOver users.
UINibclass provides a way to instantiate multiple sets of objects efficiently from the same nib file.
For information about the classes of the UIKit framework, see UIKit Framework Reference.
Foundation Framework Enhancements
The Foundation framework includes the following enhancements:
Most delegate methods are now declared in formal protocols instead of as categories on
Block-based variants are now available for many types of operations.
NSDateComponentsclass added support for specifying time zone and quarter information.
NSBlockOperationclass allows you to add blocks to operation queues.
NSFileWrapperclass allows you to work with package-based document types.
NSOrthographyclass describes the linguistic content of a piece of text.
NSCacheclass provides support for storing and managing temporary data.
The URL-related classes have been updated so that you can now pipeline URL requests and set request priorities.
For information about the classes of the Foundation framework, see Foundation Framework Reference.
OpenGL ES Enhancements
The OpenGL ES framework includes the following enhancements:
APPLE_framebuffer_multisampleextension enables full-scene anti-aliasing.
EXT_framebuffer_discardextension can be used to improve the performance of applications that use depth buffers or multisample framebuffers.
EXT_shader_texture_lodextensions provide more control over texture sampling.
OES_vertex_array_object(http://www.khronos.org/registry/gles/extensions/OES/OES_vertex_array_object.txt) API allows caching of vertex array state, to decrease driver overhead.
OES_depth_textureextension enables rendering real-time shadows using shadow maps.
OES_texture_half_float(http://www.khronos.org/registry/gles/extensions/OES/OES_texture_float.txt) extensions adds texture formats with floating point components to enable High Dynamic Range rendering.
APPLE_rgb_422(http://www.opengl.org/registry/specs/APPLE/rgb_422.txt) extension enables texturing from some common video formats.
Performance of texture creation and modification has been significantly improved.
Driver performance has been generally improved.
Game Kit Enhancements
The Game Kit framework includes a beta implementation of a centralized service called Game Center. This service provides game developers with a standard way to implement the following features:
Aliases allow users to create their own online persona. Users log in to Game Center and interact with other players anonymously through their alias. Players can set status messages as well as mark specific people as their friends.
Leader boards allow your application to post scores to Game Center and retrieve them later.
Matchmaking allows players to connect with other players with Game Center accounts.
For information about the classes of the Game Kit framework, see Game Kit Framework Reference.
Core Location Enhancements
The Core Location framework now supports the following features:
A location monitoring service that tracks significant changes using only cellular information. This solution offers a lower-power alternative for determining the user’s location.
The ability to define arbitrary regions and detect boundary crossings into or out of those regions. This feature can be used for proximity detection regardless of whether the application is running.
For information about the classes of the Core Location framework, see Core Location Framework Reference.
Map Kit Enhancements
The Map Kit framework includes the following enhancements:
Support for draggable map annotations
Support for map overlays
Draggable map annotations make it much easier to reposition those annotations after they have been added to a map. The Map Kit framework handles most of the touch events associated with initiating, tracking, and ending a drag operation. However, the annotation view must work in conjunction with the map view delegate to ensure that dragging of the annotation view is supported.
Map overlays provide a way to create more complex types of annotations. Instead of being pinned to a single point, an overlay can represent a path or shape that spans a wider region. You can use overlays to layer information such as bus routes, election maps, park boundaries, and weather maps on top of the map.
For information about the functions and types of the Map Kit framework, see Map Kit Framework Reference.
Message UI Enhancements
The Message UI framework includes a new
MFMessageComposeViewController class for composing SMS messages. This class manages a standard system interface for composing and sending SMS messages. In contrast with sending SMS messages using a specially formatted URL, this class allows you to create and send the message entirely from within your application.
For more information about the classes of the Message UI framework, see Message UI Framework Reference.
Core Graphics Enhancements
The Core Graphics framework includes the following enhancements:
The ability to embed metadata into PDF files using the
Support for creating color spaces using an ICC profile
Graphics context support for font smoothing and fine-grained pixel manipulation
For information about the functions and types of the Core Graphics framework, see Core Graphics Framework Reference.
The International Components for Unicode (ICU) libraries were updated to version 4.4. ICU is an open-source project for Unicode support and software internationalization. The installed version of ICU includes only a subset of the header files that are part of the broader ICU library. Specifically, iOS includes only the headers used to support regular expressions.
For more information about using the functions of the ICU 4.4 library, see the documentation at http://site.icu-project.org/.
Although iOS 3.2 does not run on iPhone and iPod touch devices, many of the features introduced in that version of the operating system are also supported in iOS 4. Specifically, iOS 4 supports:
Custom input views
Connecting external displays
Core Text for text layout and rendering
Text input through integration with the keyboard
ICU Regular Expressions
Xcode Tools changes
UIKit framework changes
Media Player framework changes
Core Animation changes
Foundation framework changes