Awesome iOS Developer

Coding convention

set of guidelines for a specific programming language that recommend programming style

Swift Style Guide

Swift Lint

The way of force you to adapt coding convention

otherwise project build will FAILED

if which swiftlint >/dev/null; then
  swiftlint
else
  echo "error: SwiftLint not installed, download from https://github.com/realm/SwiftLint"
  exit 1
  fi

put .yml file into root folder and apply following code in Build Phases

You can modify(delete) SwiftLint Option with opening .yml file

Shift + Command + . will show the hidden file

πŸ“šπŸ“š Recommend Book πŸ“šπŸ“š

Book Name Authors Name
Clean Code: A Handbook of Agile Software Craftsmanship Robert C. Martin
The Pragmatic Programmer Your Journey to Mastery, 20th Anniversary Edition Andrew Hunt David Hurst Thomas

Design Pattern

Check this website for design pattern in Swift

Adaptor

Adapter pattern is a structural design pattern that is useful for composing classes and objects into a larger system.

protocol Target {
    func request()
}

class Adaptee {
    func specificRequest() {}
}

class Adapter: Target {
    let adaptee: Adaptee
    
    init(adaptee: Adaptee) {
        self.adaptee = adaptee
    }
    
    func request() {
        adaptee.specificRequest()
    }
}

Delegation

Delegation is a design pattern that enables a class to hand off (or β€œdelegate”) some of its responsibilities to an instance of another class.

Example

Create a protocol

protocol SomeProtocol: AnyObject {
    func reload()
}

Create a delegate

weak var delegate: SomeProtocol?

You can check the code using delegation pattern here

Dependency Injection

Dependency injection is a pattern that can be used to eliminate the need for singletons in a project

  1. Raise Transparency
  2. Improve Testability

Type of Dependency Injection

1. initializer injection

class DataManager {

   private let serializer: Serializer

   init(serializer: Serializer) {
       self.serializer = serializer
   }

}

2. property injection

import UIKit

class ViewController: UIViewController {

   var requestManager: RequestManager?

}

3. method injection

import Foundation

class DataManager {

   func serializeRequest(request: Request, withSerializer serializer: Serializer) -> Data? {
       ...
   }

}

Nuts and Bolts of Dependency Injection in Swift

Factory

Factory method is a creational design pattern which solves the problem of creating product objects without specifying their concrete classes.

Observer

Observer is a behavioral design pattern that allows some objects to notify other objects about changes in their state.

  • Observer - An object that wishes to be notified when the state of another object changes.
  • Subject (Observable) - An object that maintains a list of observers, and inform them of state changes usually by calling one of their methods. An observable slightly differs in this in that it is just a function that sets up an observation.
  • Subscribe - An observer lets a subject know that it wants to be informed of changes through a process called subscribing.

Check following sites

TBD

KVO

KVO stands for Key Value Observing

KVC

KVO vs KVC

We are using KVC in Storyboard!

Singleton

singleton pattern is to ensure only one instance of a class is alive at any one time.

class SingletonPattern {
    static let manager = SingletonPattern()
    
    private init() {}
}

Back to Content

Code Structuring(Architecture)

πŸ“šπŸ“š Recommend Book πŸ“šπŸ“š

Book Name Authors Name
Advanced iOS App Architecture : Real-world app architecture in Swift raywenderlich Tutorial Team

MVC

MVC pattern stands for Model - View - Controller

  • Model - Model take care of storing data.
  • View - View renders the data for users
  • Controller - Controller modifies the View, accepts user input and interacts directly with the Model. And take care of view logic and business logic.

MVP

MVVM

MVVM patterns stand for Model - View - ViewModel

MVC vs MVVM

  • Model – Which holds the application data

  • View – It displays the data that is stored in model. These are visual elements through which a user interacts. These are subclasses of UIView

  • View Model – Transform model information/data and it interacts with controller or view to display those informations.

  • Controller class – It will be there but the responsibility of view business logic has been removed and give to view model

You can check App example of using MVVM here

VIPER

  • View - Displays what it is told to by the Presenter and relays user input back to the Presenter.
  • Interactor - Contains the business logic as specified by a use case.
  • Presenter - contains view logic for preparing content for display (as received from the Interactor) and for reacting to user inputs (by requesting new data from the Interactor).
  • Entity - contains basic model objects used by the Interactor.
  • Routing - contains navigation logic for describing which screens are shown in which order.

Getting Started with the VIPER Architecture Pattern

Swift Composable Architecture

The Composable Architecture. The Composable Architecture is a library for building applications in a consistent and understandable way, with composition, testing, and ergonomics in mind

// example will update here

Back to Content

UIDesign

HIG(Human Interface Guidelines)

SwiftUI

SwiftUI is a user interface toolkit that lets us design apps in a declarative way(Declarative syntax).

Useful Cheat Sheet for SwiftUI

TBA

Back to Content

iOS icon

  • SF Symbols Download SF Symbols2 for more icons!
  • icon8 You can download icons imge for your APP
  • appicon generate the app icon size
  • flaticon Free icons download

UIdesign Inspiration

Vector Graphic Editors

Design Collaboration Tools

Design Tools

  • DetailsPro You can design with SwiftUI free πŸ‘

Back to Content

Helper

All files are resuable files and protocol oriented. Just Copy and Paste inside your project and use it!! πŸ‘

