Examples and Projects - UIKit for Masterminds

HOME BOOKS QUICK GUIDES VIDEO COURSES APPLICATIONS

NEWSLETTER CONTACT

UIKit for Masterminds

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

1st Edition 2021
ISBN: 978-1-7779782-0-4

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
394.0 KBytes

Download Projects
546.9 MBytes

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 types

Listing 2-7: Declaring variables without specifying the 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 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 variable's value 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 inside 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 a tuple

Listing 2-35: Changing 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 several 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: Checking multiple conditions with Optional Binding

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

Listing 2-48: Concatenating if else instructions

Listing 2-49: Implementing the ternary operator

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

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

Listing 2-52: Checking conditions with switch

Listing 2-53: Checking multiple conditions per case

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

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

Listing 2-56: Capturing values with constants

Listing 2-57: Comparing values with where

Listing 2-58: Using while to create a loop

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

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

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

Listing 2-62: Adding a condition to a loop

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

Listing 2-64: Interrupting the loop

Listing 2-65: Ignoring values in a switch statement

Listing 2-66: 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 different 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: Declaring escaping closures

Listing 3-27: Defining a structure

Listing 3-28: Declaring a variable of type Item

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

Listing 3-30: Structures inside structures

Listing 3-31: Accessing optional properties

Listing 3-32: Creating key paths

Listing 3-33: Using read and write key paths

Listing 3-34: Defining methods

Listing 3-35: Assigning new values to properties from inside the structure

Listing 3-36: Initializing properties

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

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

Listing 3-39: Declaring the parameters of the init() method

Listing 3-40: Declaring multiple init() methods

Listing 3-41: Declaring computed properties

Listing 3-42: Defining read-only properties

Listing 3-43: Adding the set method to set a new value

Listing 3-44: Using a different name for the parameter of the set method

Listing 3-45: Adding observers to a property

Listing 3-46: Defining type properties

Listing 3-47: Defining type methods

Listing 3-48: Defining generic structures

Listing 3-49: Using generic structures

Listing 3-50: Initializing variables with standard initializers

Listing 3-51: Casting a variable

Listing 3-52: Extracting numbers from strings

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

Listing 3-54: Rounding floating-point values

Listing 3-55: Changing the value of a Bool variable

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

Listing 3-57: Inverting a range

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

Listing 3-59: Calculating random numbers

Listing 3-60: Converting a number into a string

Listing 3-61: Processing the string's characters

Listing 3-62: Calculating a specific index

Listing 3-63: Getting the next index

Listing 3-64: Inserting a character in a string

Listing 3-65: Removing a character

Listing 3-66: Getting a range of characters

Listing 3-67: Working with ranges of characters

Listing 3-68: Implementing String methods

Listing 3-69: Declaring arrays

Listing 3-70: Declaring arrays with type inference

Listing 3-71: Reading the array's elements

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

Listing 3-73: Adding new elements to an array

Listing 3-74: Concatenating two arrays

Listing 3-75: Creating multidimensional arrays

Listing 3-76: Reading values from a multidimensional array

Listing 3-77: Removing the elements of an array

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

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

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

Listing 3-81: Adding and removing elements

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

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

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

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

Listing 3-86: Reading a range of elements

Listing 3-87: Casting arrays of type ArraySlice

Listing 3-88: Removing and replacing elements

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

Listing 3-90: Filtering the values of an array

Listing 3-91: Mapping an array

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

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

Listing 3-94: Reducing an array

Listing 3-95: Reversing the elements of an array

Listing 3-96: Sorting the elements of an array

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

Listing 3-98: Sorting an array of integers

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

Listing 3-100: Getting the largest element

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

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

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

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

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 values

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: Declaring a variable of type Number

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: Synchronizing arrays

Listing 3-139: Applying all the changes at once

Listing 3-140: Defining a class

Listing 3-141: Creating an object from a class

Listing 3-142: Modifying properties from the object's methods

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

Listing 3-144: Referring to the object with self

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

Listing 3-146: Referencing one object from another

Listing 3-147: Assigning weak references

Listing 3-148: Defining a basic class

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

Listing 3-150: Creating objects from a subclass

Listing 3-151: Overriding an inherited method

Listing 3-152: Calling a method on the superclass

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

Listing 3-154: Identifying the object's data type

