Examples and Projects - SwiftUI for Masterminds 5th Edition

HOME BOOKS QUICK GUIDES VIDEO COURSES APPLICATIONS

NEWSLETTER CONTACT

SwiftUI for Masterminds

How to take advantage of SwiftUI to create insanely great apps for iPhones, iPads, and Macs

5th Edition
October 2024
ISBN: 979-8-3399-9432-9

Examples and Projects

Although writing down the examples can help you remember what you are learning, sometimes it can be time consuming. To speed up the process, you can download the codes in TXT files, all Xcode projects, or open the codes you want to see from the links below.

Download TXT Files
425.0 KBytes

Download Projects
1.15 GBytes

CHAPTER 1 - APP DEVELOPMENT

There are no Examples in this Chapter

CHAPTER 2 - INTRODUCTION TO SWIFT

Listing 2-1: Playground template

Listing 2-2: Declaring variables

Listing 2-3: Initializing variables

Listing 2-4: Declaring and initializing variables in the same statement

Listing 2-5: Assigning a new value to a variable

Listing 2-6: Declaring variables of different data types

Listing 2-7: Declaring variables without specifying the data type

Listing 2-8: Assigning variables to variables

Listing 2-9: Assigning the result of an operation to a variable

Listing 2-10: Performing operations in variables of different type

Listing 2-11: Inferring the data type from an operation

Listing 2-12: Calculating the remainder

Listing 2-13: Adding numbers to variables

Listing 2-14: Performing operations on the variable’s current value

Listing 2-15: Modifying the value of a variable using incremental operators

Listing 2-16: Declaring and initializing a constant

Listing 2-17: Declaring and initializing a Character variable

Listing 2-18: Declaring and initializing a String variable

Listing 2-19: Concatenating strings

Listing 2-20: Concatenating strings with the + and += operators

Listing 2-21: Including variables in strings

Listing 2-22: Performing operations within strings

Listing 2-23: Including special characters in a string

Listing 2-24: Generating multiple lines of text

Listing 2-25: Declaring a Boolean variable

Listing 2-26: Declaring an optional variable of type Int

Listing 2-27: Assigning new values to optional variables

Listing 2-28: Using nil to empty an optional variable

Listing 2-29: Unwrapping an optional variable

Listing 2-30: Assigning an optional to another optional

Listing 2-31: Declaring Implicitly Unwrapped Optionals

Listing 2-32: Declaring a tuple with two values

Listing 2-33: Declaring a tuple with values of different type

Listing 2-34: Reading the values of a tuple

Listing 2-35: Modifying the value of a tuple

Listing 2-36: Declaring names for the values of a tuple

Listing 2-37: Creating multiple variables from the values of a tuple

Listing 2-38: Ignoring some of the values of a tuple

Listing 2-39: Comparing two values with if

Listing 2-40: Comparing two values with the <= operator

Listing 2-41: Conditions with Boolean values

Listing 2-42: Using logical operators

Listing 2-43: Using logical operators to check multiple conditions

Listing 2-44: Checking whether an optional contains a value or not

Listing 2-45: Using Optional Binding to unwrap an optional variable

Listing 2-46: Using the same name to unwrap a value

Listing 2-47: Unwrapping an optional value of the same name

Listing 2-48: Checking multiple conditions with Optional Binding

Listing 2-49: Using if else to respond to both states of the condition

Listing 2-50: Concatenating if else instructions

Listing 2-51: Implementing if else as an expression

Listing 2-52: Implementing a ternary operator

Listing 2-53: Unwrapping an optional with a ternary operator

Listing 2-54: Unwrapping an optional with the nil-coalescing operator

Listing 2-55: Checking conditions with switch

Listing 2-56: Checking multiple conditions per case

Listing 2-57: Matching a tuple in a switch statement

Listing 2-58: Matching only the second value of a tuple

Listing 2-59: Capturing values with constants

Listing 2-60: Comparing values with where

Listing 2-61: Implementing the switch statement as an expression

Listing 2-62: Using while to create a loop

Listing 2-63: Using repeat while to create a loop

Listing 2-64: Using for in to iterate over the characters of a string

Listing 2-65: Iterating over a string without reading the characters

Listing 2-66: Adding a condition to a loop

Listing 2-67: Jumping to the next cycle of the loop

Listing 2-68: Interrupting the loop

Listing 2-69: Ignoring values in a switch statement

Listing 2-70: Interrupting a loop with guard

CHAPTER 3 - SWIFT PARADIGM

Listing 3-1: Declaring and calling functions

Listing 3-2: Calling functions from a loop

Listing 3-3: Sending values to a function

Listing 3-4: Sending multiple values to a function

Listing 3-5: Sending different values to a function

Listing 3-6: Returning a value from a function

Listing 3-7: Returning a tuple

Listing 3-8: Interrupting the execution of a function with guard

Listing 3-9: Removing the return keyword

Listing 3-10: Modifying external variables from a function

Listing 3-11: Declaring argument labels

Listing 3-12: Removing argument labels

Listing 3-13: Declaring default values for parameters

Listing 3-14: Declaring different functions with the same name

Listing 3-15: Defining generic functions

Listing 3-16: Printing values on the console with print()

Listing 3-17: Creating collections of values

Listing 3-18: Using variables and constants of different scopes

Listing 3-19: Assigning closures to variables

Listing 3-20: Initializing a variable with the value returned by a closure

Listing 3-21: Simplifying a closure

Listing 3-22: Sending a closure to a function

Listing 3-23: Assigning the closure to the function's argument

Listing 3-24: Using Trailing Closures

Listing 3-25: Inferring the closure's data types

Listing 3-26: Defining a structure

Listing 3-27: Declaring a variable of type Item

Listing 3-28: Assigning new values to the properties of a structure

Listing 3-29: Structures inside structures

Listing 3-30: Accessing optional properties

Listing 3-31: Creating key paths

Listing 3-32: Using read and write key paths

Listing 3-33: Defining methods

Listing 3-34: Assigning new values to properties from the methods in the structure

Listing 3-35: Initializing properties

Listing 3-36: Using memberwise initializers to provide the initial values of a structure

Listing 3-37: Initializing properties from the init() method

Listing 3-38: Declaring the parameters to initialize the structure

Listing 3-39: Declaring multiple init() methods

Listing 3-40: Declaring computed properties

Listing 3-41: Defining read-only properties

Listing 3-42: Adding the set() method to set a new value

