Modules

The Tealium Swift library is designed around a modular architecture. Required modules must be specified when the library is initialized in the TealiumConfig instance.

All modules have a dependency on TealiumCore. Modules are separated into Collectors and Dispatchers depending on their purpose.

Collectors

Collectors are modules that gather supplemental information from the device and append it to the data layer before it’s transmitted to the Tealium Customer Data Hub. Some collectors are included in the core library, while others are optional and installed as separate modules.

The following table lists the available collectors. Default collectors are denoted by a * next to the collector name.

Collector Name	TealiumConfig Reference
AppData*	Collectors.AppData
Attribution	Collectors.Attribution
Connectivity*	Collectors.Connectivity
Device	Collectors.Device
Crash	Collectors.Crash
AutoTracking	Collectors.AutoTracking
Lifecycle	Collectors.Lifecycle
Location	Collectors.Location
VisitorService	Collectors.VisitorService

These modules are included with the core library, but are enabled or disabled using the TealiumConfig collectors property as described below

Usage

To add a Collector, specify it in the collectors property of the TealiumConfig instance:

import TealiumCore
import TealiumLifecycle

let config = TealiumConfig(account: "ACCOUNT",
                               profile: "PROFILE",
                               environment: "ENVIRONMENT",
                               datasource: "DATASOURCE")

// Adds desired Collectors. If omitted, default Collectors are added.
config.collectors = [Collectors.AppData, Collectors.Lifecycle]                               

To only use the default collectors, omit or comment out the config.collectors line from your initialization code.

Custom Collectors

Although custom collectors are generally not required, it is possible to build a custom collector by creating your own class conforming to the Collector protocol. The following example shows a simple collector that gathers the current weekday and appends it to the data layer for each tracking call.

class MyDateCollector: Collector {
    var id = "MyDateCollector"

    var data: [String : Any]? {
        ["day_of_week": dayOfWeek]
    }

    var context: TealiumContext

    required init(context: TealiumContext,
                  delegate: ModuleDelegate?,
                  diskStorage: TealiumDiskStorageProtocol?,
                  completion: (ModuleResult) -> Void) {
        self.context = context
    }

    var dayOfWeek: String {
        return "\(Calendar.current.dateComponents([.weekday], from: Date()).weekday ?? -1)"
    }
}

// Add collector to your config instance prior to Tealium initialization

class TealiumHelper {
	// ...
	func startTracking() {
		let config = TealiumConfig(account: "ACCOUNT",
                               profile: "PROFILE",
                               environment: "ENVIRONMENT",
                               datasource: "DATASOURCE")

// Add desired Collectors. If omitted, default Collectors are added.
config.collectors = [Collectors.AppData,
					  Collectors.Lifecycle,
					  MyDateCollector.self]   
					  self.tealium = Tealium(config: config) { _ in }
	}
}

Dispatchers

Dispatchers are modules that send the data from your data layer and send it to a Tealium endpoint. The following dispatchers are currently available:

Dispatcher Name	TealiumConfig Reference
Collect	Dispatchers.Collect
RemoteCommands	Dispatchers.RemoteCommands
TagManagement	Dispatchers.TagManagement

At least one dispatcher is required. If no dispatchers are specified, your data is not sent anywhere.

Usage

To add a Dispatcher, specify it in the dispatchers property of the TealiumConfig object:

import TealiumCore
import TealiumLifecycle

let config = TealiumConfig(account: "ACCOUNT",
                               profile: "PROFILE",
                               environment: "ENVIRONMENT",
                               datasource: "DATASOURCE")

// Add desired Collectors. Do not include if you want to use compiled Collectors
config.dispatchers = [Dispatchers.Collect]                               

Custom Dispatchers

Although custom dispatchers are generally not required, it is possible to build a custom Dispatcher by creating your own class conforming to the Dispatcher protocol. The following example shows a simple dispatcher that prints the event name for each track request. A custom Dispatcher may be useful if you wish to send data to your own custom endpoint in addition to the Tealium endpoints.

class MyCustomDispatcher: Dispatcher {
    var isReady: Bool
    var id = "MyCustomDispatcher"
    var config: TealiumConfig

    required init(config: TealiumConfig, delegate: ModuleDelegate, completion: ModuleCompletion?) {
        self.config = config
        self.isReady = true
    }

    func dynamicTrack(_ request: TealiumRequest, completion: ModuleCompletion?) {
        switch request {
        case let request as TealiumTrackRequest:
            print("Track received: \(request.event ?? "no event name")")
            // perform track action, e.g. send to custom endpoint
        case _ as TealiumBatchTrackRequest:
            print("Batch track received")
            // perform batch track action, e.g. send to custom endpoint
        default:
            return
        }
    }
}

// Add dispatcher to your config instance prior to Tealium initialization
class TealiumHelper {
	// ...
	func startTracking() {
		let config = TealiumConfig(account: "ACCOUNT",
                               profile: "PROFILE",
                               environment: "ENVIRONMENT",
                               datasource: "DATASOURCE")

   // add desired Dispatchers
   config.dispatchers = [Dispatchers.Collect, MyCustomDispatcher.self]      
					  self.tealium = Tealium(config: config) { _ in }
}

Recommended Modules

Base Implementation

For a base implementation, the following list of modules are recommended. At least one Dispatcher needs to be enabled, depending on which Tealium products you plan to use.

• AppData Collector
• Device Collector
• Lifecycle Collector

Client-side

In addition to the base modules, these modules enable the Tealium library to process data client-side using Tealium iQ.

• TagManagement Dispatcher - Required to use Tealium iQ
• RemoteCommands Dispatcher - Only required if you need Remote Commands functionality

Server-side

In addition to the base modules, these modules enable the library to send data to Tealium’s server-side products (EventStream, AudienceStream, Event Data Framework).

• Collect Dispatcher - Required to use any server-side products
• Visitor Service Collector - Only required to retrieve Visitor Profiles from Tealium AudienceStream.

Install Modules

Install the modules with CocoaPods or Carthage.

CocoaPods

See Install with CocoaPods for instructions on including and excluding specific modules.

Carthage

When you install with Carthage, you must explicitly import the modules you require. You may import all modules if you prefer, and use the module list, as described earlier, but your app is lighter if you only import the modules you need. See Install with Carthage for instructions on including/excluding specific modules.

Swift Package Manager

See Install with Swift Package Manager for instructions on including and excluding specific modules.