iOS 10 App Development Essentials

Learn SwiftUI and take your iOS Development to the Next Level
SwiftUI Essentials – iOS 16 Edition book is now available in Print ($39.99) and eBook ($29.99) editions. Learn more...

1. Start Here
   
   
2. Joining the Apple iOS Developer Program
   
   
3. Installing Xcode 8 and the iOS 10 SDK
   
   
4. A Guided Tour of Xcode 8
   
   
5. An Introduction to Swift Playgrounds
   
   
6. Swift Data Types, Constants and Variables
   
   
7. Swift Operators and Expressions
   
   
8. Swift Flow Control
   
   
9. The Swift Switch Statement
   
   
10. An Overview of Swift Functions and Closures
    
    
11. The Basics of Object Oriented Programming in Swift
    
    
12. An Introduction to Swift Inheritance
    
    
13. Working with Array and Dictionary Collections in Swift
    
    
14. Understanding Error Handling in Swift
    
    
15. Creating an Interactive iOS 10 App
    
    
16. An Introduction to Auto Layout in iOS 10
    
    
17. Working with iOS 10 Auto Layout Constraints in Interface Builder
    
    
18. An iOS 10 Auto Layout Example
    
    
19. Using Trait Variations to Design Adaptive iOS User Interfaces
    
    
20. Using Storyboards in Xcode 8
    
    
21. An Overview of iOS 10 Table Views and Xcode 8 Storyboards
    
    
22. Using Xcode 8 Storyboards to Build Dynamic TableViews
    
    
23. Implementing iOS 10 TableView Navigation using Storyboards in Xcode 8
    
    
24. Working with the iOS 10 Stack View Class
    
    
25. An iOS 10 Stack View Tutorial
    
    
26. An iOS 10 Split View Master-Detail Example
    
    
27. An iOS 10 Split View Master-Detail Example
    
    
28. A Guide to Multitasking in iOS 10
    
    
29. An iOS 10 Multitasking Example
    
    
30. Working with Directories in Swift 3 on iOS 10
    
    
31. Working with Files in Swift 3 on iOS 10
    
    
32. iOS 10 Directory Handling and File I/O in Swift – A Worked Example
    
    
33. Preparing an iOS 10 App to use iCloud Storage

1. Managing Files using the iOS 8 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
     
     
2. Using iCloud Storage in an iOS 8 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
   • Running the iCloud Application
   • Reviewing and Deleting iCloud Based Documents
   • Making a Local File Ubiquitous
     
     
3. Synchronizing iOS 8 Key-Value Data using iCloud
   • An Overview of iCloud Key-Value Data Storage
   • Sharing Data Between Applications
   • Data Storage Restrictions
   • Conflict Resolution
   • 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
   • Testing the Application
     
     
4. iOS 8 Data Persistence using Archiving and Swift
   • 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
     
     
5. Swift iOS 8 Database Implementation using SQLite
   • What is SQLite?
   • Structured Query Language (SQL)
   • Trying SQLite on MacOS X
   • Preparing an iOS Application Project for SQLite Integration
   • SQLite, Swift and Wrappers
   • Key FMDB Classes
   • Creating and Opening a Database
   • Creating a Database Table
   • Extracting Data from a Database Table
   • Closing a SQLite Database
     
     
6. An Example SQLite based iOS 8 Application using Swift and FMDB
   • About the Example SQLite Application
   • Creating and Preparing the SQLite Application Project
   • Checking Out the FMDB Source Code
   • 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
     
     
7. iOS 8 Databases in Swift 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
   • Generating a Managed Object Subclass
   • Setting the Attributes of a Managed Object
   • Saving a Managed Object
   • Fetching Managed Objects
   • Retrieving Managed Objects based on Criteria
   • Accessing the Data in a Retrieved Managed Object
     
     
8. An iOS 8 Swift Core Data Tutorial
   • The Core Data Example Application
   • Creating a Core Data based Application
   • Creating the Entity Description
   • Generating the Managed Object Subclass
   • Modifying the Entity Class Name
   • Designing the User Interface
   • Accessing the Managed Object Context
   • Saving Data to the Persistent Store using Core Data
   • Retrieving Data from the Persistent Store using Core Data
   • Building and Running the Example Application
     
     
