I used to work as an Android Developer and I used to use SQLLite and I wouldn’t think that Apple would come up with SwiftData which is really powerful to save your data with really easy syntax and structure.

SwiftData enables you to add persistence to your app quickly, with minimal code and no external dependencies, you wont need to write CoreData complex code anymore. Using modern language features like macros, SwiftData enables you to write code that is fast, efficient, and safe, enabling you to describe the entire model layer for your app.

Define the data model

The first thing we will need to let SwiftData save instances of a model class, import the framework and annotate that class with the Model() macro. This macro updates the class with conformance to the PersistentModel protocol, which SwiftData uses to examine the class and generate an internal schema and enables change tracking for the class by adding conformance to the Observable protocol.

Let’s say that we need to create Todo-list application where you can add your task and add your sub-tasks inside.

So the first think we will think of is to create Task Model() and SubTask Model() and the Relationship between them.

@Model
final class Task {
    @Attribute(.unique)
    let name: String
    
    @Relationship(deleteRule: .cascade, inverse: \SubTask.task)
    var subTasks: [SubTask] = []
    
    init(name: String) {
        self.name = name
    }
}

@Model
final class SubTask {
    let name: String
    var task: Task?
    
    init(name: String) {
        self.name = name
    }
}

As we did use @Model, SwiftData will automatically convert Task()and SubTask to be savable which include all non-computed properties of a class as long as they use compatible types such as Bool, Int, and String, as well as complex value types such as structures, enumerations, and other value types that conform to the Codable protocol.

Customize the persistence behavior of model attributes

@Attribute(.unique)
let name: String

Attribute(_:originalName:hashModifier:) macro is a property of a model class that SwiftData uses to change the behavior of the model, so in our demo to make Task unique we did use @Attribute(.unique) but the framework’s default behavior for attributes is sufficient. However, if you need to alter how SwiftData handles the persistence of a particular attribute, use one of the provided schema macros.

Defining the relationship between Task and SubTask

@Relationship(deleteRule: .cascade, inverse: \SubTask.task)
var subTasks: [SubTask] = []

So as we can see that each Task can have many SubTask but each SubTask will be only inside one Task so the relationship will be one-to-many.

The class also applies the Relationship(_:deleteRule:minimumModelCount:maximumModelCount:originalName:inverse:hashModifier:) macro to the subTasks property and the values of this macro to configure the relationship.

For example the deleteRule parameter specifies how SwiftData handles delete operations with regards to the related data. The Schema.Relationship.DeleteRule.cascade delete rule tells SwiftData to delete all related data when deleting the primary object. For example, deleting an Task in the sample app causes SwiftData to also delete all subTasks contained in that Task.

The inverse parameter is a key path to define the relationship in one of the model types, So the value for inverse must point to a property of the type of the model like the store property subTasks which is declared in the related model class Task.

But if you don’t want to delete the subTasks within a task, you can use the Schema.Relationship.DeleteRule.nullify delete rule. This rule tells SwiftData to set the task’s subTasks property to nil for each subTask contained in the task when deleting the task. Because the default value for the deleteRule parameter is nullify, you can create the relationship without explicitly specifying the delete rule:

@Relationship(inverse: \SubTask.task)
var subTasks: [SubTask] = []

Saving your models into local storage

Before SwiftData can examine your models and generate the required schema, you need to tell it — at runtime — which models to persist, and optionally, the configuration to use for the underlying storage. For example, you may want the storage to exist only in memory when running tests, or to use a specific CloudKit container when syncing model data across devices.

To set up the default storage, use the modelContainer(for:inMemory:isAutosaveEnabled:isUndoEnabled:onSetup:) view modifier and specify the array of model types to persist:

import SwiftUI

@main
struct SwiftDataProApp: App {
    var body: some Scene {
        WindowGroup {
            NavigationView {
                ContentView()
                    .modelContainer(for: [Task.self])
            }
        }
    }
}

You can see that we used the view modifier modelContainer and we set Task.self at the very top of the view hierarchy so all nested views inherit the properly configured environment.

You can see that inMemory is false which means all the changes will be saved into the local storage and isAutosaveEnabled is true means each time you change your data in the models you will not need to explicitly call save, as all the changes will be saved automatically.

After that we need to manage instances of your model classes at runtime, so we use a model context which is responsible for the in-memory model data and coordination with the model container to successfully persist that data and if you are using SwiftUI you can get the context for your model container that’s bound to the main actor by accessing modelContext environment variable:

import SwiftUI
import SwiftData


struct ContentView: View {
    @Environment(\.modelContext) private var context
}

After that we need to create Task Data and to enable SwiftData to persist a model instance we call insert into the context

 Button("Save") {
   let task = Task(name: text)
   modelContext.insert(task)
}

Fetch models for display

After you begin persisting model data, you’ll likely want to retrieve the data as model instances, and display those instances in a view, SwiftData provides the Query property wrapper.

To fetch model instances, and optionally apply search criteria and a preferred sort order, use @Query in your SwiftUI view. The @Model macro adds Observable conformance to your model classes, enabling SwiftUI to refresh the containing view whenever changes occur to any of the fetched instances.

@Query(sort: \Task.name) var tasks: [Task]

var body: some View {
  List {
    ForEach(tasks) { task in
        NavigationLink {
            TaskDetailView(task: task)
                .navigationTitle(task.name)
        } label: {
            TaskCellView(task: task)
        }
    }
  }
}

Here’s the full code, easy and powerful 😍

import SwiftUI
import SwiftData

struct ContentView: View {
    @Environment(\.modelContext) private var modelContext
    @State var text: String = ""
    
    @Query(sort: \Task.name) var tasks: [Task]
    
    var body: some View {
        VStack {
            TextField("Add your Task...", text: $text)
            
            Button("Save") {
                let task = Task(name: text)
                modelContext.insert(task)
            }
            
            List {
                ForEach(tasks) { task in
                    NavigationLink {
                        TaskDetailView(task: task)
                            .navigationTitle(task.name)
                    } label: {
                        TaskCellView(task: task)
                    }
                }
            }
        }
        .padding()
    }
}

struct TaskDetailView: View {
    @State var text: String = ""
    let task: Task
    
    var body: some View {
        VStack {
            TextField("Add your Sub-Task...", text: $text)
            
            Button("Save") {
                let subTask = SubTask(name: text)
                task.tasks.append(subTask)
            }
            
            List {
                ForEach(task.tasks) { task in
                    Text(task.name)
                }
            }
        }
        .padding()
    }
}

struct TaskCellView: View {
    let task: Task
  
    var body: some View {
        VStack(alignment: .leading) {
            Text(task.name)
                .font(.headline)
            Text("Count: \(task.tasks.count)")
                .font(.caption)
        }
    }
}

@Model
final class Task {
    @Attribute(.unique)
    let name: String
    
    @Relationship(deleteRule: .cascade, inverse: \SubTask.task)
    var tasks: [SubTask] = []
    
    init(name: String) {
        self.name = name
    }
}


@Model
final class SubTask {
    let name: String
    var task: Task?
    
    init(name: String) {
        self.name = name
    }
}

Learn SwiftData with SwiftUI was originally published in Dev Genius on Medium, where people are continuing the conversation by highlighting and responding to this story.

