iOS 17 Programming for Beginners - Eighth Edition

Read it now on the O’Reilly learning platform with a 10-day free trial.

O’Reilly members get unlimited access to books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.

Book description

Embark on an exciting iOS app development journey with Swift 5.9, Xcode 15, and iOS 17. This hands-on guide equips you with the skills to create captivating apps and thrive in the competitive App Store landscape. Purchase of the print or Kindle book includes a free eBook in PDF format.

Key Features

• Dive into the latest iOS 17 features and Swift 5.9 through hands-on projects
• Develop robust apps with top design patterns used by professionals
• Expand your app's reach by effortlessly converting it for iPad, Mac, and visionOS

Book Description

In a world with nearly 2 million apps on the App Store, the demand for skilled iOS developers has never been higher. "iOS 17 Programming for Beginners, Eighth Edition" is your gateway to this lucrative and dynamic field. This hands-on guide is tailored for those who are new to iOS and takes you on a journey from learning the Swift language to crafting your own app and seeing it thrive on the App Store.

Our approach is hands-on and practical. Each chapter is designed to be a stepping stone in your development journey, providing step-by-step tutorials, real-life examples, and clear explanations of complex concepts. As you progress, you'll not only be skilled in Swift but also incorporate cutting-edge technologies into your apps. You'll learn how to publish your creations and harness the power of iOS 17 through a straightforward and easy to program example app divided into manageable parts.

By the time you've completed this book, you'll possess the skills and knowledge to not only develop and publish captivating apps but also leverage online resources to continually enhance your app development prowess.

What you will learn

• Discover the world of Xcode 15 and Swift 5.9, laying the foundation for your iOS development journey
• Implement the latest iOS 17 features through a hands-on example app, ensuring your apps remain innovative and engaging
• Build and deploy iOS apps using industry-standard design patterns and best practices.
• Implement the Model-View-Controller (MVC) design pattern to create robust and organized applications
• Expand your app's reach by effortlessly converting it for iPad, Mac, and visionOS
• Dive into UIKit, the essential framework for large-scale iOS projects

Who this book is for

This book is tailored for individuals with minimal coding experience who are new to the world of Swift and iOS app development. A basic understanding of programming concepts is recommended.

Table of contents

