iOS Swift SDK

github "amplitude/Amplitude-Swift" ~> 1.0

let amplitude = Amplitude(configuration: Configuration(
    apiKey: AMPLITUDE_API_KEY,
    autocapture: .all
))

AMPConfiguration *configuration = [AMPConfiguration initWithApiKey:AMPLITUDE_API_KEY];
configuration.autocapture = AMPAutocaptureOptions.all;
Amplitude *amplitude = [Amplitude initWithConfiguration:configuration];

let event = BaseEvent(
    eventType: "Button Clicked",
    eventProperties: ["my event prop key": "my event prop value"]
)
amplitude.track(event: event)

AMPBaseEvent *event = [AMPBaseEvent initWithEventType:@"Button Clicked"
    eventProperties:@{@"my event prop key": @"my event prop value"}];
 
[amplitude track:event];

amplitude.track(
    eventType: "Button Clicked",
    eventProperties: ["my event prop key": "my event prop value"]
)

[amplitude track:@"Button Clicked" eventProperties:@{
    @"my event prop key": @"my event prop value"
}];

let identify = Identify()
identify.set(property: "color", value: "green")
amplitude.identify(identify: identify)

AMPIdentify *identify = [AMPIdentify new];
[identify set:@"color" value:@"green"];
[amplitude identify:identify];

let amplitude = Amplitude(configuration: Configuration(
    apiKey: "API_KEY",
    autocapture: [.sessions, .appLifecycles, .screenViews, .networkTracking]
))

let amplitude = Amplitude(configuration: Configuration(
    apiKey: "API_KEY",
    autocapture: .appLifecycles     // or use `[]` to disable Autocapture.
))

AMPConfiguration *configuration = [AMPConfiguration initWithApiKey:@"API_KEY"];
configuration.autocapture = [[AMPAutocaptureOptions alloc] initWithOptionsToUnion:@[
    AMPAutocaptureOptions.sessions,
    AMPAutocaptureOptions.appLifecycles,
    AMPAutocaptureOptions.screenViews,
    AMPAutocaptureOptions.networkTracking
]];
Amplitude *amplitude = [Amplitude initWithConfiguration:configuration];

AMPConfiguration *configuration = [AMPConfiguration initWithApiKey:@"API_KEY"];
configuration.autocapture = [[AMPAutocaptureOptions alloc] initWithOptionsToUnion:@[AMPAutocaptureOptions.appLifecycles]];   // or use an empty array to disable Autocapture.
Amplitude *amplitude = [Amplitude initWithConfiguration:configuration];

let amplitude = Amplitude(configuration: Configuration(
    apiKey: "API_KEY",
    autocapture: [.sessions, .appLifecycles, .screenViews],
    enableAutoCaptureRemoteConfig: false
))

AMPConfiguration *configuration = [AMPConfiguration initWithApiKey:@"API_KEY"];
configuration.autocapture = [[AMPAutocaptureOptions alloc] initWithOptionsToUnion:@[
    AMPAutocaptureOptions.sessions,
    AMPAutocaptureOptions.appLifecycles,
    AMPAutocaptureOptions.screenViews
]];
configuration.enableAutoCaptureRemoteConfig = NO;
Amplitude *amplitude = [Amplitude initWithConfiguration:configuration];

let amplitude = Amplitude(configuration: Configuration(
    apiKey: "API_KEY",
    autocapture: .sessions
))

AMPConfiguration *configuration = [AMPConfiguration initWithApiKey:@"API_KEY"];
configuration.autocapture = [[AMPAutocaptureOptions alloc] initWithOptionsToUnion:@[AMPAutocaptureOptions.sessions]];
Amplitude *amplitude = [Amplitude initWithConfiguration:configuration];

let amplitude = Amplitude(configuration: Configuration(
    apiKey: "API_KEY",
    autocapture: .appLifecycles
))

AMPConfiguration *configuration = [AMPConfiguration initWithApiKey:@"API_KEY"];
configuration.autocapture = [[AMPAutocaptureOptions alloc] initWithOptionsToUnion:@[AMPAutocaptureOptions.appLifecycles]];
Amplitude *amplitude = [Amplitude initWithConfiguration:configuration];

// UIKit
let amplitude = Amplitude(configuration: Configuration(
    apiKey: "API_KEY",
    autocapture: .screenViews
))
 
// Swift UI
let amplitude = Amplitude(configuration: Configuration(
    apiKey: "API_KEY",
    autocapture: []
))
amplitude.track(ScreenViewedEvent(screenName: "Screen Name"))