Asynchronous code

Asynchronous code can be suspended and resumed later, although only one piece of the program executes at a time. Suspending and resuming code in your program lets it continue to make progress on short-term operations like updating its UI while continuing to work on long-running operations like fetching data over the network or parsing files.

Parallel code

Parallel code means multiple pieces of code run simultaneously — for example, a computer with a four-core processor can run four pieces of code at the same time, with each core carrying out one of the tasks.

What is Async and Await?

An asynchronous function in Swift can give up the thread that it’s running on, which lets another asynchronous function run on that thread while the first function is blocked. When an asynchronous function resumes, Swift doesn’t make any guarantee about which thread that function will run on.

To indicate that a function is asynchronous, you write the async keyword in its declaration after its parameters

When calling an asynchronous method, execution suspends until that method returns, so you have to write await in front of the call to mark the possible suspension point. Inside an asynchronous method, the flow of execution is suspended only when you call another asynchronous method which means every possible suspension point is marked with await.

So Imagine that we need to download a photo, so we will create a function which does the network request and when the data comes back we call the completion closure to notify the caller like this:

func downloadImage(from url: URL, completion: @escaping (UIImage?) -> ()) {
  URLSession.shared.dataTask(with: URLRequest(url: url)) { data, response, error in
      if let data = data,
         let httpResponse = response as? HTTPURLResponse,
         httpResponse.statusCode >= 200 &&  httpResponse.statusCode <= 300 {
          completion(UIImage(data: data))
      } else if error != nil {
          completion(nil)
      }
  }.resume()
}

So SE-0296 gave us a super sweet away to handle that by writing async to the function and use await to wait to the request to finish and download the photo data.

func downloadImage(from url: URL) async -> UIImage? {
  do {
      let (data, response) = try await URLSession.shared.data(from: url)
      if let httpResponse = response as? HTTPURLResponse,
         httpResponse.statusCode >= 200 &&  httpResponse.statusCode <= 300 {
          return UIImage(data: data)
      }
      return nil
  } catch {
      return nil
  }
}

You can see that we just got rid of the completion closure from the first function and added async/await to the second function.

How to use Async/Await to avoid Pyramid of doom

Imagine that we need to execute a sequence of simple asynchronous operations which always requires deeply-nested closures, like imagine that you need to download an image, then resize it, decode it and finally upload it and notify when its done

func processImage(from url: URL, completion: @escaping (Bool) -> ()) {
    downloadImage(from: url) { image in
        resize(image: image) { resizedImage in
            decode(image: image) { decodedImage in
                upload(image: decodedImage) { response
                    completion(response.sccuess)
                }
            }
        }
    }
}

So after SE-0296 gave us a super sweet away to handle that we can write the code super clean and neat like this:

func processImage(from url: URL) async -> Bool{
    let image = await downloadImage(from: url)
    let resizedImage = await resize(image: image)
    let decodedImage = await decode(image: resizedImage)
    let response = await upload(image: decodedImage)            
    return response.isSccuess
}

• We started by downloading the image and because downloadImage function is async we have to use await which suspends execution while it waits for that function to return.
• While this code’s execution is suspended, some other concurrent code in the same program runs. For example, maybe a long-running background task continues updating a list of new photo galleries. That code also runs until the next suspension point, marked by await, or until it completes.
• After downloadImage returns, the code will continue execution starting at that point. It assigns the value that was returned to image.
• The next await marks the call to the resize(image:) function and again the code pauses execution until that function returns, giving other concurrent code an opportunity to run.
• After resize(image:) returns, the code will continue execution starting at that point. It assigns the value that was returned to resizedImage.
• and so on until the all the async functions finished their work and finally return the state of the response.

The possible suspension points in your code marked with await indicate that the current piece of code might pause execution while waiting for the asynchronous function or method to return. Swift suspends the execution of your code on the current thread and runs some other code on that thread instead. Because code with await needs to be able to suspend execution, only certain places in your program can call asynchronous functions or methods:

• Code in the body of an asynchronous function, method, or property.
• Code in the static main() method of a structure, class, or enumeration that’s marked with @main.
• Code in an unstructured child task.

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.

As in the previous example each function had to wait to the previous function to return its result to continue executing the next function, so what about if you need to run more than one async function in 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, so imagine that you need to download 4 photos

async let image1 = downloadImage(from: url1)
async let image2 = downloadImage(from: url2)
async let image3 = downloadImage(from: url3)
async let image4 = downloadImage(from: url4)

let images = await [image1, image2, image3, image4]

All 4 calls to downloadImage will start without waiting for the previous one to complete, and 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 images is defined — at that point, the program needs the results from these asynchronous calls, so you write await to pause execution until all 4 images finish downloading.

Task Groups

Lets say that we have an array has bunch of urls and we need to download the image for each url, but we need to execute all the network requests in the same time parallel.

SE-0304 gave us Task Group which defines a scope in which one can create new child tasks programmatically. As the child tasks within the task group scope must complete when the scope exits, and will be implicitly cancelled first if the scope exits with a thrown error.

The withTaskGroup API gives us access to a task group, and controls the lifetime of the child tasks we subsequently add to the group using its addTask() method. By the time withTaskGroup finishes executing, we know that all of the subtasks have completed.

func download() async -> [UIImage] {
  let urls = [
      URL(string: "https://images.unsplash.com/photo-1575936123452-b67c3203c357")!,
      URL(string: "https://images.unsplash.com/photo-1575936123452-b67c3203c357")!,
      URL(string: "https://images.unsplash.com/photo-1575936123452-b67c3203c357")!,
      URL(string: "https://images.unsplash.com/photo-1575936123452-b67c3203c357")!,
      URL(string: "https://images.unsplash.com/photo-1575936123452-b67c3203c357")!,
      URL(string: "https://images.unsplash.com/photo-1575936123452-b67c3203c357")!,
      URL(string: "https://images.unsplash.com/photo-1575936123452-b67c3203c357")!,
      URL(string: "https://images.unsplash.com/photo-1575936123452-b67c3203c357")!,
      URL(string: "https://images.unsplash.com/photo-1575936123452-b67c3203c357")!,
      URL(string: "https://images.unsplash.com/photo-1575936123452-b67c3203c357")!,
      URL(string: "https://images.unsplash.com/photo-1575936123452-b67c3203c357")!,
      URL(string: "https://images.unsplash.com/photo-1575936123452-b67c3203c357")!,
      URL(string: "https://images.unsplash.com/photo-1575936123452-b67c3203c357")!,
      URL(string: "https://images.unsplash.com/photo-1575936123452-b67c3203c357")!,
 ]
 
  return await withTaskGroup(of: UIImage.self) { group in
      for url in urls {
          group.addTask {
              await self.downloadImage(url: url)!
          }
      }
      defer {
          group.cancelAll()
      }
      return await group.reduce(into: [UIImage]()) {
          $0.append($1)
      }
  }
}

We created withTaskGroup and inside we create a new task for each url to download the image for each url and after than we await for the result of the group to return all the downloaded images in the same time.

Swift Async and Await was originally published in The Startup on Medium, where people are continuing the conversation by highlighting and responding to this story.

