DEV Community: Ajithmadhan

Generics - Swift

Ajithmadhan — Tue, 10 May 2022 12:56:16 +0000

Swift enables us to create generic types, protocols, and functions, that aren’t tied to any specific concrete type — but can instead be used with any type that meets a given set of requirements.

Being a language that strongly emphasises type safety, generics is an essential feature that’s core to many aspects of Swift — including its standard library, which uses generics quite heavily. Just look at some of its fundamental data structures, like Array and Dictionary, both of which are generics.

Generics enable the same type, protocol, or function, to be specialised for a large number of use cases. For example, since Array is a generic, it allows us to create specialised instances of it for any kind of type.

var array = ["One", "Two", "Three"]
array.append("Four")

// This won't compile, since the above array is specialised
// for strings, meaning that other values can't be inserted:
array.append(5)

// As we pull an element out of the array, we can still treat
// it like a normal string, since we have full type safety.
let characterCount = array[0].count

To create a generic of our own, we simply have to define what our generic types are, and optionally attach constraints to them. For example, here we’re creating a Container type that can contain any value, along with a date:

struct Container<Value> {
    var value: Value
    var date: Date
}

Just like how we’re able to create specialized arrays and dictionaries, we can specialize the above Container for any kind of value, such as strings or integers:

let stringContainer = Container(value: "Message", date: Date())
let intContainer = Container(value: 7, date: Date())

Note that we don’t need to specify what concrete types we’re specializing Container with above — Swift’s type inference automatically figures out that stringContainer is a Container instance, and that intContainer is an instance of Container.

Generic Types

These are custom classes, structures, and enumerations that can work with any type, in a similar way to Array and Dictionary.

Let’s create stack,

enum StackError: Error {
    case Empty(message: String)
}

public struct Stack<T> {
    var array: [T] = []

    init(capacity: Int) {
        array.reserveCapacity(capacity)
    }

    public mutating func push(element: T) {
        array.append(element)
    }

    public mutating func pop() -> T? {
        return array.popLast()
    }

    public func peek() throws -> T {
        guard !isEmpty(), let lastElement = array.last else {
            throw StackError.Empty(message: "Array is empty")
        }
        return lastElement
    }

    func isEmpty() -> Bool {
        return array.isEmpty
    }
}

extension Stack: CustomStringConvertible {
    public var description: String {
        let elements = array.map{ "\($0)" }.joined(separator: "\n")
        return elements
    }
}

var stack = Stack<Int>(capacity: 10)
stack.push(element: 1)
stack.push(element: 2)
print(stack)

var strigStack = Stack<String>(capacity: 10)
strigStack.push(element: "aaina")
print(strigStack)

Generic Type Constraints

Since a generic can be of any type, we can’t do a lot with it. It’s sometimes useful to enforce type constraints on the types that can be used with generic functions and generic types. Type constraints specify that a type parameter must conform to a particular protocol or protocol composition.

For example, Swift’s Dictionary type places a limitation on the types that can be used as keys for a dictionary. Dictionary needs its keys to be hashable so that it can check whether it already contains a value for a particular key.

func someFunction<T: SomeClass, U: SomeProtocol>(someT: T, someU: U) {
       // function body goes here
}

Associated Types

An associated type gives a placeholder name to a type that’s used as part of the protocol. The actual type to use for that associated type isn’t specified until the protocol is adopted.

Adding Constraints to an Associated Type

You can add type constraints to an associated type in a protocol to require that conforming types satisfy those constraints.

protocol Stackable {
    associatedtype Element: Equatable
    mutating func push(element: Element)
    mutating func pop() -> Element?
    func peek() throws -> Element
    func isEmpty() -> Bool
    func count() -> Int
}

Now, Stack’s Element type needs to conform to Equatable else it will give compile time error.

Recursive Protocol Constraints:

A protocol can appear as part of its own requirements.

protocol SuffixableContainer: Container {
    associatedtype Suffix: SuffixableContainer where Suffix.Item == Item
    func suffix(_ size: Int) -> Suffix
}

Suffix has two constraints: It must conform to the SuffixableContainer protocol (the protocol currently being defined), and its Item type must be the same as the container’s Item type.

Extending Generic Type:

When you extend a generic type, you don’t provide a type parameter list as part of the extension’s definition. Instead, the type parameter list from the original type definition is available within the body of the extension, and the original type parameter names are used to refer to the type parameters from the original definition.

extension Stack {
   var topItem: Element? {
     return items.isEmpty ? nil : items[items.count - 1]
   }
}

Extensions with a Generic Where Clause

You can also use a generic where clause as part of an extension. The example below extends the generic Stack structure from the previous examples to add an isTop(_:)method.

extension Stack where Element: Equatable {
    func isTop(_ item: Element) -> Bool {
        guard let topItem = items.last else {
            return false
        }
        return topItem == item
    }
}

The extension adds the isTop(_:)method only when the items in the stack are equatable. You can use a generic where clause with extensions to a protocol too. Multiple requirements can be added in where clause by separating with a comma.

Generic Specialization:

Generic specialization means that the compiler clones a generic type or function, such as Stack, for a concrete parameter type, such as Int. This specialized function can then be optimized specifically for Int, removing all indirection. The process of replacing type parameters with type arguments at compile time is known as specialization.

Multithreading - a deep dive in swift

Ajithmadhan — Fri, 06 May 2022 07:52:31 +0000

What is concurrency?

