iOS SDK

import kameleoonClient

let visitorCode = "visitorCode"
let siteCode = "a8st4f59bj"
do {
    // pass client configuration as an argument
    let config = try KameleoonClientConfig(
        clientId: "clientId", // optional
        clientSecret: "clientSecret", // optional
        refreshIntervalMinute: 15, // optional, 60 minutes by default
        dataExpirationIntervalMinute: 60*24*365, // optional, `Date.distantFuture` by default
        defaultTimeoutMillisecond: 10_000, // optional, 10_000 milliseconds by default
        trackingIntervalMillisecond: 500, // optional, 1000 milliseconds by default
        environment: "production", // optional
        isUniqueIdentifier: false, // optional, false by default. Set to true if the visitorCode corresponds to your customer's unique userId.
        networkDomain: "example.com", // optional, nil by default
        defaultDataFile: "{...}", // optional, nil by default
        activityTrackingIntervalMillisecond: 20_000 // optional, 15_000 milliseconds by default
    )
    let kameleoonClient = try KameleoonClientFactory.create(
        siteCode: siteCode,
        visitorCode: visitorCode, // optional
        config: config // optional
    )
} catch KameleoonError.visitorCodeInvalid {
  // Provided visitor code is invalid
} catch KameleoonError.siteCodeIsEmpty {
  // Indicates that provided site code is empty
} catch {
    // Unexpected error occurred
}

do {
    // read client configuration from a file 'kameleoon-client-swift.plist'
    // visitor code isn't provided, so SDK generates a random visitor code which it will use in the future
    let kameleoonClient = try KameleoonClientFactory.create(siteCode: siteCode)
} catch KameleoonError.visitorCodeInvalid {
    // Provided visitor code is invalid
} catch {
    // Unexpected error occurred
}

try? kameleoonClient.addData(CustomData(id: index, values: "newVisitorCode"))

do {
    let variation = try kameleoonClient.getVariation(featureKey: "new_checkout")
} catch KameleoonError.Feature.notFound {
    // The feature flag isn't in the SDK configuration: fall back to your default behavior.
} catch let error as KameleoonError.Feature {
    // Any other feature-related error, for example .environmentDisabled.
} catch let error as KameleoonError {
    // Any general SDK error, for example .sdkNotReady.
    print("Kameleoon error: \(error.localizedDescription)")
} catch {
    // Any other error.
}

// The `none` log level does not allow logging.
KameleoonLogger.logLevel = .none

// The `ERROR` log level only allows logging issues that may affect the SDK's main behaviour.
KameleoonLogger.logLevel = .error

// The `WARNING` log level allows logging issues which may require additional attention.
// It extends the `ERROR` log level.
// The `WARNING` log level is a default log level.
KameleoonLogger.logLevel = .warning

// The `INFO` log level allows logging general information on the SDK's internal processes.
// It extends the `WARNING` log level.
KameleoonLogger.logLevel = .info

// The `DEBUG` level logs additional details about the SDK’s internal processes and extends the `INFO` level
// with more granular diagnostic output.
// This information is not intended for end-user interpretation but can be sent to support
// to assist with internal troubleshooting.
KameleoonLogger.logLevel = .debug

public struct CustomLogger: Logging {
    let customLogger = Logger(subsystem: "com.yourcompany.app", category: "app")

    public func log(level: LogLevel, message: String) {
        switch level {
            case .error:
                customLogger.error("\(message)")
            case .warning:
                customLogger.warning("\(message)")
            case .info:
                customLogger.info("\(message)")
            case .debug:
                customLogger.debug("\(message)")
            default:
                break
        }
    }
}


// Log level filtering is applied separately from log handling logic.
// The custom logger will only accept logs that meet or exceed the specified log level.
// Ensure the log level is set correctly.
KameleoonLogger.logLevel = .debug // Optional, defaults to `LogLevel.WARNING`.
KameleoonLogger.logger = CustomLogger()

let visitorCode = "visitorCode"
let siteCode = "a8st4f59bj"
do {
    // pass client configuration as an argument
    let config = try KameleoonClientConfig(
        clientId: "clientId", // optional
        clientSecret: "clientSecret", // optional
        refreshIntervalMinute: 15, // optional, 60 minutes by default
        dataExpirationIntervalMinute: 60*24*365, // optional, `Date.distantFuture` by default
        defaultTimeoutMillisecond: 10_000, // optional, 10_000 milliseconds by default
        trackingIntervalMillisecond: 500, // optional, 1000 milliseconds by default
        environment: "production", // optional
        isUniqueIdentifier: false, // optional, false by default. Set to true if the visitorCode corresponds to your customer's unique userId.
        networkDomain: "example.com", // optional, nil by default
        defaultDataFile: "{...}", // optional, nil by default
        activityTrackingIntervalMillisecond: 20_000 // optional, 15_000 milliseconds by default
    )
    let kameleoonClient = try KameleoonClientFactory.create(
        siteCode: siteCode,
        visitorCode: visitorCode, // optional
        config: config // optional
    )
} catch KameleoonError.visitorCodeInvalid {
  // Provided visitor code is invalid
} catch KameleoonError.siteCodeIsEmpty {
  // Indicates that provided site code is empty
} catch {
    // Unexpected error occurred
}