Actors are a new kind of reference type that protect their instance data from concurrent access. Swift actors achieve this with actor isolation, which ensures (at compile time) that all accesses to that instance data go through a synchronization mechanism that serializes execution.

Actors are fantastic for isolating instance data, providing a form of reference type that can be used in concurrent programs without introducing data races. However, when the data that needs to be isolated is scattered across a program, or is representing some bit of state that exists outside of the program, bringing all of that code and data into a single actor instance might be impractical (say, in a large program) or even impossible (when interacting with a system where those assumptions are pervasive).

# Defining global actors

A global actor is a globally-unique actor identified by a type. That type becomes a custom attribute. Any declaration can state that it is actor-isolated to that particular global actor by naming the global actor type as an attribute, at which point all of the normal actor-isolation restrictions come into play: the declaration can only be synchronously accessed from another declaration on the same global actor, but can be asynchronously accessed from elsewhere.

A global actor is a type that has the @globalActor attribute and contains a static property named shared that provides a shared instance of an actor.

@globalActor actor UserProfileActor {
    static var shared = UserProfileActor()
}

A global actor type can be a struct, enum, actor, or final class. It is essentially just a marker type that provides access to the actual shared actor instance via shared. The shared instance is a globally-unique actor instance that becomes synonymous with the global actor type, and will be used for synchronizing access to any code or data that is annotated with the global actor.

Global actors implicitly conform to the GlobalActor protocol, which describes the shared requirement. The conformance of a @globalActor type to the GlobalActor protocol must occur in the same source file as the type definition, and the conformance itself cannot be conditional.

/// A type that represents a globally-unique actor that can be used to isolate
/// various declarations anywhere in the program.
///
/// A type that conforms to the `GlobalActor` protocol and is marked with
/// the `@globalActor` attribute can be used as a custom attribute. Such types
/// are called global actor types, and can be applied to any declaration to
/// specify that such types are isolated to that global actor type. When using
/// such a declaration from another actor (or from nonisolated code),
/// synchronization is performed through the shared actor instance to ensure
/// mutually-exclusive access to the declaration.
@available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *)
public protocol GlobalActor {

    /// The type of the shared actor instance that will be used to provide
    /// mutually-exclusive access to declarations annotated with the given global
    /// actor type.
    associatedtype ActorType : Actor

    /// The shared actor instance that will be used to provide mutually-exclusive
    /// access to declarations annotated with the given global actor type.
    ///
    /// The value of this property must always evaluate to the same actor
    /// instance.
    static var shared: Self.ActorType { get }

    /// The shared executor instance that will be used to provide
    /// mutually-exclusive access for the global actor.
    ///
    /// The value of this property must be equivalent to `shared.unownedExecutor`.
    static var sharedUnownedExecutor: UnownedSerialExecutor { get }
}

# Defining MainActor

Its a globally unique actor who performs its tasks on the main thread. You can use it for properties, methods, instances, and closures to perform tasks on the main thread. Proposal SE-0316 Global Actors.

/// A singleton actor whose executor is equivalent to the main
/// dispatch queue.
@available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *)
@globalActor final public actor MainActor : GlobalActor {

    /// The shared actor instance that will be used to provide mutually-exclusive
    /// access to declarations annotated with the given global actor type.
    ///
    /// The value of this property must always evaluate to the same actor
    /// instance.
    public static let shared: MainActor

    /// Retrieve the executor for this actor as an optimized, unowned
    /// reference.
    ///
    /// This property must always evaluate to the same executor for a
    /// given actor instance, and holding on to the actor must keep the
    /// executor alive.
    ///
    /// This property will be implicitly accessed when work needs to be
    /// scheduled onto this actor.  These accesses may be merged,
    /// eliminated, and rearranged with other work, and they may even
    /// be introduced when not strictly required.  Visible side effects
    /// are therefore strongly discouraged within this property.
    @inlinable nonisolated final public var unownedExecutor: UnownedSerialExecutor { get }

    /// The shared executor instance that will be used to provide
    /// mutually-exclusive access for the global actor.
    ///
    /// The value of this property must be equivalent to `shared.unownedExecutor`.
    @inlinable public static var sharedUnownedExecutor: UnownedSerialExecutor { get }

    @inlinable nonisolated final public func enqueue(_ job: UnownedJob)

    /// The type of the shared actor instance that will be used to provide
    /// mutually-exclusive access to declarations annotated with the given global
    /// actor type.
    public typealias ActorType = MainActor
}

Imagine when we need to fetch the user pofile photo, we do network request and when the response came we switch to the main thread, we used to do this:

func fetchProfilePhoto() async {
    // Here we do the normal Netwrok Request fo fetch the profile photo
    
    DispatchQueue.main.async {
        // Here we switch to the main thread to update the profile photo.
    }
}

So now after having @MainActor we don’t need to use DispatchQueue anymore we can just label the function to @MainActor and it will execute the logic on the main thread like this:

@MainActor
func fetchProfilePhoto() {
    // Here we do the normal Netwrok Request fo fetch the profile photo
    // After the request is done, we dont need to switch to Main thread anymore as @MainActor will take care for us.
}

#Using actors on functions and variable

You can label the variables as well to make the access happens only on the main thread

final class User {
    @MainActor var name: String?
    
    @MainActor func update(name: String) {
        self.name = name
    }
}

If we tried to update the name in the User class, our compiler will complain as we can access name variable only from the main thread so we have to fix it by labeling update function to @MainActor as well.

#Using actors on a class

If we wanna make everything in the class be executed on the main thread, we can mark the class with @MainActor

@MainActor
final class UserViewModel {
    func updateProfilePhoto() {
        print("Update the profile photo done on MainThread: \(Thread.isMainThread)")
        print("Update the profile photo done on Thread: \(Thread.current)")
    }
    
    @UserProfileActor
    func fetchProfilePhoto() async {
        print("Fetch the profile photo done on MainThread: \(Thread.isMainThread)")
        print("Fetch the profile photo done on Thread: \(Thread.current)")
        await updateProfilePhoto()
    }
}

@globalActor actor UserProfileActor {
    static var shared = UserProfileActor()
}

# But how can we use this GlobalActor along with MainActor?

Imagine that you need to make everything in the class be executed on the main thread but in the same time there is a part of this class needs to be executed on a different thread, here comes the usage of global actor.

The function fetchProfilePhoto is labeled as @UserProfileActor which we did create earlier, then the fetch itself will be on the global actor like a different thread but the update itself will be on the main actor like main thread.

Fetch the profile photo done on MainThread: false
Fetch the profile photo done on Thread: <NSThread: 0x600000c34940>{number = 7, name = (null)}

Update the profile photo done on MainThread: true
Update the profile photo done on Thread: <_NSMainThread: 0x600000c280c0>{number = 1, name = main}

As we can see that both of the logic has been done on different threads.

How to use Swift @MainActor and @globalActor was originally published in Dev Genius on Medium, where people are continuing the conversation by highlighting and responding to this story.

What is Protocol-Oriented Programming?

Protocol-Oriented Programming is a new programming paradigm which is used by Swift. In the Protocol-Oriented approach, we start designing our system by defining protocols then the protocol extensions, protocol inheritance, and protocol compositions which allow us to add a new functionality not only to one type, but to a whole collection of types that all conform to the same protocol.