Listing 3-155: Casting an object

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

Listing 3-157: Casting an object on the fly

Listing 3-158: Working with objects of AnyObject type

Listing 3-159: Declaring a Designated Initializer

Listing 3-160: Declaring a Convenience Initializer

Listing 3-161: Inheriting the Designated Initializer

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

Listing 3-163: Declaring a deinitializer

Listing 3-164: Defining lazy properties

Listing 3-165: Declaring private properties

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

Listing 3-167: Defining protocols

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

Listing 3-169: Using protocols as data types

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

Listing 3-171: Returning values of a protocol data type

Listing 3-172: Defining generic protocols

Listing 3-173: Conforming to the Equatable protocol

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

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

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

Listing 3-177: Conforming to the Comparable protocol

Listing 3-178: Conforming to the Hashable protocol

Listing 3-179: Defining our own hash value

Listing 3-180: Conforming to the CaseIterable protocol

Listing 3-181: Extending a protocol

Listing 3-182: Extending data types

Listing 3-183: Extending custom data types

Listing 3-184: Defining a conditional extension

Listing 3-185: Customizing string interpolation

Listing 3-186: Delegating tasks

Listing 3-187: Delegating with protocols

Listing 3-188: Using different delegates

Listing 3-189: Producing an error inside a method

Listing 3-190: Throwing errors

Listing 3-191: Handling errors

Listing 3-192: Getting information about the error

Listing 3-193: Catching errors with try?

Listing 3-194: Ignoring the errors

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

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

CHAPTER 4 – 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: Creating and reading an NSRange value

Listing 4-11: Converting a range of string indexes

Listing 4-12: Working with NSNumber objects

Listing 4-13: Formatting a number

Listing 4-14: Rounding a number

Listing 4-15: Disabling grouping

Listing 4-16: Adding the sign

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

Listing 4-18: Formatting currency values

Listing 4-19: Storing dates with Date structures

Listing 4-20: Comparing two dates

Listing 4-21: Extracting components from a date

Listing 4-22: Extracting multiple components from a date

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

Listing 4-24: Using a Gregorian calendar

Listing 4-25: Adding components to a date

Listing 4-26: Comparing dates

Listing 4-27: Finding a date in an interval

Listing 4-28: Formatting dates

Listing 4-29: Specifying a custom format

Listing 4-30: Including multiple date components

Listing 4-31: Specifying a different locale

Listing 4-32: Working with different time zones

Listing 4-33: Initializing Measurement structures

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

Listing 4-35: Adding two values of different units

Listing 4-36: Converting units

Listing 4-37: Formatting a measurement

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

Listing 4-39: Formatting the measurement's value

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

Listing 4-41: Creating a non-repeating timer

Listing 4-42: Creating a repeating timer

Listing 4-43: Initializing Core Graphics' structures

Listing 4-44: Using the CGRect convenience initializer

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

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

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

CHAPTER 5 – UIKIT FRAMEWORK

Listing 5-1: Accessing the UIApplication object

Listing 5-2: Getting information from the device

Listing 5-3: Getting information from the screen

Listing 5-4: Creating a view

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

Listing 5-6: Assigning an adaptable color to the view

Listing 5-7: Adding subviews to a container view

Listing 5-8: Defining a property in the app's delegate object

Listing 5-9: Initializing a Scene

Listing 5-10: Adding our own code to the ViewController.swift file

Listing 5-11: Modifying the main view from the view controller

Listing 5-12: Adding an Outlet for a label to the view controller

Listing 5-13: Defining the label's text from code

Listing 5-14: Creating dynamic font types

Listing 5-15: Defining a specific font and size

Listing 5-16: Using the system's standard font

Listing 5-17: Getting the font size used by default for buttons

Listing 5-18: Clipping the label's text

Listing 5-19: Customizing the text

Listing 5-20: Assigning attributes to a label

Listing 5-21: Assigning attributes to a range of characters

Listing 5-22: Assigning additional attributes to the label

Listing 5-23: Assigning attributes to a customized range of characters

Listing 5-24: Applying a shadow to the text

Listing 5-25: Applying multiple attributes at once

Listing 5-26: Modifying the attributes of a run

Listing 5-27: Defining an Action for the button

Listing 5-28: Responding to multiple buttons

