Course Overview
- Must Have Good Understanding of Programming Concepts
- Must Have Good Understanding of OOPS Concepts
- Basic Knowledge of OS X usage and navigation would be desired, not mandatory
Requirements
- iOS App Development Basics, the second course in the iOS App Development with Swift specialization, expands your programming skills and applies them to authentic app development projects. The topics covered in this course include XCode basics, Core iOS and Cocoa Touch frameworks, simple user interface creation, MVC Architecture and much more. With a focus on using Apple’s components to access sensors like camera, microphone and GPS, by the end of this course you will be able to create a basic App according to specified parameters and guidelines.
Curriculum
-
Day 1
- Introduction to iOS Development Fundaments
- Introduction to SWIFT Development Fundaments
- Start Up – Understanding the Development Environment
- Start Up – Installing the Tools
- Start Up – Installing the Tools
- Start Up – Understanding the XCode and IB interface
- Start Up – Understanding the Playground
- Start Up – Understanding the advantages and Limitations of Simulator
- Swift Programming Language
- Swift Basics – The language basics
- Swift Basics – Constants and Variables
- Swift Basics – Type Annotations
- Swift Basics – Data Types
- Swift Basics – Type-Safety and Inference
- Swift Basics – Conversions
- Swift Basics – Tuples
- Swift Basics – Optionals
- Basic Operators
- Strings and Characters
- Collection Types – Arrays
- Collection Types – Dictionaries
- Collection Types – Assignment and Copy behavior
- Collection Types – Mutation in Collections
- Control Flow – Conditional Statements
- Control Flow – Iteration Statements
- Control Flow – Value bindings
- Control Flow – Control Transfer
- Functions – Defining Functions
- Functions – Function Parameters
- Functions – Functions with Multiple Return values
- Functions – External Parameters
- Functions – In-Out Parameters
- Functions – Function Types
- Functions – Function Types are Parameters
- Functions – Nested Functions
- Closures – Closure Expressions
- Closures – Closure Context
- Closures – Trailing Closures
- Closures – Closures as Reference types
- Enumerations – Enumeration Basics
- Enumerations – Associated Values
- Enumerations – Raw Values
- Optional Chaining
- Type Casting – Class Hierarchy for Type Casting
- Type Casting – Type Checking
- Type Casting – Down Casting
- Type Casting – Object Casting
-
Day 2
- Classes and Structures
- Defining class and structure instances
- Properties – Stored Properties
- Properties – Computer Properties
- Properties – Property Observers
- Properties – Type Properties
- Initializers
- Methods – Type Methods
- Methods – Instance Methods
- Methods – Subscripts
- Inheritance
- Defining Base Class
- Subclassing
- Overriding
- Preventing Overrides
- Initialization – Designated Initializer
- Initialization – Custom Initialization
- Initialization – Default Initialization
- Initialization – Initializer Chaining and Safety
- Deinitialization
- Automatic Reference Counting – How ARC Works
- Automatic Reference Counting – Strong Reference Cycles
- Automatic Reference Counting – Resolving Strong Reference Cycles
- Extensions – Types
- Extensions – Methods
- Extensions – Initializers
- Extensions – Subscripts
- Extensions – Nested Types
- Protocols – Property Requirements
- Protocols – Method requirements
- Protocols – Mutating Requirements
- Protocols – Protocols as Types
- Protocols – Delegation
- Protocols – Protocol Conformation with Extension
- Protocols – Protocol Adaption
- Protocols – Collections of Protocol
- Protocols – Protocol Inheritance
- Protocols – Optional Protocols
- Generics – Why use Generics
- Generics – Functions
- Generics – Type parameters
- Generics – Types
- Generics – Constraints
- Generics – Associated Types
- Generics – Where Clauses
- User Interface
-
Day 3
- UI basic – Using iPhone Project Templates
- UI basic – The Units of Measurement
- UI basic – The iOS Hello World Boilerplate Dissection
- UI basic – Understanding the App Startup process
- UI basic – The iOS Architecture
- UI basic – Retina v/s non-Retina UI considerations
- UI basic – The Developer License
- UI basic – Understanding Views and Windows
- UI basic – Creating User Interface
- Basic GUI Components – UITextField, UISlider, UISegementControl, UIStepper, UIButton etc
- Actions, Outlets and Events
- Handling Basic Interactions
- The Human Interface Guidelines
- Understanding Delegation
- Exercise – Create a Settings Controller that allows to Switch Font Sizes, Change RGB color background, Allow Text Events
- Understanding UITableView -Understanding UINavigationController
- Understanding UITableView – Creating a Simple Table View
- Understanding UITableView – Reusing TableViewCells
- Understanding UITableView – Customizing a TableView
- Understanding UITableView – Grouping Data in Tables
- Understanding UITableView – Selecting and Navigation in TableViews
- Modal Views – Alerting a User
- Modal Views – Customization AlertViews
- Modal Views – Capturing User response
- Modal Views – TextField Alerts and Keyboard Styles
- Modal Views – Implementing ActionSheets
- UICollectionView – Using a UICollectionView
- UICollectionView – DataSource and Delegates
- UICollectionView – Custom UICollectionViewCells
- UICollectionView – Reusing Collection Cells
- Creating Custom Controls by Subclassing – Creating Controls Programmatically
- Creating Custom Controls by Subclassing – Adding Interactivity to Controls
- Creating Custom Controls by Subclassing – Subclassing UIControls
- Creating Custom Controls by Subclassing – Creating Custom Controls
- Advanced UITableViews – Adding Custom controls to TableView
- Advanced UITableViews – Loading custom cells from Nib
- Advanced UITableViews – Adding Interaction to TableView Controls
- Advanced UITableViews – Lazy Loading Table Cells
- iPad Considerations – Split-View Controller and Popovers
-
Day 4
- Multi-View Applications – Container and Content Views
- Multi-View Applications – Introduction to Multi-View Applications
- Multi-View Applications – The MVC Architecture. Why and How to use MVC.
- Multi-View Applications – Subclassing Controllers
- Multi-View Applications – Creating a Utility Application and Creating Protocols
- Multi-View Applications – Implementing Different Animation for View Transitions
- The Application Project Structure
- Creating and Accessing your own Bundles
- A Start Up Project using Different Controllers. ###
- Creating a Multi-View Application from Scratch
- Creating Scenes and Segues
- Adding Controllers
- Passing Data Across Scenes
- Understanding Master-detail Application
- Universal Applications
- This project forms the base line for our Further Topics. – This App, to start up, deals with a few concepts like:
- This project forms the base line for our Further Topics. – Creating a Project with an MVC Architecture
- Passing Data across controllers – Forward data passing
- Passing Data across controllers – Creating your own Protocol to pass data backwards.
- Passing Data across controllers – Comparing Your Protocol with UITableViewDataSource Protocol`
- Passing Data across controllers – Different styles of Segues
- Passing Data across controllers – Initiating a Segue
- Further, with Data Persistence, we will get the data from an SQLite store to populate the App
- Further on, we shall consume a web-service, save the data into the SQLite data, and that data will populate the App
- Debugging and Troubleshooting – Using NSLog for Troubleshooting and understanding App Flow
- Debugging and Troubleshooting – Using the Debugger
- Debugging and Troubleshooting – Creating breakpoints and Navigating through
- Debugging and Troubleshooting – Checking and Changing the values of Variables at Breakpoints
- Debugging and Troubleshooting – Troubleshooting our Sample App
- Basic Data Handling – Understanding the Controller States in Life Cycle
- Basic Data Handling – Understanding Application Document Structure
- Basic Data Handling – Understanding the Product Folder Structure
- Basic Data Handling – The Application Default Folders and File Manager
- Basic Data Handling – Capturing Files form Bundles
- Basic Data Handling – Storing and retrieving data from Files
- Basic Data Handling – Storing and Retrieving data from Plists
- Data Persistence – Limitations of iOS Data Access
- Data Persistence – Creating Preference / Settings Bundles
- Data Persistence – Using User Defaults to store user defaults
- Data Persistence – Updating the UI for Settings Bundle
- Data Persistence – Creating the Settings bundle
- Data Persistence – Using settings bundle values in the App
- Data Persistence – The Notification Message Pattern
- Database storage
- Sqlite – Using the SQlite Library
- Sqlite – Creating a SQLite database
- Sqlite – Accessing SQLite database
- Sqlite – Mapping datatypes with UI elements and Creating a Model Class
- Sqlite – Getting SQLite data into our Sample App. ###
-
Day 5
- Web and Networking – Reading data from Network
- Web and Networking – HTTP requests
- Web and Networking – XML Parsing
- Web and Networking – Getting the Data from Web service and Populating our Sample Project
- Web and Networking – JSON Serialization and Deserialization
- Web and Networking – Synchronous and asynchronous Downloads
- Multi-threading & Performance – Block & Categories
- Multi-threading & Performance – Threads and Alternatives
- Multi-threading & Performance – Synchronous and Asynchronous APIs
- Multi-threading & Performance – The Grand Central Dispatch
- Multi-threading & Performance – The Operations Queue
- Multi-threading & Performance – Enabling Background Apps
- Multi-threading & Performance – Handling the App States and Application Guidelines
- Handling Device Features – Identifying Device Capabilities
- Handling Device Features – Using Accelerometer
- Handling Device Features – Capturing Accelerometer Data
- Handling Device Features – Auto-Layouts and Constraints
- Handling Device Features – Gesture Recognition, Taps and Touches
- Handling Device Features – Adding Gestures to UI Elements
- Handling Device Features – Multi-touch terminology
- Handling Device Features – Detecting Swipes, Touches and Taps
- Handling Device Features – Using UIApplicationDelegate and UIResponder
- Handling Device Features -Understanding the Responder chain
- Wrap Up – Localization
- IWrap Up – nstruments – Error Detection and Tuning
- Wrap Up – Running the Analyzer
- Wrap Up – Using Instruments for Memory leaks, Time Profiling
- Wrap Up – Detecting Zombies and Leaks.
- Setting up the App Properties
- Registering as Developer
- Understanding Provisioning
- Procuring Provisioning Files
- Packaging the Application for iTunes, Distribution