9. An Introduction to CloudKit Data Storage on iOS 8
   • An Overview of CloudKit
   • CloudKit Containers
   • CloudKit Public Database
   • CloudKit Private Databases
   • Data Storage and Transfer Quotas
   • CloudKit Records
   • CloudKit Record IDs
   • CloudKit References
   • CloudKit Assets
   • Record Zones
   • CloudKit Subscriptions
   • Obtaining iCloud User Information
   • CloudKit Dashboard
     
     
10. An iOS 8 CloudKit Example
    • About the Example CloudKit Project
    • Creating the CloudKit Example Project
    • Designing the User Interface
    • Establishing Outlets and Actions
    • Accessing the Public Database
    • Hiding the Keyboard
    • Implementing the selectPhoto method
    • Saving a Record to the Cloud Database
    • Implementing the notifyUser Method
    • Testing the Record Saving Method
    • Searching for Cloud Database Records
    • Updating Cloud Database Records
    • Deleting a Cloud Record
    • Testing the Application
      
      
11. An iOS 8 CloudKit Subscription Example
    • Push Notifications and CloudKit Subscriptions
    • Registering an App to Receive Push Notifications
    • Configuring a CloudKit Subscription
    • Handling Remote Notifications
    • Implementing the didReceiveRemoteNotification Method
    • Fetching a Record From a Cloud Database
    • Implementing the didFinishLaunchingWithOptions Method
    • Testing the Application
      
      
12. An Overview of iOS 8 Multitouch, Taps and Gestures
    • The Responder Chain
    • Forwarding an Event to the Next Responder
    • Gestures
    • Taps
    • Touches
    • Touch Notification Methods
    • touchesBegan method
    • touchesMoved method
    • touchesEnded method
    • touchesCancelled method
      
      
13. An Example Swift iOS 8 Touch, Multitouch and Tap Application
    • The Example iOS 8 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
      
      
14. Detecting iOS 8 Touch Screen Gesture Motions in Swift
    • The Example iOS 8 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 Gesture Example
      
      
15. Identifying Gestures using iOS 8 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
      
      
16. An iOS 8 Swift Gesture Recognition Tutorial
    • Creating the Gesture Recognition Project
    • Designing the User Interface
    • Implementing the Action Methods
    • Testing the Gesture Recognition Application
      
      
17. Implementing TouchID Authentication in iOS 8 Apps
    • The Local Authentication Framework
    • Checking for TouchID Availability
    • Evaluating TouchID Policy
    • A TouchID Example Project
    • Checking for TouchID Availability
    • Seeking TouchID Authentication
    • Testing the Application
      
      
18. An Overview of iOS 8 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
      
      
19. A Swift iOS 8 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
      
      
20. Subclassing and Extending the iOS 8 Collection View Flow Layout in Swift
    • 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
    • Testing the Application
      
      
21. Drawing iOS 8 2D Graphics in Swift with Core Graphics
    • Introducing Core Graphics and Quartz 2D
    • The drawRect Method
    • Points, Coordinates and Pixels
    • The Graphics Context
    • Working with Colors in Quartz 2D
      
      
22. Interface Builder Live Views and iOS 8 Embedded Frameworks
    • Embedded Frameworks
    • Interface Builder Live Views
    • Creating the Example Project
    • Adding an Embedded Framework
    • Implementing the Drawing Code in the Framework
    • Making the View Designable
    • Making Variables Inspectable
      
      
23. An iOS 8 Swift Graphics Tutorial using Core Graphics and Core Image
    • The iOS Drawing Example Application
    • Creating the New Project
    • Creating the UIView Subclass
    • Locating the drawRect Method in the UIView Subclass
    • Drawing a Line
    • Drawing a Rectangle
    • Drawing an Ellipse or Circle
    • Filling a Path with a Color
    • Drawing an Arc
    • Drawing a Cubic Bézier Curve
    • Drawing a Quadratic Bézier Curve
    • Dashed Line Drawing
    • Drawing Shadows
    • Drawing Gradients
    • Drawing an Image into a Graphics Context
    • Image Filtering with the Core Image Framework
      
      