Listing 3-43: Using a different name for the parameter of the set() method

Listing 3-44: Adding observers to a store property

Listing 3-45: Defining type properties

Listing 3-46: Defining type methods

Listing 3-47: Defining generic structures

Listing 3-48: Using generic structures

Listing 3-49: Initializing variables with standard initializers

Listing 3-50: Casting a variable

Listing 3-51: Extracting numbers from strings

Listing 3-52: Checking the maximum possible value for the Int8 type

Listing 3-53: Rounding floating-point values

Listing 3-54: Modifying the value of a Bool variable

Listing 3-55: Using for in to iterate over a range

Listing 3-56: Inverting a range

Listing 3-57: Using range operators in a switch statement

Listing 3-58: Calculating random numbers

Listing 3-59: Converting a number into a string

Listing 3-60: Processing the characters of a string

Listing 3-61: Calculating a specific index

Listing 3-62: Getting the next index

Listing 3-63: Inserting a character in a string

Listing 3-64: Removing a character

Listing 3-65: Getting a range of characters

Listing 3-66: Working with ranges of characters

Listing 3-67: Implementing String methods

Listing 3-68: Declaring arrays

Listing 3-69: Declaring arrays with type inference

Listing 3-70: Reading the array’s elements

Listing 3-71: Assigning a new value to an element

Listing 3-72: Adding new elements to an array

Listing 3-73: Concatenating two arrays

Listing 3-74: Creating multidimensional arrays

Listing 3-75: Reading values from a multidimensional array

Listing 3-76: Removing the elements of an array

Listing 3-77: Reading an array with a for in loop

Listing 3-78: Reading indexes and values of an array

Listing 3-79: Checking whether an array contains a value in a specific index

Listing 3-80: Adding and removing elements

Listing 3-81: Removing all the elements that meet a condition

Listing 3-82: Finding if an element meets a condition

Listing 3-83: Selecting a random value from an array

Listing 3-84: Changing the order of the elements of an array

Listing 3-85: Reading a range of elements

Listing 3-86: Casting arrays of type ArraySlice

Listing 3-87: Removing and replacing elements

Listing 3-88: Initializing an array with elements of the same value

Listing 3-89: Filtering the values of an array

Listing 3-90: Mapping an array

Listing 3-91: Converting the elements of an array into strings

Listing 3-92: Using a structure initializer with the map() method

Listing 3-93: Reducing an array

Listing 3-94: Reversing the elements of an array

Listing 3-95: Sorting the elements of an array

Listing 3-96: Sorting the elements of an array in a custom order

Listing 3-97: Sorting an array of integers

Listing 3-98: Sorting strings according to the number of characters

Listing 3-99: Getting the largest element

Listing 3-100: Getting the first value of an array

Listing 3-101: Getting the index of a specific value

Listing 3-102: Getting the index of a value that meets a condition

Listing 3-103: Working with a range of indexes

Listing 3-104: Creating an empty set of integers

Listing 3-105: Creating a set of integers

Listing 3-106: Using contains() to find an element in a set

Listing 3-107: Inserting a new element in a set

Listing 3-108: Removing an element from a set

Listing 3-109: Sorting the elements of a set

Listing 3-110: Combining sets

Listing 3-111: Comparing sets

Listing 3-112: Declaring a dictionary with initial values

Listing 3-113: Declaring a dictionary with type inference

Listing 3-114: Assigning a new value to an element of a dictionary

Listing 3-115: Adding a new element to a dictionary

Listing 3-116: Reading an element that does not exist

Listing 3-117: Reading the value of an element in a dictionary

Listing 3-118: Removing an element from a dictionary

Listing 3-119: Using for in to iterate over a dictionary

Listing 3-120: Combining dictionaries with arrays

Listing 3-121: Reading arrays inside dictionaries

Listing 3-122: Grouping values by a key

Listing 3-123: Adding and removing elements from a dictionary

Listing 3-124: Sorting the values of a dictionary

Listing 3-125: Iterating over the dictionary’s keys

Listing 3-126: Reading the keys of a dictionary

Listing 3-127: Defining an enumeration type

Listing 3-128: Declaring the enumeration values in one statement

Listing 3-129: Initializing an instance of an enumeration

Listing 3-130: Assigning a new value to a variable of type Number

Listing 3-131: Using switch with an enumeration type

Listing 3-132: Assigning raw values to enumeration values

Listing 3-133: Reading raw values

Listing 3-134: Creating an enumeration from a raw value

Listing 3-135: Adding methods to an enumeration

Listing 3-136: Associating values

Listing 3-137: Reading associated values from an if statement

Listing 3-138: Defining a class

Listing 3-139: Creating an object from a class

Listing 3-140: Modifying properties from the object’s methods

Listing 3-141: Declaring a type method for a class

Listing 3-142: Referencing the object with self

Listing 3-143: Referring to the data type with self

Listing 3-144: Referencing one object from another

Listing 3-145: Assigning weak references

Listing 3-146: Defining a basic class

Listing 3-147: Inheriting properties and methods from another class

Listing 3-148: Creating objects from a subclass

Listing 3-149: Overriding an inherited method

Listing 3-150: Calling a method on the superclass

Listing 3-151: Creating an array of objects from different subclasses

Listing 3-152: Identifying the object’s data type

Listing 3-153: Casting an object

Listing 3-154: Casting an object with the as? operator

Listing 3-155: Casting an object on the fly

Listing 3-156: Working with objects of AnyObject type

Listing 3-157: Declaring a Designated Initializer

Listing 3-158: Declaring a Convenience Initializer

Listing 3-159: Inheriting the Designated Initializer

Listing 3-160: Declaring a Designated Initializer for the subclass

Listing 3-161: Declaring a deinitializer

Listing 3-162: Defining lazy properties

Listing 3-163: Declaring private properties

Listing 3-164: Declaring a public getter and private setter

Listing 3-165: Defining a singleton

Listing 3-166: Defining protocols

Listing 3-167: Defining multiple structures that conform to the same protocol

Listing 3-168: Using protocols as data types

Listing 3-169: Accessing the instance's own properties

Listing 3-170: Returning values of a protocol type

Listing 3-171: Defining generic protocols

Listing 3-172: Conforming to the Equatable protocol

Listing 3-173: Letting the compiler create the protocol methods for us

Listing 3-174: Adding a type constraint to a generic function