Wikipedia defines concurrency as “the decomposability property of a program, algorithm, or problem into order-independent or partially-ordered components or units.” What this means is looking at the logic of your app to determine which pieces can run at the same time, and possibly in a random order, yet still result in a correct implementation of your data flow.

Why use concurrency?

It’s critical to ensure that your app runs as smoothly as possible and that the end user is not ever forced to wait for something to happen. A second is a minuscule amount of time for most everything not related to a computer. However, if a human has to wait a second to see a response after taking an action on a device like an iPhone, it feels like an eternity. “It’s too slow” is one of the main contributors to your app being uninstalled.

Scrolling through a table of images is one of the more common situations wherein the end user will be impacted by the lack of concurrency. If you need to download an image from the network, or perform some type of image processing before displaying it, the scrolling will stutter and you’ll be forced to display multiple “busy” indicators instead of the expected image.

GCD vs Operations

There are two APIs that you’ll use when making your app concurrent: Grand Central Dispatch, commonly referred to as GCD, and Operations. These are neither competing technologies nor something that you have to exclusively pick between. In fact, Operations are built on top of GCD!

Grand Central Dispatch

GCD is Apple’s implementation of C’s libdispatch library. Its purpose is to queue up tasks — either a method or a closure — that can be run in parallel, depending on availability of resources; it then executes the tasks on an available processor core.

While GCD uses threads in its implementation, you, as the developer, do not need to worry about managing them yourself. GCD’s tasks are so lightweight to enqueue that Apple, in its 2009 technical brief on GCD, stated that only 15 instructions are required for implementation, whereas creating traditional threads could require several hundred instructions.

All of the tasks that GCD manages for you are placed into GCD-managed first-in, first-out (FIFO) queues. Each task that you submit to a queue is then executed against a pool of threads fully managed by the system.

More details about GCD is covered in This blog

// Class level variable
let queue = DispatchQueue(label: "sample")

// Somewhere in your function
queue.async {
  // Call slow non-UI methods here

  DispatchQueue.main.async {
    // Update the UI here
  }
}

Synchronous and asynchronous tasks

Work placed into the queue may either run synchronously or asynchronously. When running a task synchronously, your app will wait and block the current run loop until execution finishes before moving on to the next task. Alternatively, a task that is run asynchronously will start, but return execution to your app immediately. This way, the app is free to run other tasks while the first one is executing.

In general, you’ll want to take any long-running non-UI task that you can find and make it run asynchronously in the background. GCD makes this very simple via closures with a few lines of code.

Operations

Operations in Swift are a powerful way to separate responsibilities over several classes while keeping track of progress and dependencies. They’re formally known as NSOperations and used in combination with the OperationQueue.

An Operation is typically responsible for a single synchronous task. It’s an abstract class and never used directly. You can make use of the system-defined BlockOperation subclass or by creating your own subclass. You can start an operation by adding it to an OperationQueue or by manually calling the start method. However, it’s highly recommended to give full responsibility to the OperationQueue to manage the state.

Making use of the system-defined BlockOperation looks as follows:

let blockOperation = BlockOperation {
    print("Executing!")
}

let queue = OperationQueue()
queue.addOperation(blockOperation)

And can also be done by adding the block directly on the queue:

queue.addOperation {
  print("Executing!")
}

The given task gets added to the OperationQueue that will start the execution as soon as possible.

Creating a custom operation

You create separation of concern with custom operations. You could, for example, create a custom implementation for importing content and another one for uploading content.

The following code example shows a custom subclass for importing content:

final class ContentImportOperation: Operation {

    let itemProvider: NSItemProvider

    init(itemProvider: NSItemProvider) {
        self.itemProvider = itemProvider
        super.init()
    }

    override func main() {
        guard !isCancelled else { return }
        print("Importing content..")

        // .. import the content using the item provider

    }
}

The class takes an item provider and imports the content within the main method. The main() function is the only method you need to overwrite for synchronous operations. Add the operation to the queue and set a completion block to track completion:

let fileURL = URL(fileURLWithPath: "..")
let contentImportOperation = ContentImportOperation(itemProvider: NSItemProvider(contentsOf: fileURL)!)

contentImportOperation.completionBlock = {
    print("Importing completed!")
}

queue.addOperation(contentImportOperation)

// Prints:
// Importing content..
// Importing completed!

This moves all your logic for importing content into a single class on which you can track progress, completion, and you can easily write tests for it!

Different states of an operation

An operation can be in several states, depending on its current execution status.

Ready: It’s prepared to start
Executing: The task is currently running
Finished: Once the process is completed
Canceled: The task canceled It’s important to know that an operation can only execute once. Whenever it’s in the finished or canceled state, you can no longer restart the same instance.

The OperationQueue will remove the task automatically from its queue once it becomes finished, which happens both after execution or cancellation.

Making use of dependencies

A benefit of using operations is the use of dependencies. You can easily add a dependency between two instances. For example, to start uploading after the content is imported:

let fileURL = URL(fileURLWithPath: "..")
let contentImportOperation = ContentImportOperation(itemProvider: NSItemProvider(contentsOf: fileURL)!)
contentImportOperation.completionBlock = {
    print("Importing completed!")
}

let contentUploadOperation = UploadContentOperation()
contentUploadOperation.addDependency(contentImportOperation)
contentUploadOperation.completionBlock = {
    print("Uploading completed!")
}