Listing 5-29: Modifying the button's configuration

Listing 5-30: Updating the button's configuration

Listing 5-31: Creating a button from code

Listing 5-32: Configuring a button with an Action

Listing 5-33: Adding an action to a button from code

Listing 5-34: Disabling a button

Listing 5-35: Turning a button into a toggle button

Listing 5-36: Displaying a menu with a button

Listing 5-37: Identifying the option selected by the user

Listing 5-38: Defining a Pop Up button

Listing 5-39: Getting the selected option

Listing 5-40: Selecting an option from code

Listing 5-41: Implementing an Outlet Collection

Listing 5-42: Customizing the progress bar

Listing 5-43: Working with an Activity Indicator

Listing 5-44: Responding to the Value Changed event of a Segmented Control

Listing 5-45: Adding actions to a Segmented Control

Listing 5-46: Modifying a Segmented Control

Listing 5-47: Changing the color of a label with a Switch

Listing 5-48: Changing the colors of the switch

Listing 5-49: Incrementing or decrementing a value with a Slider

Listing 5-50: Working with custom values

Listing 5-51: Customizing the values of a Stepper

Listing 5-52: Processing the user's input

Listing 5-53: Trimming text

Listing 5-54: Disabling the Text Field

Listing 5-55: Assigning a delegate to the Text Field and declaring its methods

Listing 5-56: Determining the number of characters allowed

Listing 5-57: Allowing only numbers

Listing 5-58: Responding to the keyboard

Listing 5-59: Highlighting the Text Field

Listing 5-60: Highlighting two Text Fields

Listing 5-61: Identifying Text Fields

Listing 5-62: Adding attributes to the attributed text of a Text View

Listing 5-63: Adding attributes to a range of characters

Listing 5-64: Opening and closing the keyboard from code

Listing 5-65: Dismissing the keyboard when the user touches the screen

Listing 5-66: Finding the First Responder

Listing 5-67: Providing values for the picker

Listing 5-68: Reading the selected value

Listing 5-69: Selecting the initial value

Listing 5-70: Creating a picker with multiple components

Listing 5-71: Displaying the selected date

Listing 5-72: Setting the initial date

Listing 5-73: Adding a background pattern to the main view

Listing 5-74: Implementing SF Symbols

Listing 5-75: Selecting a variant of an SF Symbols

Listing 5-76: Configuring an SF Symbols

Listing 5-77: Defining the colors of an SF Symbols

Listing 5-78: Replacing the picture when the button is pressed

Listing 5-79: Switching pictures

Listing 5-80: Reducing the size of an image

CHAPTER 6 – ADAPTIVITY

Listing 6-1: Reading the intrinsic content size

Listing 6-2: Adding a view to the Stack View programmatically

Listing 6-3: Laying out elements with constraints defined in code

Listing 6-4: Removing constraints

Listing 6-5: Updating constraints

Listing 6-6: Attaching constraints to the view's anchors

Listing 6-7: Adding constraints with the isActive property

Listing 6-8: Attaching constraints to the Safe Area's Layout Guide

Listing 6-9: Adapting the interface to make room for the keyboard

Listing 6-10: Detecting changes in the Trait Collection

Listing 6-11: Detecting rotation

Listing 6-12: Performing a task after the transition is over

Listing 6-13: Deactivating rotation for a view controller

Listing 6-14: Allowing only landscape orientation

CHAPTER 7 – SCROLL VIEWS

Listing 7-1: Adding a Scroll View from code

Listing 7-2: Showing the content full screen

Listing 7-3: Adding more views to the content area

Listing 7-4: Pinning content to the frame of the Scroll View

Listing 7-5: Allowing zooming

Listing 7-6: Calculating the minimum and maximum scales

Listing 7-7: Organizing the content area in pages

Listing 7-8: Calculating the page

Listing 7-9: Zooming the pages in and out

Listing 7-10: Adapting the content area to a new orientation

CHAPTER 8 — GESTURE RECOGNIZERS

Listing 8-1: Responding to a gesture

Listing 8-2: Adding gestures from code

CHAPTER 9 — NAVIGATION

Listing 9-1: Adding the Action for the Unwind Segue

Listing 9-2: Processing changes in the Slider

Listing 9-3: Reading properties from the source