These helper files are not with Error Handling! careful at use

Email, Message, Call

You can check the file in the follow link

Usage

import MessageUI first

import MessageUI

Then use it

Don't forget to extend the mail, message delegate to your ViewController!

    lazy var conversation = ConversationManager(presentingController: self, mailDelegate: self, messageDelegate: self, viewController: self)
    
    @IBAction private func sendEmail(_ sender: UIButton) {
        conversation.sendEmail(feedback: MailFeedback(recipients: ["[email protected]"], subject: "FeedBack", body: "Write feedback here"))
    }
    @IBAction private func sendMessage(_ sender: UIButton) {
        conversation.sendMessage(feedback: MessageFeedBack(recipients: ["1111111111"], body: "Type here"))
    }
    @IBAction private func startCall(_ sender: UIButton) {
        conversation.makeCall(number: "1111111111")
    }

Good To GO πŸ‘πŸ‘πŸ‘

See Example here

Back to Content

Network Layer

Usage

First, set the base URL in EndPointType file

Don't forget to put your API key in it!

var baseURL: URL {
        guard let url = URL(string: "https://api.openweathermap.org/data/2.5/") else {
            fatalError("baseURL could not be configured.")
        }
        return url
    }

then make a instance of router.swift file in your code

private let router = Router<YourAPI>()

for YourAPI part, simply create a new enum with cases about specific api URL

It will make your router more dynamic!
Don't forget extension to EndPointType!

enum YourAPI {
    case first(country: String)
    case second(time: Int)
    case third(name: String)
}

extension YourAPI: EndPointType {
    var path: String {
        switch self {
        case .first(let country):
            return "\(country).json"
        case .second(let time):
            return "\(time).json"
        case .third(let name):
            return "\(name).json"
        }
    }
}

then, use it like this

router.request(.first(country: London)) { [weak self] (results: Result<CountryWeather, AppError>) in
            guard let self = self else { return }
            switch results {
            case .success(let data):
                // insert your modifications!
                
            case .failure(let error):
                // insert your modifications!
                print(error)
            }
        }

CountryWeather should be a model with Decodable

If you want to see how can I use Network Layer in Project, check this

This reusable network layer files for referenced from here

Also Alamofire will be a great option for Network Layer!

Image Picker

Usage

Copy and Paste in your project and then declare Image Picker object inside your project

lazy var imagePicker = ImagePicker(presentationController: self, delegate: self)

Then, extend ImagePickerDelegate to your viewController

extension ViewController: ImagePickerDelegate {
    func didSelect(image: UIImage?) {
        self.yourImageView.image = image
        self.dismiss(animated: true, completion: nil)
    }
}

Good To GO πŸ‘πŸ‘πŸ‘

See Example here

File Manager

Usage

Copy and Paste in your project

let readData = FileManageHelper.manager.readFile(filename: fileNameTextField.text ?? "", type: extensionTextField.text ?? "")
resultTextField.text = readData

File Manager are wrote with singleton pattern, therefore no need to declare in side your code!

Good To GO πŸ‘πŸ‘πŸ‘

Video Downloader

Usage

Make an object of VideoManager inside your code

let videoManager = VideoManager()

use downloadVideoLinkAndCreateAsset function to start download with entering URL

self.videoManager.downloadVideoLinkAndCreateAsset(text)

Good To GO πŸ‘πŸ‘πŸ‘

Image Downloader

There is no file for Image Downloader.

To download images into device, only thing is this

if let data = try? Data(contentsOf: urls),
   let image = UIImage(data: data) {
   UIImageWriteToSavedPhotosAlbum(image, nil, nilil)
}

Just change urls into your image URL

UIImageWriteToSavedPhotosAlbum will take care it to download to device.

For more info go here

Good To GO πŸ‘πŸ‘πŸ‘

Location Manager

Currently Working

Back to Content

Local Notification Manager

Back to Content

API

API(Application Programming Interface) is an interface that defines interactions between multiple software applications or mixed hardware-software intermediaries. It defines the kinds of calls or requests that can be made, how to make them, the data formats that should be used, the conventions to follow, etc.

Various API Site

Back to Content

xAPI

The Experience API (or xAPI) is a new specification for learning technology that makes it possible to collect data about the wide range of experiences a person has (online and offline). This API captures data in a consistent format about a person or group’s activities from many technologies. Very different systems are able to securely communicate by capturing and sharing this stream of activities using xAPI’s simple vocabulary.

JSON

JSON is a language-independent data format

Which is relative with KEY - VALUE pair

{
    "main": [
        {
            "title": "example1",
            "body": "body1"
        },
        {
            "title": "example2",
            "body: "body2"
        }
    ]
}

JSON parser extension for Chrome

This extension makes JSON more structable
JSON parser pro FREE :+1:

JSONDecoder

To use JSONDecoder in swift, you have to define the model to be Codable or Decodable

public typealias Codable = Decodable & Encodable

Decodable can only decode the json data. Can't encoded json file!!

struct User: Codable {
    var firstName: String
    var lastName: String
    var country: String
    
    enum CodingKeys: String, CodingKey {
        case firstName = "first_name"
        case lastName = "last_name"
        case country
    }
}

To avoid snake_case in swift, use CodingKeys or JSONDecoder.KeyDecodingStrategy