queue.addOperations([contentImportOperation, contentUploadOperation], waitUntilFinished: true)

// Prints:
// Importing content..
// Uploading content..
// Importing completed!
// Uploading completed!

The upload will only start after the content importation is finished. It does not take into account cancelation which means that if the import operation cancels, the upload would still start. You have to implement a check to see whether the dependencies were canceled or not:

final class UploadContentOperation: Operation {
    override func main() {
        guard !dependencies.contains(where: { $0.isCancelled }), !isCancelled else {
            return
        }

        print("Uploading content..")
    }
}

GCD advantage over NSOperation:

i. implementation
For GCD implementation is very light-weight
Operation is complex and heavy-weight

Operation advantages over GCD:

i. Control On Operation
you can Pause, Cancel, Resume an NSOperation

ii. Dependencies
you can set up a dependency between two Operations
operation will not started until all of its dependencies return true for finished.

iii. State of Operation
can monitor the state of an operation or operation queue. ready ,executing or finished

iv. Max Number of Operation
you can specify the maximum number of queued operations that can run simultaneously

Racing Condition

A race condition occurs when two or more threads can access shared data and they try to change it at the same time. Because the thread scheduling algorithm can swap between threads at any time, you don't know the order in which the threads will attempt to access the shared data. Therefore, the result of the change in data is dependent on the thread scheduling algorithm, i.e. both threads are "racing" to access/change the data.

Dispatch Group

DispatchGroup allows for aggregate synchronization of work. You can use them to submit multiple different work items and track when they all complete, even though they might run on different queues. This behavior can be helpful when progress can’t be made until all of the specified tasks are complete.

A Scenario when this could be useful is if you have multiple webservice calls that all need to finish before continuing. For example, you need to download multiple sets of data that needs to be processed by some function. You have to wait for all webservices to complete before calling the function to process all the received data.

func doLongTasksAndWait () {
    print("starting long running tasks")
    let group = DispatchGroup()          //create a group for a bunch of tasks we are about to do
    for i in 0...3 {                     //launch a bunch of tasks (eg a bunch of webservice calls that all need to be finished before proceeding to the next ViewController)
        group.enter()                    //let the group know that something is being added
        DispatchQueue.global().async {   //run tasks on a background thread
            sleep(arc4random() % 4)      //do some long task eg webservice or database lookup (here we are just sleeping for a random amount of time for demonstration purposes)
            print("long task \(i) done!")
            group.leave()                //let group know that the task is finished
        }
    }
    group.wait()                         //will block whatever thread we are on here until all the above tasks have finished (so maybe dont use this function on your main thread)
    print("all tasks done!")
}

//starting long running tasks
//long task 0 done!
//long task 3 done!
//long task 1 done!
//long task 2 done!
//all tasks done!

Semaphores

Semaphores give us the ability to control access to a shared resource by multiple threads.

A semaphore consists of a threads queue and a counter value (type Int).

The threads queue is used by the semaphore to keep track of waiting threads in FIFO order (The first thread entered into the queue will be the first to get access to the shared resource once it is available).

The counter value is used by the semaphore to decide if a thread should get access to a shared resource or not. The counter value changes when we call signal() or wait() function.

So, when should we call wait() and signal() functions?

Call wait() each time before using the shared resource. We are basically asking the semaphore if the shared resource is available or not. If not, we will wait.
Call signal() each time after using the shared resource. We are basically signaling the semaphore that we are done interacting with the shared resource.

Calling wait() will do the following:

Decrement semaphore counter by 1.
If the resulting value is less than zero, the thread is frozen.
If the resulting value is equal to or bigger than zero, the code will get executed without waiting

Calling signal() will do the following:

Increment semaphore counter by 1.
If the previous value was less than zero, this function wakes the oldest thread currently waiting in the thread queue.
If the previous value is equal to or bigger than zero, it means the thread queue is empty, aka, no one is waiting.

Example

    let queue = DispatchQueue.global()
        let group = DispatchGroup()

        let sem = DispatchSemaphore(value: 1)

        queue.async(group: group){
            sem.wait()
            let movie = self.downloadMovie(name: "Avatar")
            self.movies.append(movie)
            sem.signal()
        }

        queue.async(group: group){
            sem.wait()
            self.saveMovie()
            self.movies.remove(at: 0)
            sem.signal()
        }

    func downloadMovie(name:String) -> String{
        sleep(4)
        print("Movie has been Downloaded")
        return name
    }

    func saveMovie(){
        sleep(2)
        print("Movie has been Saved")
    }

Concurrency in swift (GCD)

Ajithmadhan — Wed, 27 Apr 2022 10:17:32 +0000

Concurrency

Concurrency means that an application is making progress on more than one task at the same time (concurrently). If the computer only has one CPU, then the application may not make progress on more than one task at exactly the same time, but more than one task is being processed at a time inside the application using the technique called context switching. It doesn’t completely finish one task before it begins the next.

Parallelism

Parallelism is the notion of multiple things happening at the same time (no context switching).

Grand Central Dispatch (GCD)

Grand Central Dispatch or GCD is a low-level API for doing Concurrency / Parallelism in your application.

How GCD perform Concurrency / Parallelism

GCD under the hood manage a shared thread pools and add optimal number of threads in that pool. With GCD you add blocks of code or work items to queues and GCD decides which thread to execute them on. GCD executes this task either concurrently or parallely depending upon the system physical condition or current load.

Without GCD