Listing 9-4: Sending values to the second view controller before its main view is loaded

Listing 9-5: Processing values according to the segue

Listing 9-6: Storing the data

Listing 9-7: Showing the data

Listing 9-8: Assigning the scene's title from code

Listing 9-9: Configuring the Navigation Bar for standard and compact heights

Listing 9-10: Setting up Navigation Bar features

Listing 9-11: Configuring the back button

Listing 9-12: Deactivating large titles

Listing 9-13: Adding buttons to the Navigation Bar

Listing 9-14: Replacing the back button

Listing 9-15: Configuring the appearance of the Toolbar

Listing 9-16: Defining our own method to navigate back

Listing 9-17: Storing common data in the app's delegate

Listing 9-18: Storing the index of the selected picture

Listing 9-19: Showing the selected picture and storing the rating in the app's delegate

Listing 9-20: Defining a global structure to store common data

Listing 9-21: Accessing the data model from the ViewController class

Listing 9-22: Accessing the data model from the SecondViewController class

Listing 9-23: Updating the badge from the view controller

Listing 9-24: Modifying the appearance of the bar

Listing 9-25: Configuring the items

Listing 9-26: Initializing the Tab Bar Controller

Listing 9-27: Defining the Tab Bar Controller's delegate

Listing 9-28: Allowing the selection of a tab

CHAPTER 10 — TABLE VIEWS

Listing 10-1: Defining a model for a diffable data source

Listing 10-2: Defining the diffable data source and the snapshot

Listing 10-3: Including more information in the cell

Listing 10-4: Configuring the texts

Listing 10-5: Implementing standard configurations

Listing 10-6: Assigning a background configuration to the cell

Listing 10-7: Defining a background configuration for multiple states

Listing 10-8: Configuring the cells from a UITableViewCell subclass

Listing 10-9: Creating a cell from a custom subclass

Listing 10-10: Defining the cell's padding

Listing 10-11: Configuring a cell with a custom List Content View

Listing 10-12: Defining the views for a custom cell

Listing 10-13: Deleting a custom cell

Listing 10-14: Defining a custom configuration structure

Listing 10-15: Defining a custom Content View

Listing 10-16: Implementing a custom configuration

Listing 10-17: Selecting multiple items

Listing 10-18: Opening the Detail View when a cell is selected

Listing 10-19: Showing the details of the selected row

Listing 10-20: Deselecting the selected row

Listing 10-21: Adding items to the model

Listing 10-22: Removing the selected item

Listing 10-23: Activating and deactivating the editing mode

Listing 10-24: Implementing the data source delegate methods

Listing 10-25: Implementing our data source subclass

Listing 10-26: Creating our own actions

Listing 10-27: Reorganizing the model when a cell is moved

Listing 10-28: Modifying an item

Listing 10-29: Sending the selected item

Listing 10-30: Managing the table from a subclass of UITableViewController

Listing 10-31: Presenting a Refresh Control

Listing 10-32: Filtering the data

Listing 10-33: Processing the input from the search controller

Listing 10-34: Expanding the model to work with a scope bar

Listing 10-35: Adding a scope bar

Listing 10-36: Storing the data in sections

Listing 10-37: Defining a snapshot with sections

Listing 10-38: Declaring the sections' titles

Listing 10-39: Configuring the headers

Listing 10-40: Showing the index

Listing 10-41: Deleting empty sections

Listing 10-42: Defining the content of static cells

CHAPTER 11 — COLLECTION VIEWS

Listing 11-1: Creating a Collection View cell

Listing 11-2: Configuring a Collection View

Listing 11-3: Configuring the background of a Collection View cell

Listing 11-4: Configuring Flow layout

Listing 11-5: Declaring a specific size for each cell

Listing 11-6: Assigning a compositional layout to the Collection View

Listing 11-7: Customizing a compositional layout

Listing 11-8: Defining a reusable view

Listing 11-9: Defining the supplementary views

Listing 11-10: Adding supplementary views to a compositional layout

Listing 11-11: Working with multiple sections

Listing 11-12: Snapshot for multiple sections

Listing 11-13: Defining a model to test section snapshots

Listing 11-14: Moving items between section snapshots

Listing 11-15: Creating a Collection View List

Listing 11-16: Defining the header for a list

