book

iOS 13 Programming Fundamentals with Swift

by Matt Neuburg

October 2019

Intermediate to advanced

677 pages

18h 28m

English

O'Reilly Media, Inc.

Read now

Unlock full access

The Scope of This BookFrom the Programming iOS 4 PrefaceVersionsAcknowledgmentsConventions Used in This BookUsing Code ExamplesO’Reilly Online LearningHow to Contact Us
Ground of BeingEverything Is an Object?Three Flavors of Object TypeVariablesFunctionsThe Structure of a Swift FileScope and LifetimeObject MembersNamespacesModulesInstancesWhy Instances?The Keyword selfPrivacyDesign
Function Parameters and Return ValueVoid Return Type and ParametersFunction SignatureExternal Parameter NamesOverloadingDefault Parameter ValuesVariadic ParametersIgnored ParametersModifiable ParametersCalling Objective-C with Modifiable ParametersCalled by Objective-C with Modifiable ParametersReference Type Modifiable ParametersFunction in FunctionRecursionFunction as ValueAnonymous FunctionsUsing Anonymous Functions InlineAnonymous Function Abbreviated SyntaxDefine-and-CallClosuresHow Closures Improve CodeFunction Returning FunctionClosure Setting a Captured VariableClosure Preserving Captured EnvironmentEscaping ClosuresCurried FunctionsFunction References and SelectorsFunction Reference ScopeSelectors
Variable Scope and LifetimeVariable DeclarationComputed Variable InitializationComputed VariablesComputed PropertiesProperty WrappersSetter ObserversLazy InitializationSingletonLazy Initialization of Instance PropertiesBuilt-In Simple TypesBoolNumbersStringCharacter and String IndexRangeTupleOptional
Object Type Declarations and FeaturesInitializersPropertiesMethodsSubscriptsNested Object TypesEnumsRaw ValuesAssociated ValuesEnum Case IterationEnum InitializersEnum PropertiesEnum MethodsWhy Enums?StructsStruct InitializersStruct PropertiesStruct MethodsStruct as NamespaceClassesValue Types and Reference TypesSubclass and SuperclassClass InitializersClass DeinitializerClass PropertiesStatic/Class MembersPolymorphismCastingCasting DownType Testing and Casting Down SafelyType Testing and Casting OptionalsBridging to Objective-CType ReferencesFrom Instance to TypeFrom self to TypeType as ValueSummary of Type TerminologyComparing TypesProtocolsWhy Protocols?Adopting a Library ProtocolProtocol Type Testing and CastingDeclaring a ProtocolProtocol CompositionClass ProtocolsOptional Protocol MembersImplicitly Required InitializersExpressible by LiteralGenericsGeneric DeclarationsContradictory Resolution Is ImpossibleType ConstraintsExplicit SpecializationGeneric InvarianceAssociated Type ChainsWhere ClausesExtensionsExtending ProtocolsExtending GenericsUmbrella TypesAnyAnyObjectAnyClassCollection TypesArrayDictionarySet
Flow ControlBranchingLoopsJumpingPrivacyPrivate and FileprivatePublic and OpenPrivacy RulesIntrospectionOperatorsMemory ManagementMemory Management of Reference TypesExclusive Access to Value TypesMiscellaneous Swift Language FeaturesSynthesized Protocol ImplementationsKey PathsDynamic MembershipProperty WrappersCustom String InterpolationReverse GenericsFunction BuildersResult
New ProjectThe Project WindowThe Navigator PaneThe Utilities PaneThe EditorProject File and DependentsContents of the Project FolderGroupsThe TargetBuild PhasesBuild SettingsConfigurationsSchemes and DestinationsFrom Project to Built AppBuild SettingsProperty List SettingsNib FilesResourcesCode FilesFrameworks, SDKs, and PackagesThe App Launch ProcessThe Entry PointHow an App Gets GoingApp Without a StoryboardRenaming Parts of a Project
The Nib Editor InterfaceDocument OutlineCanvasInspectorsLoading a NibLoading a View Controller NibLoading a Main View NibLoading a View Nib ManuallyConnectionsOutletsThe Nib OwnerAutomatically Configured NibsMisconfigured OutletsDeleting an OutletMore Ways to Create OutletsOutlet CollectionsAction ConnectionsMore Ways to Create ActionsMisconfigured ActionsConnections Between Nibs — Not!Additional Configuration of Nib-Based Instances

