Open main menu
IPad iOS 6 Development Essentials
Revision as of 15:11, 19 December 2012 by
Neil
(
Talk
|
contribs
)
(
diff
)
← Older revision
|
Latest revision
(
diff
) |
Newer revision →
(
diff
)
Revision as of 15:11, 19 December 2012 by
Neil
(
Talk
|
contribs
)
(
diff
)
← Older revision
|
Latest revision
(
diff
) |
Newer revision →
(
diff
)
Table of Contents
Next
About iPad iOS 6 Development Essentials
<google>BUY_IOS6_IPAD</google>
Table of Contents
About iPad iOS 6 Development Essentials
The iOS 6 SDK
For New iOS Developers
For iOS 5 Developers
Source Code Download
Errata
Joining the Apple iOS 6 Developer Program
Registered Apple Developer
Downloading Xcode and the iOS 6 SDK
iOS Developer Program
When to Enroll in the iOS Developer Program?
Enrolling in the iOS Developer Program
Installing Xcode 4 and the iOS 6 SDK
Identifying if you have an Intel or PowerPC based Mac
Installing Xcode and the iOS 6 SDK
Starting Xcode
Creating a Simple iPad iOS 6 App
Starting Xcode
Creating the iOS App User Interface
Changing Component Properties
Adding Objects to the User Interface
Building and Running an iOS App in Xcode
Dealing with Build Errors
Testing Different Screen Sizes
iPad iOS 6 Architecture and SDK Frameworks
iPhone OS becomes iOS
An Overview of the iOS 6 Architecture
The Cocoa Touch Layer
The iOS Media Layer
The iOS Core Services Layer
Foundation Framework (Foundation.framework)
The iOS Core OS Layer
Testing iOS 6 Apps on the iPad – Developer Certificates and Provisioning Profiles
Creating an iOS Development Certificate Signing Request
Submitting the iOS Development Certificate Signing Request
Installing an iOS Development Certificate
Assigning Devices
Creating an App ID
Creating an iOS Development Provisioning Profile
Enabling an iPad Device for Development
Associating an App ID with an App
iOS and SDK Version Compatibility
Installing an App onto a Device
The Basics of Objective-C Programming
Objective-C Data Types and Variables
Objective-C Expressions
Objective-C Flow Control with if and else
Looping with the for Statement
Objective-C Looping with do and while
Objective-C do ... while loops
The Basics of Object Oriented Programming in Objective-C
What is an Object?
What is a Class?
Creating the Example Project
Declaring an Objective-C Class Interface
Adding Instance Variables to a Class
Defining Instance Methods
Declaring an Objective-C Class Implementation
Declaring and Initializing a Class Instance
Calling Methods and Accessing Instance Data
How Variables are Stored
An Overview of Indirection
Indirection and Objects
Indirection and Object Copying
Creating the Program Section
Compiling and Running the Program
Objective-C - Data Encapsulation, Synthesized Accessors and Dot Notation (iOS 6)
Data Encapsulation
Properties, Synthesized Accessor Methods
Accessing Property Instance Variables
The Modified Bank Account Example
Objective-C and Dot Notation
The Basics of Modern Objective-C (iPad)
Default Property Synthesis
Method Ordering
NSNumber Literals
Array Literals
Dictionary Literals
Creating an Interactive iOS 6 iPad App
Creating the New Project
Creating the User Interface
Building and Running the Sample Application
Adding Actions and Outlets
Connecting the Actions and Outlets to the User Interface
Building and Running the Finished Application
Writing iOS 6 Code to Hide the iPad Keyboard
Creating the Example Application
Hiding the Keyboard when the User Touches the Return Key
Hiding the Keyboard when the User Taps the Background
Establishing iOS 6 Outlets and Actions using the Xcode Assistant Editor (iPad)
Displaying the Assistant Editor
Using the Assistant Editor
Adding an Outlet using the Assistant Editor
Adding an Action using the Assistant Editor
An Introduction to iPad Auto Layout in iOS 6
An Overview of Auto Layout
Alignment Rects
Intrinsic Content Size
Content Hugging and Compression Resistance Priorities
Three Ways to Create Constraints
Constraints in more Detail
Working with iPad iOS 6 Auto Layout Constraints in Interface Builder
A Simple Example of Auto Layout in Action
Enabling and Disabling Auto Layout in Interface Builder
The Auto Layout Features of Interface Builder
Automatic Constraints
Visual Cues
Viewing and Editing Constraints Details
Creating New Constraints in Interface Builder
An iPad iOS 6 Auto Layout Example
Preparing the Project
Designing the User Interface
Adjusting Constraint Priorities
Alignment and Width Equality
Testing the Application
Implementing iPad iOS 6 Auto Layout Constraints in Code
Creating Constraints in Code
Adding a Constraint to a View
Turning off Auto Resizing Translation
An Example Application
Creating the Views
Creating and Adding the Constraints
Removing Constraints
Implementing iPad Cross-Hierarchy Auto Layout Constraints in iOS 6
The Example Application
Establishing Outlets
Writing the Code to Remove the Old Constraint
Adding the Cross Hierarchy Constraint
Testing the Application
Understanding the iPad iOS 6 Auto Layout Visual Format Language
Introducing the Visual Format Language
Visual Language Format Examples
Using the constraintsWithVisualFormat: Method
Using Xcode Storyboarding with iOS 6 (iPad)
Creating the Storyboard Example Project
Accessing the Storyboard
Adding Scenes to the Storyboard
Configuring Storyboard Segues
Configuring Storyboard Transitions
Associating a View Controller with a Scene
Passing Data Between Scenes
Unwinding Storyboard Segues
Triggering a Storyboard Segue Programmatically
Using Xcode Storyboards to create an iOS 6 iPad Tab Bar Application
An Overview of the Tab Bar
Understanding View Controllers in a Multiview Application
Setting up the Tab Bar Example Application
Reviewing the Project Files
Renaming the Initial View Controller
Adding the View Controller for the Second Content View
Adding the Tab Bar Controller to the Storyboard
Adding a Second View Controller to the Storyboard
Designing the View Controller User interfaces
Configuring the Tab Bar Items
Building and Running the Application
An Overview of iPad iOS 6 Table Views and Xcode Storyboards
An Overview of the Table View
Static vs. Dynamic Table Views
The Table View Delegate and dataSource
Table View Styles
Table View Cell Styles
Table View Cell Reuse
Using Xcode Storyboards to Build Dynamic iOS 6 iPad TableViews with Prototype Table View Cells
Creating the Example Project
Adding the TableView Controller to the Storyboard
Creating the UITableViewController and UITableViewCell Subclasses
Declaring the Cell Reuse Identifier
Designing a Storyboard UITableView Prototype Cell
Modifying the CarTableViewCell Class
Creating the Table View Datasource
Downloading and Adding the Image Files
Compiling and Running the Application
Implementing iPad iOS 6 TableView Navigation using Xcode Storyboards
Understanding the Navigation Controller
Adding the New Scene to the Storyboard
Adding a Navigation Controller
Establishing the Storyboard Segue
Modifying the CarDetailViewController Class
Using prepareForSegue: to Pass Data between Storyboard Scenes
Testing the Application
Using an Xcode Storyboard to Create a Static iPad iOS 6 Table View
An Overview of the Static Table Project
Creating the Project
Adding a Table View Controller
Changing the Table View Content Type
Designing the Static Table
Adding Items to the Table Cells
Modifying the StaticTableViewController Class
Building and Running the Application
An iPad iOS 6 Split View and Popover Example
An Overview of Split View and Popovers
About the Example iPad Split View and Popover Project
Creating the Project
Reviewing the Project
Reviewing the Application Delegate Class
Configuring Master View Items
Configuring the Detail View Controller
Connecting Master Selections to the Detail View
Popover Implementation
Testing the Application
Working with Directories on iOS 6 (iPad)
The Application Documents Directory
The Objective-C NSFileManager, NSFileHandle and NSData Classes
Understanding Pathnames in Objective-C
Creating an NSFileManager Instance Object
Identifying the Current Working Directory
Identifying the Documents Directory
Identifying the Temporary Directory
Changing Directory
Creating a New Directory
Deleting a Directory
Listing the Contents of a Directory
Getting the Attributes of a File or Directory
Working with iPad Files on iOS 6
Creating an NSFileManager Instance
Checking for the Existence of a File
Comparing the Contents of Two Files
Checking if a File is Readable/Writable/Executable/Deletable
Moving/Renaming a File
Copying a File
Removing a File
Creating a Symbolic Link
Reading and Writing Files with NSFileManager
Working with Files using the NSFileHandle Class
Creating an NSFileHandle Object
NSFileHandle File Offsets and Seeking
Reading Data from a File
Writing Data to a File
Truncating a File
iOS 6 iPad Directory Handling and File I/O – A Worked Example
The Example iPad Application
Setting up the Application Project
Designing the User Interface
Checking the Data File on Application Startup
Implementing the Action Method
Building and Running the Example
Preparing an iOS 6 iPad App to use iCloud Storage
What is iCloud?
iCloud Data Storage Services
Preparing an Application to Use iCloud Storage
Creating an iOS 6 iCloud enabled App ID
Creating and Installing an iCloud Enabled Provisioning Profile
Creating an iCloud Entitlements File
Manually Creating the Entitlements File
Accessing Multiple Ubiquity Containers
Ubiquity Container URLs
Managing Files using the iOS 6 UIDocument Class
An Overview of the UIDocument Class
Subclassing the UIDocument Class
Conflict Resolution and Document States
The UIDocument Example Application
Creating a UIDocument Subclass
Designing the User Interface
Implementing the Application Data Structure
Implementing the contentsForType Method
Implementing the loadFromContents Method
Loading the Document at App Launch
Saving Content to the Document
Testing the Application
Using iCloud Storage in an iPad iOS 6 Application
iCloud Usage Guidelines
Preparing the iCloudStore Application for iCloud Access
Configuring the View Controller
Implementing the viewDidLoad Method
Implementing the metadataQueryDidFinishGathering: Method
Implementing the saveDocument Method
Enabling iCloud Document and Data Storage on an iPad
Running the iCloud Application
Reviewing and Deleting iCloud Based Documents
Making a Local File Ubiquitous
Synchronizing iPad iOS 6 Key-Value Data using iCloud
An Overview of iCloud Key-Value Data Storage
Sharing Data Between Applications
Data Storage Restriction
Receiving Notification of Key-Value Changes
An iCloud Key-Value Data Storage Example
Enabling the Application for iCloud Key Value Data Storage
Designing the User Interface
Implementing the View Controller
Modifying the viewDidLoad Method
Implementing the Notification Method
Implementing the saveData Method
iOS 6 iPad Data Persistence using Archiving
An Overview of Archiving
The Archiving Example Application
Designing the User Interface
Checking for the Existence of the Archive File on Startup
Archiving Object Data in the Action Method
Testing the Application
iOS 6 iPad Database Implementation using SQLite
What is SQLite?
Structured Query Language (SQL)
Trying SQLite on MacOS X
Preparing an iPad Application Project for SQLite Integration
Key SQLite Functions
Declaring a SQLite Database
Opening or Creating a Database
Preparing and Executing a SQL Statement
Creating a Database Table
Extracting Data from a Database Table
Closing a SQLite Database
An Example SQLite based iOS 6 iPad Application
About the Example SQLite iPad Application
Creating and Preparing the SQLite Application Project
Importing sqlite3.h and declaring the Database Reference
Designing the User Interface
Creating the Database and Table
Implementing the Code to Save Data to the SQLite Database
Implementing Code to Extract Data from the SQLite Database
Building and Running the Application
Working with iOS 6 iPad Databases using Core Data
The Core Data Stack
Managed Objects
Managed Object Context
Managed Object Model
Persistent Store Coordinator
Persistent Object Store
Defining an Entity Description
Obtaining the Managed Object Context
Getting an Entity Description
Creating a Managed Object
Getting and Setting the Attributes of a Managed Object
Fetching Managed Objects
Retrieving Managed Objects based on Criteria
An iOS 6 iPad Core Data Tutorial
The iPad Core Data Example Application
Creating a Core Data based iPad Application
Creating the Entity Description
Adding a View Controller
Designing the User Interface
Saving Data to the Persistent Store using Core Data
Retrieving Data from the Persistent Store using Core Data
Building and Running the Example Application
An Overview of iOS 6 iPad Multitouch, Taps and Gestures
The Responder Chain
Forwarding an Event to the Next Responder
Gestures
Taps
Touches
Touch Notification Methods
An Example iOS 6 iPad Touch, Multitouch and Tap Application
The Example iOS 6 iPad Tap and Touch Application
Creating the Example iOS Touch Project
Designing the User Interface
Enabling Multitouch on the View
Implementing the touchesBegan Method
Implementing the touchesMoved Method
Implementing the touchesEnded Method
Getting the Coordinates of a Touch
Building and Running the Touch Example Application
Detecting iOS 6 iPad Touch Screen Gesture Motions
The Example iOS 6 iPad Gesture Application
Creating the Example Project
Designing the Application User Interface
Implementing the touchesBegan Method
Implementing the touchesMoved Method
Implementing the touchesEnded Method
Building and Running the iPad Gesture Example
Identifying iPad Gestures using iOS 6 Gesture Recognizers
The UIGestureRecognizer Class
Recognizer Action Messages
Discrete and Continuous Gestures
Obtaining Data from a Gesture
Recognizing Tap Gestures
Recognizing Pinch Gestures
Detecting Rotation Gestures
Recognizing Pan and Dragging Gestures
Recognizing Swipe Gestures
Recognizing Long Touch (Touch and Hold) Gestures
An iPad iOS 6 Gesture Recognition Tutorial
Creating the Gesture Recognition Project
Designing the User Interface
Implementing the Action Methods
Testing the Gesture Recognition Application
An Overview of iPad iOS 6 Collection View and Flow Layout
An Overview of Collection Views
The UICollectionView Class
The UICollectionViewCell Class
The UICollectionReusableView Class
The UICollectionViewFlowLayout Class
The UICollectionViewLayoutAttributes Class
The UICollectionViewDataSource Protocol
The UICollectionViewDelegate Protocol
The UICollectionViewDelegateFlowLayout Protocol
Cell and View Reuse
An iPad iOS 6 Storyboard-based Collection View Tutorial
Creating the Collection View Example Project
Removing the Template View Controller
Adding a Collection View Controller to the Storyboard
Adding the Collection View Cell Class to the Project
Designing the Cell Prototype
Implementing the Data Model
Implementing the Data Source
Testing the Application
Setting Sizes for Cell Items
Changing Scroll Direction
Implementing a Supplementary View
Implementing the Supplementary View Protocol Methods
Deleting Collection View Items
Subclassing and Extending the iOS 6 Collection View Flow Layout (iPad)
About the Example Layout Class
Subclassing the UICollectionViewFlowLayout Class
Extending the New Layout Class
Implementing the layoutAttributesForItemAtIndexPath: Method
Implementing the layoutAttributesForElementsInRect: Method
Implementing the modifyLayoutAttributes: Method
Adding the New Layout and Pinch Gesture Recognizer
Implementing the Pinch Recognizer
Avoiding Image Clipping
Adding the QuartzCore Framework to the Project
Testing the Application
Basic iOS 6 iPad Animation using Core Animation
UIView Core Animation Blocks
Understanding Animation Curves
Receiving Notification of Animation Completion
Performing Affine Transformations
Combining Transformations
Creating the Animation Example Application
Implementing the Interface File
Drawing in the UIView
Detecting Screen Touches and Performing the Animation
Building and Running the Animation Application
An Overview of iPad iOS 6 Application State Preservation and Restoration
The Preservation and Restoration Process
Opting In to Preservation and Restoration
Assigning Restoration Identifiers
Default Preservation Features of UIKit
Saving and Restoring Additional State Information
Understanding the Restoration Process
Saving General Application State
An iOS 6 iPad State Preservation and Restoration Tutorial
Creating the Example Application
Trying the Application without State Preservation
Opting-in to State Preservation
Setting Restoration Identifiers
Encoding and Decoding View Controller State
Adding a Navigation Controller to the Storyboard
Adding the Third View Controller
Creating the Restoration Class
Integrating Maps into iPad iOS 6 Applications using MKMapItem
MKMapItem and MKPlacemark Classes
An Introduction to Forward and Reverse Geocoding
Creating MKPlacemark Instances
Working with MKMapItem
MKMapItem Options and Enabling Turn-by-Turn Directions
Adding Item Details to an MKMapItem
An Example iOS 6 iPad MKMapItem Application
Creating the MapItem Project
Designing the User Interface
Converting the Destination using Forward Geocoding
Launching the Map
Adding Build Libraries
Building and Running the Application
Getting iPad Location Information using the iOS 6 Core Location Framework
The Basics of Core Location
Configuring the Desired Location Accuracy
Configuring the Distance Filter
The Location Manager Delegate
Obtaining Location Information from CLLocation Objects
Longitude and Latitude
Accuracy
Altitude
Calculating Distances
Location Information and Multitasking
An Example iOS 6 iPad Location Application
Creating the Example iOS 6 iPad Location Project
Adding the Core Location Framework to the Project
Designing the User Interface
Creating the CLLocationManager Object
Implementing the Action Method
Implementing the Application Delegate Methods
Building and Running the iPad Location Application
Working with iOS 6 Maps on the iPad with MapKit and the MKMapView Class
About the MapKit Framework
Understanding Map Regions
About the iPad MKMapView Tutorial
Creating the iPad Map Tutorial
Adding the MapKit Framework to the Xcode Project
Creating the MKMapView Instance and Toolbar
Configuring the Map View
Changing the MapView Region
Changing the Map Type
Testing the iPad MapView Application
Updating the Map View based on User Movement
Adding Basic Annotations to a Map View
Using iOS 6 Event Kit to Create iPad Date and Location Based Reminders
An Overview of the Event Kit Framework
The EKEventStore Class
Accessing Calendars in the Database
Accessing Current Reminders
Creating Reminders
Creating Alarms
Creating the Example Project
Designing the User Interface for the Date/Time Based Reminder Screen
Implementing the Reminder Code
Hiding the Keyboard
Designing Location-based Reminder Screen
Creating a Location-based Reminder
Adding the Core Location and Event Kit Frameworks
Testing the Application
Integrating Twitter and Facebook into iPad iOS 6 Applications
The iOS 6 UIActivityViewController class
The Social Framework
iOS 6 Accounts Framework
Using the UIActivityViewController Class
Using the SLComposeViewController Class
An iPad iOS 6 Facebook Integration Tutorial using UIActivityViewController
Creating the Facebook Social App
Designing the User Interface
Creating Outlets and Actions
Implementing the selectImage and Delegate Methods
Hiding the Keyboard
Posting the Message to Facebook
Adding the Social Framework to the Build Phases
Running the Social Application
iPad iOS 6 Facebook and Twitter Integration using SLRequest
Using SLRequest and the Account Framework
Twitter Integration using SLRequest
Facebook Integration using SLRequest
An iOS 6 iPad Twitter Integration Tutorial using SLRequest
Creating the TwitterApp Project
Designing the User Interface
Modifying the Interface File
Accessing the Twitter API
Calling the getTimeLine Method
The Table View Delegate Methods
Adding the Account and Social Frameworks to the Build Phases
Building and Running the Application
Making Store Purchases with the iPad iOS 6 SKStoreProductViewController Class
The SKStoreProductViewController Class
Creating the Example Project
Creating the User Interface
Displaying the Store Kit Product View Controller
Implementing the Delegate Method
Adding the Store Kit Framework to the Build Phases
Testing the Application
Building In-App Purchasing into iPad iOS 6 Applications
In-App Purchase Options
Uploading App Store Hosted Content
Configuring In-App Purchase Items
Sending a Product Request
Accessing the Payment Queue
The Transaction Observer Object
Initiating the Purchase
The Transaction Process
Transaction Restoration Process
Testing In-App Purchases
Preparing an iPad iOS 6 Application for In-App Purchases
About the Example Application
Creating the App ID
Creating the Provisioning Profile
Creating the Xcode Project
Installing the Provisioning Profile
Configuring Code Signing
Configuring the Application in iTunes Connect
Creating an In-App Purchase Item
An iPad iOS 6 In-App Purchase Tutorial
The Application User Interface
Designing the Storyboard
Creating the Purchase View Controller
Completing the InAppDemoViewController Class
Completing the PurchaseViewController Class
Adding the StoreKit Framework to the Build
Testing the Application
Troubleshooting
Configuring and Creating App Store Hosted Content for iPad iOS 6 In-App Purchases
Configuring an Application for In-App Purchase Hosted Content
The Anatomy of an In-App Purchase Hosted Content Package
Creating an In-App Purchase Hosted Content Package
Archiving the Hosted Content Package
Validating the Hosted Content Package
Uploading the Hosted Content Package
<google>ADSDAQBOX</google>
Last modified on 18 November 2016, at 15:40