To use JSONDecoding, declare JSONDecoder and use decode() function

 do {
    let data = try JSONDecoder().decode(T.self, from: unwrappedData)
    completionOnMain(.success(data))
} catch {
    print(error)
    completionOnMain(.failure(.parseError))
}

T.self -> Model(Struct) of the data that you want to decode

data will decoded to form of T

unwrappedData -> Input actual data from file or server

This should be a Data Type!!

JSONSerialization

JSONSerialization is a old way of decode the JSON file.

Apple populated Codable since Swift 4

Example

Example of number.json data

{
    "number": [
        {
            "name": "Dennis",
            "number": "111-222-3333"
        },
        {
            "name": "Jenny",
            "number": "444-555-6666"
        },
        {
            "name": "Ben",
            "number": "777-888-9999"
        }
    ]
}

Here is a example of JSONSerialization with actaul JSON file in project folder

Otherwise you can use URL!

    private func populateDataFromJson() {
        
        if let path = Bundle.main.path(forResource: "NumberData", ofType: "json") {
            do {
                let dataJson = try Data(contentsOf: URL(fileURLWithPath: path))
                let jsonDict = try JSONSerialization.jsonObject(with: dataJson, options: .mutableContainers)
                if let jsonResults = jsonDict as? [String: Any],
                   let results = jsonResults["number"] as? [[String: Any]] {
                    results.forEach { dict in
                        // simply appended to list(array)
                        self.phoneNumberList.append(PhoneNumber(name: dict["name"] as? String ?? "", number: (dict["number"] as? String ?? "")))
                        self.phoneNumberListClone.append(PhoneNumber(name: dict["name"] as? String ?? "", number: (dict["number"] as? String ?? "")))
                    }
                }
            } catch {
                print(error.localizedDescription)
            }
        }
    }

.mutableContainers allows to working like a array and dictionary type

JSON Parser Library

This library provide JSON parsing

Back to Content

NotificationCenter

A notification dispatch mechanism that enables the broadcast of information to registered observers.

Back to Content

UserDefaults

The UserDefaults class provides a programmatic interface for interacting with the defaults system. Check Apple Document for more info

UserDefaults has to have key-value pair

When do we use UserDafaults

  • User information, like name, email address, age, occupation
  • App settings, like user interface language, app color theme or β€œdetailed vs. simple UI”
  • Flags, more on this later
  • If store data is small

How to find documentDirectory

Put this line of code inside of your project

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        print(NSSearchPathForDirectoriesInDomains(.documentDirectory, .userDomainMask, true).last ?? "")
        return true
    }

simply move into that path and you can find the documentDirectory of your Application

if Library is not shown up, just do Shift + Command + . to show hidden files in your folder

Usage

As you can see in the below, intArray will stored inside the device through UserDefaults(), so that if device is shut down, changed value wil be stored in device.

class ViewController: UIViewController {
    var intArray = [1,2,3,4,5]
    let defaults = UserDefaults()
    
    override func viewDidLoad() {
        super.viewDidLoad()
        intArray = defaults.array(forKey: "IntArray") as! [Int]
    }
    
    @IBOutlet weak var textField: UILabel!
    @IBAction private func isClicked(_ sender: UIButton) {
        intArray.append(6)
        defaults.set(intArray, forKey: "IntArray")
        textField.text = "\(intArray)"
    }
}

You can your plist file like this!

Declare Userdefault like this!

let defaults = UserDefaults.standard

standard allows to access from anywhere inside device

With using set function, you can set userdefaults

Also these function will allow to get a data from plist

Store Object

Store Object

You are GOOD TO GO πŸ‘πŸ‘πŸ‘

Back to Content

Core Data

Everything Core Data

Use Core Data to save your application’s permanent data for offline use, to cache temporary data, and to add undo functionality to your app on a single device.

Core Data in Swift is using SQLite as DEFAULT

Image From London App Brewery

πŸ“šπŸ“š Recommend Book πŸ“šπŸ“š

Book Name Authors Name
Core Data by Tutorials: iOS 12 and Swift 4.2 Edition raywenderlich Tutorial Team

Core Data Stack

  • NSManagedObject - This is a base class of all the core data model object. This provides the schema of our database table. This is used to store model data in our application. KVO and KVC compliant. It can notify any changes that are done on its properties if any object is listening.

  • NSManagedObjectContext - Most important class. This is the place where you do all the computations. You can think this as a scratch pad where you do all the operations realated to core data (CRUD). It's an object which you can use to manipulate and track any changes done to manage object. All the changes done on a context object will be held until and unless you are discarding or writing those changes permaneently to persistntent storage.

  • NSPersistentStoreCoordinator - The main functionality is to provide a communication between context and persistent store.

  • NSPersistentStore - They are the stores in which the data are being saved. These includes SQLite, In-Memory, Binary, XML(the XML store is not available on iOS).

  • NSPersistentContainer - This contains the whole core data stacks.

Set Up Core Data

Simply Click Core Data check box when you create a new project

If you want to attach Core Data in exsiting project

Create Data Model file first

Then import CoreData inside your AppDelegate.swift file

import CoreData