Listing 3-175: Using the Numeric protocol to set a type constraint

Listing 3-176: Conforming to the Comparable protocol

Listing 3-177: Conforming to the Hashable protocol

Listing 3-178: Defining our own hash value

Listing 3-179: Conforming to the CaseIterable protocol

Listing 3-180: Extending a protocol

Listing 3-181: Extending data types

Listing 3-182: Extending custom data types

Listing 3-183: Defining a conditional extension

Listing 3-184: Customizing string interpolation

Listing 3-185: Delegating tasks

Listing 3-186: Delegating with protocols

Listing 3-187: Using different delegates

Listing 3-188: Getting an error inside a method

Listing 3-189: Throwing errors

Listing 3-190: Handling errors

Listing 3-191: Getting information about the error

Listing 3-192: Catching errors with try?

Listing 3-193: Ignoring the errors

Listing 3-194: Returning an error with a Result enumeration

Listing 3-195: Processing an error with the get() method

Listing 3-196: Defining a property wrapper

Listing 3-197: Using a property wrapper

Listing 3-198: Implementing Freestanding macros

CHAPTER 4 - INTRODUCTION TO FRAMEWORKS

Listing 4-1: Applying math functions

Listing 4-2: Creating an NSString object

Listing 4-3: Casting a String value into an NSString object

Listing 4-4: Creating a formatted string

Listing 4-5: Formatting numbers

Listing 4-6: Comparing String values

Listing 4-7: Comparing String values with options

Listing 4-8: Comparing only a range of characters

Listing 4-9: Searching and replacing characters in a string

Listing 4-10: Getting the components of a string

Listing 4-11: Creating and reading an NSRange value

Listing 4-12: Converting a range of string indexes

Listing 4-13: Working with NSNumber objects

Listing 4-14: Formatting a number

Listing 4-15: Rounding a number

Listing 4-16: Disabling grouping

Listing 4-17: Adding the sign

Listing 4-18: Formatting the number as a percentage value

Listing 4-19: Formatting currency values

Listing 4-20: Storing dates with Date structures

Listing 4-21: Comparing two dates

Listing 4-22: Extracting components from a date

Listing 4-23: Extracting multiple components from a date

Listing 4-24: Creating a new date from single components

Listing 4-25: Using a Gregorian calendar

Listing 4-26: Adding components to a date

Listing 4-27: Comparing dates

Listing 4-28: Finding a date in an interval

Listing 4-29: Formatting dates

Listing 4-30: Specifying a custom format

Listing 4-31: Including multiple date components

Listing 4-32: Specifying a different locale

Listing 4-33: Working with different time zones

Listing 4-34: Initializing Measurement structures

Listing 4-35: Adding the values of two Measurement structures

Listing 4-36: Adding two values of different units

Listing 4-37: Converting units

Listing 4-38: Formatting a measurement

Listing 4-39: Formatting a measurement for a specific purpose

Listing 4-40: Formatting the measurement value

Listing 4-41: Formatting a measurement for a specific locale

Listing 4-42: Creating a non-repeating timer

Listing 4-43: Creating a repeating timer

Listing 4-44: Using regular expressions

Listing 4-45: Capturing values with subexpressions

Listing 4-46: Capturing multiple values

Listing 4-47: Processing multiple lines of text with a regular expression

Listing 4-48: Replacing the characters that match a regular expression

Listing 4-49: Initializing Core Graphics' structures

Listing 4-50: Using the CGRect convenience initializer

Listing 4-51: Accessing the structures inside a CGRect structure

Listing 4-52: Assigning empty structures to a CGRect variable

Listing 4-53: Calculating the coordinate at the center of the rectangle

CHAPTER 5 - SWIFTUI FRAMEWORK

Listing 5-1: Initializing the app

Listing 5-2: Defining a structure that conforms to the View protocol

Listing 5-3: Defining the preview for the canvas

Listing 5-4: Generating multiple previews

Listing 5-5: Returning values of complex data types

Listing 5-6: Returning opaque types

Listing 5-7: Displaying values with a Text view

Listing 5-8: Formatting a value for a Text view

Listing 5-9: Displaying a date with a Text view

Listing 5-10: Displaying a timer with a Text view

Listing 5-11: Applying modifiers to a view

Listing 5-12: Assigning a fixed size to a view

Listing 5-13: Creating flexible containers

Listing 5-14: Adding padding to a view

Listing 5-15: Assigning a specific padding for each side

Listing 5-16: Assigning padding with Edge values

Listing 5-17: Assigning dynamic font types

Listing 5-18: Using the system font

Listing 5-19: Using standard fonts

Listing 5-20: Using custom fonts

Listing 5-21: Applying multiple styles to a text

Listing 5-22: Nesting Text views

Listing 5-23: Styling the font

Listing 5-24: Formatting text

Listing 5-25: Truncating text

Listing 5-26: Implementing Color views

Listing 5-27: Defining the color with RGB values

Listing 5-28: Assigning a dynamic color

Listing 5-29: Assigning a custom color

Listing 5-30: Assigning a color to the text of a Text view

Listing 5-31: Assigning a background color to a Text view

Listing 5-32: Assigning a background color to a view with a padding

Listing 5-33: Assigning a border to the view

Listing 5-34: Displaying a view in front of another view

Listing 5-35: Applying a predefined gradient to a view

Listing 5-36: Blending colors

Listing 5-37: Applying a material

Listing 5-38: Applying a material to the view's content

Listing 5-39: Displaying an image

Listing 5-40: Loading an image from the ImageResource structure

Listing 5-41: Clipping the image

Listing 5-42: Resizing the image

Listing 5-43: Resizing an image to fit the view

Listing 5-44: Resizing the image to fit within the view with the scaledToFit() modifier

Listing 5-45: Resizing and clipping the image to fill the view

Listing 5-46: Resizing image to fill the container

Listing 5-47: Applying style modifiers to an Image view

Listing 5-48: Applying visual effects to an Image view

Listing 5-49: Scaling an image to the selected font size

Listing 5-50: Displaying SF symbols

Listing 5-51: Styling a symbol

Listing 5-52: Storing the font in a constant

Listing 5-53: Assigning a variant to a symbol

Listing 5-54: Displaying multicolor symbols

Listing 5-55: Displaying a multicolor symbol with custom colors

Listing 5-56: Displaying a variable SF Symbol

Listing 5-57: Displaying a text with an SF Symbol