The Documentation WindowClass Documentation PagesQuick HelpSymbol DeclarationsHeader FilesSample CodeInternet Resources
Environmental DependenciesConditional CompilationPermissible Runtime EnvironmentBackward CompatibilityDevice TypeArguments and Environment VariablesVersion ControlEditing and Navigating Your CodeText Editing PreferencesMultiple SelectionAutocompletion and PlaceholdersSnippetsRefactoring and Structure EditingFix-it and Live Syntax CheckingNavigationFindingRunning in the SimulatorDebuggingCaveman DebuggingThe Xcode DebuggerTestingUnit TestsInterface TestsTest PlansCleanRunning on a DeviceObtaining a Developer Program MembershipSigning an AppAutomatic SigningManual SigningRunning the AppManaging Development Certificates and DevicesProfilingGaugesMemory DebuggingInstrumentsLocalizationCreating Localized ContentTesting LocalizationDistributionMaking an ArchiveThe Distribution CertificateThe Distribution ProfileDistribution for TestingFinal App PreparationsScreenshots and Video PreviewsProperty List SettingsSubmission to the App Store
SubclassingCategories and ExtensionsHow Swift Uses ExtensionsHow You Use ExtensionsHow Cocoa Uses CategoriesProtocolsOptional MembersInformal ProtocolsSome Foundation ClassesNSRangeNSNotFoundNSString and FriendsNSDate and FriendsNSNumberNSValueNSDataNSMeasurement and FriendsEquality, Hashability, and ComparisonNSArray and NSMutableArrayNSDictionary and NSMutableDictionaryNSSet and FriendsNSIndexSetNSNullImmutable and MutableProperty ListsCodableAccessors, Properties, and Key–Value CodingSwift AccessorsKey–Value CodingHow Outlets WorkCocoa Key PathsUses of Key–Value CodingKeyPath NotationThe Secret Life of NSObject
Reasons for EventsSubclassingNotificationsReceiving a NotificationUnregisteringPosting a NotificationTimerDelegationCocoa DelegationImplementing DelegationData SourcesActionsThe Responder ChainNil-Targeted ActionsKey–Value ObservingRegistration and NotificationUnregisteringKey–Value Observing ExampleSwamped by EventsDelayed Performance
Principles of Cocoa Memory ManagementRules of Cocoa Memory ManagementWhat ARC Is and What It DoesHow Cocoa Objects Manage MemoryAutorelease PoolMemory Management of Instance PropertiesRetain Cycles and Weak ReferencesUnusual Memory Management SituationsNotification ObserversKVO ObserversTimersOther Unusual SituationsNib Loading and Memory ManagementMemory Management of CFTypeRefsProperty Memory Management PoliciesDebugging Memory Management Mistakes
Visibility Through an Instance PropertyVisibility by InstantiationGetting a ReferenceVisibility by RelationshipGlobal VisibilityNotifications and Key–Value ObservingThe Combine FrameworkThe Promise of SwiftUIFunction Builders and ModifiersState PropertiesBindingsPassing Data DownhillPassing Data UphillCustom State ObjectsGlobal Objects
The C LanguageC Data TypesC EnumsC StructsC PointersC ArraysC FunctionsObjective-CObjective-C Objects and C PointersObjective-C Objects and Swift ObjectsExposure of Swift to Objective-CBridged Types and Boxed TypesObjective-C MethodsObjective-C Initializers and FactoriesSelectorsCFTypeRefsBlocksAPI MarkupBilingual Targets

Content preview from iOS 13 Programming Fundamentals with Swift

Chapter 6. Anatomy of an Xcode Project

Xcode is the application used to develop an iOS app. An Xcode project is the source for an app; it’s the entire collection of files and settings used to construct the app. To create, develop, and maintain an app, it helps to know how to manipulate and navigate an Xcode project. You’ll want to be familiar with Xcode, and you’ll need to know about the nature and structure of Xcode projects and how Xcode shows them to you. That’s the subject of this chapter.

Xcode is a powerful, complex, and very large program. Our survey will chart a safe, restricted, and essential path, focusing on aspects of Xcode that you most need to understand immediately, and resolutely ignoring everything else.

Note

The term “Xcode” is used in two ways. It’s the name of the application in which you edit and build your app, and it’s the name of an entire suite of utilities that accompanies it; in the latter sense, Instruments and the Simulator are part of Xcode. This ambiguity should generally present little difficulty.

New Project

Even before you’ve written any code, an Xcode project is quite elaborate. To see this, let’s make a new, essentially “empty” project; you’ll find that it isn’t empty at all.

Start up Xcode and choose File → New → Project.
The “Choose a template” dialog appears. The template is your project’s initial set of files and settings. When you pick a template, you’re really picking an existing folder full of files; this folder is hidden deep inside ...