do {
    // read client configuration from a file 'kameleoon-client-swift.plist'
    // visitor code isn't provided, so SDK generates a random visitor code which will be used in the future
    let kameleoonClient = KameleoonClientFactory.create(siteCode: siteCode)
} catch KameleoonError.visitorCodeInvalid {
  // Provided visitor code is invalid
} catch KameleoonError.siteCodeIsEmpty {
  // Indicates that provided site code is empty
} catch {
    // Unexpected error occurred
}

let ready = kameleoonClient.ready

let featureKey = "new_checkout"
var hasNewCheckout = false

do {
    hasNewCheckout = try kameleoonClient.isFeatureActive(featureKey: featureKey)
    // disabling tracking
    hasNewCheckout = kameleoonClient.isFeatureActive(featureKey: featureKey, track: false);
} catch {
    switch error {
        case KameleoonError.sdkNotReady:
            // Exception indicating that the SDK has not completed its initialization yet.
            hasNewCheckout = false
        case KameleoonError.Feature.notFound:
		    // The feature key is not in the configuration file that has been fetched by the SDK.
            hasNewCheckout = false
        default:
            // Any other error.
            hasNewCheckout = false
    }
}

if hasNewCheckout
{
  // Implement new checkout code here
}

let featureKey = "featureKey"
var variation: Types.Variation?
do {
    variation = try kameleoonClient.getVariation(featureKey: featureKey)
    // disabling tracking
    variation = kameleoonClient.getVariation(featureKey: featureKey, track: false);
} catch {
    switch error {
        case KameleoonError.sdkNotReady:
            // Exception indicating that the SDK has not completed its initialization yet.
        case KameleoonError.Feature.notFound:
		    // The feature key is not in the configuration file that has been fetched by the SDK.
        case KameleoonError.Feature.environmentDisabled:
		    // The feature flag is disabled for the environment.
        default:
            // Any other error.
    }
}

let title = variation?.variables["title"].value

switch variation?.key {
    case "on":
        // Main variation key is selected for visitorCode
    case "alternative_variation":
        // Alternative variation key
    default:
        // Default variation key
}

do {
    let variations = kameleoonClient.getVariations();
    // only active variations
    let variations = kameleoonClient.getVariations(onlyActive: true);
    // disable tracking
    let variations = kameleoonClient.getVariations(track: false);
} catch KameleoonError.sdkNotReady {
    // Exception indicating that the SDK has not completed its initialization yet.
}

let experimentId = 9516
do {
    // Forcing the variation "on" for the experiment 9516 for the visitor
    try kameleoonClient.setForcedVariation(experimentId: experimentId, variationKey: "on")

    // Forcing the variation "on" while preserving segmentation and targeting conditions during the experiment
    try kameleoonClient.setForcedVariation(experimentId: experimentId, variationKey: "on", forceTargeting: false)

    // Resetting the forced variation for the experiment 9516 for the visitor
    try kameleoonClient.setForcedVariation(experimentId: experimentId, variationKey: nil);
} catch {
    // Handling the KameleoonError, KameleoonError.Feature and common Error
}

do {
    try kameleoonClient.evaluateAudiences();
} catch {
    // Handling the errors
}

let allFeatureList = kameleoonClient.getFeatureList()

do {
    let dataFile = try kameleoonClient.getDataFile()
} catch KameleoonError.sdkNotReady {
    // Exception indicates that the SDK has not completed its initialization yet.
} catch {
    // Handling the KameleoonError, KameleoonError.Feature and common Error
}

let goalId = 83023
kameleoonClient.trackConversion(goalId: goalId, revenue: 10.0)

kameleoonClient.trackConversion(goalId: goalId, revenue: 10.0, metadata: CustomData(id: 1, values: "metadata"))

let visitorCode = kameleoonClient.visitorCode

// Add a single data item (tracked by default)
kameleoonClient.addData(CustomData(index: 1, values: "value"))

// Add multiple data items (tracked by default)
kameleoonClient.addData(
    CustomData(index: 20, values: "value"),
    Geolocation(country: "France")
)

// Add multiple data items stored locally for targeting only (not sent to the Kameleoon Data API)
kameleoonClient.addData(
    track: false,
    CustomData(index: 20, values: "value"),
    Geolocation(country: "France")
)