And Copy and Paste this lines of code inside your AppDelegate.swift file

    // MARK: - Core Data stack

    lazy var persistentContainer: NSPersistentContainer = {
        /*
         The persistent container for the application. This implementation
         creates and returns a container, having loaded the store for the
         application to it. This property is optional since there are legitimate
         error conditions that could cause the creation of the store to fail.
        */
        let container = NSPersistentContainer(name: "Your DataModel file name")
        container.loadPersistentStores(completionHandler: { (storeDescription, error) in
            if let error = error as NSError? {
                // Replace this implementation with code to handle the error appropriately.
                // fatalError() causes the application to generate a crash log and terminate. You should not use this function in a shipping application, although it may be useful during development.
                 
                /*
                 Typical reasons for an error here include:
                 * The parent directory does not exist, cannot be created, or disallows writing.
                 * The persistent store is not accessible, due to permissions or data protection when the device is locked.
                 * The device is out of space.
                 * The store could not be migrated to the current model version.
                 Check the error message to determine what the actual problem was.
                 */
                fatalError("Unresolved error \(error), \(error.userInfo)")
            }
        })
        return container
    }()

    // MARK: - Core Data Saving support

    func saveContext () {
        let context = persistentContainer.viewContext
        if context.hasChanges {
            do {
                try context.save()
            } catch {
                // Replace this implementation with code to handle the error appropriately.
                // fatalError() causes the application to generate a crash log and terminate. You should not use this function in a shipping application, although it may be useful during development.
                let nserror = error as NSError
                fatalError("Unresolved error \(nserror), \(nserror.userInfo)")
            }
        }
    }

Don't forget to change it

let container = NSPersistentContainer(name: "Your DataModel file name")

And goto SceneDelegate.swift file, copy below lines of code and replace yours

func sceneDidEnterBackground(_ scene: UIScene) {
        // Called as the scene transitions from the foreground to the background.
        // Use this method to save data, release shared resources, and store enough scene-specific state information
        // to restore the scene back to its current state.

        // Save changes in the application's managed object context when the application transitions to the background.
        (UIApplication.shared.delegate as? AppDelegate)?.saveContext()
    }

If your target is below iOS13, put this line of code in side your applicationWillTerminate of AppDelegate.swift file

self.saveContext()

Core Data Usage

Once you create your DataModel file, you can simply create a Entity(Class) and Attributes(Properties)

And then, change the type of attributes in inspector like this

Once you create your own Entities & Attributes, go to Inspector and change Module to CurrentProductModule

If you didn't set it, thats fine, but if you are working in big project, then you need to set it. Otherwise this can occurs some error.

Codegen

As you can see in above, there are three options

  • Manual/None - Swift didn't generate CoreDataClass, CoreDataProperties files so that you have to create yourself (full control)
  • Class Definition - Swift will generate CoreDataClass, CoreDataProperties files. (No control)
  • Category/Extension - Swift will generate only Extension file (Some Control)

CoreDataClass, CoreDataProperties are located in below

/Users/dennis/Library/Developer/Xcode/DerivedData/CoreDataUserDefaultPractice-hisefjfyuvglrjekndpftwazftug/Build/Intermediates.noindex/CoreDataUserDefaultPractice.build/Debug-iphonesimulator/CoreDataUserDefaultPractice.build/DerivedSources/CoreDataGenerated/CoreDataUserDefaultPractice

And CoreDataClass, CoreDataProperties are looking like this,

If your code can run it but didn't get your Entities, Rebuild it or Restart your Xcode

The reason that files divided into two files is that one for writing Business Logic, one for Properties

Entities

An entity represents a table in your database. It is the blueprint for the NSManagedObject subclass instances that you will create and use throughout your application.

Attributes

Attributes are properties of your object. They translate to a column in your database table and a property in your managed object. You can choose from a variety of primitive values that the database has to offer such as a string, integer, or date.

Relationships

A relationship describes how one entity relates to another. Two important aspects of this are the cardinality and the deletion rule

Cardinality

  • One-to-many - Lets say that each Department has a group of Employees that can only work for a single Department. This would be a β€œone-to-many” relationship since each Department could have many Employees and each Employee can only work for one Department.
  • Many-to-many - If a single Employee could work for multiple Departments, then our Department/Employee relationship would be β€œmany-to-many” because each Department could have many Employees and each Employee could work for multiple Departments.

Delete Rules

Core Data Relationships and Delete Rules

  • No Action - Do nothing to the object at the destination of the relationship. For example, if you delete a department, leave all the employees as they are, even if they still believe they belong to that department.
  • Nullify (Default) - Set the inverse relationship for objects at the destination to null. For example, if you delete a department, set the department for all the current members to null. This only makes sense if the department relationship for an employee is optional, or if you ensure that you set a new department for each of the employees before the next save operation.
  • Cascade - Delete the objects at the destination of the relationship. For example, if you delete a department, fire all the employees in that department at the same time.
  • Deny - If there is at least one object at the relationship destination, then the source object cannot be deleted. For example, if you want to remove a department, you must ensure that all the employees in that department are first transferred elsewhere (or fired!) otherwise the department cannot be deleted.

Store Data

Declare context as a global variable

let context = (UIApplication.shared.delegate as! AppDelegate).persistentContainer.viewContext

Get viewContext that we defined in AppDelegate.swift file

Simply you can use this code to save your data to CoreData

func saveItem() {
        do {
            try context.save()
        } catch {
            print("Error Saving Context: \(error.localizedDescription)")
        }
    }

Use it wherever you want

Data can be find if you print the path

print(FileManager.default.urls(for: .documentDirectory, in: .userDomainMask))

You can check Entities, Properties inside that file