The value types in Swift like struct or enum cannot inherit from other structs or enums which means we cannot use inheritance with value types, but the value types can inherit from protocols, even multiple protocols which is the most powerful feature of Swift which gives us much reuse and less redundancy of the code. Highly recommended to watch Protocol-Oriented Programming in Swift WWDC and read more about Apple Combine.

Let’s say we have a User and the user has an email and we need to check if this email is valid or not, so let’s start by this sequence:

1- Define protocol

• Define the EmailValidator protocol and the inputs which the protocol will need like email.

2- Extend Protocol

• Extend the protocol and apply all the logic we need to validate if the email is valid or not.

3- Apply Protocol

• Then apply the EmailValidator into the User struct and without writing any code to validate the email, the user will inherit that. It’s super easy, huh? 😍
• We can apply the EmailValidator protocol to any class or struct which need to validate the email without writing any more code to do that. 🎉

4- Test with Protocol

• The most powerful thing about using POP is the testing, let’s say that we need for some reasons to return all the time that the email is invalid, all we need is to extend the EmailValidator where is being conformed by MockUser and override the logic of isValidEmail to always return false super easy, I love it!.

That’s how we can use the Protocol-Oriented Programming in Swift, it’s so easy to reuse and test and thence we will apply the same concept on the Network layer.

• In this Demo will learn how to call the network request to get the movies popular list, you can check all the code at the end of this article.

1- Define protocol

• Define the URLRequestBuilder protocol which conforms URLRequestConvertible protocol which is part from Alamofire.
• Then we need to define all the inputs which our protocol needs, but before doing that we need to check the URLRequestConvertible protocol.

• When we did check URLRequestConvertible protocol, will find only one function asURLRequest() which will returns URLRequest.
• So we need to know how we can buildURLRequest, so will define all the inputs which the network request will need like: URL, path, ParameterEncoding, HTTPHeaders, HTTPMethod.

2- Extend Protocol

• Do URLRequestBuilder extension and add the implementation for each input which will depend on the request like: if the httpMethod is .get then the encoding will be URLEncoding and if its .post then the encoding will be JSONEncoding.
• Build URLRequest with the httpMethod and add the header values for the request.
• Try to encode the urlRequest with the parameters and return it in asURLRequest function.

3- Apply Protocol

• In this example we have two network calls one get the popular movies list and the other one search the movies, then we need to apply our URLRequestBuilder protocol into them, so let see how.

• Create MoviesAPIs enum which will extend our protocol URLRequestBuilder and has the two cases for the two network calls.

• In MoviesAPIs extension implement the path for each case/call.

• In MoviesAPIs extension implement the parameters for each case/call like: we need to have language, api_key, page for getPopularList case/call.

• In MoviesAPIs extension implement the http method for each case/call.

4- Create NetworkService

• Create NetworkServiceProtocol protocol which have one function to execute URLRequest.
• In NetworkServiceProtocol will implement execute function and now Alamofire supports Combine.
• First we need to get DataResponsePublisher by calling publishDecodable with the model type which we will decode to codable.
• Then we need to subscribe the publisher on the background queue to execute our network call.
• Then we need to receive the publisher on the main queue to handle all UI changes.
• Then we need to sink to the publisher to get the result and return in the completion.
• Finally we need to return the AnyCancellable from Sink function so we can cancel it anytime.

4- How to use NetworkService

• Just create the network service class and execute the network request like Endpoints.getPopularList(self.pager.nextPage).resolve() and add the type of the response like MoviesResponse.self and the network layer itself will care for the rest, super easy! 😃

Hope you enjoyed as I did 😃🎉 and if so feel free to clap 😄 and share with your friends, Its always pleasure to share with people, here’s all the source code if you would like to check as well:

deda9/MovizySwiftUI

How to build Alamofire Network Layer with Protocol-Oriented Programming and Combine was originally published in Dev Genius on Medium, where people are continuing the conversation by highlighting and responding to this story.

AVFoundation is a multimedia framework with APIs in Objective-C and Swift which provides high-level services for working with time-based audiovisual media and combines six major technology areas which will go through each one in more details up and running, so let’s start with the first area in this article:

• Audio Playback, Recording, and Processing
• Media Composition and Editing
• Cameras and Media Capture
• Media Playback and Selection
• Importing and exporting audiovisual media on Apple platforms.
• Speech Synthesis and Convert text to spoken audio

Play an audio with AVAudioPlayer

• Create the songURL for the audio which wanna play.
• Create the player and hold the reference of AVAudioPlayer because if we don’t have a reference, the player will be deallocated and can’t play the audio.
• Need to set the AVAudioPlayerDelegate to update the UI when the audio is finished.
• Set numberOfLoops to .max in case wanna repeat playing this audio to infinity.
• prepareToPlay: preloads buffers and acquires the audio hardware needed for playback, which minimizes the lag between calling the play() method and the start of sound output, but calling the stop() method, or allowing a sound to finish playing, undoes this setup.

Trace the current playing time

• You can trace the current time by creating Timer which will repeatedly reschedule itself each 0.2 second and use the currentTime of the current playing audio.
• Don’t forget to hold the reference to the Timer, otherwise will not work.
• Don’t forget to invalidate the Timer when deinit is called to avoid crashes.

Change the playing rate

• If the audio is already playing, we can’t change the rate unless we replace the old player with a new one.
• Set enableRate to true before set the rate value.
• Play the new created player.

Handle the UI when the audio is finished

• After setting the player delegate, we can update the UI when the audio is finished in audioPlayerDidFinishPlaying.

Recording Audio with AVAudioRecorder

• Recording audio requires a user’s permission to stop malicious apps doing malicious things. If the permission is granted, we’ll update the UI and start recording.
• Create the AVAudioSession which acts as an intermediary between your app and the operating system. You use an audio session to communicate to the operating system the general nature of your app’s audio without detailing the specific behavior or required interactions with the audio hardware. You delegate the management of those details to the audio session, which ensures that the operating system can best manage the user’s audio experience.
• We need to active the audio session before request the permission by setActive(true).
• When the permission is granted we can start recording and update the UI to show that the recording started.

• We need to set NSMicrophoneUsageDescription’s permission in the info.plist and describe why your app will use the microphone.