Listing 11-17: Adding supplementary views to the list

Listing 11-18: Configuring cell's separators

Listing 11-19: Adding accessories to the cells

Listing 11-20: Selecting and deselecting a cell in a list

Listing 11-21: Defining the buttons for swipe gestures

Listing 11-22: Defining a model for a hierarchical list

Listing 11-23: Creating a hierarchical list

CHAPTER 12 — SPLIT VIEW CONTROLLERS

Listing 12-1: Controlling the Primary scene

Listing 12-2: Displaying the item in the Secondary scene

Listing 12-3: Configuring the Split View Controller

Listing 12-4: Managing the columns from code

Listing 12-5: Changing the Split View Controller display mode

Listing 12-6: Selecting the item by default

Listing 12-7: Declaring the initial column for a collapsed interface

Listing 12-8: Defining a model to work with a three-column Split View Controller

Listing 12-9: Showing the categories

Listing 12-10: Showing the items in a category

Listing 12-11: Showing the item's values

Listing 12-12: Adding the Secondary Only button

Listing 12-13: Sending the selected item to the new scene

Listing 12-14: Showing a large version of the item's thumbnail

Listing 12-15: Defining a medium Page Sheet

Listing 12-16: Dismissing a single scene

Listing 12-17: Instantiating the scene from code

Listing 12-18: Dismissing the adaptive scene

Listing 12-19: Showing an alternative modal scene

Listing 12-20: Sending the item to the popover

Listing 12-21: Displaying information in a popover

Listing 12-22: Modifying the adaptive style

CHAPTER 13 — ALERT VIEWS

Listing 13-1: Presenting an Alert View

Listing 13-2: Changing the background color of the Text Field when the button is pressed

Listing 13-3: Adding a Cancel button

Listing 13-4: Creating and processing a login form

Listing 13-5: Creating an Action Sheet

Listing 13-6: Presenting the Action Sheet as a popover in iPads

CHAPTER 14 — CONCURRENCY

Listing 14-1: Creating an asynchronous task

Listing 14-2: Running multiple asynchronous tasks

Listing 14-3: Cancelling a task

Listing 14-4: Reading a value returned by a task

Listing 14-5: Defining and asynchronous properties

Listing 14-6: Responding to errors

Listing 14-7: Defining a concurrent task

Listing 14-8: Defining an actor

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

Listing 14-10: Executing code in the Main Actor

Listing 14-11: Returning a value from the Main Actor

Listing 14-12: Defining an asynchronous sequence

Listing 14-13: Defining a task group

CHAPTER 15 — STORAGE

Listing 15-1: Storing values in the User Defaults system

Listing 15-2: Storing app values

Listing 15-3: Configuring the Text View according to the values set by the user

Listing 15-4: Saving the settings

Listing 15-5: Reading values with specific methods

Listing 15-6: Setting values by default

Listing 15-7: Getting the Documents directory's URL

Listing 15-8: Creating a file inside Documents

Listing 15-9: Creating a directory inside Documents

Listing 15-10: Listing the content of a directory

Listing 15-11: Creating files in a custom directory

Listing 15-12: Moving files

Listing 15-13: Copying files

Listing 15-14: Removing files

Listing 15-15: Reading the file's attributes

Listing 15-16: Managing the file's content

Listing 15-17: Loading a file added to the project

Listing 15-18: Encoding and decoding data

Listing 15-19: Encoding and decoding a custom data type

Listing 15-20: Encoding and decoding arrays of custom structures

Listing 15-21: Initializing the Core Data stack in the app's delegate

Listing 15-22: Accessing the context from a view controller

Listing 15-23: Defining the model to work with Core Data

Listing 15-24: Adding new objects to the Persistent Store

Listing 15-25: Fetching values from the Persistent Store

Listing 15-26: Adding an author to the book

Listing 15-27: Defining a model to manage books and authors

Listing 15-28: Listing authors

Listing 15-29: Inserting new authors

Listing 15-30: Counting the authors available

Listing 15-31: Counting the books of each author

Listing 15-32: Filtering books by year

Listing 15-33: Filtering books by author

Listing 15-34: Creating filters with placeholders

Listing 15-35: Creating filters with multiple values

Listing 15-36: Filtering values with predicate keywords

Listing 15-37: Checking for duplicates