In the past we do concurrency using manually creating threads. We create a thread on some core and give the task to run. Threaded solutions is a low level solutions and must be managed manually.

It’s developer responsibility to decide optimal number of threads for an application because if you create thousands of threads most of the time it will do context switching instead of doing actual work Optimal number of threads for an application can change dynamically based on the current system load.
Synchronization mechanisms typically used with threads add complexity
It’s developer or application responsibility to make use of the extra cores more effectively.
Number of cores that can be used efficiently, which is a challenging thing for an application to compute on its own.

Developer Responsibility With GCD

All you have to do is define the tasks you want to execute concurrently and add them to an appropriate dispatch queue. GCD takes care of creating the needed threads and of scheduling your tasks to run on those threads

Dispatch Queues

Dispatch queues are a C-based mechanism for executing custom tasks. Dispatch queue always dequeues and starts tasks in the same order in which they were added to the queue.) Dispatch queues are thread-safe which means that you can access them from multiple threads simultaneously. Dispatch Queue is not Thread
If you want to perform concurrent task through GCD you add them to an appropriate dispatch queue. GCD will pick the task and execute them on the basic of the configuration done on the dispatch queues.
Dispatch queue is the core of the GCD. On the basis of Dispatch queues configuration GCD pick and execute concurrent tasks.

GCD provides three main types of queues:

Main queue: runs on the main thread and is a serial queue.

Global queues: concurrent queues that are shared by the whole system. There are four such queues with different priorities : high, default, low, and background.

Custom queues: queues that you create which can be serial or concurrent. Requests in these queues actually end up in one of the global queues.
When sending tasks to the global concurrent queues, you don’t specify the priority directly. Instead, you specify a Quality of Service (QoS) class property. This indicates the task’s importance and guides GCD in determining the priority to give to the task.

Example to create above said queues:

let mainQueue = DispatchQueue.main
let globalQueue = DispatchQueue.global
let custom = DispatchQueue(label: String, qos: DispatchQoS,attributes: DispatchQueue.Attributes,autoreleaseFrequency: DispatchQueue.AutoreleaseFrequency, target: DispatchQueue?)

label: This is a string label that is attached to the queue to uniquely identify it in debugging tools, such as instruments and crash reports. It is recommended that we use a reverse DNS naming convention. This parameter is optional and can be nil.
attributes: This specifies the type of queue. Like DISPATCH_QUEUE_SERIAL, DISPATCH_QUEUE_CONCURRENT. If the this parameter is nil, a serial queue will be created.
qos: Quality of services. Types are User-interactive,User-initiated, Utility, Background. Higher the priority, higher will be the allocation of resources to that queue.
AutoreleaseFrequency: It has different options. Like:inherit, workitem, never

The QoS classes are:

User-interactive: This represents tasks that must complete immediately in order to provide a nice user experience. Use it for UI updates, event handling and small workloads that require low latency. The total amount of work done in this class during the execution of your app should be small. This should run on the main thread.

User-initiated: The user initiates these asynchronous tasks from the UI. Use them when the user is waiting for immediate results and for tasks required to continue user interaction. They execute in the high priority global queue.

Utility: This represents long-running tasks, typically with a user-visible progress indicator. Use it for computations, I/O, networking, continuous data feeds and similar tasks. This class is designed to be energy efficient. This will get mapped into the low priority global queue.

Background: This represents tasks that the user is not directly aware of. Use it for prefetching, maintenance, and other tasks that don’t require user interaction and aren’t time-sensitive. This will get mapped into the background priority global queue.

Synchronous vs. Asynchronous

With GCD, you can dispatch a task either synchronously or asynchronously.

A synchronous function returns control to the caller after the task completes. You can schedule a unit of work synchronously by calling DispatchQueue.sync(execute:).

An asynchronous function returns immediately, ordering the task to start but not waiting for it to complete. Thus, an asynchronous function does not block the current thread of execution from proceeding on to the next function. You can schedule a unit of work asynchronously by calling DispatchQueue.async(execute:).

Class vs Struct in Swift

Ajithmadhan — Mon, 25 Apr 2022 13:29:36 +0000

Class and struct are general-purpose of a template to defines bellow characteristics.

Property
Method/functions
Initializers
Protocol
Extension

Class and struct looks similar except the keyword used to define.
eg:

struct A{
var name = "Ajith"
var age = 10
var run(){...}
}

class B {
var name = "Ajith"
var age = 10
var run(){...}
}

What is common in both?

Both has property,methods,Initializers,Protocol,Extension
Provides Subscripts to access their values
failable init can be used in both
Properties and method in both are accessed using .(dot) syntax.

Things Available Only in Class:

deinit can be used only with class.
Classes can inherit the characteristics of another class. Struct can’t inherit from other struct.
Reference counting allows more than one references.
Type of class instance can be checked at runtime.

Things Available Only in Struct:

Struct has default member wise initializer. For class we need to define explicitly.
Struct have the benefit of mutation safety that behind its hood no other thing can mutate its value which may prone to many bugs that are hard to debug.

Difference between struct and class:

Class uses keyword "class" and Struct uses keyword "struct" .
For modifying the self property in struct from a function you need to define mutating at the beginning of function. Class doesn’t required anything.
One of the most difference is value vs reference type.
If you create struct instance with let property, you can’t modify its properties. If you create a class instance with let property, you can modify its properties.

Value vs reference types:

Classes are reference type : which means reference to a location in the memory where class instance is stored.
Struct and enumeration are value type: which means each reference has it’s own copy of data
If you share/assign instance of class to different references, all these references will have a single shared data. That means any changes in that class instance will be available to every reference
If you share/assign instance of struct to different references, every reference will creates its own memory to store the data. Any changes in struct in one reference will not affect in other reference.
Memory allocation for both class and struct is different. Because of this difference, class and struct behaves differently while sharing its instances.

Value types are stored in stack memory and reference type are stored in heap memory.

ViewController lifecycle in iOS

Ajithmadhan — Mon, 25 Apr 2022 12:53:52 +0000

iOS View Controller Life manages a set of views and makes your app’s user interface. It coordinates with model objects and other controller objects. Basically, it plays a combined role for both view objects and controller objects. Each view controller shows it’s own views to display the app content. The views are automatically loaded when the view property of the view controller is accessed in the app.

A View Controller provides multiple methods for manage the views.

View controller Life Cycle :

Lifecycle methods:

loadView

This method use when view Controller creates from code . Its good not to do anything on this method.If view Controller made from .xib or storyboard.
What to do in View Load : loadView( ) is a method managed by the viewController. The viewController calls it when its current view is nil. loadView( ) basically takes a view (that you create) and sets it to the viewController’s view (superview).

viewDidLoad

This Method is loaded once in view controller life cycle .Its Called When all the view are loaded.
what to do in viewDidLoad:you can do some common tasks like Network call which need Once,User Interface,Others Task Those are Need to do Once

Note:
This method is called before the bounds are defined.

ViewWillAppear

This method is called every time a view is a appeared on screen.
What to do in ViewWillAppear:You can override this method to perform custom tasks associated with displaying the view such as hiding fields or disabling actions before the view becomes visible.

ViewDidAppear

This method is called after the view present on the screen.
What to do in ViewDidAppear: save data to core data or start animation or start playing a video or a sound, or to start collecting data from the network This type of task good for this method.

ViewWillDisappear:

This method is called before view is removed from view hierarchy (the view is still in view hierarchy).
What to do in ViewWillDisappear:hide the keyboard, canceling network requests, revert any changes to the parent UI. Also, this is an ideal place to save the state.

ViewDidDisappear:

This method is called after the view is removed from view hierarchy.
What to do in ViewDidDisappear:You can stop listening for notifications or device sensors.

didReceiveMemoryWarning:

When the memory starts to fill up,iOS does not manages the app's memory status, you are responsible to clear up some objects out of memory.Be aware that if the memory of your app goes over a certain threshold, iOS will shut down your app. Unfortunately, this will look like a crash to the end-user.

viewWillTransition(to:with:)

When the interface orientation changes, UIKit calls this method on the window’s root view controller before the size changes are about to be made. The root view controller then notifies its child view controllers, propagating the message throughout the view controller hierarchy. The parameter to contains the new CGSize size of the container’s view and the parameter with contains a UIViewControllerTransitionCoordinator coordinator, an enum that describes the new orientation.

Application Lifecycle in iOS

Ajithmadhan — Mon, 25 Apr 2022 11:12:23 +0000

The application life cycle constitutes the sequence of events that occurs between the launch and termination of application.

Steps involved in device reboot to App launch:

When a device reboots no apps will be running except the apps that belongs to OS.
When a user touches the app icon on the screen,The SpringBoard launches the app.

SpringBoard is the standard application that manages the iPhone’s home screen.

While SpringBoot animates your app's launch screen, your app and necessary shared libraries will be loaded in the memory. Eventually your app begins execution and application delegate receives the notifications.
Appdelegate is the application delegate object which inherits from UIResponder and implements the UIApplicationDelegate protocol.
Main entry point of the app is UIApplicationDelegate which is a protocol to be implemented in our app to get notified to app launch and user events

Execution stages for a App:

There are mainly Five stages in App lifecycle,

Not Running state : The app has not been launched or terminated by the system.
Inactive state : The app is entering the foreground state but not receiving events.
Active state: The app enters the foreground state and can process event.
Background state : In this state, if there is executable code, it will execute and if there is no executable code or the execution is complete, the application will be suspended immediately.
Suspended state : The app is in the background(in memory) but is not executing code and if system does not have enough memory, it will terminate the app.

Mapping the App states with Code:

    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        // Override point for customization after application launch. 
    }

    func sceneDidBecomeActive(_ scene: UIScene) {
        // Called when the scene has moved from an inactive state to an active state.
        // Use this method to restart any tasks that were paused (or not yet started) when the scene was inactive.
    }

    func sceneWillResignActive(_ scene: UIScene) {
        // Called when the scene will move from an active state to an inactive state.
        // This may occur due to temporary interruptions (ex. an incoming phone call).
    }

    func sceneWillEnterForeground(_ scene: UIScene) {
        // Called as the scene transitions from the background to the foreground.
        // Use this method to undo the changes made on entering the background.
    }

    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.
    }

The Main Run Loop:

An app’s main run loop processes all user-related events.
App delegate sets up the main run loop at launch time and uses it to process events and handle updates to view-based interfaces.
main run loop executes on the app’s main thread
main thread is serial thread and this ensures that user-related events are processed serially in the order in which they were received.

swift - parse JSON Data from API

Ajithmadhan — Sun, 16 Jan 2022 08:39:30 +0000

JSON stands for JavaScript Object Notation. It’s a popular text-based data format used everywhere for representing structured data. Almost every programming language supports it with Swift being no exception.