Listing 5-58: Performing a task when the view appears

Listing 5-59: Applying custom modifiers

Listing 5-60: Customizing a custom modifier

Listing 5-61: Creating a vertical stack of views

Listing 5-62: Aligning views in a vertical stack

Listing 5-63: Adding a space between the views

Listing 5-64: Creating a horizontal stack of views

Listing 5-65: Creating a ZStack

Listing 5-66: Setting the Z index of a view

Listing 5-67: Assigning modifiers to the stack and its content

Listing 5-68: Nesting stacks

Listing 5-69: Aligning the views with a flexible space

Listing 5-70: Aligning the views to the left and the top

Listing 5-71: Ignoring the safe area

Listing 5-72: Ignoring only the container safe area at the bottom

Listing 5-73: Expanding the safe area

Listing 5-74: Arranging the views with priorities by default

Listing 5-75: Assigning a higher priority to a view

Listing 5-76: Defining a view with a fixed size

Listing 5-77: Aligning images to the center with standard values

Listing 5-78: Aligning an image to the center with custom values

Listing 5-79: Aligning all images to the center with custom values

Listing 5-80: Defining custom alignment guides

Listing 5-81: Aligning views with custom alignment guides

Listing 5-82: Arranging the views in groups

Listing 5-83: Assigning different views to the body property

Listing 5-84: Defining a grid layout

Listing 5-85: Defining a multicolumn cell

Listing 5-86: Embedding a grid within another grid

Listing 5-87: Extracting views

Listing 5-88: Defining a custom layout

Listing 5-89: Selecting a layout

Listing 5-90: Wrapping views in an AnyView view

Listing 5-91: Constructing views with the @ViewBuilder property wrapper

Listing 5-92: Returning an empty view

Listing 5-93: Responding to updates in the states of the environment

Listing 5-94: Activating dark mode

Listing 5-95: Adding custom properties to the environment

CHAPTER 6 - DECLARATIVE USER INTERFACE

Listing 6-1: Defining a state

Listing 6-2: Defining multiple states

Listing 6-3: Defining bidirectional binding

Listing 6-4: Using @Binding properties

Listing 6-5: Accessing the properties of a State structure

Listing 6-6: Initializing @State properties

Listing 6-7: Accessing the values of a @Binding property

Listing 6-8: Creating a Binding structure

Listing 6-9: Creating a Binding structure with an immutable value

Listing 6-10: Defining a state property for a preview

Listing 6-11: Implementing Button views

Listing 6-12: Using functions to organize the code

Listing 6-13: Referencing a method

Listing 6-14: Adding and removing views from the interface

Listing 6-15: Disabling a button

Listing 6-16: Defining the label of a button with an Image view

Listing 6-17: Styling buttons

Listing 6-18: Assigning a role

Listing 6-19: Scaling buttons

Listing 6-20: Defining custom styles for the button

Listing 6-21: Configuring a text field

Listing 6-22: Responding to the Done button

Listing 6-23: Responding to changes in focus

Listing 6-24: Closing the keyboard

Listing 6-25: Checking the values before storing

Listing 6-26: Disabling the button

Listing 6-27: Controlling user's input

Listing 6-28: Accepting only integer numbers

Listing 6-29: Defining a multiline text field

Listing 6-30: Selecting text

Listing 6-31: Using a secure text field

Listing 6-32: Implementing a text editor

Listing 6-33: Implementing a Toggle

Listing 6-34: Including a subtitle

Listing 6-35: Defining a custom label for the Toggle view

Listing 6-36: Implementing a toggle button

Listing 6-37: Defining a custom Toggle view

Listing 6-38: Creating a slider

Listing 6-39: Responding to the slider state

Listing 6-40: Showing progress

Listing 6-41: Simulating progress

Listing 6-42: Showing an activity indicator

Listing 6-43: Creating a stepper

Listing 6-44: Defining the steps of a stepper

Listing 6-45: Modifying the interface when the value is incremented or decremented

Listing 6-46: Defining a group of views

Listing 6-47: Storing our data in an observable object

Listing 6-48: Initializing the observable object

Listing 6-49: Creating a bidirectional binding with the observable object

Listing 6-50: Defining an observable object for a view

Listing 6-51: Initializing the view's observable object

Listing 6-52: Initializing the view's observable object when the view appears

Listing 6-53: Disabling observation for a property in an observable object

Listing 6-54: Updating the views manually

Listing 6-55: Assigning the observable object to the view's environment

Listing 6-56: Getting a reference to the observable object from the environment

Listing 6-57: Turning the environment property into a bindable property

CHAPTER 7 - LISTS

Listing 7-1: Creating a list of views dynamically

Listing 7-2: Creating a list with a standard design

Listing 7-3: Defining a model to work with lists of views

Listing 7-4: Injecting the model into the environment

Listing 7-5: Creating a list of views with data from the model

Listing 7-6: Creating a scrollable list of views

Listing 7-7: Configuring the scroll view

Listing 7-8: Scrolling the list of views horizontally

Listing 7-9: Adapting the size of the views to the container

Listing 7-10: Scrolling the content page by page

Listing 7-11: Scrolling two views at a time

Listing 7-12: Defining each view as a scroll target

Listing 7-13: Scrolling the content programmatically

Listing 7-14: Applying a visual effect to the transition

Listing 7-15: Applying multiple visual effects to the transition

Listing 7-16: Scrolling the list programmatically

Listing 7-17: Performing an action when a view becomes visible

Listing 7-18: Responding to the current state of the ScrollView view

Listing 7-19: Creating a grid with a fixed number of items

Listing 7-20: Defining flexible items

Listing 7-21: Defining adaptive items

Listing 7-22: Creating a list of views with the List view

Listing 7-23: Creating a plain list

Listing 7-24: Customizing the rows

Listing 7-25: Assigning alternate backgrounds

Listing 7-26: Mixing static and dynamic content in a list

Listing 7-27: Dividing the content into sections

Listing 7-28: Configuring the section separators

Listing 7-29: Configuring the list from the environment

Listing 7-30: Providing an ordered list of values

Listing 7-31: Deleting rows

Listing 7-32: Activating the edit mode

Listing 7-33: Moving rows

Listing 7-34: Selecting a row

Listing 7-35: Selecting multiple rows

Listing 7-36: Customizing the edit mode

Listing 7-37: Customizing the selection

Listing 7-38: Storing the selection in the model

Listing 7-39: Defining custom swipe actions