kameleoonClient.addData(CustomData(id: 20, values: "true", "20"))
kameleoonClient.addData(Conversion(goalId: 32, revenue: 10.0, negative: false))

kameleoonClient.flush() // Interval tracking (most performant way for tracking)
kameleoonClient.flush(instant: true) // Instant tracking

kameleoonClient.setLegalConsent(true)

kameleoonClient.addData(Conversion(goalId: 32, revenue: 10.0, negative: false))

kameleoonClient.addData(Conversion(goalId: 32, metadata: CustomData(id: 1, values: "metadata")))

kameleoonClient.addData(CustomData(index: 1, values: "value"))

// With several values
kameleoonClient.addData(CustomData(index: 1, values: "value 1", "value 2"))

// To set the 'overwrite' flag to false
kameleoonClient.addData(CustomData(index: 1, overwrite: false, values: ["first value", "second value"]))

// To use a name instead of the index
kameleoonClient.addData(CustomData(name: "my-custom-data", values: "value"))

try? kameleoonClient.addData(Device.desktop);

kameleoonClient.addData(Geolocation(country: "France", region: "Île-de-France", city: "Paris"));

// Retrieves the dictionary of feature flags from the DataFile.
// The dictionary is keyed by feature flag identifiers, with each value being a FeatureFlag object.
let featureFlags = dataFile.featureFlags

// Retrieves the last modification timestamp of the DataFile.
// The value is an Int representing milliseconds since the Unix epoch.
let dateModified = dataFile.dateModified

// Check whether the feature flag is enabled in the current environment
let isEnvironmentEnabled = featureFlag.environmentEnabled

// Retrieve the key of the default variation
let defaultVariationKey = featureFlag.defaultVariationKey

// Retrieve the default variation object
let defaultVariation = featureFlag.defaultVariation

// Retrieve all variations of the feature flag as a map (key = variation key, value = Variation object)
let variations = featureFlag.variations

// Retrieve all targeting rules associated with the feature flag
let rules = featureFlag.rules

// Retrieve all variations of the rule as a map (key = variation key, value = Variation object)
let variations = rule.variations

// Retrieving the variation name
let variationName = variation.name

// Retrieving the variation key
let variationKey = variation.key

// Retrieving the variation id
let variationId = variation.id

// Retrieving the experiment id
let experimentId = variation.experimentId

// Retrieving the variables map
let variables = variation.variables

// Retrieving the variables map
let variables = variation.variables

// Variable type can be retrieved for further processing
let type = variables["isDiscount"]?.type ?? ""

// Get the bool value of "isDiscount" (default to false if missing or not a Bool)
let isDiscount = variables["isDiscount"]?.value as? Bool ?? false

// Get the numeric value of "number" as an Int (default to 0 if missing or not numeric)
let number = (variables["number"]?.value as? NSNumber)?.intValue ?? 0

// Get the String value of "title" (default to an empty string if missing or not a String)
let title = variables["title"]?.value as? String ?? ""

let featureKey = "new_checkout"
var variationKey = ""

do {
	variationKey = try kameleoonClient.getFeatureVariationKey(featureKey: featureKey)
    switch variationKey {
        case "variation 1":
            // The visitor has been bucketed with variation 1 key
        case "variation 2":
            // The visitor has been bucketed with variation 2 key
        default:
            //The visitor has been bucketed with the default variation or is part of the unallocated traffic sample
    }
} catch {
    switch error {
        case KameleoonError.sdkNotReady:
            // Exception indicating that the SDK has not completed its initialization yet.
        case KameleoonError.Feature.notFound:
		    // The feature key is not in the configuration file that has been fetched by the SDK. Trigger the old checkout for this visitor.
        case KameleoonError.Feature.environmentDisabled:
		    // The feature flag is disabled for the environment.
        default:
            // Any other error.
    }
}

let activeFeatureFlags = kameleoonClient.getActiveFeatureList()

let activeFeatures = kameleoonClient.getActiveFeatures()

String featureKey = "myFeature"
String variableKey = "myVariable"

try {
	let variable = kameleoonClient.getFeatureVariable(featureKey: featureKey, variableKey: variableKey)
    // your custom code, depending on variableValue
} catch {
    switch error {
        case KameleoonError.sdkNotReady:
            // Exception indicating that the SDK has not completed its initialization.
        case KameleoonError.Feature.notFound:
		    // The Feature Key is not in the configuration file that has been fetched by the SDK. Trigger the old checkout for this visitor.
        case KameleoonError.Feature.environmentDisabled:
		    // The feature flag is disabled for the environment.
        case KameleoonError.Feature.variableNotFound:
            // Exception indicating that the requested variable has not been found. Check that the variable's key matches the one in your code.

        default:
            // Any other error.
    }
}