Swift Quick Start

let Application = Swift as TheCoursingRiver
//With all the force of a great Typhoon!

Requirements

CocoaPods install

Typhoon can be installed via CocoaPods easily. Add this to your Podfile:

pod 'Typhoon', :head

Create a YOURPROJECTNAME-Bridging-Header.h if it does not already exist and import the Typhoon Objective-C header there to use it in your Swift project.

#import "Typhoon.h"

Dynamic framework install

Typhoon can be linked against as a Dynamic Framework.

# platform *must* be atleast 8.0
platform :ios, '8.0'

# flag makes all dependencies build as frameworks
use_frameworks!

# framework dependencies
pod 'Typhoon', '2.3.3'

Simply import the Typhoon module in any Swift file that uses the framework:

import Typhoon

Setup Dependency Injection

Two following steps are required to use Dependency Injection with Typhoon:

1. Configure TyphoonAssembly subclass(es)
2. Use TyphoonDefinitions to tell the framework which classes should be considered for Dependency Injection

Initial setup and configuration

Create a sub-class of TyphoonAssembly, and define your class that should have a property injected (in this case we are injecting the assembly itself into the AppDelegate)

class ApplicationAssembly : TyphoonAssembly {
    
    dynamic func appDelegate() -> AnyObject {
        return TyphoonDefinition.withClass(AppDelegate.self) {
            (definition) in
            
            definition.injectProperty("assembly", with: self)
        }
    }    
}

Then create an entry TyphoonInitialAssemblies of type Array in your Info.plist and add your assembly subclass name to register the assembly:

Then, add the following property to your AppDelegate:

var assembly : ApplicationAssembly?

Definition of what should be injected into which class

Edit the ApplicationAssembly you defined above to include the following definitions. (You may need to create the classes and protocols or adjust them to your current project)

    dynamic func basicKnight() -> AnyObject {
        
        return TyphoonDefinition.withClass(Knight.self) {
            (definition) in
            
            definition.useInitializer("initWithQuest:") {
                (initializer) in
                
                initializer.injectParameterWith(self.defaultQuest())
                
            }
        }
    }
    
    dynamic func defaultQuest() -> AnyObject {
        return TyphoonDefinition.withClass(CampaignQuest.self)
    }

Now you can access the ApplicationAssembly in the AppDelegate:

   func application(application: UIApplication, 
       didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) 
       -> Bool {
        
        //Code-completion + no 'magic strings'  
        var knight : Knight = assembly.basicKnight()
        
        // . . continue setting up App        

        return true
    }

That's it!

Key Concept

Before activation each method returns a TyphoonDefinition. After activation we'll use the same interface to return built instances. In Swift, the return type of TyphoonAssembly methods must be AnyObject, to satisfy its strict type checking both before and after activation.

Other Notable Points

• You don't need to inject the assembly into the app delegate. In fact, you can inject anything anywhere you want
• Most of the times you will not inject the assembly itself but your classes (e.g. inject an implementation of CityDao protocol into the CitiesListViewController or similar) to have a real Dependency Injection as it was intended
• IMPORTANT! Every class you want to inject has to be a subclass of NSObject in some way (either by subclassing or adding @objc modifier). Also if you define a protocol property in your class (e.g. var cityDao: CityDao?), that protocol must also have the @objc modifier). Otherwise injection will not work. See the sample project for more information.

Sample Application

• Here is a Swift Sample Application