Listing 7-40: Implementing a custom button to delete the rows

Listing 7-41: Refreshing the list

Listing 7-42: Defining the model to create a hierarchical list

Listing 7-43: Displaying a hierarchical list

Listing 7-44: Implementing an OutlineGroup view

Listing 7-45: Defining a model to test tables

Listing 7-46: Creating a table with multiple columns

Listing 7-47: Defining the rows manually

Listing 7-48: Sorting the values by column

Listing 7-49: Allowing the user to select items in a table

Listing 7-50: Using a context menu to process a row

Listing 7-51: Defining the content of a column with a Toggle view

Listing 7-52: Defining a custom sort comparator

Listing 7-53: Sorting Boolean values on a table

Listing 7-54: Defining a model with hierarchical data

Listing 7-55: Disclosing hierarchical data

Listing 7-56: Defining a picker

Listing 7-57: Selecting an initial value

Listing 7-58: Listing values by index

Listing 7-59: Implementing a segmented picker

Listing 7-60: Defining a DatePicker to select a date

Listing 7-61: Limiting the DatePicker to a range of values

Listing 7-62: Presenting a picker with a spinning wheel

Listing 7-63: Picking multiple dates

Listing 7-64: Defining a form

Listing 7-65: Defining a custom label for a form

Listing 7-66: Styling a form

Listing 7-67: Disclosing controls

Listing 7-68: Defining a custom container

Listing 7-69: Implementing a custom container

Listing 7-70: Applying different styles to the views in a custom container

Listing 7-71: Adding a container value

Listing 7-72: Modifying a container value

Listing 7-73: Using container values

Listing 7-74: Changing the container value of a view

CHAPTER 8 - NAVIGATION

Listing 8-1: Initiating a navigation stack

Listing 8-2: Setting the title mode

Listing 8-3: Adding a button to the navigation bar

Listing 8-4: Adding multiple buttons

Listing 8-5: Adding buttons to the bottom toolbar

Listing 8-6: Defining the buttons intent

Listing 8-7: Customizing the bar

Listing 8-8: Creating a popup menu

Listing 8-9: Filtering the data in the model

Listing 8-10: Displaying a search bar

Listing 8-11: Keeping the search bar on the screen

Listing 8-12: Changing the focus state of the search field

Listing 8-13: Performing the search when the Return/Done key is pressed

Listing 8-14: Suggesting terms to the user

Listing 8-15: Cancelling the search programmatically

Listing 8-16: Adding scope buttons

Listing 8-17: Searching by title and author

Listing 8-18: Adding tokens

Listing 8-19: Filtering books by author

Listing 8-20: Including a navigation link

Listing 8-21: Defining a second view

Listing 8-22: Dismissing the view from the environment

Listing 8-23: Selecting rows with a navigation link

Listing 8-24: Defining a Detail view

Listing 8-25: Defining custom navigation

Listing 8-26: Adding and removing views from the path

Listing 8-27: Removing a view from the path

Listing 8-28: Controlling the navigation path from the model

Listing 8-29: Controlling the navigation path from the initial view

Listing 8-30: Adding views to the navigation path programmatically

Listing 8-31: Returning to different views

Listing 8-32: Opening a view with a zoom transition

Listing 8-33: Displaying a sheet

Listing 8-34: Defining the view for the sheet

Listing 8-35: Disabling the interactive feature to dismiss the sheet

Listing 8-36: Assigning a predefined height

Listing 8-37: Assigning a custom height

Listing 8-38: Declaring the size of the sheet

Listing 8-39: Presenting a sheet for every value on the list

Listing 8-40: Editing a book

Listing 8-41: Presenting the inspector

Listing 8-42: Defining the size of the inspector

Listing 8-43: Showing a popover

Listing 8-44: Defining the content of the popover

Listing 8-45: Displaying an alert view

Listing 8-46: Defining an Alert view with multiple buttons

Listing 8-47: Defining an action sheet

Listing 8-48: Defining a tip

Listing 8-49: Presenting a tip

Listing 8-50: Presenting a tip in a popover

Listing 8-51: Showing the tips for testing

Listing 8-52: Invalidating a tip

Listing 8-53: Showing the tip only once

Listing 8-54: Adding actions to a tip

Listing 8-55: Performing an action

Listing 8-56: Defining a TabView view with two tabs

Listing 8-57: Displaying a badge on a tab

Listing 8-58: Selecting the Settings view

Listing 8-59: Adding a search tab

Listing 8-60: Configuring the TabView view to show content in pages

Listing 8-61: Expanding the TabView view with a sidebar

Listing 8-62: Adding a header to the sidebar

Listing 8-63: Creating a section for the sidebar

Listing 8-64: Customizing the TabView view

Listing 8-65: Designing a TabView view for content

Listing 8-66: Updating the model

Listing 8-67: Designing the rows according to the app's configuration

Listing 8-68: Configuring the app

Listing 8-69: Searching for books

Listing 8-70: Detecting changes in the horizontal size class

Listing 8-71: Using a GeometryReader to detect orientation

Listing 8-72: Adapting an Image view to the size of its container

Listing 8-73: Reading the position of the GeometryReader view

Listing 8-74: Reading the position and size of a view

Listing 8-75: Setting and reading preferences

Listing 8-76: Defining a two-column split view

Listing 8-77: Defining the view for the left column

Listing 8-78: Defining a placeholder view for the right column

Listing 8-79: Defining a Multiplatform Detail view

Listing 8-80: Showing an item by default

Listing 8-81: Enabling navigation in the right column

Listing 8-82: Creating a navigation path for the right column

Listing 8-83: Expanding the cover in a Multiplatform application

Listing 8-84: Adding navigation to the left column

Listing 8-85: Opening a view on the left column

Listing 8-86: Providing the list of authors

Listing 8-87: Defining a three-column layout

Listing 8-88: Showing the authors

Listing 8-89: Showing the books

Listing 8-90: Hiding columns programmatically

Listing 8-91: Configuring the columns

CHAPTER 9 - CONCURRENCY

Listing 9-1: Initiating an asynchronous task

Listing 9-2: Running multiple asynchronous processes

Listing 9-3: Defining a task explicitly

Listing 9-4: Cancelling a task

Listing 9-5: Reading a value returned by a task

Listing 9-6: Defining asynchronous properties

Listing 9-7: Responding to errors

Listing 9-8: Defining a concurrent task

