Usage and Implementation

Implementation

The AnalyticLayer is a generic framework that empowers the client to implement it in many different ways. The following usage example is only a recommendation and is not the only way to implement this framework.

The working example project is in the repository and can be run and modified to get a sense of how this framework operates which is recommended for any first time users.

1) Create your AnalyticsParameter type

Some tools make use of parameters which allow events to carry more information with them.

class ExampleParameter: AnalyticsParameter {
    var parameter: ParameterType
    
    typealias ParameterType = [AnyHashable: Any]
    
    init(parameters: [AnyHashable: Any]) {
        self.parameter = parameters
    }
}

2) Wrap your analytic tools in EventTrackers

There a three parts to event trackers:

1. Tracking events with no additional information.
2. Tracking events with parameters, for this method you should be unwrapping the AnalyticsParameter that we previously created.
3. Setting some event validity. This will verify at runtime that your event string will track properly (many tools have strict naming conventions for events and will fail silently).

import AnalyticTool

class AnalyticToolEventTracker: EventTracker {
	func track(event: String) {
		AnalyticTool.track(event)
	}

	func track<T>(event: String, with parameters: T) where T : AnalyticsParameter {
		if let unwrappedParameters = parameters as? [AnyHashable: Any] {
			AnalyticTool.track(event, with: unwrappedParameters)
		}
	}

	func isEventNameSupported(event: String) -> Bool {
		return AnalyticTool.isEventValid(event)
	}
}

3) Create the EventTrackerKeys

EventTrackerKeys allows us to hand off the responsibility of dispatching events from your classes to the events that you create.

enum EventTrackerKeys: CaseIterable {
    case exampleTracker
    case launchOnlyTracker
    
    var key: EventTrackerKey {
        switch self {
        case .exampleTracker:
            return EventTrackerKey("exampleTrackerKey")
        case .launchOnlyTracker:
            return EventTrackerKey("launchOnlyTrackerKey")
        }
    }
}

4) Create AnalyticsEvents

Events are what drive analytics. The following is a way to create many events in a readable and maintainable method. Events have a name and an array of EventTrackerKeys.

enum ExampleEvents: AnalyticsEvent {
    case launch
    case userInteractedWithApp
    case buttonPressed
    
    var name: String {
        switch self {
        case .launch: return "Launch"
        case .userInteractedWithApp: return "User interacted with the app"
        case .buttonPressed: return "BUTTON_PRESSED"
        }
    }
    
    var supportedTrackers: [EventTrackerKey] {
        switch self {
        case .userInteractedWithApp,
             .buttonPressed:
            return [EventTrackerKeys.exampleTracker.key]
        case .launch:
            return [EventTrackerKeys.launchOnlyTracker.key]
        }
    }
}

And that is it! 🎊🎉🎊🎉🎊🎉

Usage

The usage is by far the easiest part of using the AnalyticLayer. Whether you decide to use the build in singleton or implement your own the usage is extremely simple.

@IBAction func buttonPressed() {
    analytics.track(event: ExampleEvents.buttonPressed)
}

OR

@IBAction func buttonPressed() {
    Analytics.shared.track(event: ExampleEvents.buttonPressed)
}