24. Basic iOS 8 Swift 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 Variables
    • Drawing in the UIView
    • Detecting Screen Touches and Performing the Animation
    • Building and Running the Animation Application
      
      
25. iOS 8 UIKit Dynamics – An Overview
    • Understanding UIKit Dynamics
    • The UIKit Dynamics Architecture
    • Dynamic Items
    • Dynamic Behaviors
    • The Reference View
    • The Dynamic Animator
    • Implementing UIKit Dynamics in an iOS 8 Application
    • Dynamic Animator Initialization
    • Configuring Gravity Behavior
    • Configuring Collision Behavior
    • Configuring Attachment Behavior
    • Configuring Snap Behavior
    • Configuring Push Behavior
    • The UIDynamicItemBehavior Class
    • Combining Behaviors to Create a Custom Behavior
      
      
26. A Swift iOS 8 UIKit Dynamics Tutorial
    • Creating the UIKit Dynamics Example Project
    • Adding the Dynamic Items
    • Creating the Dynamic Animator Instance
    • Adding Gravity to the Views
    • Implementing Collision Behavior
    • Attaching a View to an Anchor Point
    • Implementing a Spring Attachment Between two Views
      
      
27. An Introduction to iOS 8 Sprite Kit Game Programming
    • What is Sprite Kit?
    • The Key Components of a Sprite Kit Game
    • Sprite Kit View
    • Scenes
    • Nodes
    • Physics Bodies
    • Physics World
    • Actions
    • Transitions
    • Texture Atlas
    • Constraints
    • An Example Sprite Kit Game Hierarchy
    • The Sprite Kit Game Rendering Loop
    • The Sprite Kit Level Editor
      
      
28. An iOS 8 Swift Sprite Kit Level Editor Game Tutorial
    • About the Sprite Kit Demo Game
    • Creating the SpriteKitDemo Project
    • Reviewing the SpriteKit Game Template Project
    • Restricting Interface Orientation
    • Modifying the GameScene SpriteKit Scene File
    • Creating the Archery Scene
    • Transitioning to the Archery Scene
    • Adding the Texture Atlas
    • Designing the Archery Scene
    • Preparing the Archery Scene
    • Preparing the Animation Texture Atlas
    • Animating the Archer Sprite Node
    • Creating the Arrow Sprite Node
    • Shooting the Arrow
    • Adding the Ball Sprite Node
      
      
29. A Swift iOS 8 Sprite Kit Collision Handling Tutorial
    • Defining the Category Bit Masks
    • Assigning the Category Masks to the Sprite Nodes
    • Configuring the Collision and Contact Masks
    • Implementing the Contact Delegate
    • Implementing a Physics Joint Between Nodes
    • Game Over
      
      
30. An iOS 8 Sprite Kit Particle Emitter Tutorial
    • What is the Particle Emitter?
    • The Particle Emitter Editor
    • The SKEmitterNode Class
    • Using the Particle Emitter Editor
    • Particle Emitter Node Properties
    • Background
    • Particle Texture
    • Particle Birthrate
    • Particle Life Cycle
    • Particle Position Range
    • Angle
    • Particle Speed
    • Particle Acceleration
    • Particle Scale
    • Particle Rotation
    • Particle Color
    • Particle Blend Mode
    • Experimenting with the Particle Emitter Editor
    • Bursting a Ball using Particle Emitter Effects
    • Adding the Burst Particle Emitter Effect
      
      
31. Integrating iAds into an iOS 8 App using Swift
    • Preparing to Run iAds within an Application
    • iAd Advertisement Formats
    • Banner Ads
    • Interstitial Ads
    • Medium Rectangle Ads
    • Pre-Roll Video Ads
    • Creating an Example iAds Application
    • Adding the iAds Framework to the Xcode Project
    • Enabling Banner Ads
    • Adding a Medium Rectangle Ad
    • Implementing an Interstitial Ad
    • Configuring iAds Test Settings
      
      