// UIKit
AMPConfiguration *configuration = [AMPConfiguration initWithApiKey:@"API_KEY"];
configuration.autocapture = [[AMPAutocaptureOptions alloc] initWithOptionsToUnion:@[AMPAutocaptureOptions.screenViews]];
Amplitude *amplitude = [Amplitude initWithConfiguration:screenViews];
 
// Swift UI
configuration.autocapture = [[AMPAutocaptureOptions alloc] initWithOptionsToUnion:@[]];
[amplitude track:[AMPScreenViewedEvent initWithScreenName:@"Screen Name"]];

let amplitude = Amplitude(configuration: Configuration(
    apiKey: "API_KEY",
    autocapture: .networkTracking
))

AMPConfiguration *configuration = [AMPConfiguration initWithApiKey:@"API_KEY"];
configuration.autocapture = [[AMPAutocaptureOptions alloc] initWithOptionsToUnion:@[AMPAutocaptureOptions.networkTracking]];
Amplitude *amplitude = [Amplitude initWithConfiguration:configuration];

// Style 1: Use the default configuration and append a new rule
let networkTrackingOptions = NetworkTrackingOptions.default // contain a rule for all hosts, statusCodeRange: "500-599"
networkTrackingOptions.captureRules.append(
    .init(hosts: ["*.example.com", "example.com"], statusCodeRange: "0,500-599")
)
networkTrackingOptions.ignoreHosts.append("notmyapi.com")
 
let amplitude = Amplitude(configuration: Configuration(
    apiKey: "API_KEY",
    autocapture: .networkTracking,
    networkTrackingOptions: networkTrackingOptions,
))
 
// Style 2: Create a new configuration with a custom rule
let amplitude = Amplitude(configuration: Configuration(
    apiKey: "API_KEY",
    autocapture: .networkTracking,
    networkTrackingOptions: .init(
        captureRules: [
            .init(hosts: ["*"]), // all hosts, statusCodeRange: "500-599"
            .init(hosts: ["*.example.com", "example.com"], statusCodeRange: "0,400-599"),
        ],
        ignoreHosts: ["notmyapi.com"]
    ),
))

// Style 1: Use the default configuration and append a new rule
AMPNetworkTrackingOptions *networkTrackingOptions = AMPNetworkTrackingOptions.defaultOptions;  // contain a rule for all hosts, statusCodeRange: "500-599"
NSMutableArray<AMPNetworkTrackingCaptureRule *> *rules = [networkTrackingOptions.captureRules mutableCopy];
[rules addObject:[[AMPNetworkTrackingCaptureRule alloc] initWithHosts:@[@"*.example.com", @"example.com"] statusCodeRange:@"0,400-599"]];
networkTrackingOptions.captureRules = rules;
 
// Style 2: Create a new configuration with a custom rule
NSArray<AMPNetworkTrackingCaptureRule *> *rules = @[
    [[AMPNetworkTrackingCaptureRule alloc] initWithHosts: @[@"*"] statusCodeRange:@"500-599"],
    [[AMPNetworkTrackingCaptureRule alloc] initWithHosts: @[@"*.example.com", @"example.com"] statusCodeRange:@"0,400-599"]
];
AMPNetworkTrackingOptions *networkTrackingOptions = [[AMPNetworkTrackingOptions alloc] initWithCaptureRules:rules
                                                                                                ignoreHosts:@[@"notmyapi.com"]
                                                                                    ignoreAmplitudeRequests:true];
 
// Then use the configuration to initialize the Amplitude instance
AMPConfiguration *configuration = [AMPConfiguration initWithApiKey:@"API_KEY"];
configuration.autocapture = [[AMPAutocaptureOptions alloc] initWithOptionsToUnion:@[AMPAutocaptureOptions.networkTracking]];
configuration.networkTrackingOptions = networkTrackingOptions;
Amplitude *amplitude = [Amplitude initWithConfiguration:configuration];

let amplitude = Amplitude(configuration: Configuration(
    apiKey: "API_KEY"
))
 
amplitude.track(DeepLinkOpenedEvent(url: URL()))
amplitude.track(DeepLinkOpenedEvent(url: "url", referrer:"referrer"))
amplitude.track(DeepLinkOpenedEvent(activity: activity))

AMPConfiguration *configuration = [AMPConfiguration initWithApiKey:@"API_KEY"];
Amplitude *amplitude = [Amplitude initWithConfiguration:configuration];
 
[amplitude track:[AMPDeepLinkOpenedEvent initWithUrl:@"url"]];
[amplitude track:[AMPDeepLinkOpenedEvent initWithUrl:@"url" referrer:@"referrer"]];
[amplitude track:[AMPDeepLinkOpenedEvent initWithActivity:activity]];

let amplitude = Amplitude(configuration: Configuration(
    apiKey: "API_KEY",
    autocapture: .elementInteractions
))

