book

Swift: Developing iOS Applications

by Andrew J Wagner, Giordano Scalzo, Jon Hoffman

August 2016

Intermediate to advanced

1027 pages

23h 11m

English

Packt Publishing

Read now

Unlock full access

What this learning path covers
Downloading the example codeErrataPiracyQuestions

Defining our goals for this book
Core Swift typesConstants and variablesContainersTuplesArraysDictionaries
ConditionalsSwitchesLoops
Basic functionsParameterized functionsFunctions that return valuesFunctions with default argumentsGuard statement
StructsTypes versus instancesPropertiesMember and static methodsComputed propertiesReacting to property changesSubscriptsCustom initialization
Inheriting from another classInitializationOverriding initializerRequired initializerDesignated and convenience initializersOverriding methods and computed propertiesMethodsComputed propertiesCastingUpcastingDowncasting
Basic declarationTesting enumeration valuesRaw valuesAssociated valuesMethods and properties
Setting up a command-line Xcode projectCreating and using an external fileInterfacing with code from other filesFile organization and navigation
How scope is definedNested types
Defining an optional
Optional bindingForced unwrappingNil coalescing
Functional programming philosophyState and side effectsDeclarative versus imperative code
Closures as variablesClosures as parametersSyntactic sugar
FilterReduceMapSortHow these affect the state and nature of code
ProtocolsDefining a protocolImplementing a protocolUsing type aliases
Generic functionGeneric typeType constraintsProtocol constraintsWhere clauses for protocolsWhere clauses for equality
Adding methods to all forms of a genericAdding methods to only certain instances of a genericExtending protocols
GeneratorsSequencesProduct of Fibonacci numbers under 50
Computer data storageFile systemMemory
Determining value type or reference typeBehavior on assignmentBehavior on inputClosure capture behavior
Object relationshipsStrongWeakUnowned
Between objectsSpottingFixingWith closuresSpottingFixing
Between objectsWith closures
Throwing errorsDefining an error typeDefining a function that throws an errorImplementing a function that throws an error
Forceful tryOptional tryCatching an errorPropagating errors
Order of execution when errors occurDeferring execution
What is a design pattern?
IteratorObserverCallbackNotification center
CompositeHierarchiesAlternative to subclassingDelegateModel view controller
Singleton/shared instanceAbstract factory
Replacing class hierarchiesConcisely representing state
Avoiding unnecessary memory usageAvoiding unnecessary processingLocalizing logic to the concerned property
Swift's relationship to Objective-C
Value typesReference types
ArraysDictionaries
ConditionalsSwitchesLoops
StructuresEnumerationsClassesBasic classInitializersPropertiesMethodsInheritanceCategoriesProtocolsBlocks
Header filesImplementation filesOrganization
Bridging header
Using typesContainersAnnotationsNullabilityContainer element types
Conceptualizing the appFeaturesInterfaceData
Apple's documentation
Blog postsForums
The first look at SwiftLet's go to the playgroundThe building blocks – variables and constantsCollecting variables in containersControlling the flowTransforming the values using functionsStructs – custom compound typesClasses – common behavior objectsLoose coupling with protocolsComposing objects using protocol extensionsChecking the existence of an optional valueEnumerations on steroidsExtended pattern matchingCatching errorsSwift functional programming patterns
The app is…Building a skeleton appAdding the graphics componentsConnecting the dotsAdding the code
The app is…
Implementing the basic menu screenCreating a nice menu screen
The structureAdding a collection viewSizing the components
What we are expectingThe card entityCrafting the deckShuffling the deckFinishing the deckPut the cards on the tableAdding the assetsThe CardCell structureHandling touches
Implementing the game logicWe got a pairWe made the wrong moveEt voilà! The game is completed
The app is…
Implementing an empty appAdding third-party libraries with CocoaPodsImplementing the Todos view controller
Adding entitiesImplementing datastoreConnecting datastore and View ControllerConfiguring tableViewFinishing touchesSwipe that cell!
The add a Todo viewThe add a Todo View ControllerFinishing TodoDatastoreList View ControllerWhere do we go from here?
The app is…
Creating the projectAdding assets
The UI in blocks
Implementing CurrentWeatherViewBuilding WeatherHourlyForecastViewSeeing the next day's forecast in WeatherDaysForecastView
Searching in Flickr
Using Core Location
Getting the forecast from OpenWeatherMapRendering CurrentWeatherViewRendering WeatherHourlyForecastViewRendering WeatherDaysForecastView
The app is…
Creating the projectImplementing the menu
SpriteKit in a nutshellExplaining the codeSimulating a three-dimensional world using parallaxHow to implement scrolling
Adding the Bird nodeMaking the bird flap
Implementing the pipes node
Setting up the collision-detection engine
Colliding with pipesAdding the scoreAdding a restart pop-up
Adding juicinessLet there be sounds!Playing the soundtrackShaking the screen!
What Game Center providesSetting up Game CenterCreating an app record on iTunes ConnectEnabling Game CenterCreating fake user accounts to test Game CenterAuthenticating a player
The app is…
What is SceneKit?Building an empty sceneAdding a green torusLet there be light!Let's make it move!
The game skeletonImplementing the menu
Setting up a sceneAdding a fighterTexturing the worldMake it moveAdding cubesAdding more obstacles
The scoreLet's add music
Creating a real gameDetecting collisionsGame over!Adding the juiceGame Center
The app is…The first requirement: login and registrationThe second requirement: the products gridThe third requirement: the open cart
The skeleton app
The e-commerce product listThe product cellParsing and storing products
Adding a product to the cartRemoving items from cart and checkout
The interface of the ASAP Server
An OS X skeleton serverPreparing the OS X environmentThe HelloWorld skeleton serverPreparing the Linux environment
The ProductsThe cartThe order
The productsThe CartThe order
What is Swift?Swift features
Getting started with PlaygroundsiOS and OS X PlaygroundsShowing images in a PlaygroundCreating and displaying graphs in PlaygroundsWhat Playgrounds are notSwift language syntaxCommentsSemicolonsParenthesesCurly bracesAn assignment operator does not return a valueSpaces are optional in conditional and assignment statements
Constants and variablesDefining constants and variablesType safetyType inferenceExplicit typesNumeric typesIntegersFloating-pointThe Boolean typeThe string typeOptional variablesEnumerations
The assignment operatorComparison operatorsArithmetic operatorsThe remainder operatorIncrement and decrement operatorsCompound assignment operatorsThe ternary conditional operatorThe logical NOT operatorThe logical AND operatorThe logical OR operator
Swift collection types
Creating and initializing arraysAccessing the array elementsCounting the elements of an arrayIs the array empty?Appending to an arrayInserting a value into an arrayReplacing elements in an arrayRemoving elements from an arrayAdding two arraysReversing an arrayRetrieving a subarray from an arrayMaking bulk changes to an arrayAlgorithms for arrayssortInPlacesortfiltermapforEachIterating over an array
Creating and initializing dictionariesAccessing dictionary valuesCounting key or values in a dictionaryIs the dictionary empty?Updating the value of a keyAdding a key-value pairRemoving a key-value pair
Initializing a setInserting items into a setThe number of items in a setChecking whether a set contains an itemIterating over a setRemoving items in a setSet operations
NSNumberNSStringNSArrayNSDictionary
What we have learned so farCurly bracketsParentheses
Conditional statementsThe if statementConditional code execution with the if-else statementThe for loopsUsing the for loop variantUsing the for-in loop variantThe while loopUsing the while loopUsing the repeat-while loopThe switch statementUsing case and where statements with conditional statementsFiltering with the where statementFiltering with the for-case statementUsing the if-case statementControl transfer statementsThe continue statementThe break statementThe fallthrough statementThe guard statement
Using a single parameter functionUsing a multiparameter functionDefining a parameter's default valuesReturning multiple values from a functionReturning optional valuesAdding external parameter namesUsing variadic parametersParameters as variablesUsing inout parametersNesting functions
What are classes and structures?Similarities between classes and structuresDifferences between classes and structuresValue versus reference types
PropertiesStored propertiesComputed propertiesProperty observersMethods
Internal and external parameter namesFailable initializers
Overriding methodsOverriding propertiesPreventing overrides
Property requirementsMethod requirementsOptional requirements
Reference versus value typesThe working of ARCStrong reference cycles
Protocols as types
Error handling prior to Swift 2.0
Representing errorsThrowing errorsCatching errors
XML and JSON
XML and NSXMLDocument
Parsing a JSON documentCreating a JSON document
Introducing subscripts
Introducing optionals
Defining an optionalUsing optionalsForced unwrapping an optionalOptional bindingReturning optionals from functions, methods, and subscriptsUsing optionals as a parameter in a function or methodOptional types with tuples
The nil coalescing operator
An introduction to generics
An introduction to closures
What is mix and match
Creating the projectAdding Swift file to the Objective-C projectThe Objective-C bridging header file – part 1Adding the Objective-C file to the projectThe Messages Objective-C classThe Objective-C bridging header file – part 2The MessageBuilder Swift class – accessing Objective-C code from SwiftThe Objective-C class – accessing Swift code from Objective-C
Concurrency and parallelismGrand Central DispatchCreating and managing dispatch queuesCreating queues with the dispatch_queue_create() functionCreating concurrent dispatch queues with the dispatch_queue_create() functionCreating a serial dispatch queue with the dispatch_queue_create() functionRequesting concurrent queues with the dispatch_get_global_queue() functionRequesting the main queue with the dispatch_get_main_queue() functionUsing the dispatch_after() functionUsing the dispatch_once() functionUsing NSOperation and NSOperationQueue typesUsing the NSBlockOperation implementation of NSOperationUsing the addOperationWithBlock() method of the operation queueSubclassing the NSOperation class
What is a programming style guide?
Do not use semicolons at the end of statementsDo not use parentheses for conditional statementsNamingClassesFunctions and methodsConstants and variablesIndentingCommentsUsing the self keywordTypesConstants and variablesOptional typesUse optional bindingUse optional chaining over optional binding for multiple unwrappingUse type inferenceUse shorthand declaration for collectionsUse for-in loops over for loopsUse switch rather than multiple if statementsDon't leave commented-out code in your applicationGrand Central DispatchSet the attribute in the dispatch_queue_create() functionUse a reverse DNS name for the tag parameter of the dispatch_queue_create() functionUse dispatch_get_global_queue() over dispatch_queue_create()
What is network development?
NSURLSessionNSURLSessionConfigurationNSURLSessionTaskUsing the NSURL classNSMutableURLRequestNSURLHTTPResponse
RSURLRequestRSTransaction and RSTransactionRequestRSTransactionRSTransactionRequestExtensions
Value versus reference types
The singleton design patternThe builder design patternThe factory method pattern
The bridge patternThe façade patternThe proxy design pattern
The command design patternThe strategy pattern

Content preview from Swift: Developing iOS Applications

RSNetworking2 for Swift 2

You can find RSNetworking2 on GitHub with https://github.com/hoffmanjon/RSNetworking2

The RSNetworking2 library is a network library written entirely in the Swift programming language. RSNetworking2 is built using Apple's powerful URL loading system (https://developer.apple.com/library/mac/documentation/Cocoa/Conceptual/URLLoadingSystem/URLLoadingSystem.html), which features the NSURLSession class that we used earlier in this chapter. The main design goal of RSNetworking2 is to make it easy and quick for developers to add powerful asynchronous networking requests to their applications that are written in Swift.

There are the three ways in which we can use RSNetworking2:

RSURLRequest: This API provides a very simple and ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Start your free trial

iOS Development with Swift

Craig Grummitt

iOS Development with Swift in Motion

Craig Grummitt

Intermediate Swift: iOS App Development with UIKit

Lucas Derraugh

iOS 13 Programming Fundamentals with Swift

Matt Neuburg

Publisher Resources

ISBN: 9781787120242