Listing 15-38: Sorting the books by title

Listing 15-39: Sorting books by author and year

Listing 15-40: Sorting by title without differentiating between lowercase and uppercase letters

Listing 15-41: Sending the book selected by the user

Listing 15-42: Editing a book

Listing 15-43: Defining the request and the snapshot from the model

Listing 15-44: Implementing the protocol methods to delete a book

Listing 15-45: Deleting a book

Listing 15-46: Updating the model to work with a Fetched Results Controller

Listing 15-47: Working with a Fetched Results Controller

Listing 15-48: Working with objects identifiers

Listing 15-49: Searching for books by title

Listing 15-50: Organizing the Books objects in sections

Listing 15-51: Implementing the protocol method to get the sections' titles

Listing 15-52: Generating an index

Listing 15-53: Reading the values of a To-Many relationship

Listing 15-54: Assigning multiple authors per book

Listing 15-55: Selecting and deselecting authors

Listing 15-56: Fetching books by author

Listing 15-57: Systematically removing authors from books

CHAPTER 16 — NOTIFICATIONS

Listing 16-1: Sending notifications from the model

Listing 16-2: Listening to notifications

Listing 16-3: Adding new values to the model

Listing 16-4: Adding information to the notification

Listing 16-5: Reading the value in the notification

Listing 16-6: Cancelling the task

Listing 16-7: Responding to the Text View notification

Listing 16-8: Responding to font size changes in the Settings app

Listing 16-9: Detecting the current orientation

Listing 16-10: Asking permission to send notifications

Listing 16-11: Checking authorization status

Listing 16-12: Scheduling a notification

Listing 16-13: Attaching an image to a notification

Listing 16-14: Scheduling provisional notifications

Listing 16-15: Checking the status of a provisional authorization

Listing 16-16: Showing notifications while the app is running

Listing 16-17: Organizing notifications into groups

Listing 16-18: Configuring a summary of notifications

Listing 16-19: Adding and processing actions for notifications

Listing 16-20: Processing an input action

Listing 16-21: Defining a custom class to work with KVC

Listing 16-22: Modifying property values using KVC

Listing 16-23: Observing the value of a property

Listing 16-24: Reporting changes

Listing 16-25: Working with a KVO compliant property

CHAPTER 17 — ICLOUD

Listing 17-1: Storing setting values in iCloud

Listing 17-2: Updating the interface when a new value is received

Listing 17-3: Creating the document

Listing 17-4: Loading the document

Listing 17-5: Processing query results

Listing 17-6: Saving the document

Listing 17-7: Initiating the query

Listing 17-8: Keeping the table up to date

Listing 17-9: Populating the table

Listing 17-10: Sending the name of the selected document to the second scene

Listing 17-11: Creating new documents

Listing 17-12: Reading and modifying a document

Listing 17-13: Creating the model

Listing 17-14: Reading and storing countries in the Private database

Listing 17-15: Storing cities in the Private database

Listing 17-16: Storing assets

Listing 17-17: Passing the selected city to the view controller

Listing 17-18: Reading assets

Listing 17-19: Processing Remote Notifications

Listing 17-20: Configuring the database

Listing 17-21: Initiating the process to get the updates from the server

Listing 17-22: Getting the updates from the server

Listing 17-23: Storing the Countries records in a custom zone

Listing 17-24: Storing the Cities records in a custom zone

Listing 17-25: Checking CloudKit availability

Listing 17-26: Checking for errors

Listing 17-27: Preparing Core Data to work with CloudKit

Listing 17-28: Defining the model to work with CloudKit

Listing 17-29: Listing the countries stored in the Persistent Store

Listing 17-30: Listing the cities of a country

Listing 17-31: Posting notifications when the Persistent Store changes

Listing 17-32: Updating the interface when the Persistent Store changes

CHAPTER 18 — MEDIA

Listing 18-1: Taking a picture

Listing 18-2: Storing pictures in the Photo Library

Listing 18-3: Selecting a picture from the Photo Library

Listing 18-4: Showing the picker in a popover

Listing 18-5: Defining the model to keep track of the selection

Listing 18-6: Displaying the pictures selected by the user

Listing 18-7: Displaying the picture on the screen

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

Listing 18-9: Informing the user that the camera is not available