AMPConfiguration *configuration = [AMPConfiguration initWithApiKey:@"API_KEY"];
configuration.autocapture = [[AMPAutocaptureOptions alloc] initWithOptionsToUnion:@[AMPAutocaptureOptions.elementInteractions]];
Amplitude *amplitude = [Amplitude initWithConfiguration:configuration];

amplitude.track(
    event: BaseEvent(
        eventType: "event type",
        eventProperties: [
            "eventPropertyKey": "eventPropertyValue"
        ],
        groups: ["orgId": "15"]
    )
)

AMPBaseEvent *event = [AMPBaseEvent initWithEventType:@"event type"
    eventProperties:@{@"eventPropertyKey": @"eventPropertyValue"}];
[event.groups set:@"orgId" value:@"15"];
[amplitude track:event];

let groupType = "plan"
let groupName = "enterprise"
let identify = Identify().set(property: "key", value: "value")
amplitude.groupIdentify(groupType: groupType, groupName: groupProperty, identify: identify)

NSString *groupType = @"plan";
NSString *groupName = @"enterprise";
AMPIdentify *identify = [AMPIdentify new];
[identify set:@"key" value:@"value"];
[amplitude groupIdentify:groupType groupName:groupName identify:identify];

let revenue = Revenue()
revenue.price = 3.99
revenue.quantity = 3
revenue.productId = "com.company.productId"
amplitude.revenue(revenue: revenue)

AMPRevenue *revenue = [AMPRevenue new];
revenue.price = 3.99;
revenue.quantity = 3;
revenue.productId = @"com.company.productId";
[amplitude revenue:revenue];

amplitude.setUserId(userId: "user@amplitude.com")

[amplitude setUserId:@"user@amplitude.com"];

amplitude.setDeviceId(NSUUID().uuidString)

[amplitude setDeviceId:[[NSUUID UUID] UUIDString]];

amplitude.reset()

[amplitude reset];

class EnrichmentPlugin: Plugin {
    let type: PluginType
    var amplitude: Amplitude?
 
    init() {
        self.type = PluginType.enrichment
    }
 
    func setup(amplitude: Amplitude) {
        self.amplitude = amplitude
    }
 
    func execute(event: BaseEvent?) -> BaseEvent? {
        event?.sessionId = -1
        if event?.eventProperties == nil {
            event?.eventProperties = [:]
        }
        event?.eventProperties?["event prop key"] = "event prop value"
        return event
    }
}
 
amplitude.add(plugin: EnrichmentPlugin())

[amplitude add:[AMPPlugin initWithType:AMPPluginTypeEnrichment
    execute:^AMPBaseEvent *_Nullable(AMPBaseEvent * _Nonnull event) {
    event.sessionId = -1;
    [event.eventProperties set:@"event prop key" value:@"event prop value"];
    return event;
}]];

class TestDestinationPlugin: DestinationPlugin {
    override func track(event: BaseEvent) -> BaseEvent? {
        return event
    }
 
    override func identify(event: IdentifyEvent) -> IdentifyEvent? {
        return event
    }
 
    override func groupIdentify(event: GroupIdentifyEvent) -> GroupIdentifyEvent? {
        return event
    }
 
    override func revenue(event: RevenueEvent) -> RevenueEvent? {
        return event
    }
 
    override func flush() {
    }
 
    override func setup(amplitude: Amplitude) {
        self.amplitude = amplitude
    }
 
    override func execute(event: BaseEvent?) -> BaseEvent? {
        return event
    }
}

[amplitude add:[AMPPlugin initWithType:AMPPluginTypeDestination
    execute:^AMPBaseEvent * _Nullable(AMPBaseEvent * _Nonnull event) {
    if ([event.eventType isEqualToString:@"$identify"]) {
        // ...
    } else if ([event.eventType isEqualToString:@"$groupidentify"]) {
        // ...
    } else if ([event.eventType isEqualToString:@"revenue_amount"]) {
        // ...
    } else {
        // ...
    }
    return nil;
} flush:^() {
    // ...
}]];

let amplitude = Amplitude(
    configuration: Configuration(
        apiKey: AMPLITUDE_API_KEY,
        minTimeBetweenSessionsMillis: 1000
    )
)

AMPConfiguration *configuration = [AMPConfiguration initWithApiKey:AMPLITUDE_API_KEY];
configuration.minTimeBetweenSessionsMillis = 1000;
Amplitude *amplitude = [Amplitude initWithConfiguration:configuration];

let outOfSessionOptions = EventOptions(sessionId: -1)
 
amplitude.identify(
    event: Identify().set(property: "user-prop", value: true),
    options: outOfSessionOptions
)
 