Listing 9-9: Defining an actor

Listing 9-10: Defining a non-isolated method

Listing 9-11: Defining a non-isolated method

Listing 9-12: Asking the compiler not to check conformity to the Sendable protocol

Listing 9-13: Declaring a global variable unsafe

Listing 9-14: Executing a method in the Main Actor

Listing 9-15: Executing code in the Main Actor

Listing 9-16: Returning a value from the Main Actor

Listing 9-17: Accessing the Main Actor from a task

Listing 9-18: Declaring global variables in the Main Actor

Listing 9-19: Defining an asynchronous sequence

Listing 9-20: Defining a task group

Listing 9-21: Loading an image asynchronously

Listing 9-22: Configuring the image after it is downloaded

CHAPTER 10 - STORAGE

Listing 10-1: Storing and reading values from User Defaults

Listing 10-2: Storing app settings in User Defaults

Listing 10-3: Adapting the interface to the app's settings

Listing 10-4: Modifying the app's settings

Listing 10-5: Defining a SwiftData model

Listing 10-6: Creating the container

Listing 10-7: Controlling the navigation path from an observable object

Listing 10-8: Fetching books from the database

Listing 10-9: Storing a book in the database

Listing 10-10: Storing unique values

Listing 10-11: Using the #Unique macro to avoid duplicates

Listing 10-12: Creating indexes for better performance

Listing 10-13: Creating a second model to store the authors

Listing 10-14: Creating a relationship with the Author class

Listing 10-15: Defining the relationship in the Book class

Listing 10-16: Defining the relationship in the Author class

Listing 10-17: Controlling the values selected by the user from the model

Listing 10-18: Opening additional views for navigation

Listing 10-19: Assigning an author to a book

Listing 10-20: Listing the authors

Listing 10-21: Adding new authors

Listing 10-22: Displaying the author's name

Listing 10-23: Including all the models in the container

Listing 10-24: Deleting objects

Listing 10-25: Sorting objects

Listing 10-26: Sorting objects with a SortDescriptor structure

Listing 10-27: Sorting books by author and year

Listing 10-28: Sorting with a lexical comparator

Listing 10-29: Filtering books by year

Listing 10-30: Filtering books by author and year

Listing 10-31: Filtering books by text

Listing 10-32: Defining an expression

Listing 10-33: Evaluating an expression

Listing 10-34: Defining a dynamic query

Listing 10-35: Searching books by title

Listing 10-36: Fetching objects manually

Listing 10-37: Counting objects

Listing 10-38: Checking for duplicates

Listing 10-39: Providing sample data for the previews

Listing 10-40: Implementing a custom container in the preview

Listing 10-41: Preparing the selectedBook property to add new books

Listing 10-42: Opening the view to edit a book

Listing 10-43: Editing a book

Listing 10-44: Storing images externally

Listing 10-45: Displaying an image from a UIImage object

Listing 10-46: Displaying the image in the DetailView view

Listing 10-47: Converting a UIImage object into data

Listing 10-48: Creating Book objects with images from the Asset Catalog

Listing 10-49: Sorting the books

Listing 10-50: Displaying the books in sections

Listing 10-51: Storing the letters for the sections

Listing 10-52: Adding the relationship to sort the books by letter

Listing 10-53: Getting the SortLetters object that correspond to the book

Listing 10-54: Listing books in alphabetical sections

Listing 10-55: Listing books in alphabetical sections

Listing 10-56: Defining a Codable structure

Listing 10-57: Storing and decoding data

Listing 10-58: Encoding data

Listing 10-59: Displaying encoded data

Listing 10-60: JSON file

Listing 10-61: Decoding with JSON

Listing 10-62: Encoding with JSON

Listing 10-63: Preparing the models for CloudKit

Listing 10-64: Saving files

Listing 10-65: Opening a sheet to add files to the model

Listing 10-66: Creating new files

Listing 10-67: Getting the list of files

Listing 10-68: Listing the files created by the user

Listing 10-69: Reading the content of a file

Listing 10-70: Allowing the user to open a file

Listing 10-71: Displaying the contents of a file

Listing 10-72: Deleting a file

Listing 10-73: Allowing the user to delete files

Listing 10-74: Storing text in a file

Listing 10-75: Editing the content of a file

Listing 10-76: Loading a file from the bundle

Listing 10-77: Displaying the content of a file stored in the bundle

Listing 10-78: Defining a document model

Listing 10-79: Creating a Document app

Listing 10-80: Editing the document

Listing 10-81: Exporting a document

Listing 10-82: Importing a document

CHAPTER 11 - GRAPHICS AND ANIMATIONS

Listing 11-1: Drawing standard shapes

Listing 11-2: Filling a shape with a color

Listing 11-3: Defining a border

Listing 11-4: Defining a custom border

Listing 11-5: Combining shapes with other views

Listing 11-6: Assigning a shape as the background of a button

Listing 11-7: Defining a linear gradient

Listing 11-8: Defining a linear gradient with custom stops

Listing 11-9: Defining a circular gradient

Listing 11-10: Defining a conic gradient

Listing 11-11: Defining a mesh gradient

Listing 11-12: Adding a shadow to a view

Listing 11-13: Filling a shape with an image

Listing 11-14: Defining a custom path

Listing 11-15: Combining lines and arcs

Listing 11-16: Combining lines and ellipses

Listing 11-17: Creating complex curves

Listing 11-18: Adapting the size of the path to the size of the container

Listing 11-19: Creating a custom shape view

Listing 11-20: Implementing custom shape views

Listing 11-21: Displacing an image

Listing 11-22: Rotating the image

Listing 11-23: Clipping the image

Listing 11-24: Adding a border to an irregular shape

Listing 11-25: Rotating a shape

Listing 11-26: Inverting a shape with the scale() modifier

Listing 11-27: Trimming a path

Listing 11-28: Drawing an image on the canvas

Listing 11-29: Drawing an image on the canvas

Listing 11-30: Drawing shapes and text

Listing 11-31: Rotating the canvas

Listing 11-32: Rotating an image

Listing 11-33: Performing multiple transformations

Listing 11-34: Preparing images

Listing 11-35: Clipping the canvas

Listing 11-36: Working with different configurations

Listing 11-37: Applying filters to the graphics

Listing 11-38: Providing the data for a chart

Listing 11-39: Visualizing data with a bar chart

Listing 11-40: Visualizing data with a line chart