• We need to create the URL where we will save the recorded audio, so we will get the documentDirectory url and then append the name of the recored audio which can be any name and the extension, like newRecord.m4a.
• We need to create the AVAudioRecorder and to do so we need to create the settings of the audio which will be recorded.
• We have two types of the settings:
• AVAudioPlayer Settings which contains the information about the sound associated with the player like:
• 1- AVChannelLayoutKey: The corresponding value is an NSData object containing an AudioChannelLayout. Channel layout can be used to describe how your audio is organized, like Mono is just 1 channel, Stereo is 2 channel. Each individual channel stand for a source, and a channel layout is just a combinations of channels
• 2- AVEncoderBitRateKey: An integer that identifies the audio bit rate which is the amount of data encoded for a unit of time, and for streaming is usually referenced in megabits per second (Mbps) for video, and in kilobits per second (kbps) for audio. From a streaming perspective, a higher video bitrate means a higher quality video that requires more bandwidth.
• 3- AVFormatIDKey: A format identifier and it can be any value of Audio Data Format Identifiers.
• 4- AVNumberOfChannelsKey: The number of channels expressed as an NSNumber integer value.
• 5- AVSampleRateKey: A sample rate, in hertz, expressed as an NSNumber floating point value which defines how many times per second a sound is sampled. Technically speaking, it is the frequency of samples used in a digital recording. The standard sample rate used for audio CDs is 44.1 kilohertz (44,100 hertz). The human ear can detect sounds from roughly 20 hertz to 20 kilohertz.
• AVAudioRecorder Settings which contains the information of the encoder which will encode the sound like:
• 1- AVEncoderAudioQualityKey: A constant from AVAudioQuality which is (.min, .low, .medium, .high, .max)
• 2- AVEncoderBitRateKey: An integer that identifies the audio bit rate.
• 3- AVEncoderBitRatePerChannelKey: An integer that identifies the audio bit rate per channel.
• 4- AVEncoderBitRateStrategyKey: An AVAudioBitRateStrategy constant.
• 5- AVEncoderBitDepthHintKey: An integer ranging from 8 through 32. A more effective way to improve the quality of digital audio is to increase the bit depth, which determines amplitude range of each sample
• After creating the url and the settings we can create the recorder and then set the delegate (AVAudioRecorderDelegate) so we can use it later to update the UI when the recording is finished.
• Before starting the actual recording we need to ask the user about the microphone permission.

Handle the UI when the recording is finished

• After setting the recorder the delegate, we can update the UI when the recoding is finished in audioRecorderDidFinishRecording function.

Manage audio behavior by AVAudioSession

AVAudioSession acts as an intermediary between your app and the operating system. You use it to communicate to the operating system the nature of your app’s audio without detailing the specific behavior or required interactions with the audio hardware. Delegating the management of those details to the audio session ensures optimal management of the user’s audio experience.

All iOS, tvOS, and watchOS apps have a default audio session that comes preconfigured with the following behavior:

• It supports audio playback, but disallows audio recording (tvOS doesn’t support audio recording).
• In iOS, setting the Ring/Silent switch to silent mode silences any audio the app is playing.
• In iOS, locking a device silences the app’s audio.
• When the app plays audio, it silences any other background audio.

• The primary means of configuring your audio session is by setting its category. The precise behaviors associated with each category are not under your app’s control, but rather are set by the operating system, so your best strategy is to pick the category that most accurately describes your intentions for the audio behavior you want.
• Certain categories support overriding their default behavior by setting one or more category options on the session . For instance, the default behavior associated with the playback category interrupts other system audio when the session is activated. In most cases, a playback app needs this behavior. However, if you want your audio to mix with other system audio, you can override this behavior by setting the mixWithOthers option on the session AVAudioSession.CategoryOptions.

Audio Session category behavior:

Modes and associated categories:

Tips:

• For your app to continue playing audio when the Ring/Silent switch is set to silent and the screen is locked, make sure the UIBackgroundModes audio key has been added to your app’s Info.plist file. This requirement is in addition to your using the correct category.
• You can activate the audio session at any time after setting its category, but it’s generally preferable to defer this call until your app begins audio playback. Deferring the call ensures that you won’t prematurely interrupt any other background audio that may be in progress.

Hope you enjoyed as I did 😃🎉 and if so feel free to clap 😄 and share with your friends, Its always pleasure to share with people, here’s all the source code if you would like to check as well:

deda9/AVFoundationExample

Learn how to play and record audio on iOS AVFoundation was originally published in Dev Genius on Medium, where people are continuing the conversation by highlighting and responding to this story.

Before starting playing, streaming, recording sounds or configure how your application and the operating system should respond to the interruptions, we need to take a small journey to the Core Audio and some definitions about the audio just to get the full picture. In the next parts will talk in more details up and running.

What’s Core Audio?

Core Audio is the digital audio infrastructure of iOS and OS X. It includes a set of software frameworks designed to handle the audio needs in your applications which is optimized for the computing resources available in a battery powered mobile platform.

Core Audio uses the notion of proxy objects to represent such things as files, streams, audio players, and so on. When you want your application to work with an on-disk audio file, for example, the first step is to instantiate an audio file object of type AudioFileID which is declared as an opaque data.

typealias AudioFileID = OpaquePointer

You instantiate an audio file object and create an actual audio file tied to that object by calling the AudioFileCreateWithURL function. The function gives you a reference to the new audio file object.

Apple has designed the software interfaces to Core Audio using a layered, cooperative, task-focused approach which are arranged into three layers:

Low Level Service Layer:

• The I/O Kit which interacts with drivers.
• The audio hardware abstraction layer (audio HAL) which provides a device-independent, driver-independent interface to hardware.
• Core MIDI which provides software abstractions for working with MIDI (Musical Instrument Digital Interface) streams and devices.
• Host Time Services which provides access to the computer’s clock.

Mid Level Service Layer:

• Audio Converter Services lets applications work with audio data format converters.
• Audio File Services supports reading and writing audio data to and from disk-based files.
• Audio Unit Services and Audio Processing Graph Services let applications work with digital signal processing (DSP) plug-ins such as equalizers and mixers.
• Audio File Stream Services supports building applications that can parse streams, such as for playing files streamed over a network connection.
• Core Audio Clock Services supports audio and MIDI synchronization as well as time-base conversions.
• Audio Format Services assists with managing audio data formats in your application.

High Level Service Layer:

• Audio Queue Services lets you record, play, pause, loop, and synchronize audio.
• The AVAudioPlayer supports playing and looping audio as well as implementing rewind and fast-forward.
• Extended Audio File Services combines features from Audio File Services and Audio Converter services. It gives you a unified interface for reading and writing uncompressed and compressed sound files.
• OpenAL is the Core Audio implementation of the open-source OpenAL standard for positional audio. It is best suited for games development.

What are the available frameworks which we can use?

There are many audio frameworks which we can use, and here’s a short brief about each one. In the next parts will talk about each one in more details up and running.

• AVFoundation.framework provides the AVAudioPlayer class for audio playback and also provides the AVAudioEngine class for more sophisticated audio handling.
• AudioToolbox.framework: manages the Audio Session and the behavior of your application’s audio in the context of a device.
• AudioUnit.framework: let your applications work with audio plug-ins including audio units and codecs.
• CoreAudio.framework supplies data types used across Core Audio as well as interfaces for the low-level services.
• OpenAL.framework provides the interfaces to work with OpenAL and it’s more for games suited development.
• CoreAudioKit.framework provides a small API for creating user interfaces for audio units (not available in iOS).
• CoreMIDI.framework lets applications work with MIDI data and configure MIDI networks (not available in iOS).
• CoreMIDIServer.framework lets MIDI drivers communicate with the OS X MIDI server (not available in iOS).

Audio Data Formats

You don’t need a detailed knowledge of audio data formats so that one set of code can work with any format supported by the operating system. An audio data format describes audio data such things as sample rate, bit depth, format flags or the number of frames in a packet of audio data.

Some audio file formats can contain just one sort of audio data format for instance, an MP3 file can contain only MP3 audio data. Other file formats such as Apple’s CAF format can contain a variety of audio data formats. You can find more details about AudioStreamBasicDescription

