quintonpryce

public func track(event: AnalyticsEvent) {
    trackAnalytic(event: event, parameters: EmptyParameter())
}

public func track<T>(event: AnalyticsEvent, with parameters: T) where T : AnalyticsParameter {
    trackAnalytic(event: event, parameters: parameters)
}

private func trackAnalytic<T: AnalyticsParameter>(event: AnalyticsEvent, parameters: T?) {
    for trackerKey in event.supportedTrackers {

quintonpryce

private var eventTrackers: [EventTrackerKey: EventTracker] = [:]

public func addEventTracker(key: EventTrackerKey, tracker: EventTracker) {
    DispatchQueue(label: "com.test.mySerialQueue").sync {
        eventTrackers[key] = tracker
    }
}

quintonpryce

public class EventTrackerKey: Hashable {
    public func hash(into hasher: inout Hasher) {
        hasher.combine(self.name.hashValue)
    }
    
    public static func == (lhs: EventTrackerKey, rhs: EventTrackerKey) -> Bool {
        return (lhs.name == rhs.name)
    }
    
    public let name: String

quintonpryce

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

quintonpryce

public protocol AnalyticsParameter {
    var parameter: ParameterType { get }
    
    associatedtype ParameterType
}

quintonpryce

public protocol AnalyticsEvent {
    var name: String {get}
    
    var supportedTrackers: [EventTrackerKey] {get}
}

quintonpryce

func checkEventToken(eventToken: String) {
    guard !ADJUtil.isNull(eventToken) else {
        logger.error("Missing Event Token")
        return false
    }
    guard eventToken.count == 6 else {
        logger.error("Malformed Event Token \(eventToken)")
        return false
    }
    return true

quintonpryce

public protocol EventTracker {
    func track(event: String)
    
    func track<T: AnalyticsParameter>(event: String, with parameters: T)

    func isEventNameSupported(event: String) -> Bool
}