Listing 18-10: Initializing the camera

Listing 18-11: Displaying the video from the camera

Listing 18-12: Detecting the device's orientation

Listing 18-13: Taking a picture

Listing 18-14: Rotating the preview layer

Listing 18-15: Using a standard video player

Listing 18-16: Building a video player

Listing 18-17: Preparing the video player

Listing 18-18: Updating the progress bar

Listing 18-19: Playing and pausing the video

Listing 18-20: Detecting when the video finishes playing

Listing 18-21: Initiating the asynchronous task to listen to player notifications

Listing 18-22: Playing a list of videos

Listing 18-23: Presenting a color picker

CHAPTER 19 — WEB

Listing 19-1: Opening a website

Listing 19-2: Encoding URLs

Listing 19-3: Loading a website with a Safari View Controller

Listing 19-4: Configuring the scene

Listing 19-5: Displaying the bars in their original size

Listing 19-6: Assigning a delegate to the Safari View Controller

Listing 19-7: Loading a website with a WebKit View

Listing 19-8: Implementing a custom web browser

Listing 19-9: Loading a remote document

Listing 19-10: Instantiating a custom session

Listing 19-11: Following a redirection

Listing 19-12: JSON file

Listing 19-13: Swift structure to decode JSON data

Listing 19-14: Decoding JSON data

Listing 19-15: Defining a model to decode posts

Listing 19-16: Decoding JSON data from the Web

CHAPTER 20 — MAP KIT

Listing 20-1: Configuring the map

Listing 20-2: Displaying a region

Listing 20-3: Defining an annotation

Listing 20-4: Adding an annotation

Listing 20-5: Configuring the annotation view

Listing 20-6: Defining a custom annotation

Listing 20-7: Adding custom data to an annotation

Listing 20-8: Configuring the callout bubble

Listing 20-9: Detecting and showing the user's location

Listing 20-10: Keeping track of the user's location

Listing 20-11: Implementing the user location button

Listing 20-12: Searching for pizza places

Listing 20-13: Updating the annotations

Listing 20-14: Setting the route's starting point and destination

Listing 20-15: Calculating the route

Listing 20-16: Drawing the route

Listing 20-17: Zooming out to show the route

Listing 20-18: Calculating routes to the destinations selected by the user

Listing 20-19: Showing additional information

CHAPTER 21 — DRAG AND DROP

Listing 21-1: Allowing the user to drag an image

Listing 21-2: Defining the preview

Listing 21-3: Dropping images in an Image View

Listing 21-4: Changing the background color

Listing 21-5: Defining the model to test drag and drop

Listing 21-6: Defining the cell to test drag and drop

Listing 21-7: Defining a Collection View for drag and drop

Listing 21-8: Dropping elements in a Collection View

CHAPTER 22 — MAC CATALYST

Listing 22-1: Detecting the platform before compiling

Listing 22-2: Detecting the platform when the app is running

Listing 22-3: Defining the action for a menu option

Listing 22-4: Modifying a menu option

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

Listing 22-6: Defining the action in the view controller

Listing 22-7: Modifying the main menu

Listing 22-8: Defining a model to store the state of the menu

Listing 22-9: Defining the menu according to the current state

Listing 22-10: Rebuilding the menu

Listing 22-11: Defining the toolbar's delegate

Listing 22-12: Creating a toolbar

Listing 22-13: Assigning a custom title to the toolbar

Listing 22-14: Disabling an item

Listing 22-15: Modifying an item

Listing 22-16: Adding a hover gesture recognizer

Listing 22-17: Adding a tooltip to a view

Listing 22-18: Configuring a switch for the Mac

Listing 22-19: Opening a new window

Listing 22-20: Defining the model to test multiple windows

Listing 22-21: Storing the state in an NSUserActivity object

Listing 22-22: Reading the state from the NSUserActivity object

CHAPTER 23 — APP STORE

There are no Examples in this Chapter

TABLE OF CONTENTS

Select Country

Paperback

$ 37.00 BUY NOW

Kindle

$ 9.95 BUY NOW

Apple Books

$ 9.99 BUY NOW

Google Books

$ 9.99 BUY NOW

Information

1st Edition 2021

ISBN: 978-1-7779782-0-4

More than 700 Codes Explained!

More than 250 Projects!