In Swift, parsing JSON is a common necessity. Luckily, working with JSON is easy in Swift. It doesn’t even require setting up any external dependencies.

To convert this JSON to a Swift object, let’s store this JSON data in a structure.
To start off, let’s create a structure that conforms to the Decodable protocol to store all the listed properties found in the JSON data:

struct Slip:Codable{
    var slip:Advice
}

struct Advice:Codable{
    var id:Int
    var advice:String
}

Key terms

URLSession An object that coordinates a group of related, network data transfer tasks.
JSONDecoder An object that decodes instances of a data type from JSON objects.

Creating getSlip function to fetch data from an Url


let url = "https://api.adviceslip.com/advice"

func getSlip(from url:String){

    URLSession.shared.dataTask(with: URL(string: url)!, completionHandler:{ data,response,error in
        guard let data = data else
        {
            print("Something went wrong")
            return
        }
        var result:Slip?
        do{
             result = try JSONDecoder().decode(Slip.self,from:data)
        }catch{
            print("Failed decoding data")
        }
        guard let json = result else{
            return
        }
        print("ID: \(json.slip.id)")
        print("Advice: \(json.slip.advice)")

    }).resume()
}

getSlip(from: url)
//ID: 134
//Advice: The person who never made a mistake never made anything.

Swift - ARC

Ajithmadhan — Sun, 16 Jan 2022 08:04:48 +0000

Memory management functions and its usage are handled in Swift 4 language through Automatic reference counting (ARC). ARC is used to initialize and deinitialize the system resources thereby releasing memory spaces used by the class instances when the instances are no longer needed. ARC keeps track of information about the relationships between our code instances to manage the memory resources effectively.

Functions of ARC

ARC allocates a chunk of memory to store the information each and every time when a new class instance is created by init().
Information about the instance type and its values are stored in memory.
When the class instance is no longer needed it automatically frees the memory space by deinit() for further class instance storage and retrieval.
ARC keeps in track of currently referring class instances properties, constants and variables so that deinit() is applied only to those unused instances.
ARC maintains a 'strong reference' to those class instance property, constants and variables to restrict deallocation when the class instance is currently in use.

Example,

class StudDetails {
   var stname: String!
   var mark: Int!

   init(stname: String, mark: Int) {
      self.stname = stname
      self.mark = mark
   }
   deinit {
      print("Deinitialized \(self.stname)")
      print("Deinitialized \(self.mark)")
   }
}

let stname = "Swift 4"
let mark = 98

print(stname)
print(mark)

//Swift 4
//98

ARC Strong Reference Cycles Class Instances

class studmarks {
   let name: String
   var stud: student?

   init (name: String) {
      print("Initializing: \(name)")
      self.name = name
   }
   deinit {
      print("Deallocating: \(self.name)")
   }
}

class student {
   let name: String
   var strname: studmarks?

   init (name: String) {
      print("Initializing: \(name)")
      self.name = name
   }
   deinit {
      print("Deallocating: \(self.name)")
   }
}

var shiba: studmarks?
var mari: student?

shiba = studmarks(name: "Swift 4")
mari = student(name: "ARC")

shiba!.stud = mari
mari!.strname = shiba

//Initializing: Swift 4
//Initializing: ARC

ARC Weak and Unowned References

Class type properties has two ways to resolve strong reference cycles

Weak References
Unowned References

These references are used to enable one instance to refer other instances in a reference cycle. Then the instances may refer to each and every instances instead of caring about strong reference cycle. When the user knows that some instance may return 'nil' values we may point that using weak reference. When the instance going to return something rather than nil then declare it with unowned reference.

Weak Reference Program

class module {
   let name: String
   init(name: String) { self.name = name }
   var sub: submodule?
   deinit { print("\(name) Is The Main Module") }
}

class submodule {
   let number: Int
   init(number: Int) { self.number = number }
   weak var topic: module?

   deinit { print("Sub Module with its topic number is \(number)") }
}

var toc: module?
var list: submodule?
toc = module(name: "ARC")
list = submodule(number: 4)
toc!.sub = list
list!.topic = toc

toc = nil
list = nil
//When we run the above program using playground, we get the //following result −

//ARC Is The Main Module
//Sub Module with its topic number is 4

Unowned Reference Program

class student {
   let name: String
   var section: marks?
   init(name: String) {
      self.name = name
   }
   deinit { print("\(name)") }
}

class marks {
   let marks: Int
   unowned let stname: student

   init(marks: Int, stname: student) {
      self.marks = marks
      self.stname = stname
   }
   deinit { print("Marks Obtained by the student is \(marks)") }
}

var module: student?
module = student(name: "ARC")
module!.section = marks(marks: 98, stname: module!)
module = nil
//When we run the above program using playground, we get the //following result −

//ARC
//Marks Obtained by the student is 98

swift - protocols

Ajithmadhan — Sun, 16 Jan 2022 07:30:12 +0000

Protocols provide a blueprint for Methods, properties and other requirements functionality. It is just described as a methods or properties skeleton instead of implementation. Methods and properties implementation can further be done by defining classes, functions and enumerations. Conformance of a protocol is defined as the methods or properties satisfying the requirements of the protocol.

Syntax
Protocols also follow the similar syntax as that of classes, structures, and enumerations −

protocol SomeProtocol {
   // protocol definition 
}