amplitude.track(
    event: BaseEvent(eventType: "Button Clicked"),
    options: outOfSessionOptions
)

AMPEventOptions *outOfSessionOptions = [AMPEventOptions new];
outOfSessionOptions.sessionId = -1;
 
AMPIdentify *identify = [AMPIdentify new];
[identify set:@"user-prop" value:YES];
[amplitude identify:identify options:outOfSessionOptions];
 
AMPBaseEvent *event = [AMPBaseEvent initWithEventType:@"Button Clicked"];
[amplitude track:event options:outOfSessionOptions];

let amplitude = Amplitude(
    configuration: Configuration(
        apiKey: AMPLITUDE_API_KEY,
        logLevel: LogLevelEnum.LOG
    )
)

AMPConfiguration *configuration = [AMPConfiguration initWithApiKey:AMPLITUDE_API_KEY];
configuration.logLevel = AMPLogLevelLOG;
Amplitude *amplitude = [Amplitude initWithConfiguration:configuration];

amplitude.reset()

[amplitude reset];

let trackingOptions = TrackingOptions()
trackingOptions.disableTrackCity().disableTrackIpAddress()
let amplitude = Amplitude(
    configuration: Configuration(
        apiKey: AMPLITUDE_API_KEY,
        trackingOptions: trackingOptions
    )
)

AMPConfiguration *configuration = [AMPConfiguration initWithApiKey:AMPLITUDE_API_KEY];
[configuration.trackingOptions disableTrackCity];
[configuration.trackingOptions disableTrackIpAddress];
Amplitude *amplitude = [Amplitude initWithConfiguration:configuration];

let amplitude = Amplitude(
    configuration: Configuration(
        apiKey: AMPLITUDE_API_KEY,
        enableCoppaControl: true
    )
)

AMPConfiguration *configuration = [AMPConfiguration initWithApiKey:AMPLITUDE_API_KEY];
configuration.enableCoppaControl = true;
Amplitude *amplitude = [Amplitude initWithConfiguration:configuration];

let deviceId = amplitude.getDeviceId()

NSString *deviceId = [amplitude getDeviceId];

let amplitude = Amplitude(
    configuration: Configuration(
        apiKey: AMPLITUDE_API_KEY,
        optOut: true
    )
)

AMPConfiguration *configuration = [AMPConfiguration initWithApiKey:AMPLITUDE_API_KEY];
configuration.optOut = true;
Amplitude *amplitude = [Amplitude initWithConfiguration:configuration];

class SampleLogger: Logger {
    typealias LogLevel = LogLevelEnum
 
    var logLevel: Int
 
    init(logLevel: Int = LogLevelEnum.OFF.rawValue) {
        self.logLevel = logLevel
    }
 
    func error(message: String) {
        // TODO: handle error message
    }
 
    func warn(message: String) {
        // TODO: handle warn message
    }
 
    func log(message: String) {
        // TODO: handle log message
    }
 
    func debug(message: String) {
        // TODO: handle debug message
    }
}
 
let amplitude = Amplitude(
    configuration: Configuration(
        apiKey: AMPLITUDE_API_KEY,
        loggerProvider: SampleLogger()
    )
)

AMPConfiguration *configuration = [AMPConfiguration initWithApiKey:AMPLITUDE_API_KEY];
configuration.loggerProvider = ^(NSInteger logLevel, NSString * _Nonnull message) {
    switch(logLevel) {
    case AMPLogLevelERROR:
        // TODO: handle error message
        break;
    case AMPLogLevelWARN:
        // TODO: handle warn message
        break;
    case AMPLogLevelLOG:
        // TODO: handle log message
        break;
    case AMPLogLevelDEBUG:
        // TODO: handle debug message
        break;
    }
};
Amplitude *amplitude = [Amplitude initWithConfiguration:configuration];

let amplitude = Amplitude(
    configuration: Configuration(
        apiKey: "API-KEY",
        instanceName: "my-unqiue-instance-name"
    )
)

AMPConfiguration *configuration = [AMPConfiguration initWithApiKey:@"API-KEY"
                                                    instanceName:@"my-unqiue-instance-name"];
Amplitude *amplitude = [Amplitude instanceWithConfiguration:configuration];

let amplitude = Amplitude(
    configuration: Configuration(
        apiKey: "API-KEY",
        offline: NetworkConnectivityCheckerPlugin.Disabled
    )
)

AMPConfiguration *configuration = [AMPConfiguration initWithApiKey:AMPLITUDE_API_KEY];
configuration.offline = AMPNetworkConnectivityCheckerPlugin.Disabled;
Amplitude *amplitude = [Amplitude initWithConfiguration:configuration];