Home

Awesome

<img src="http://i.imgur.com/pp7QHRW.png" width="40%" height="40%"/>

Build Status Plaforms Carthage Compatible Swift Package Manager Compatible Pod version

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)

Contents:

What can I do with Overdrive?

Requirements

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:

Workflow:

  1. Create subclass of Task<T>
  2. Override run() method and encapsulate any synchronous or asynchronous operation
  3. Finish execution with value(T) or error(Error) by using finish(with:) method
  4. Create instance of subclass
  5. 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.

Long term plans

This section defines some long term plans for Overdrive. They're not scheduled for implementation or for any specific version.

Remove Foundation.Operation dependency

Currently, Overdrive leverages Foundation.Operation and Foundation.OperationQueue classes for concurrency and execution. While those classes provide excellent functionality, they're still rewrites of their Objective C counterpart (NSOperation and NSOperationQueue). This means that writing Task<T> requires a lot of overrides and state management.

For example, any task subclass must override run() method to define execution point. If this method is not overridden, queue will perform assert to notify that this method should be overridden. Same will happen if super.run() is called.

In the future, Overdrive should only use libdispatch for it's functionality.