YES! Finally after a month of sleepless nights it is announced. Us nerds here at Gravity Jack have been waiting for the iPad announcement. The only bad news we heard was that it doesn’t have a camera and GPS. So it won’t be the augmented reality device we were hoping for. In fact there isn’t THAT much that is revolutionary about the iPad. It is just a big ass iPhone. Well ok there are SOME cool things. 🙂 For one this will start the revolution to kill the Kindle.
The major points:
1) It runs iPhone OS and runs the iPhone apps that exist in full screen mode
2) It is a half inch thick
3) It supports 16 to 64 GB of memory
4) It has bluetooth, wifi and optional 3GS from AT&T
5) You get 10 hours of battery life, a month if you don’t turn the sucker on
6) It is sexy looking and you can read all your PDFs plus iBooks are the thing, a boatload of publishers have signed up to provide content
|Wi-Fi + 3G
If you want 3G it is 14.99 for 250 MB per month and 29.99 for unlimited data. Not a bad deal and this is no contract and the device is not locked to AT&T
For you programmers out there:
User Interface Changes
Applications running on iPad have several new options for presenting content and receiving input from the user.
Popovers are floating views that reside above your applicationâ€™s window and help you organize the contents of your user interface. Popovers help to eliminate the clutter that might occur in applications that need to display important controls or information in an unobtrusive way that does not distract from the main content.
The benefit of using a popover is that:
- It appears only in response to specific user interactions and is dismissed automatically when the user taps outside of its bounds. This behavior makes the popover less obtrusive to the user.
- It typically covers only a small portion of the screen and so does not obscure as much of the underlying content as a modal view might.
UISplitViewController class is a new container view controller that you use to manage two side-by-side content views. These content views are typically used to create a master-detail interface, whereby selecting an item in one view causes the other view to display detailed information about the selection. The views themselves are managed by view controllers that you provide.
The split view controller coordinates any interactions between your view controllers and the system. For example, when the user rotates the device, the split view controller rotates both view controllers together, forwarding any needed notifications to both of them.
Custom Input Views
Instances of the
UIResponder class now support the ability to display custom input and accessory views when they become the first responder. Now, you can provide input views for any of your custom views and have them presented automatically by the system. (Previously, the keyboard was the only supported input view, and it was supported only by text view and text field objects.)
In addition to input views, you can also provide a custom accessory view to display above the input view. Accessory views are commonly used to provide additional buttons and controls when the keyboard is displayed. The explicit support now provided by responder objects makes it easy to animate your accessory views into position.
External Display Support
An iPad can be connected to an external display through a set of supported cables. When connected, the associated screen can be used by the application to display content. Information about the screen, including its supported resolutions, is accessible through the interfaces of the UIKit framework. You also use that framework to associate your applicationâ€™s windows with one screen or another.
UIScreenclass provides support for retrieving screen objects for all available screens (including the deviceâ€™s main screen). Each screen object contains information about the properties of the screen itself, including the dimensions that correctly take into account the size and pixel aspect ratio of the screen.
UIScreenModeclass provides information about one particular size and pixel aspect ratio setting of a screen.
- Windows (represented by the
UIWindowclass) can now be assigned to a specific screen.
Gesture recognizers are objects that you attach to views and use to detect common types of gestures. After attaching it to your view, you tell it what action you want performed when the gesture occurs. The gesture recognizer object then tracks the raw events and applies the system-defined heuristics for what the given gesture should be. Prior to gesture recognizers, the process for detecting a gesture involved tracking the raw stream of touch events coming to your view and applying potentially complicated heuristics to determine whether the events represented the given gesture.
UIKit now includes a
UIGestureRecognizer class that defines the basic behavior for all gesture recognizers. You can define your own custom gesture recognizer subclasses or use one of the system-supplied subclasses to handle any of the following standard gestures:
- Tapping (any number of taps)
- Pinching in and out (for zooming)
- Panning or dragging
- Swiping (in any direction)
- Rotating (fingers moving in opposite directions)
- Long presses
Improved Text Support
In iPhone OS 3.2, there is significant new support for text input and rendering. This support is provided for applications, such as word processors, that need more sophisticated text-handling capabilities.
The Core Text framework (
CoreText.framework) contains a set of simple, high-performance C-based interfaces for laying out text and handling fonts. The Core Text framework provides a complete text layout engine that you can use to manage the placement of text on the screen. The text you manage can also be styled with different fonts and rendering attributes.
This framework is intended for use by applications that require sophisticated text handling capabilities, such as word processing applications. If your application requires only simple text input and display, you should continue to use the existing classes of the UIKit framework.
Text Input Support
The UIKit framework (
UIKit.framework) includes new protocols that allow you to implement custom text-input objects. If you are implementing an application that requires sophisticated text-handling capabilities, you can use these protocols to implement new views and controls for receiving incoming text. Depending on your needs, there are different protocols for receiving text input. Which protocols you use will depend on the complexity of your user interface.
UIKeyInputprotocol lets you define simple objects (like text fields) that are capable of character-by-character input.
UITextInputprotocol lets you define complex text views that support multiple lines of text, selections, pasteboard operations, and more.
Custom Font Support
Applications that want to use custom fonts can now include those fonts in their application bundle and register those fonts with the system by including the
UIAppFonts key in their
Info.plist file. The value of this key is an array of strings identifying the font files in the applicationâ€™s bundle. When the system sees the key, it loads the specified fonts and makes them available to the application.
ICU Regular-Expression Support
The BSD layer of iPhone OS now exposes a modified version of 4.2 of the International Components for Unicode (ICU) libraries. ICU is an open-source project for Unicode support and software internationalization. The installed version of ICU includes only those header files necessary to support regular expressions.
File and Document Support
In iPhone OS 3.2, there is new support for exchanging and opening files. This support makes it easier to implement more document-centric applications, similar to what you might find on a desktop computer, while still maintaining a simplified interface for your users.
Applications that want to share files with the user can now do so using the file-sharing support in iPhone OS 3.2. Hereâ€™s how it works:
- An application indicates that it wants to share files by including the
UIFileSharingEnabledkey in its
- It puts whatever files it wants to share in its
- When the device is plugged into the userâ€™s computer, a mount point is added to the system and the contents of any shared directories appear on the userâ€™s desktop.
- Users can modify the contents of this directory freely by copying files out, deleting files, or dragging new files in.
Applications that support file sharing should recognize when files have been added to the directory or removed and respond appropriately. For example, if the user added files to the directory, your iPad application might make those files available from its interface. You should never expect the user to go searching for files in this directory, nor should your application rely on any files being in this directory. It is strictly for sharing files with the userâ€™s computer.
An application can now register the file types it supports with the system and receive notifications when a file of the given type needs to be opened. It does this by including the
CFBundleDocumentTypes key in its Info.plist file. An application that registers one or more file types may also be expected to open files of those types at some point later. It does this by implementing the
application:didFinishLaunchingWithOptions: method in its application delegate and look for a file in the
UIApplicationLaunchOptionsURLKey key of the provided dictionary.
Complimenting the ability to open files of known types is the addition of the
UIDocumentInteractionController class in the UIKit framework. This class provides a user-based interaction model for managing files that your application does not know how to open. The document interaction controller provides options for previewing the contents of a file in place or opening it in another application. Document interaction controllers are particularly useful for email applications or applications that may download files from the network.
The UIKit framework (
UIKit.framework) includes new functions for generating PDF files and data objects from your applicationâ€™s custom content. You can use this support to generate PDF-based content for use within your application or for storing to the local disk. The UIKit functions manage the setup and pagination for the PDF data. You provide the actual content using the same native platform graphics technologies (UIKit, Core Graphics, Core Text, and so on) already available for drawing to the screen. (You cannot draw to a PDF context directly using OpenGL commands. However, you can transfer the pixels of your rendered content to a
CGImageRef data type and draw that.)
Xcode includes new features to make developing applications that run on iPad much simpler, including the following:
- Xcode simplifies the process of sharing code between your iPhone and iPad applications by helping you update your existing iPhone projects to include the necessary files to support iPad. The Transition command (in the Project menu) creates a new target for the iPad and modifies a copy of your projectâ€™s nib files to support the larger screen size.
- Xcode simplifies the validation and submission process of your applications by allowing you to debug signed applications.
- You can now easily transfer your iPhone developer identity information to a new computer. The Organizer window includes an option to export your profile and certificate information. To begin developing on a new computer, all you have to do is import the resulting data file into Xcode on that computer.
- Interface Builder supports the new view controllers and window sizes available for iPad.
The following frameworks and technologies include additional incremental changes.
UIKit Framework Changes
The UIKit framework includes the following additions:
UIBezierPathclass is a new class that supports the creation of vector-based shapes. This class provides an object-oriented wrapper around Core Graphics paths.
UIScrollViewDelegateprotocol includes additional methods for processing zoom-related events in a scroll view.
- Modal view controllers can now be presented in a style other than full screen. The
UIViewControllerclass includes a
modalPresentationStyleproperty that allows you to present modal view controllers using one of several predefined styles.
UIMenuControllerclass now allows you to add custom menu items. You can use custom menu items to augment the Cut, Copy, Paste, and Select behavior provided by the system.
- Support for popovers, described in â€œPopovers.â€
UISplitViewControllerclass, described in â€œSplit Views.â€
- Support for gesture recognizers, described in â€œGesture Recognizers.â€
- Support for implementing custom input and accessory views, described in â€œCustom Input Views.â€
- Support for getting information about externally connected displays, described in â€œExternal Display Supportâ€
- Support for creating PDF files, described in â€œPDF Generation.â€
- Support for previewing and opening documents, described in â€œDocument Support.â€
Media Player Framework Changes
The video classes in the Media Player framework (
MediaPlayer.framework) have been redesigned to give you more control over the presentation of video content. Instead of simply playing a video full screen, the
MPMoviePlayerController class now vends a view that you can incorporate into your interface however you want. This class also includes more sophisticated support for managing and controlling the playback of movies.
For situations where you want a simpler alternative to movie presentation, you can now use the
MPMoviePlayerViewController class. This new class provides a view controller-based wrapper for a movie interface and is for applications that want the same basic behavior offered by the older movie player controller design.
Core Animation Changes
The Core Animation technology (defined in
QuartzCore.framework) includes the following additional features:
CATextLayerclass is now available for incorporating text-based content into your layer hierarchies.
- You can now apply shadow effects to a layer and customize the appearance of the shadow using the
- You can configure the rasterization behavior of the layer using the
MapKit Framework Changes
MKReverseGeocoder class now includes a
placemark property for accessing the placemark that was computed by the reverse geocoding service. You can use this property to retrieve placemark information after the results are reported to the associated delegate object.
Foundation Framework Changes
NSString class now includes the ability to search the text of a string using regular expressions. The
NSStringCompareOptions type includes a new flag called
NSRegularExpressionSearch, which you can use in conjunction with the following methods:
When you pass the
NSRegularExpressionSearch as an option, the search string is interpreted as a regular expression instead of a string literal. The regular expression syntax conforms to the syntax used by the International Components for Unicode (ICU) library. When performing regular expression searches, the only other options you can include in the mask parameter are the
NSCaseInsensitiveSearch and the
Because some regular expressions can trigger a match but still return a zero-length range, you should check both the location and range length of the result. If a match was unsuccessful, the search methods always return a range whose location is set to
NSNotFound and whose length is