Listing 11-41: Displaying an overlay

Listing 11-42: Defining a custom scale for the y axis

Listing 11-43: Assigning different styles based on a value

Listing 11-44: Representing the values with different types of marks

Listing 11-45: Drawing a line in the plot area

Listing 11-46: Selecting a value

Listing 11-47: Visualizing large datasets with a point plot

Listing 11-48: Plotting a mathematical function

Listing 11-49: Representing the values with different types of marks

Listing 11-50: Visualizing two series of values

Listing 11-51: Visualizing two series of values with a bar chart

Listing 11-52: Defining the positions of the bars

Listing 11-53: Scrolling the chart

Listing 11-54: Creating an image from a view

Listing 11-55: Animating a view

Listing 11-56: Applying a linear animation

Listing 11-57: Declaring a specific duration

Listing 11-58: Configuring the animation

Listing 11-59: Defining a custom animation

Listing 11-60: Animating multiple states at a time

Listing 11-61: Applying a different animation to each state

Listing 11-62: Instantiating a view with a value that can be animated

Listing 11-63: Defining an animatable path

Listing 11-64: Updating the interface

Listing 11-65: Animating the canvas

Listing 11-66: Creating a real animation

Listing 11-67: Adding and removing a view with a transition

Listing 11-68: Extending the AnyTransition structure

Listing 11-69: Defining an asymmetric transition

Listing 11-70: Combining transitions

Listing 11-71: Customizing the transition

Listing 11-72: Coordinating transitions

Listing 11-73: Coordinating views

Listing 11-74: Animating an SF Symbol

Listing 11-75: Animating an SF Symbol when a value changes

Listing 11-76: Animating an SF Symbol multiple times

Listing 11-77: Configuring animations

Listing 11-78: Scaling a symbol

Listing 11-79: Removing a symbol from the screen

Listing 11-80: Adapting the layout to the effect

Listing 11-81: Replacing a symbol

CHAPTER 12 - GESTURES

Listing 12-1: Detecting a tap gesture on an image

Listing 12-2: Showing the image

Listing 12-3: Detecting a long press gesture

Listing 12-4: Disabling the tap gesture

Listing 12-5: Defining the shape of the content

Listing 12-6: Defining a TapGesture recognizer

Listing 12-7: Defining a LongPressGesture recognizer

Listing 12-8: Controlling the states of a gesture with an enumeration

Listing 12-9: Defining a MagnificationGesture recognizer

Listing 12-10: Determining a minimum and a maximum scale

Listing 12-11: Defining a RotationGesture recognizer

Listing 12-12: Allowing the user to drag an image

Listing 12-13: Providing a custom preview for the gesture

Listing 12-14: Dropping images into an Image view

Listing 12-15: Providing feedback to the user

Listing 12-16: Dragging custom values

Listing 12-17: Using a custom content type

Listing 12-18: Dragging and dropping custom values

CHAPTER 13 - MAP KIT

Listing 13-1: Displaying a map

Listing 13-2: Displaying a hybrid map

Listing 13-3: Selecting points of interest

Listing 13-4: Configuring the map from the model

Listing 13-5: Zooming on a region on the map

Listing 13-6: Showing the current latitude and longitude

Listing 13-7: Disabling panning

Listing 13-8: Defining the boundaries for the camera

Listing 13-9: Applying the boundaries to the map

Listing 13-10: Adding markers to the map

Listing 13-11: Displaying annotations

Listing 13-12: Drawing a circle over the labels

Listing 13-13: Drawing a line

Listing 13-14: Finding places with Local Search

Listing 13-15: Searching for places

Listing 13-16: Selecting markers

Listing 13-17: Showing a callout with additional information

Listing 13-18: Opening a sheet with additional information

Listing 13-19: Displaying map controls

Listing 13-20: Creating custom controls

Listing 13-21: Creating a Look Around preview

Listing 13-22: Presenting a Look Around preview

Listing 13-23: Presenting the Look Around sheet

Listing 13-24: Calculating a route

Listing 13-25: Displaying a route

Listing 13-26: Asking permission and responding to errors

Listing 13-27: Requesting authorization and showing the user's location

Listing 13-28: Implementing the user location button

CHAPTER 14 - NOTIFICATIONS

Listing 14-1: Listening to notifications from the model

Listing 14-2: Listening to notifications

Listing 14-3: Adding new values to the model

Listing 14-4: Adding information to the notification

Listing 14-5: Reading the value in the notification

Listing 14-6: Cancelling the task

Listing 14-7: Interface to test the keyboard

Listing 14-8: Scrolling the interface to make room for the keyboard

Listing 14-9: Listening to keyboard notifications

Listing 14-10: Modifying the interface when the keyboard state changes

Listing 14-11: Detecting changes in the orientation

Listing 14-12: Adapting the interface to changes in the orientation

Listing 14-13: Sending notifications

Listing 14-14: Scheduling a notification

Listing 14-15: Playing a sound

Listing 14-16: Attaching an image to a notification

Listing 14-17: Defining a delegate for the User Notification Center

Listing 14-18: Showing notifications while the app is running

Listing 14-19: Organizing notifications into groups

Listing 14-20: Configuring a summary of notifications

Listing 14-21: Adding an action to a notification

Listing 14-22: Processing actions for notifications

Listing 14-23: Adding an input action to a notification

Listing 14-24: Processing the user's feedback

Listing 14-25: Defining an observable property for KVO

Listing 14-26: Observing a property

Listing 14-27: Working with a KVO property

Listing 14-28: Detecting changes in the app's state

Listing 14-29: Defining a custom app delegate

Listing 14-30: Assigning the app delegate from a SwiftUI application

Listing 14-31: Defining a custom Scene delegate

Listing 14-32: Configuring a Scene

Listing 14-33: Modifying the model from the app delegate

Listing 14-34: Creating a Just publisher

Listing 14-35: Assigning a subscriber to the view

Listing 14-36: Creating a PassthroughSubject

Listing 14-37: Generating a publisher from a Timer

Listing 14-38: Cancelling the publisher

CHAPTER 15 - ICLOUD

Listing 15-1: Storing a value in iCloud

Listing 15-2: Defining the interface to store and read values from iCloud

Listing 15-3: Storing multiple values in iCloud

Listing 15-4: Reading multiple values from iCloud

Listing 15-5: Saving multiple values in iCloud

Listing 15-6: Creating the document