Load Data

Refer this code and apply it to your code wherever you want to reload it

    func loadItem() {
        let request: NSFetchRequest<Item> = Item.fetchRequest()
        do {
            itemArray = try context.fetch(request)
        } catch {
            print("Load Item Error: \(error.localizedDescription)")
        }
    }

Item will be your Entity, itemArray will be your Entity object
Don't forget to import CoreData

Update Data

Simply use setValue function so that you can update your value in DB

itemArray[0].setValue(<#T##value: Any?##Any?#>, forKey: <#T##String#>)

if you are using TableView or CollectionView, change 0 to indexPath.row

Delete Data

Simply use delete function in context

context.delete(itemArray[0])

change number for dynamic!

You are GOOD TO GO πŸ‘πŸ‘πŸ‘

Back to Content

Core Bluetooth

You are GOOD TO GO πŸ‘πŸ‘πŸ‘

Back to Content

Third Party Library

Third Party Library saves you time as you do not need to develop the functionality that the library provides.
SHOULD DEVELOPERS USE THIRD-PARTY LIBRARIES?

Relying on library(abused) is not a good idea

Dependency/Package Manager

A package manager is a tool that simplifies the process of working with code from multiple sources.

  • Centralised hosting of packages and source code with public server with access to developers or contributors
  • Download the source code at the run time, so that we don’t need to include it in the repository
  • Link the source code to our working repository by including source files

More Info

CocoaPods

Download cocoapods

$ sudo gem install cocoapods

After finish download cocoapods, go to your root folder of your project and make pod file

$ pod init

Click into your pod file and edit

Image

After finish editing, update your pod file

$ pod install

You are GOOD TO GO πŸ‘πŸ‘πŸ‘

Back to Content

Carthage

First, install Carthage through HomeBrew

$ brew install carthage

if already installed, check if there is latest version.

$ carthage update

Then, go to your root project folder, and do this

touch Cartfile

open cartfile, put library that you want to use

github "<owner>/<repo>" == <version>

Example

github "Alamofire/Alamofire" == 4.9.0
github "Alamofire/AlamofireImage" ~> 3.4

And then, do this

carthage update --platform iOS

After finish downloading it, go to Xcode -> Build phases

TBD

You are GOOD TO GO πŸ‘πŸ‘πŸ‘

Back to Content

Swift Package Manager

Enter url of library that you want to install

You are GOOD TO GO πŸ‘πŸ‘πŸ‘

Back to Content

Recommend Library

  • SDWebImage - Downloading and caching images from the web
  • Kingfisher - Downloading and caching images from the web
  • Hero - Various kind of animation with using Segue
  • Alamofire - Network Layer tool
  • Moya - Network abstraction layer written in Swift
  • RxSwift - Reactive Programming in Swift
  • SwiftyJSON - JSON parsar Helper
  • IQKeyboardManager - Easy to manage Keyboard settings
  • SnapKit - Swift Auto Layout DSL for iOS
  • Charts - Make Beutiful Charts in your App
  • Quick/Nimble - Testing Library + Asynchronous tests purpose
  • etc...

Back to Content

Localization

Localization is the process of making your app support other languages. (Base language is English)

Localization Usage

First, you have to check Use Base Internationalization

It might be checked

English is a base Language

After you check it, add languages that you want to support in your App

Then, you can check your language file like this!

Create Localizable.strings file into your project

Unlike Swift, the .strings file requires that each line terminate with a semicolon
.strings file is where you can add translation data as key-value pairs

In your .strings file, check localization button and choose language

And then add Key - Value pairs for tanslation

To use localization, use NSLocalizedString to implement it

NSLocalizedString(<#T##key: String##String#>, comment: <#T##String#>)
  • [key] - put (key - value) pair that you created in .strings file
  • [comment] - It will help your translators significantly and result in better translations

Simple example below

@IBAction func showAlert() {
        let alertTitle = NSLocalizedString("Welcome", comment: "")
        let alertMessage = NSLocalizedString("How are you", comment: "")
        let cancelButtonText = NSLocalizedString("Cancel", comment: "")
        let signupButtonText = NSLocalizedString("Signup", comment: "")

        let alert = UIAlertController(title: alertTitle, message: alertMessage, preferredStyle: UIAlertController.Style.alert)
        let cancelAction = UIAlertAction(title: cancelButtonText, style: UIAlertAction.Style.cancel, handler: nil)
        let signupAction = UIAlertAction(title: signupButtonText, style: UIAlertAction.Style.default, handler: nil)
        alert.addAction(cancelAction)
        alert.addAction(signupAction)
        present(alert, animated: true, completion: nil)
    }

After that, we have to test if localization is working correctly or not

To test it, you can do either Edit Scheme or New Scheme

go to Run section, and change App Language

After finish setting Scheme try to run it!

You are GOOD TO GO πŸ‘πŸ‘πŸ‘

Back to Content

Useful for Localization

  • localazy localization tool for iOS and macOS apps. Supporting .strings, .stringsdict, .plist and XLIFF files.
  • locastudio Analyze, review, and edit your app translations.

Back to Content

Accessibility

Accessibility is all about making the iPhone, iPod touch, and iPad work for as wide a range of people as possible. That can include the very young, the very old, people brand new to computers and mobile devices, and also people with disabilities and special needs.

  • Designing your app for accessibility makes it easier to write functional tests, whether you’re using the UI Testing in Xcode.

  • You’ll also broaden your market and user base by making your app usable by a larger group.

  • Implementing accessibility in your app shows you’re willing to go the extra mile for every user, and that’s a good thing.

  • iOS Accessibility: Getting Started

Accessibility Usage

To use accessibility, you have to enable this

For most UIKit classes, the default is true, but for UILabel it’s false

label.isAccessibilityElement = true
  • accessibilityLabel - short description of control e.g. "Save" for button, "Rating" for label
  • accessibilityHint - helps the user to understand result of the action e.g "Save the documents"
  • accessibilityTraits - collection of constants that describe the type of control and/or hot it should be treated
  • accessibilityValue - Used to describe the value of a none-label UI component e.g. "50%" for progress bar

Back to Content

GCD

GCD(Grand Central Dispatch) is a low-level API for managing concurrent operations. It can help you improve your app’s responsiveness by deferring computationally expensive tasks to the background.

DispatchQueue

An object that manages the execution of tasks serially or concurrently on your app's main thread or on a background thread.

main

We can say main is a serial queue

global()

We can say global is a concurrent queue

Thread Safety

Concurrency & Thread Safety in Swift
Thread Safety in Swift

  • Dispatch Barrier

Use a barrier to synchronize the execution of one or more tasks in your dispatch queue.

Dispatch Barrier Apple Documentation

  • Dispatch Semaphore

Dispatch Semaphore Apple Documentation

  • NSLock

An object that coordinates the operation of multiple threads of execution within the same application.

NSLock

DispatchGroup

DispatchGroup Apple Document

DispatchWorkItem

The work you want to perform, encapsulated in a way that lets you attach a completion handle or execution dependencies.

DispatchWorkItem Apple Document

Operation

NSOperation Apple Documentation

OperationQueue

NSOperationQueue Apple Documentation

Back to Content

Thread Sanitizer

Thread Sanitizer is a tool to identifies the potential thread-related corruption issues. And it is a good way to find the Readers and Writers problem in your application.

Back to Content

How to Use Thread Sanitizer

Go to this Option and Click EDIT SCHEME... πŸ‘ˆ

And then go to RUN and check THREAD SANITIZER πŸ‘ˆ

Testing

Test Double

Test Double is a generic term for any case where you replace a production object for testing purposes.

  • Mocks - Mocks are pre-programmered with expectations which form a specification of the calls they are expected to receive. They can throw an exception if they receive a call they don't expect and are checked during verification to ensure they got all the calls they were expecting.
// exaple code will update
  • Fake - Objects actually have working implementations, but usually take some shortcut which makes them not suitable for production.
// exaple code will update
  • Spies - Spies are stubs that also record some information based on how they were called. One form of this might be an email service that records how many messages it was sent.
// exaple code will update
  • Stubs - Stubs provide canned answers to calls made during the test, usually not responding at all to anything outside what's programmed in for the test.
// exaple code will update
  • Dummy - Objects are passed around but never actually used. Usually they are just used to fill parameter lists.
// exaple code will update

TDD

Test Driven Development

BDD

BDD improves communication between tech and non-tech teams and stakeholders. In BDD, tests are more user-focused and based on the system’s behavior.

Behavior Driven Development

  • Encouraging collaboration across roles to build shared understanding of the problem to be solved
  • Working in rapid, small iterations to increase feedback and the flow of value
  • Producing system documentation that is automatically checked against the system’s behaviour

Three Steps(Iterative) in BDD

First, take a small upcoming change to the system – a User Story – and talk about concrete examples of the new functionality to explore, discover and agree on the details of what’s expected to be done.

Next, document those examples in a way that can be automated, and check for agreement.

Finally, implement the behaviour described by each documented example, starting with an automated test to guide the development of the code.

Code Coverage

Before start your Testing, add coverage will be a good option to show the result of test

First, check code coverage

Then, go to EDIT SHEME, check like this

Integration Testing

Integration Testing Swift by Sundell

Unit Testing

Unit Testing Swift by Sundell

πŸ“šπŸ“š Recommend Book πŸ“šπŸ“š

Book Name Authors Name
iOS Unit Testing by Example Jon Reid

UI Testing

Your first UITest in Swift

TestFlight

TestFlight makes it easy to invite users to test your apps and App Clips and collect valuable feedback before releasing your apps on the App Store.

CI/CD

CI and CD stand for continuous integration and continuous delivery/continuous deployment

Jenkins

Jenkins

Jenkins is most popular CI/CD tools

Jira

Jira is project management software first and foremost, but it began its life in 2002 as an issue tracking platform for software developers

CircleCI

CircleCI

Codemagic

Codemagic - Build, test and deliver your mobile projects 20% faster.

Xcode Cloud

WWDC21 Apple released Xcode Cloud for continuous integration

For more info, go to Apple Developer Website

Back to Content

In App Purchase(IAP)

Requirement

  • Full Apple Developoment Program($99)
  • Physical IPhone Device to test IAP

Simulator can not test IAP!!

Paywall

Paywall is a way to restrict access to their information so that only paying users can use it.

Lots of developer recommend 80% - (Paywall) - 20%

Set Up

TBD

For more info about getting start of IAP, go here πŸ“‘

Back to Content

Notification

  • Notifications are an integral way of conveying information to the user outside of an app.

  • Notifications can be either local or remote. The app on the device schedules and configures local notifications. In contrast, a server sends remote notifications using Apple Push Notification Service (APNS)

  • You can configure both local and remote notifications using the UserNotifications framework.

Local Notification

If you set repeatation less than 60 sec, it will cause ERROR!

Back to Content

Remote Notification

APNs

APNS stands for Apple Push Notification service

APNs Setting

First, go to Signing & Capabilities and add two features like this

APNs Usage

FRP

Functional Reactive Programming

Rxswift

πŸ“šπŸ“š Recommend Book πŸ“šπŸ“š

Book Name Authors Name
RxSwift: Reactive Programming with Swift raywenderlich Tutorial Team

Back to Content

Combine

Combine released on iOS13 from Apple for Functional Reactive Programming.

Swiftbysundell

πŸ“šπŸ“š Recommend Book πŸ“šπŸ“š

Book Name Authors Name
Combine: Asynchronous Programming with Swift raywenderlich Tutorial Team

RxCombine

RxCombine provides bi-directional type bridging between RxSwift and Apple's Combine framework.

RxCombine

Security

Security secure the data your app manages, and control access to your app.

Check below for more detail about iOS Security as well as Application security

Back to Content

Checklist For App Security

  • [ ] Keychain For Sensitive Data Storage
  • [ ] Application Transport Security Layer(TSL)
  • [ ] SSL Pinning
  • [ ] Jailbroken Device Check
  • [ ] Disable Debug Logs
  • [ ] Third-Party Library Usage Check
  • [ ] Code Obfuscation
  • [ ] Cryptography
  • [ ] Biometric Access

Keychain

SSL Pinning

When a mobile app communicates with a server, it uses SSL(Secure Socket Layer) pinning technique for protecting the transmitted data against tampering and eavesdropping.

How SSL Works

  1. A browser attempts to connect with a website which is secured with a SSL. The browser then requests the web server to identify itself.
  2. Web server then sends the browser its SSL certificate copy.
  3. The browser checks if the SSL certificate must be trusted. If it can be, a message is sent to the web server.
  4. Web server then sends back an acknowledgement to begin the SSL encrypted session.
  5. The encrypted data is then finally shared between the browser and web server.

SSL pinning methods

  • Pin the certificate – you can download the server’s certificate and bundle them in the app. At the runtime, the app compares the server certificate to ones that you have embedded.
  • Pin the public key – you can retrieve the public key of certificate in the code as string. At the runtime, the application compared the certificate’s public key to one which is hard-coded in the code.

Using URLSession

func urlSession(_ session: URLSession, didReceive challenge: URLAuthenticationChallenge, completionHandler: @escaping (URLSession.AuthChallengeDisposition, URLCredential?) -> Void) {
    if (challenge.protectionSpace.authenticationMethod == NSURLAuthenticationMethodServerTrust) {
        if let serverTrust = challenge.protectionSpace.serverTrust {
            var secresult = SecTrustResultType.invalid
            let status = SecTrustEvaluate(serverTrust, &secresult)
            
            if (errSecSuccess == status) {
                if let serverCertificate = SecTrustGetCertificateAtIndex(serverTrust, 0) {
                    let serverCertificateData = SecCertificateCopyData(serverCertificate)
                    let data = CFDataGetBytePtr(serverCertificateData);
                    let size = CFDataGetLength(serverCertificateData);
                    let cert1 = NSData(bytes: data, length: size)
                    let file_der = Bundle.main.path(forResource: "name-of-cert-file", ofType: "cer")
                    
                    if let file = file_der {
                        if let cert2 = NSData(contentsOfFile: file) {
                            if cert1.isEqual(to: cert2 as Data) { completionHandler(URLSession.AuthChallengeDisposition.useCredential, URLCredential(trust:serverTrust))
                                return
                            }
                        }
                    }
                }
            }
        }
    }
    
    // Pinning failed completionHandler(URLSession.AuthChallengeDisposition.cancelAuthenticationChallenge, nil)
}

Using Alamofire 5

If you are using above version, this code should be changed

More Info

First, Download SSL certificate to your project folder

https://www.yourdomain.com (NOT IN THIS WAY)

openssl s_client -showcerts -connect yourdomain.com:443 < /dev/null | openssl x509 -outform DER > yourdomain.cer

Make a SessionManager to get SSL Pinning


let sessionManager: SessionManager = {
    let serverTrustPolicies: [String: ServerTrustPolicy] = ["yourdomain.com": .pinCertificates(certificates: ServerTrustPolicy.certificates(),
                                                                                                validateCertificateChain: true,
                                                                                                validateHost: true)]
    
    return SessionManager(serverTrustPolicyManager: ServerTrustPolicyManager(policies: serverTrustPolicies))
}()

request from sessionManager, if it is invalid, print error

sessionManager.request("https://yourdomain.com").responseString { (dataResponse) in
    switch dataResponse.result {
    case .failure(let err):
        print(err)
    case .success(let val):
        print(val)
        if let headerFields = dataResponse.response?.allHeaderFields {
            print(headerFields)
        }
    }
}

Relative Stuff

TrustKit makes it easy to deploy SSL public key pinning

TrustKit

Code Obfuscation

Code obfuscation is the act of deliberately obscuring source code, making it very difficult for humans to understand, and making it useless to hackers who may have ulterior motives.

Cryptography

Introducing Swift Crypto

Biometric Access

Apple made a big change when it released the iPhone X: It ditched Touch ID fingerprint security for a new face-based biometric sign-on tool called Face ID. The fingerprint scanner on most post-iPhone X Apple products is gone, and in its place is a new camera array capable of capturing a face map that is, according to Apple, 20 times less likely to be hacked than a Touch ID fingerprint.

Apple's Face ID: Cheat sheet

Face ID & Touch ID

To use Face ID, Add Privacy - Face ID Usage Description into your info.plist file in your project

import LocalAuthentication, which can allow you to implement Biometric Access

import LocalAuthentication

After that, using LAContext() we can implement Face ID

Here are simple example that how Face ID can impelement

@IBAction private func isTouched(_ sender: UIButton!) {
        let context = LAContext()
        var error: NSError? = nil
        if  context.canEvaluatePolicy(.deviceOwnerAuthenticationWithBiometrics, error: &error) {
            let reason = "touch id"
            context.evaluatePolicy(.deviceOwnerAuthenticationWithBiometrics, localizedReason: reason) { [weak self](success, error) in
                DispatchQueue.main.async {
                   
                    guard success, error == nil else {
                        // If Fail
                        let alert  = UIAlertController(title: "FAceID Fail", message: "error", preferredStyle: .alert)
                        let action = UIAlertAction(title: "cancle", style: .cancel, handler: nil)
                        alert.addAction(action)
                        self?.present(alert, animated: true, completion: nil)
                        return
                    }
                    // If success
                    let vc = UIViewController()
                    vc.title = "hi"
                    vc.view.backgroundColor = .blue
                    self?.present(vc, animated: true, completion: nil)
                }
            }
        } else {
            // If device is not supporting Face ID
        }
    }

Error Handling is your own part

You are GOOD TO GO πŸ‘πŸ‘πŸ‘

Back to Content

Objective-C

Still we need to study Objective-C for legacy code which is still remain in our project!

Here are some useful website that you can study about simple concept of Obj-C!!

Learn Objective-C in 24 Days

πŸ“šπŸ“š Recommend Book πŸ“šπŸ“š

Book Name Authors Name
Objective-C Programming: The Big Nerd Ranch Guide Aaron Hillegass, Mikey Ward

Pure Swift Application?

Can we really say "Our application is built with pure Swift"?. NO! Lots of Objective-C codes are running in the background to built swift.

Here is a example that you can try

Simply create a pure swift application and use this lines in debug console!!

break set -r "-\[.*\]"
break set -r DebugMode
break set -r Emoji

Use one of above line when you want to find out how many Objective-C codes are consist in simple pure swift application!!

Back to Content

Bridging Header

Bridging header means access classes and other declarations from your Objective-C code in Swift.

Importing Objective-C into Swift Apple Documentation

Back to Content

Error Search

Find your common error here

Error Search

Useful Stuff

I listed some of the useful & interesting stuff related with Swift

Back to Content

How to submit your app to the AppStore

Online Swift Playground

SwiftPlayground - Online Swift Playground

Show Preview in UIKit(Build UI with Code Base) πŸ‘ πŸ‘ πŸ‘ πŸ‘ πŸ‘

Copy this code and Paste into your controller

#if canImport(SwiftUI) && DEBUG
import SwiftUI
struct SwiftLeeViewRepresentable: UIViewRepresentable {
    func makeUIView(context: Context) -> UIView {
        return UIStoryboard(name: "Main", bundle: Bundle.main).instantiateInitialViewController()!.view
    }
    
    func updateUIView(_ view: UIView, context: Context) {
        
    }
}

@available(iOS 13.0, *)
struct SwiftLeeViewController_Preview: PreviewProvider {
    static var previews: some View {
        SwiftLeeViewRepresentable()
    }
}
#endif

Enable canvas option like this

You are GOOD TO GO πŸ‘πŸ‘πŸ‘

Compare Changes in Swift Version

You can compare changes based on Swift Verison

Whatsnewinswift

Managing Xcode Space

This will be helful when you are running out of storage in your mac

# 1
echo "Removing Derived Data..."
rm -rf ~/Library/Developer/Xcode/DerivedData/

# 2
echo "Removing Device Support..."
rm -rf ~/Library/Developer/Xcode/iOS\ DeviceSupport
rm -rf ~/Library/Developer/Xcode/watchOS\ DeviceSupport
rm -rf ~/Library/Developer/Xcode/tvOS\ DeviceSupport

# 3
echo "Removing old simulators..."
xcrun simctl delete unavailable

# 4
echo "Removing caches..."
rm -rf ~/Library/Caches/com.apple.dt.Xcode
rm -rf ~/Library/Caches/org.carthage.CarthageKit

# 5
if command -v pod  &> /dev/null
then
    # 6
    pod cache clean --all
fi

echo "Done!"

After writing, run it with this command

chmod u+x clean-xcode.sh

And then

./clean-xcode.sh

This will cleans out derived data, device support, simulators and caches. So that once you execute it, You have to build your project AGAIN

For More Info, visit here

Back to Content

Roadmap for iOS Developer

check this out here

Use VIM in Xcode

Check this site for more info!

Since Xcode 13(BETA), you can find Vim in Preference -> Text Editing -> Editing -> Enable Vim Key bindings

GitHub

https://github.com/jphong1111/awesome-ios-developer