AnalyticsManager

AnalyticsManager.swift

import UIKit

public protocol AnalyticsServiceType {
    var trackedEvents: [AnalyticsSectionEvent] { get }
    func initialize(application: UIApplication, launchOptions: [UIApplication.LaunchOptionsKey: Any]?)
    func track(event: AnalyticsEvent)
}

extension AnalyticsServiceType {
    func shouldTrack(event: AnalyticsSectionEvent) -> Bool {
        return trackedEvents.contains(event)
    }
}

public enum AnalyticsEvent {
    case imageViewed(identifier: String, category: String)
    case imageCommented(identifier: String, category: String)
    case imageShared(identifier: String, destination: String)
    case sortSelected(sortType: String)
    case notificationSettingsChanged

    public var name: String {
        switch self {
        case .imageViewed:
            return "Image Viewed"
        case .imageCommented:
            return "Image Commented"
        case .imageShared:
            return "Image Shared"
        case .sortSelected:
            return "Sort Selected"
        case .notificationSettingsChanged:
            return "Notification Settings Changed"

        }
    }

    public var eventProperties: [String: Any] {
        // here each event returns a properties dictionary
        return [:]
    }

    public var analyticsSection: AnalyticsSectionEvent {
        switch self {
        case .imageViewed, .imageCommented, .imageShared:
            return .image
        case .sortSelected:
            return .feed
        case .notificationSettingsChanged:
            return .settings
        }
    }
}

public final class AnalyticsManager: AnalyticsServiceType {
    private let services: [AnalyticsServiceType]
    public init(with serviceTypes: [AnalyticsServiceIntegrationType]) {
        self.services = serviceTypes.compactMap { $0.analyticsService }
    }

    public var trackedEvents: [AnalyticsSectionEvent] {
        return AnalyticsSectionEvent.allCases
    }

    public func initialize(application: UIApplication, launchOptions: [UIApplication.LaunchOptionsKey: Any]?) {
        services.forEach { $0.initialize(application: application, launchOptions: launchOptions) }
    }

    public func track(event: AnalyticsEvent) {
        services.filter { $0.shouldTrack(event: event.analyticsSection) }
            .forEach { $0.track(event: event) }
    }
}

public enum AnalyticsServiceIntegrationType {
    case amplitude
    case mixpanel

    var analyticsService: AnalyticsServiceType {
        switch self {
        case .amplitude:
            return AmplitudeAnalyticsService()
        case .mixpanel:
            return MixpanelAnalyticsService()
        }
    }
}


// Amplitude Example
class AmplitudeAnalyticsService: AnalyticsServiceType {
    private static let Token = "KEY"

    public var trackedEvents: [AnalyticsSectionEvent] {
        return AnalyticsSectionEvent.allCases
    }

    public func initialize(application: UIApplication, launchOptions: [UIApplication.LaunchOptionsKey: Any]?) {
        Amplitude.instance().initializeApiKey(AmplitudeAnalyticsService.Token)
    }

    public func track(event: AnalyticsEvent) {
        Amplitude.instance().logEvent(event.name, withEventProperties: event.eventProperties)
    }
}

// Mixpanel Example
class MixpanelAnalyticsService: AnalyticsServiceType {
    private static let Token = "KEY"

    public var trackedEvents: [AnalyticsSectionEvent] {
        return AnalyticsSectionEvent.allCases
    }

    public func initialize(application: UIApplication, launchOptions: [UIApplication.LaunchOptionsKey: Any]?) {
        Mixpanel.instance().initializeApiKey(AmplitudeAnalyticsService.Token)
    }

    public func track(event: AnalyticsEvent) {
        Mixpanel.instance().logEvent(event.name, withEventProperties: event.eventProperties)
    }
}

// if we use Singleton
AnalyticsManager.sharedInstance.add(service: .amplitud)
AnalyticsManager.sharedInstance.add(service: .mixpanel)
AnalyticsManager.sharedInstance.initialize(application: application, launchOptions: launchOptions)