Magic Cookies

It refers to information included in audio file header used to describe data formats. The metadata gives a decoder the details it needs to properly decompress the file or stream. When converting audio data you must check to see if the format of the audio data you are attempting to convert has a magic cookie. If the audio data format has a magic cookie associated with it, you must add this information to the instance of the audio converter being used. This is done by using the AudioConverterSetProperty API along with the kAudioConverterDecompressionMagicCookie property and the magic cookie data blob.

Audio Data Packets

It’s as a collection of one or more frames. It is the smallest meaningful so it is the best unit of audio data to represent a unit of time in an audio file. You can use packets to calculate useful audio data buffer sizes. In order to communicate audio via networks the audio packets are sent to the network from the sending side and the receiving side picks up the audio packet and integrates the finely segmented digital signals to turn it back into an analogue signal which enables the original audio to be heard.

Data Format Conversion

To convert audio data from one format to another, you use an audio converter. You can make simple conversions such as changing sample rate or interleaving/deinterleaving. You can also perform complex conversions such as compressing or decompressing audio.

Three types of conversions are available:

• Decoding an audio format to linear PCM format.
• Converting linear PCM data into a different audio format.
• Converting between different variants of linear PCM

Playing Multiple Sounds Simultaneously

To play multiple sounds simultaneously, create one playback audio queue object for each sound. For each audio queue, schedule the first buffer of audio to start at the same time using the AudioQueueEnqueueBufferWithParameters function.

Audio format is critical when you play sounds simultaneously on iPhone or iPod touch. This is because playback of certain compressed formats in iOS employs an efficient hardware codec. Only a single instance of one of the following formats can play on the device at a time:

• AAC
• ALAC
• MP3

To play high quality, simultaneous sounds, use linear PCM or IMA4 audio.

Audio Queue Services

Audio Queue Services provides a straightforward, low overhead way to record and play audio. It lets your application use hardware recording and playback devices (such as microphones and loudspeakers) without knowledge of the hardware interface. It also lets you use sophisticated codecs without knowledge of how the codecs work.

You can use it to synchronize playback of multiple audio queues, to play sounds simultaneously, to independently control playback level of multiple sounds, and to perform looping.

System Sounds: Alerts and Sound Effects

To play short sound files when you do not need level, positioning, audio session, or other control. When you just want to play a short sound in the simplest way possible use System Sound Services which is declared in the Audio Toolbox framework. In iOS, sounds played using System Sound Services are limited to a maximum duration of 30 seconds.

In iOS, you call the AudioServicesPlaySystemSound function to immediately play a sound effect file that you designate. Alternatively, you can call AudioServicesPlayAlertSound when you need to alert the user. Each of these functions will invoke vibration on an iPhone if the user has set the silence switch.

Digital Audio and Linear PCM

Most Core Audio services use and manipulate audio in linear pulse-code-modulated (linear PCM) format, the most common uncompressed digital audio data format. Digital audio recording creates PCM data by measuring an analog audio signal’s magnitude at regular intervals (the sampling rate) and converting each sample to a numerical value.

Standard compact disc (CD) audio uses a sampling rate of 44.1 kHz, with a 16-bit integer describing each sample constituting the resolution or bit depth.

• A sample is single numerical value for a single channel.
• A frame is a collection of time-coincident samples. For instance, a stereo sound file has two samples per frame, one for the left channel and one for the right channel.
• A packet is a collection of one or more contiguous frames. In linear PCM audio, a packet is always a single frame. In compressed formats, it is typically more.

The 16-bit integer samples in standard CD audio allow 65,536 possible values between silence and maximum level.

Configuring an Audio Session

An audio session is the intermediary between your app and the operating system that is used to configure your app’s audio behavior. Upon launch, your app is automatically provided with a singleton audio session. You configure it such as whether your audio should continue when the Ringer/Silent switch is flipped.

All iOS, tvOS, and watchOS apps have a default audio session that is preconfigured as follows:

• Audio playback is supported, but audio recording is disallowed.
• In iOS, setting the Ring/Silent switch to silent mode silences any audio being played by the app.
• In iOS, when the device is locked, the app’s audio is silenced.
• When your app plays audio, any other background audio — such as audio being played by the Music app — is silenced.

You can customize it to better suit your app’s needs by setting its category.

Enabling Background Audio

When you enable background audio your app’s audio can continue when users switch to another app or when they lock their iOS devices and to do so, you need to select your app’s target in Xcode and select the Capabilities tab. Under the Capabilities tab, set the Background Modes switch to ON and select the “Audio, AirPlay, and Picture in Picture” option from the list of available modes.

Hope you enjoyed as I did 😃🎉 and if so feel free to clap 😄 and share with your friends, Its always pleasure to share with people. Stay tuned for the other parts while having real code examples.

Introduction into iOS Core Audio was originally published in Dev Genius on Medium, where people are continuing the conversation by highlighting and responding to this story.

Will talk about how we can use Apple Combine with Core Data but if you like to read more about Core Data itself and how can we use it to save, fetch and delete the entities you can read the previous article about Core Data with Sugar Syntax.

First we will need to create a custom Combine Publisher and fortunately it’s super easy to do that we will need just 3 steps to do it but before doing that we need to understand how the publisher actually work, so let’s talk about that for a bit before applying our customer Publisher to the Core Data and we need to understand the Publisher, the Subscription and the Subscriber

• The Publisher is just a simple internal protocol which has the Failure type (When our logic did fail the publisher will publish this error in the completion with failure case), the Output type (It is the result which our publisher will publish when did succeed) and receive<S>(subscriber:) function where we will make the the subscriber to successfully subscribe to the publisher.

• When we extend that protocol we need to set the type for both ofFailure and Output.
• Actually the publisher doesn't do the work, but every publisher is backed by a Subscription which will be our custom class which will extend Subscription where the magic happens.
• The Subscription is just another simple internal protocol which has one function request(_ demand:) which will have all our logic.

• The Subscriber is another simple internal protocol that declares a type that can receive input from a publisher.

…and after we knew the Publisher’s components let’s go deep and start the 3 steps to make it happen 😃

1- Create a struct and extend Publisher Protocol

1- Create CoreDataSaveModelPublisher which extends thePublisher.

2- Pass the NSManagedObjectContext property where we can use the context to save the entities into the Core Data.

3- Pass theAction property closure which will hold all the creation of the entities (NSManagedObjects) which will be executed later.

4- The Failure type will be NSError and the Output will be Bool just to tell us the process is succeeded or not.

5- Create a custom Subscription class which will do all the magic and pass all the properties which we will use later.