1. Preface
   1. Who this book is for
   2. What this book covers
   3. To get the most out of this book
   4. Get in touch
   1. Technical requirements
   2. Downloading and installing Xcode from the App Store
   3. Exploring the Xcode user interface
   4. Running your app in Simulator
      1. Understanding the Devices and Build sections
      1. Trusting the Developer App certificate on your iOS device
      1. Technical requirements
      2. Introducing Swift playgrounds
         1. Customizing fonts and colors
         2. Running playground code
         1. Representing integers
         2. Representing floating-point numbers
         3. Representing strings
         4. Representing Booleans
         5. Using common data types in the playground
         1. Using type annotation to specify a type
         2. Using type safety to check values
         1. Using arithmetic operators
         2. Using compound assignment operators
         3. Using comparison operators
         4. Using logical operators
         5. Performing string operations
         1. Technical requirements
         2. Introducing conditionals
            1. Using if statements
            2. Using switch statements
            1. Technical requirements
            2. Exploring range operators
            3. Exploring loops
               1. The for-in loop
               2. The while loop
               3. The repeat-while loop
               1. Technical requirements
               2. Exploring arrays
                  1. Creating an array
                  2. Checking the number of elements in an array
                  3. Adding a new element to an array
                  4. Accessing an array element
                  5. Assigning a new value to a specified index
                  6. Removing an element from an array
                  7. Iterating over an array
                  1. Creating a dictionary
                  2. Checking the number of elements in a dictionary
                  3. Adding a new element to a dictionary
                  4. Accessing a dictionary element
                  5. Assigning a new value to an existing key
                  6. Removing an element from a dictionary
                  7. Iterating over a dictionary
                  1. Creating a set
                  2. Checking the number of elements in a set
                  3. Adding a new element to a set
                  4. Checking whether a set contains an element
                  5. Removing an item from a set
                  6. Iterating over a set
                  7. Performing set operations
                  8. Understanding set membership and equality
                  1. Technical requirements
                  2. Exploring functions
                     1. Creating a function
                     2. Using custom argument labels
                     3. Using nested functions
                     4. Using functions as return types
                     5. Using functions as parameters
                     6. Using a guard statement to exit a function early
                     1. Simplifying closures
                     1. Technical requirements
                     2. Understanding classes
                        1. Creating a class declaration
                        2. Making an instance of the class
                        3. Making a subclass
                        4. Overriding a superclass method
                        1. Creating a structure declaration
                        2. Making an instance of the structure
                        3. Comparing value types and reference types
                        4. Deciding between classes and structures
                        1. Creating an enumeration
                        1. Technical requirements
                        2. Exploring protocols
                           1. Creating a protocol declaration
                           1. Adopting a protocol via an extension
                           2. Creating an array of different types of objects
                           1. Technical requirements
                           2. Understanding Swift concurrency
                           3. Examining an app without concurrency
                           4. Updating the app using async/await
                           5. Improving efficiency using async-let
                           6. Summary
                           1. Technical requirements
                           2. Learning useful terms in iOS development
                           3. A tour of the JRNL app
                              1. Using the Journal List screen
                              2. Using the Add New Journal Entry screen
                              3. Using the Journal Entry Detail screen
                              4. Using the Map screen
                              1. Setting the tab bar button titles and icons
                              2. Embedding view controllers in navigation controllers
                              3. Configuring Interface Builder
                              1. Technical requirements
                              2. Adding a table view to the Journal List screen
                              3. Connecting storyboard elements to the view controller
                              4. Configuring data source methods for the table view
                                 1. Setting the delegate and data source properties of the table view
                                 2. Adopting the UITableViewDataSource and UITableViewDelegate protocols
                                 1. Adding a bar button to the navigation bar
                                 2. Adding a new view controller scene
                                 3. Adding Cancel and Save buttons to the navigation bar
                                 1. Technical requirements
                                 2. Implementing the Journal Entry Detail screen
                                 3. Implementing the Map screen
                                 4. Summary
                                 1. Technical requirements
                                 2. Modifying the Journal List screen
                                    1. Adding an image view to journalCell
                                    2. Adding labels to journalCell
                                    1. Adding a custom view to the New Entry scene
                                    2. Adding a switch to the New Entry scene
                                    3. Adding a text field and a text view to the New Entry scene
                                    4. Adding an image view to the New Entry scene
                                    5. Embedding user interface elements in a stack view
                                    1. Configuring the number and size of static table view cells
                                    2. Adding user interface elements to static table view cells
                                    1. Technical requirements
                                    2. Understanding the Model-View-Controller design pattern
                                       1. Exploring view controllers
                                       1. Conforming to the UITableViewDataSource protocol
                                       2. Conforming to the UITableViewDelegate protocol
                                       3. Creating a TableViewExampleController instance
                                       1. Technical requirements
                                       2. Understanding model objects
                                       3. Creating a class to represent a journal entry
                                       4. Creating sample data
                                       5. Displaying data in a table view
                                          1. Creating a custom UITableViewCell subclass
                                          2. Connecting the outlets in journalCell
                                          3. Updating the data source methods in JournalListViewController
                                          1. Technical requirements
                                          2. Passing data from the Add New Journal Entry screen to the Journal List screen
                                             1. Creating the AddJournalEntryViewController class
                                             2. Connecting the UI elements to the AddJournalEntryViewController class
                                             3. Creating a JournalEntry instance from user input
                                             4. Updating the table view with a new journal entry
                                             1. Creating the JournalEntryDetailViewController class
                                             2. Connecting the UI elements to the JournalEntryDetailViewController class
                                             3. Displaying the details of a journal entry
                                             4. Displaying the details of a selected journal entry
                                             1. Technical requirements
                                             2. Getting your device location using the Core Location framework
                                                1. Modifying the AddJournalEntryViewController class
                                                2. Modifying the Info.plist file
                                                3. Creating the MapViewController class
                                                1. Configuring a pin to display a callout
                                                2. Going from the Map screen to the Journal Entry Detail screen
                                                1. Technical requirements
                                                2. Creating a singleton
                                                3. Modifying the JournalEntry class to be JSON-compatible
                                                4. Loading and saving JSON data
                                                5. Summary
                                                1. Technical requirements
                                                2. Creating a custom UIStackView subclass
                                                3. Adding your custom view to the Add New Journal Entry screen
                                                4. Adding your custom view to the Journal Entry Detail screen
                                                5. Summary
                                                1. Technical requirements
                                                2. Creating a new UIImagePickerController instance
                                                3. Implementing UIImagePickerControllerDelegate methods
                                                4. Getting permission to use the camera or photo library
                                                5. Summary
                                                1. Technical requirements
                                                2. Implementing a search bar for the Journal List screen
                                                3. Modifying table view data source methods
                                                4. Modifying the prepare(for:sender:) method
                                                5. Modifying the method to remove journal entries
                                                6. Summary
                                                1. Technical requirements
                                                2. Understanding collection views
                                                3. Modifying the Journal List screen to use a collection view
                                                   1. Replacing the table view with a collection view
                                                   2. Adding user interface elements to the collection view cell
                                                   3. Modifying the JournalListTableViewCell class
                                                   4. Modifying the JournalListViewController class
                                                   1. Understanding size classes
                                                   2. Modifying the JournalListViewController class
                                                   1. Technical requirements
                                                   2. Introducing SwiftData
                                                   3. Modifying the JournalEntry class
                                                   4. Implementing SwiftData components
                                                   5. Modifying the JournalListViewController class
                                                   6. Summary
                                                   1. Technical requirements
                                                   2. Creating a SwiftUI Xcode project
                                                   3. Creating the Journal List screen
                                                   4. Adding model objects and configuring navigation
                                                   5. Using MapKit for SwiftUI
                                                   6. Completing the Journal Entry Detail screen
                                                   7. Summary
                                                   1. Technical requirements
                                                   2. Introducing widgets
                                                   3. Adding a widget target to your app
                                                   4. Providing timeline entries to your widget
                                                   5. Customizing your widget’s view
                                                   6. Adding a widget to your Home and Lock screens
                                                   7. Summary
                                                   1. Technical requirements
                                                   2. Introducing visionOS
                                                   3. Adding a visionOS target to your project
                                                   4. Improving your app’s appearance in visionOS
                                                   5. Adding 3D objects to your app
                                                   6. Summary
                                                   1. Technical requirements
                                                   2. Getting an Apple Developer account
                                                   3. Exploring your Apple Developer account
                                                      1. Generating a certificate signing request
                                                      2. Creating development and distribution certificates
                                                      3. Registering an App ID
                                                      4. Registering your devices
                                                      5. Creating provisioning profiles
                                                      1. Creating icons for your app
                                                      2. Creating screenshots for your app
                                                      3. Creating an App Store listing
                                                      4. Creating an archive build
                                                      5. Completing the information in App Store Connect
                                                      1. Testing your app internally
                                                      2. Testing your app externally
                                                      Show and hide more

                                                      Product information

                                                      • Title: iOS 17 Programming for Beginners - Eighth Edition
                                                      • Author(s): Ahmad Sahar
                                                      • Release date: October 2023
                                                      • Publisher(s): Packt Publishing
                                                      • ISBN: 9781837630561