Protocols are declared after the class, structure or enumeration type names. Single and Multiple protocol declarations are also possible. If multiple protocols are defined they have to be separated by commas.

struct SomeStructure: Protocol1, Protocol2 {
   // structure definition 
}

When a protocol has to be defined for super class, the protocol name should follow the super class name with a comma.

class SomeClass: SomeSuperclass, Protocol1, Protocol2 {
   // class definition 
}

Notes:
The protocol just holds the method or properties definition, not their actual body.
The protocol must specify whether the property will be gettable or gettable and settable.

Conform Class To Swift Protocol

In Swift, to use a protocol, other classes must conform to it. After we conform a class to the protocol, we must provide an actual implementation of the method.

Here's how to conform a class to the protocol,

protocol Greet {

  // blueprint of a property 
  var name: String { get }


  // blueprint of a method 
  func message() 
}   

// conform class to Greet protocol
class Employee: Greet {

  // implementation of property
  var name = "Perry"

  // implementation of method
  func message() {
    print("Good Morning!")
  }
}

Conforming Multiple Protocols

In Swift, a class can also conform to multiple protocols. For example,

protocol Sum {
  ...
}

protocol Multiplication {
  ...
}

class Calculate: Sum, Multiplication {
  ...
}

Swift Protocol Inheritance

Similar to classes, protocols can inherit other protocols. For example,

protocol Car {
  ...
}

protocol Brand: Car {
  ...
}

Here, the Brand protocol inherits the Car protocol. Now, if any class implements Brand, it should provide implementations for all properties of both Car and Brand.

Example,

protocol Car {
  var colorOptions: Int { get }
}

// inherit Car protocol
protocol Brand: Car {
  var name: String { get }
}

class Mercedes: Brand {

  // must implement properties of both protocols 
  var name: String = ""
  var colorOptions: Int = 0
}

var car1 = Mercedes()
car1.name = "Mercedes AMG"
car1.colorOptions = 4

print("Name:", car1.name)
print("Color Options:", car1.colorOptions)

Protocol Extensions

In Swift, we can extend protocols using the extension keyword. For example,

// protocol definition
protocol Brake {
  func applyBrake()
}

// define class that conforms Brake
class Car: Brake {
  var speed: Int = 0

  func applyBrake() {
    print("Brake Applied")
  }
}

// extend protocol
extension Brake {
  func stop() {
    print("Engine Stopped")
  }
}

let car1 = Car()
car1.speed = 61
print("Speed:", car1.speed)

car1.applyBrake()

// access extended protocol
car1.stop()

swift - extensions

Ajithmadhan — Sun, 16 Jan 2022 06:56:09 +0000