5- The subscriber successfully subscribed to the publisher in receive<S>(subscriber:.

2- Create a Subscription class and extend Subscription Protocol

1- Create CoreDataSaveModelPublisher.Subscription which extends theSubscription which will hold the NSManagedObjectContext, Action and Subscriber.

2- Do the logic to save the entity into the Core Data in the function request(_ demand:).

3- If the process succeeded then notify the Subscriber with the success value otherwise notify with completion: .failure(error).

4- Extend Cancellable to make our custom publisher is cancellable.

3- Use the custom CoreDataSaveModelPublisher

1- After creating CoreDataSaveModelPublisher its the time to use it, create all the entities which we need to save into the Core Data and warp that block in aAction closure.

2- Then use the publisher(save: action) of coreDataStore (you can find it on the code repository) and then we can use sink, receive(on:) or subscribe(on:) as normal.

and here’s all the final publishers to Save & Fetch & Delete data into the Core Data:

1- Save any Entity into the Core Data by CoreDataSaveModelPublisher

2- Fetch the data from the Core Data by CoreDataFetchResultsPublisher.

3- Delete any Entity from the Core Data by CoreDataDeleteModelPublisher.

Hope you enjoyed as I did 😃🎉 and if so feel free to clap and if you liked more feel free to clap more 😃 and share with your friends, Its always pleasure to share with people, and here’s all the source code if you would like to check as well:

deda9/CoreData-Combine

iOS Core Data With Combine was originally published in The Startup on Medium, where people are continuing the conversation by highlighting and responding to this story.

When I started iOS programming since years ago I was mixing up between the Core Data and the Database, but in fact the Core Data is not a database even Core Data is actually backed by an SQLite database but both of them are ways of providing searchable and persistent storage. In short description we can say that SQLite is a database itself and Core Data is an ORM (Object Relational Model) which creates a layer between the database and the UI.

What’s Core Data?

Core Data is a framework that you use to manage the model layer objects in your application. It provides generalized and automated solutions to common tasks associated with object life cycle and object graph management, including persistence. It typically decreases by 50 to 70 percent the amount of code you write to support the model layer and to well understand the Core data and how it works we need to understand the Core Data Stack.

What’s Core Data Stack?

The Core Data stack is a collection of framework objects that are accessed as part of the initialization of Core Data and that mediate between the objects in your application and external data stores. The Core Data stack handles all of the interactions with the external data stores so that your application can focus on its business logic. The stack consists of four primary objects:

• NSPersistentContainer handles the creation of the Core Data stack and offers access to the NSManagedObjectContext as well as a number of convenience methods.
• NSManagedObjectModel describes the data that is going to be accessed by the Core Data stack. During the creation of the Core Data stack, the NSManagedObjectModel is loaded into memory as the first step in the creation of the stack. After the NSManagedObjectModel object is initialized, the NSPersistentStoreCoordinator object is constructed.
• NSManagedObjectContext is the object that your application will interact with the most. Think of it as an intelligent scratch pad. When you fetch objects from a persistent store, you bring temporary copies onto the scratch pad where they form an object graph. You can then modify those objects however you like and if you choose to save the changes you have made, the context ensures that your objects are in a valid state. If they are, the changes are written to the persistent store, new records are added for objects you created, and records are removed for objects you deleted.
• NSPersistentStoreCoordinator sits in the middle of the Core Data stack. It is responsible for realizing instances of entities that are defined inside of the model. It creates new instances of the entities in the model, and it retrieves existing instances from a persistent store (NSPersistentStore) which can be on disk or in memory depending on the structure of the application.

1- Initializing the Core Data Stack

• The initialization of the stack prepares Core Data for data requests and the creation of data.
• Starting in iOS 10 the NSPersistentContainer handles the creation of the Core Data stack but prior to iOS 10 the creation of the Core Data stack was more involved and you can read more.
• Here’s an example of how to create that Core Data stack:

2- Creating a Managed Object Model

• Much of Core Data’s functionality depends on the schema you create to describe your application’s entities, their properties, and the relationships between them. Core Data uses a schema called a managed object model an instance of NSManagedObjectModel.
• Image that we have an entity is called Person who has first_name and last_name and owns a car then the Car will be another entity which has a name and the owner attributes.
• The owner might have more than one car then we will create one-to-many relationship between the owner and the car.

1- Click on Add Entity button and create the Person and Car entities.
2- Create the first_name and last_name attributes for the Person entity.
3- Create the relationship between the owner and the car.
4- Make the relationship one-to-many.
5- Do the same for the Car entity.

3- Creating Managed Objects

• After you have defined your managed object model and initialized the Core Data stack within your application, you are ready to start creating objects for data storage.
• I’ve created some sugar syntax to create entities and save them and you can check the complete source code at the end of the article.

4- Saving Managed Objects

• After creating the entities and their attributes all we need is to call save or saveSync to explicitly save that context to persist those changes to your persistent store.

5- Fetching Objects

• Now that data is stored in the Core Data persistent store, you will use an NSFetchRequest to access that existing data.
• You start by constructing an NSFetchRequest that describes the data you want returned.
• You then call fetch(:) on the NSManagedObjectContext and pass in the request.
• I’ve added some sugar syntax to make our life easy and just call fetch.

6- Deleting Entities from CoreData

• Actually it’s so simple to delete any entity from the Core Data. It only requires to pass NSFetchRequest instance and after that we execute the batch delete request on your managed object context.

7- Using Core Data in the Background

• Core Data is designed to work in a multithreaded environment.
• Managed object contexts are bound to the thread that they are associated with upon initialization.
• Managed objects retrieved from a context are bound to the same queue that the context is bound to.
• There are two types of managed object contexts: main queue and private queue.
• Here’s an example how we can use a private queue to support concurrency

• We created a new NSManagedObjectContext that is defined as a private queue and the new context is set as a child of the main queue context that runs the application then call performBlock: to do the actual work and after all of the data has been consumed, you call save on the private context, which moves all of the changes into the main queue context without blocking the main queue.

8- Performance tips

• Each round trip to the persistent store incurs an overhead, both in accessing the store and in merging the returned objects into the persistence stack. Avoid executing multiple requests if you can instead combine them into a single request that will return all the objects you require.
• If a fetch request requires a compound predicate, you can make the fetch more efficient by ensuring that the most restrictive predicate is the first, especially if the predicate involves text matching (contains, endsWith, like, and matches).
• You can set a limit to the number of objects a fetch will return to minimize the working set of managed objects in memory and so improve the performance of your application.
• Use Prefetching and the idea behind prefetching is the anticipation of future needs. When you fetch some objects, sometimes you know that soon after you will also need related objects which may be represented by faults.
• Avoid using Core Data as a store for large blocks of binary data, such as videos, images, or audio.
• Avoid blocking the main thread of your application by using background threading and switching to the main queue to update the user interface.

Here’s all the complete sugar syntax

Hope you enjoyed as I did 😃🎉 and if so feel free to clap and if you liked more feel free to clap more 😃 and share with your friends, Its always pleasure to share with people, and here’s all the source code if you would like to check as well:

deda9/CoreDataExample

iOS Core Data with Sugar Syntax was originally published in Dev Genius on Medium, where people are continuing the conversation by highlighting and responding to this story.

In Part 1 talked about what’s Combine and how we can understand and use it and in Part 2 talked about more examples of the usage.

Now let’s leverage what we have learned and apply into real examples.

1- Listen to UITextField when text did change

2- Check if the device orientation is portrait

3- Execute network request when user types any text on UITextField

• You can read more about Debounce, CompactMap, RemoveDuplicates, FlatMap and ReceiveOn.

4- Performing Key-Value Observing to listen to a property’s value change

• The User class should beNSObject and the property should be@objc dynamic.

5- Create a Timer

• You can read more about AutoConnect and ReceiveOn.

6- Credentials validation to enable login button

• You can read more about CombineLatest and Share

7- Ask the user for the notification permission

• You can read more about Future and Catch
• Its always good to breakdown the code into small functions, otherwise it will be ended up with a huge chain and that’s one of the drawback of reactive programming.

8- Execute URLSession request

9- Execute two URLSession requests and wait for their results when they are finished

10- Trace user location when it changed

Hope you enjoyed as I did 😃🎉 and if so feel free to clap and if you liked more feel free to clap more 😃 and share with your friends, Its always pleasure to share with people.

Don’t forget to check the other pars of the series 🚀

• Learn Combine by code Series (Part 1)
• Learn Combine by code Series (Part 2)

Learn Combine by code Series (Part 3) was originally published in Dev Genius on Medium, where people are continuing the conversation by highlighting and responding to this story.

In Part 1 talked about what’s Combine and how we can understand and use it and in this part will go continuing the examples of the usage.

16- Comparison

• When we need to republish items from another publisher only if each new item is in increasing order from the previously-published item.

a is: 1 b is: 4
a is: 2 b is: 4
a is: 0 b is: 4
a is: 3 b is: 4

Value is: 4

17- Concatenate

• When we need to emit all of one publisher’s elements before those from another publisher.

Value is: A1
Value is: A2
Value is: B1
Value is: B2

18- Contains

• When we need to emit a Boolean value when a specified element is received from its upstream publisher.

Does numbers contains A1?  true

19- ContainsWhere

• When we need to emits a Boolean value upon receiving an element that satisfies the predicate closure.

Does numbers contains A?:  true

20- Count

• When we need to publish the number of elements received from the upstream publisher.

Count of numbers publisher is: 3

21- Debounce

• When we need to publish elements only after a specified time interval elapses between events.

Time now is:  2020-10-25 19:20:25 +0000
value is: AA at time:  2020-10-25 19:20:27 +0000

22- Delay

• When we need to delay the delivery of the elements and the completion to the downstream receiver.

Time now is:  2020-10-26 22:43:26 +0000
value: is 1 at time:  2020-10-26 22:43:36 +0000
value: is 2 at time:  2020-10-26 22:43:36 +0000
value: is 3 at time:  2020-10-26 22:43:36 +0000
Finished at time:  2020-10-26 22:43:36 +0000

23- Drop

• When we need to omit a specified number of elements before republishing later elements.

24- DropUntilOutput

• When we need to ignore elements from the upstream publisher until it receives an element from second publisher.

value is:  A3
value is:  A4

25- DropWhile

• When we need to omit elements from an upstream publisher until a given closure returns false.

value is:  B1
value is:  B2

26- Filter

• When we need to republish all elements that match a provided closure.

value is:  A1
value is:  A2

27- First

• When we need to publish the first element of a stream, then finishes.

value is:  A1

28- FirstWhere

• When we need only to publish the first element of a stream to satisfy a predicate closure.

value is:  A1

29- FlatMap

• When we need to transform elements from an upstream publisher into a new publisher.

value is:  2
value is:  4
value is:  6

30- HandleEvents

• When we need to perform the specified closures when publisher events occur.

receiveSubscription [1, 2, 3]
receiveRequest demand unlimited
receiveOutput 1
value is:  1
receiveOutput 2
value is:  2
receiveOutput 3
value is:  3
receiveCompletion finished

31- IgnoreOutput

• When we need to ignore all upstream elements, but passes along a completion state (finish or failed).

receiveCompletion finished

32- Last

• When we need only to publish the last element of a stream, after the stream finishes.

value is:  3

33- LastWhere

• When we need only to publish the last element of a stream that satisfies a predicate closure, once the stream finishes.

value is:  3

34- MakeConnectable

• When we need to provide explicit connectability to another publisher.

value is:  B1

35- Map

• When we need to transform all elements from the upstream publisher with a provided closure.

value is:  A1
value is:  A2
value is:  A3

36- Merge

• When we need applying the merge function to two upstream publishers

value is:  1
value is:  2
value is:  3
value is:  4
value is:  5
value is:  6

37- Multicast

• When we need to use a subject to deliver elements to multiple subscribers.
• It returns a ConnectablePublisher which publishing only begins after a call to connect().

Stream 1 received: First
Stream 1 received: Second
Stream 1 received: Third
Stream 2 received: First
Stream 2 received: Second
Stream 2 received: Third

38- ReceiveOn

• When we need to deliver elements to its downstream subscriber on a specific scheduler.

value is:  First
value is:  Second
value is:  Third

39- RemoveDuplicates

• When we need to publish only elements that don’t match the previous element.

value is:  First
value is:  Third

40- Reduce

• When we need to apply a closure to all received elements and produces an accumulated value when the upstream publisher finishes.

55 finished

41- Scan

• When we need to accumulate all previously-published values into a single value, which you then combine with each newly-published value.

0 1 3 6 10 15

42- Share

• When we need to share the output of an upstream publisher with multiple subscribers.

Random: receive subscription: ([55, 69, 38])
Random: request unlimited
Random: receive value: (55)
Stream 1 received: 55
Random: receive value: (69)
Stream 1 received: 69
Random: receive value: (38)
Stream 1 received: 38
Random: receive finished

43- SubscribeOn

• When we need to receive elements from an upstream publisher on a specific scheduler.

Stream received: 1
Stream received: 2
Stream received: 3

44- SwitchToLatest

• When we need to produce a sequence of events from only the most recent one.

URL: https://example.org/get?index=5

45- Throttle

• When we need to selectively republish elements from an upstream publisher during an interval you specify.

Received Timestamp 2020-10-28 20:24:17 +0000
receive value: (2020-10-28 20:24:18 +0000)
receive value: (2020-10-28 20:24:19 +0000)
receive value: (2020-10-28 20:24:20 +0000)
Received Timestamp 2020-10-28 20:24:20 +0000
receive value: (2020-10-28 20:24:21 +0000)
receive value: (2020-10-28 20:24:22 +0000)
receive value: (2020-10-28 20:24:23 +0000)
Received Timestamp 2020-10-28 20:24:23 +0000

46- Zip

• When we need to combine the latest elements from two publishers and emit a tuple to the downstream.

(1, "A")
(2, "B")

47- TryCatch

• When we need to decide how to handle from an upstream publisher by either replacing the publisher with a new publisher, or throwing a new error.

Received 5.
Received 4.
Received 3.
Received 2.
Received 1.
Received 0.
Completion: finished.

48- Timeout

• When we need to terminate a publisher if an element isn’t delivered within a timeout interval you specify.

completion: finished at 2020-10-28 20:34:54 +0000

I really do love the reactive programming and enjoying learning it. Hope you enjoyed as I did 😃🎉 and if so feel free to clap and if you liked more feel free to clap more 😃 and share with your friends, Its always pleasure to share with people.

Don’t forget to check the other parts of the series 🚀

• Learn Combine by code Series (Part 1)
• Learn Combine by code Series (Part 3)

Learn Combine by code Series (Part 2) was originally published in Dev Genius on Medium, where people are continuing the conversation by highlighting and responding to this story.