Listing 15-7: Initializing the model required to store a document in iCloud

Listing 15-8: Processing query results

Listing 15-9: Updating the document

Listing 15-10: Defining the main interface

Listing 15-11: Editing the document

Listing 15-12: Working with multiple documents

Listing 15-13: Processing the list of files in the container

Listing 15-14: Updating the container

Listing 15-15: Adding and removing documents from the container

Listing 15-16: Opening, saving, and closing a document

Listing 15-17: Listing the documents available in the container

Listing 15-18: Creating new documents

Listing 15-19: Displaying the document's content

CHAPTER 16 - FRAMEWORK INTEGRATION

Listing 16-1: Preparing a UIKit view to work with SwiftUI

Listing 16-2: Showing a UIKit view within a SwiftUI view

Listing 16-3: Sending and receiving values from the SwiftUI view

Listing 16-4: Receiving and sending values to a UIKit view

Listing 16-5: Creating a UIKit view controller

Listing 16-6: Creating the representable view for a UIKit view controller

Listing 16-7: Loading a UIKit view controller from a SwiftUI view

CHAPTER 17 - WEB

Listing 17-1: Opening a website

Listing 17-2: Encoding URLs

Listing 17-3: Encoding custom URLs

Listing 17-4: Creating a Safari Browser

Listing 17-5: Opening a Safari Browser

Listing 17-6: Configuring the view controller

Listing 17-7: Preserving the bars at their original size

Listing 17-8: Assigning a delegate to the Safari View Controller

Listing 17-9: Disabling the button from the Safari View Controller delegate

Listing 17-10: Loading a website with a WebKit View

Listing 17-11: Showing the WebKit view

Listing 17-12: Allowing the user the insert a URL

Listing 17-13: Updating the WKWebView with the URLs inserted by the user

Listing 17-14: Providing buttons for navigation

Listing 17-15: Navigating back and forth in the navigation history

Listing 17-16: Loading a remote document

Listing 17-17: Displaying the document's content

Listing 17-18: Initializing a custom session

Listing 17-19: Redirecting the user

Listing 17-20: Loading a JSON document

Listing 17-21: Listing the values from the document

CHAPTER 18 - MEDIA

Listing 18-1: Creating a Photo picker

Listing 18-2: Embedding the Photos Picker in our interface

Listing 18-3: Hiding controls

Listing 18-4: Defining the model for multiple selection

Listing 18-5: Allowing the user to perform multiple selections

Listing 18-6: Creating the Image Picker Controller to take pictures

Listing 18-7: Defining the interface to take pictures

Listing 18-8: Saving the picture in the Photo Library

Listing 18-9: Sharing the image with other applications

Listing 18-10: Defining a UIView subclass to show the camera's preview video

Listing 18-11: Defining the properties we need to manage the camera

Listing 18-12: Asking for permission to use the camera

Listing 18-13: Initializing the camera

Listing 18-14: Showing the video from the camera on the screen

Listing 18-15: Taking a picture

Listing 18-16: Processing the image

Listing 18-17: Showing the image

Listing 18-18: Taking a picture

Listing 18-19: Preparing the video to be played

Listing 18-20: Playing a video

Listing 18-21: Automatically playing a video

Listing 18-22: Presenting views over the video

Listing 18-23: Building a custom video player

Listing 18-24: Building a custom video player

Listing 18-25: Showing a video

Listing 18-26: Preparing the video player

Listing 18-27: Playing and pausing the video

Listing 18-28: Executing an asynchronous method to detect the end of the video

Listing 18-29: Playing a list of videos

Listing 18-30: Showing a color picker

CHAPTER 19 - MULTIPLATFORM APPLICATIONS

Listing 19-1: Detecting the platform before compiling

Listing 19-2: Applying different modifiers to each platform

Listing 19-3: Defining a multiplatform interface

Listing 19-4: Detecting the version of the operating system

Listing 19-5: Adding a menu to the menu bar

Listing 19-6: Assigning a keyboard shortcut to a menu option

Listing 19-7: Adding options to a standard menu

Listing 19-8: Removing options

Listing 19-9: Defining a property in the model to store the index of the selected option

Listing 19-10: Adding a submenu

Listing 19-11: Adding predefined options to import resources

Listing 19-12: Importing an image form an external device

Listing 19-13: Defining a state to enable and disable a menu option

Listing 19-14: Enabling and disabling a menu option

Listing 19-15: Defining a TextField view to enable and disable the option

Listing 19-16: Storing a focus state in the FocusedValues structure

Listing 19-17: Passing the focus state to the FocusedValues structure

Listing 19-18: Disabling a menu option according to the focus state of a view

Listing 19-19: Defining a two-column interface

Listing 19-20: Adding items to the toolbar for a Mac application

Listing 19-21: Hiding the toolbar

Listing 19-22: Showing a tooltip for a button

Listing 19-23: Showing suggestions for a text field

Listing 19-24: Defining a model to test alternate backgrounds

Listing 19-25: Creating a list with alternate background

Listing 19-26: Opening an auxiliary window

Listing 19-27: Opening a window programmatically

Listing 19-28: Closing a window programmatically

Listing 19-29: Configuring the window to adopt the size of the content

Listing 19-30: Giving the view a fixed size

Listing 19-31: Assigning a position by default

Listing 19-32: Defining a custom position and size for the window

Listing 19-33: Disabling window controls

Listing 19-34: Applying a custom design to a window

Listing 19-35: Dragging a view

Listing 19-36: Defining a Settings Scene

Listing 19-37: Inserting a control in the system's menu bar

Listing 19-38: Defining a control to open a view

Listing 19-39: Storing the state of the Scene

CHAPTER 20 - INTERNATIONALIZATION

Listing 20-1: Testing String Catalogs

Listing 20-2: Selecting the language for the previews

Listing 20-3: Including comments for the translator

Listing 20-4: Localizing strings

Listing 20-5: Localizing values

Listing 20-6: Specifying singular and plural versions of the text

CHAPTER 21 - APP STORE

There are no Examples in this Chapter

TABLE OF CONTENTS

Tools and Resources

Select Country

Paperback

$ 39.95 BUY NOW

Kindle

$ 9.99 BUY NOW

Apple Books

$ 9.99 BUY NOW

Google Books

$ 9.75 BUY NOW

Information

5th Edition

October 2024

ISBN: 979-8-3399-9432-9

More than 800 Codes Explained!

More than 300 Projects!