Extensions add new functionality to an existing class, structure, enumeration, or protocol type. This includes the ability to extend types for which you don’t have access to the original source code (known as retroactive modeling). Extensions are similar to categories in Objective-C. (Unlike Objective-C categories, Swift extensions don’t have names.

Extensions in Swift can:

Add computed instance properties and computed type properties
Define instance methods and type methods
Provide new initializers
Define subscripts
Define and use new nested types
Make an existing type conform to a protocol

Extensions can add new functionality to a type, but they can’t override existing functionality.

Extension Syntax

Declare extensions with the extension keyword:

extension SomeType {
    // new functionality to add to SomeType goes here
}

computed instance properties

Extensions can add computed instance properties and computed type properties to existing types. This example adds five computed instance properties to Swift’s built-in Double type, to provide basic support for working with distance units:

extension Double {
    var km: Double { return self * 1_000.0 }
    var m: Double { return self }
    var cm: Double { return self / 100.0 }
    var mm: Double { return self / 1_000.0 }
    var ft: Double { return self / 3.28084 }
}
let oneInch = 25.4.mm
print("One inch is \(oneInch) meters")
// Prints "One inch is 0.0254 meters"
let threeFeet = 3.ft
print("Three feet is \(threeFeet) meters")
// Prints "Three feet is 0.914399970739201 meters"

Initializers

Extensions can add new initializers to existing types. This enables you to extend other types to accept your own custom types as initializer parameters, or to provide additional initialization options that were not included as part of the type’s original implementation.

The example below defines a custom Rect structure to represent a geometric rectangle. The example also defines two supporting structures called Size and Point, both of which provide default values of 0.0 for all of their properties:

struct Size {
    var width = 0.0, height = 0.0
}
struct Point {
    var x = 0.0, y = 0.0
}
struct Rect {
    var origin = Point()
    var size = Size()
}

Because the Rect structure provides default values for all of its properties, it receives a default initializer and a memberwise initializer automatically, as described in Default Initializers. These initializers can be used to create new Rect instances:

let defaultRect = Rect()
let memberwiseRect = Rect(origin: Point(x: 2.0, y: 2.0),
   size: Size(width: 5.0, height: 5.0))

You can extend the Rect structure to provide an additional initializer that takes a specific center point and size:

extension Rect {
    init(center: Point, size: Size) {
        let originX = center.x - (size.width / 2)
        let originY = center.y - (size.height / 2)
        self.init(origin: Point(x: originX, y: originY), size: size)
    }
}


let centerRect = Rect(center: Point(x: 4.0, y: 4.0),
                      size: Size(width: 3.0, height: 3.0))
// centerRect's origin is (2.5, 2.5) and its size is (3.0, 3.0)

Methods

Extensions can add new instance methods and type methods to existing types. The following example adds a new instance method called repetitions to the Int type:

extension Int {
    func repetitions(task: () -> Void) {
        for _ in 0..<self {
            task()
        }
    }
}

The repetitions(task:) method takes a single argument of type () -> Void, which indicates a function that has no parameters and doesn’t return a value.

After defining this extension, you can call the repetitions(task:) method on any integer to perform a task that many number of times:

3.repetitions {
    print("Hello!")
}
// Hello!
// Hello!
// Hello!

Subscripts

Extensions can add new subscripts to an existing type. This example adds an integer subscript to Swift’s built-in Int type. This subscript [n] returns the decimal digit n places in from the right of the number:

123456789[0] returns 9
123456789[1] returns 8
…and so on:

extension Int {
    subscript(digitIndex: Int) -> Int {
        var decimalBase = 1
        for _ in 0..<digitIndex {
            decimalBase *= 10
        }
        return (self / decimalBase) % 10
    }
}
746381295[0]
// returns 5
746381295[1]
// returns 9
746381295[2]
// returns 2
746381295[8]
// returns 7

swift - concurrency

Ajithmadhan — Sun, 16 Jan 2022 06:35:51 +0000

Swift has built-in support for writing asynchronous and parallel code in a structured way. Asynchronous code can be suspended and resumed later, although only one piece of the program executes at a time.

What is a synchronous function?

By default, all Swift functions are synchronous, but what does that mean?

A synchronous function is one that executes all its work in a simple, straight line on a single thread. Although the function itself can interact with other threads – it can request that work happens elsewhere, for example – the function itself always runs on a single thread.

This has a number of advantages, not least that synchronous functions are very easy to think about: when you call function A, it will carry on working until all its work is done, then return a value. If while working, function A calls function B, and perhaps functions C, D, and E as well, it doesn’t matter – they all will execute on the same thread, and run one by one until the work completes.

What is an asynchronous function?

Although Swift functions are synchronous by default, we can make them asynchronous by adding one keyword: async. Inside asynchronous functions, we can call other asynchronous functions using a second keyword: await. As a result, you’ll often hear Swift developers talk about async/await as a way of coding.

Basic Async/await exapmle

func randomD6() async -> Int {
    Int.random(in: 1...6)
}

let result = await randomD6()
print(result)

Calling Asynchronous Functions in Parallel

Calling an asynchronous function with await runs only one piece of code at a time. While the asynchronous code is running, the caller waits for that code to finish before moving on to run the next line of code. For example, to fetch the first three photos from a gallery, you could await three calls to the downloadPhoto(named:) function as follows:

let firstPhoto = await downloadPhoto(named: photoNames[0])
let secondPhoto = await downloadPhoto(named: photoNames[1])
let thirdPhoto = await downloadPhoto(named: photoNames[2])

let photos = [firstPhoto, secondPhoto, thirdPhoto]
show(photos)

This approach has an important drawback: Although the download is asynchronous and lets other work happen while it progresses, only one call to downloadPhoto(named:) runs at a time. Each photo downloads completely before the next one starts downloading. However, there’s no need for these operations to wait—each photo can download independently, or even at the same time.

To call an asynchronous function and let it run in parallel with code around it, write async in front of let when you define a constant, and then write await each time you use the constant.

async let firstPhoto = downloadPhoto(named: photoNames[0])
async let secondPhoto = downloadPhoto(named: photoNames[1])
async let thirdPhoto = downloadPhoto(named: photoNames[2])

let photos = await [firstPhoto, secondPhoto, thirdPhoto]
show(photos)

In this example, all three calls to downloadPhoto(named:) start without waiting for the previous one to complete. If there are enough system resources available, they can run at the same time. None of these function calls are marked with await because the code doesn’t suspend to wait for the function’s result. Instead, execution continues until the line where photos is defined—at that point, the program needs the results from these asynchronous calls, so you write await to pause execution until all three photos finish downloading.

Swift - Error handling

Ajithmadhan — Wed, 05 Jan 2022 12:53:05 +0000

An error (exception) is an unexpected event that occurs during program execution. For example,

var numerator = 10
var denominator = 0

// try to divide a number by 0
var result = numerator / denominator // error code

Steps For Error Handling in Swift

Create an enum that represents the types of errors.
Create a throwing function using the throws keyword.
Call the function using the try keyword.
Wrap the code with try in the do {...} block and add the catch {...} block to handle all errors.

Example,

// create an enum with error values
enum DivisionError: Error {

  case dividedByZero
}

// create a throwing function using throws keyword
func division(numerator: Int, denominator: Int) throws {

  // throw error if divide by 0
  if denominator == 0 {
    throw DivisionError.dividedByZero
  }

  else {
    let result = numerator / denominator
    print(result)
  }
}

// call throwing function from do block
do {
  try division(numerator: 10, denominator: 0)
  print("Valid Division")
}

// catch error if function throws an error
catch DivisionError.dividedByZero {
  print("Error: Denominator cannot be 0")
}

Disable Error Handling

In Swift, sometimes we can be confident that the throwing function won't throw an error at runtime.

In that case, we can write try! during the function call to disable the error handling. For example,

enum DivisionError: Error {

  case dividedByZero
}

func division(numerator: Int, denominator: Int) throws {
  if denominator == 0 {
    throw DivisionError.dividedByZero
  }

  else {
    let result = numerator / denominator
    print("Result:", result)
  }
}

// disable error handling
try! division(numerator: 10, denominator: 5)