32. Integrating Maps into iOS 8 Applications using MKMapItem and Swift
    • 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
      
      
33. An Example Swift iOS 8 MKMapItem Application
    • Creating the MapItem Project
    • Designing the User Interface
    • Converting the Destination using Forward Geocoding
    • Launching the Map
    • Building and Running the Application
      
      
34. Getting Location Information using the iOS 8 Core Location Framework in Swift
    • The Core Location Manager
    • Requesting Location Access Authorization
    • Configuring the Desired Location Accuracy
    • Configuring the Distance Filter
    • The Location Manager Delegate
    • Starting Location Updates
    • Obtaining Location Information from CLLocation Objects
    • Longitude and Latitude
    • Accuracy
    • Altitude
    • Calculating Distances
    • Location Information and Multitasking
      
      
35. A Swift Example iOS 8 Location Application
    • Creating the Example iOS 8 Location Project
    • Designing the User Interface
    • Configuring the CLLocationManager Object
    • Setting up the Usage Description Key
    • Implementing the Action Method
    • Implementing the Application Delegate Methods
    • Building and Running the Location Application
      
      
36. Working with Maps on iOS 8 with Swift, MapKit and the MKMapView Class
    • About the MapKit Framework
    • Understanding Map Regions
    • About the MKMapView Tutorial
    • Creating the Map Project
    • Adding the MapKit Framework to the Xcode Project
    • Adding the Navigation Controller
    • Creating the MKMapView Instance and Toolbar
    • Obtaining Location Information Permission
    • Setting up the Usage Description Key
    • Configuring the Map View
    • Changing the MapView Region
    • Changing the Map Type
    • Testing the MapView Application
    • Updating the Map View based on User Movement
      
      
37. Working with MapKit Local Search in iOS 8 and Swift
    • An Overview of iOS 8 Local Search
    • Adding Local Search to the MapSample Application
    • Adding the Local Search Text Field
    • Performing the Local Search
    • Testing the Application
      
      
38. Using MKDirections to get iOS 8 Map Directions and Routes
    • An Overview of MKDirections
    • Adding Directions and Routes to the MapSample Application
    • Adding the New Classes to the Project
    • Configuring the Results Table View
    • Implementing the Result Table View Segue
    • Adding the Route Scene
    • Getting the Route and Directions
    • Establishing the Route Segue
    • Testing the Application
      
      
39. An Introduction to Extensions in iOS 8
    • iOS Extensions – An Overview
    • Extension Types
    • Today Extension
    • Share Extension
    • Action Extension
    • Photo Editing Extension
    • Document Provider Extension
    • Custom Keyboard Extension
    • Creating Extensions
      
      
40. An iOS 8 Today Extension Widget Tutorial
    • About the Example Extension Widget
    • Creating the Example Project
    • Adding the Extension to the Project
    • Reviewing the Extension Files
    • Designing the Widget User Interface
    • Setting the Preferred Content Size in Code
    • Modifying the Widget View Controller
    • Testing the Extension
    • Opening the Containing App from the Extension
      
      
41. Creating an iOS 8 Photo Editing Extension
    • Creating a Photo Editing Extension
    • Accessing the Photo Editing Extension
    • Configuring the Info.plist File
    • Designing the User Interface
    • The PHContentEditingController Protocol
    • Photo Extensions and Adjustment Data
    • Receiving the Content
    • Implementing the Filter Actions
    • Returning the Image to the Photos App
    • Testing the Application
      
      
42. Creating an iOS 8 Action Extension
    • An Overview of Action Extensions
    • About the Action Extension Example
    • Creating the Action Extension Project
    • Adding the Action Extension Target
    • Configuring the Action Extension
    • Designing the Action Extension User Interface
    • Receiving the Content
    • Returning the Modified Data to the Host App
    • Testing the Extension
      
      
43. Receiving Data from an iOS 8 Action Extension
    • Creating the Example Project
    • Designing the User Interface
    • Importing the Mobile Core Services Framework
    • Adding a Share Button to the Application
    • Receiving Data from an Extension
    • Testing the Application
      
      
