Overdrive - SwiftGit

SwiftUI

Overdrive

March 15, 2024

Our apps constantly do work. The faster you react to user input and produce an output, the more likely is that the user will continue to use your application. As our applications grow in complexity, the more and more work needs to be done. You need to start thinking about how to categorize and optimize work, how to make that work more efficient, more optimized and finally, faster. In most cases that doesn’t end very well because you need to know a lot about concurrency, multithreading etc. – it’s a very complex field. You need to know all API specifics before you are able to write something.

Overdrive was created as a result of that struggle. It is a framework that exposes several simple concepts which are made on top of complex system frameworks that enable multithreading, concurrency and most importantly, more speed.


                                              
                                                let task = URLSessionTask(url: “https://api.swiftable.io”)
task

.retry(3)

.onValue { json in

print(json[“message”])

}.onError { error in

print(error)

}
TaskQueue.background.add(task: task)

What can I do with Overdrive?

Execute tasks concurrently
Utilize multi-core systems by default
Easily defer task execution to custom thread or queue
Ensure that multiple tasks are executed in the correct order
Express custom conditions under which tasks can be executed
Enforce testability
Retry tasks that finished with errors
Write thread safe code by default

Requirements

Xcode 8.0+
Swift 3
Platforms:
- iOS 8.0+
- macOS 10.11+
- tvOS 9.0+
- watchOS 2.0+
- Ubuntu

Installation

Carthage


                                              
                                                github “arikis/Overdrive” >= 0.3

Cocoa Pods


                                              
                                                platform :ios, ‘8.0’

use_frameworks!
target ‘Your App Target’ do

pod ‘Overdrive’, ‘~> 0.3’

end

Swift Package Manager


                                              
                                                import PackageDescription
let package = Package(

name: “Your Package Name”,

dependencies: [

.Package(url: “https://github.com/arikis/Overdrive.git”,

majorVersion: 0,

minor: 3)

]

)

Manual installation

Overdrive can also be installed manually by dragging the Overdrive.xcodeproj to your project and adding Overdrive.framework to the embedded libraries in project settings.

Usage

Overdrive features two main classes:

Task<T> – Used to encapsulate any asynchronous or synchronous work – Documentation
TaskQueue – Used to execute tasks and manage concurrency and multi threading – Documentation

Workflow:

Create subclass of Task<T>
Override run() method and encapsulate any synchronous or asynchronous operation
Finish execution with value(T) or error(Error) by using finish(with:) method
Create instance of subclass
Add it to the TaskQueue when you want to start execution

Example Task<UIImage> subclass for photo download task:


                                              
                                                class GetLogoTask: Task<UIImage> {
override func run() {

let logoURL = URL(string: “https://swiftable.io/logo.png”)!
do {

let logoData = try Data(contentsOf: logoURL)

let image = UIImage(data: logoData)!

finish(with: .value(image)) // Finish with image

} catch {

finish(with: .error(error)) // Finish with error if any

}

}

}

To setup completion blocks, you use onValue and onError methods:


                                              
                                                let logoTask = GetLogoTask()
logoTask

.onValue { logo in

print(logo) // UIImage object

}.onError { error in

print(error)

}

To execute the task add it to the instance of TaskQueue


                                              
                                                let queue = TaskQueue()

queue.add(task: logoTask)

Concurrency

TaskQueue executes tasks concurrently by default. Maximum number of concurrent operations is defined by the current system conditions. If you want to limit the number of maximum concurrent task executions use maxConcurrentTaskCount property.


                                              
                                                let queue = TaskQueue()

queue.maxConcurrentTaskCount = 3

Thread safety

All task properties are thread-safe by default, meaning that you can access them from any thread or queue and not worry about locks and access synchronization.

Inspiration

Overdrive framework was heavily inspired by talks and code from several Apple WWDC videos.

Overdrive is a term for an effect used in electric guitar playing that occurs when guitar amp tubes starts to produce overdriven, almost distorted sound, due to the higher gain(master) setting.