44. Using iOS 8 Event Kit and Swift to Create Date and Location Based Reminders
    • An Overview of the Event Kit Framework
    • The EKEventStore Class
    • Accessing Calendars in the Database
    • 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 the Location-based Reminder Screen
    • Creating a Location-based Reminder
    • Setting up the Usage Description Key
    • Testing the Application
      
      
45. Accessing the iOS 8 Camera and Photo Library in Swift
    • The UIImagePickerController Class
    • Creating and Configuring a UIImagePickerController Instance
    • Configuring the UIImagePickerController Delegate
    • Detecting Device Capabilities
    • Saving Movies and Images
      
      
46. An Example Swift iOS 8 iPhone Camera Application
    • An Overview of the Application
    • Creating the Camera Project
    • Designing the User Interface
    • Implementing the Action Methods
    • Writing the Delegate Methods
    • Building and Running the Application
      
      
47. iOS 8 Video Playback using AVPlayer and AVPlayerViewController
    • The AVPlayer and AVPlayerViewController Classes
    • The iOS Movie Player Example Application
    • Adding the AVKit Framework to the Xcode Project
    • Designing the User Interface
    • Initializing Video Playback
    • Build and Run the Application
    • Creating AVPlayerViewController Instance from Code
      
      
48. Playing Audio on iOS 8 using AVAudioPlayer
    • Supported Audio Formats
    • Receiving Playback Notifications
    • Controlling and Monitoring Playback
    • Creating the Audio Example Application
    • Adding an Audio File to the Project Resources
    • Designing the User Interface
    • Implementing the Action Methods
    • Creating and Initializing the AVAudioPlayer Object
    • Implementing the AVAudioPlayerDelegate Protocol Methods
    • Building and Running the Application
      
      
49. Recording Audio on iOS 8 with AVAudioRecorder in Swift
    • An Overview of the AVAudioRecorder Tutorial
    • Creating the Recorder Project
    • Designing the User Interface
    • Creating the AVAudioRecorder Instance
    • Implementing the Action Methods
    • Implementing the Delegate Methods
    • Testing the Application
      
      
50. Integrating Twitter and Facebook into iOS 8 Applications using Swift
    • The UIActivityViewController class
    • The Social Framework
    • Accounts Framework
    • Using the UIActivityViewController Class
    • Using the SLComposeViewController Class
      
      
51. An iOS 8 Swift 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
    • Running the Social Application
      
      
52. iOS 8 Facebook and Twitter Integration using SLRequest and Swift
    • Using SLRequest and the Account Framework
    • Twitter Integration using SLRequest
    • Facebook Integration using SLRequest
      
      
53. An Swift iOS 8 Twitter Integration Tutorial using SLRequest
    • Creating the TwitterApp Project
    • Designing the User Interface
    • Modifying the View Controller Class
    • Accessing the Twitter API
    • Calling the getTimeLine Method
    • The Table View Delegate Methods
    • Building and Running the Application
      
      
54. Making Store Purchases in Swift with the SKStoreProductViewController Class
    • The SKStoreProductViewController Class
    • Creating the Example Project
    • Creating the User Interface
    • Displaying the Store Kit Product View Controller
    • Implementing the Delegate Method
    • Testing the Application
      
      
55. Building In-App Purchasing into iOS 8 Swift 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
      
      
56. Preparing an iOS 8 Application for In-App Purchases
    • About the Example Application
    • Creating the Xcode Project
    • Registering and Enabling the App ID for In App Purchasing
    • Configuring the Application in iTunes Connect
    • Creating an In-App Purchase Item
      
      
57. An iOS 8 Swift In-App Purchase Tutorial
    • The Application User Interface
    • Designing the Storyboard
    • Creating the Purchase View Controller Class
    • Storing the Home View Controller in the App Delegate Class
    • Completing the ViewController Class
    • Completing the PurchaseViewController Class
    • Testing the Application
    • Troubleshooting
      
      
58. Configuring and Creating App Store Hosted Content for iOS 8 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
      
      

Learn SwiftUI and take your iOS Development to the Next Level
SwiftUI Essentials – iOS 16 Edition book is now available in Print ($39.99) and eBook ($29.99) editions. Learn more...