Initialize the Swift SDK

// You must configure Real-Time Audiences for Feature Experimentation.
public struct OptimizelySdkSettings {

    /// The maximum size of audience segments cache (default: 100. The cache is disabled if this is set to 0.
    let segmentsCacheSize: Int

    /// The timeout in seconds of audience segments cache (default: 600secs). The timeout is disabled if this is set to 0.
    let segmentsCacheTimeoutInSecs: Int

    /// The timeout in seconds of odp segment fetch (default: 10secs). The OS default timeout is used if this is set to 0.
    let timeoutForSegmentFetchInSecs: Int

    /// The timeout in seconds of ODP event dispatch (default: 10secs). The OS default timeout is used if this is set to 0.
    let timeoutForOdpEventInSecs: Int

    /// ODP features are disabled if this is set to true (default: true).
    let disableOdp: Bool
  
    // Enable VUID creation and management (default: false).
    let enableVuid: Bool 
}

// Build and config OptimizelyClient
optimizely = OptimizelyClient(sdkKey: "YOUR_SDK_KEY")
let user = optimizely.createUserContext(userId: userId)
        
// Synchronously initialize the client, then make a decision for a flag rule (such as an A/B test)
do {
	try optimizely.start(datafile: datafileJSON)
  
  let decision = user.decide(key: "flagKey")
  let variationKey = decision.variationKey        
} catch {
  // errors
}  

// Or, instantiate it asynchronously with a callback
optimizely.start { result in
	let decision = user.decide(key: "flagKey")
  let variationKey = decision.variationKey   
}

// Build and config OptimizelyClient
self.optimizely = [[OptimizelyClient alloc] initWithSdkKey:@"<Your_SDK_Key>"];
self.user = [optimizely createUserContextWithUserId:userId attributes:attributes];    
// Synchronously initialize the client, then activate an experiment
BOOL status = [self.optimizely startWithDatafile:datafileJSON error:nil];

OptimizelyDecision *decision = [user decideWithKey:flagKey]; 
NSString *variationKey = decision.variationKey;

// Or, instantiate it asynchronously with a callback
[self.optimizely startWithCompletion:^(NSData *data, NSError *error) {
  OptimizelyDecision *decision = [user decideWithKey:flagKey]; 
  NSString *variationKey = decision.variationKey;
}];

// Datafile update interval can be configured when the SDK is configured
// Background datafile update is disabled if periodicDownloadInterval is zero
optimizely = OptimizelyClient(sdkKey: "YOUR_SDK_KEY",
                              periodicDownloadInterval: 5*60)
// every 5 minutes

// Datafile update interval can be configured when the SDK is configured
// Background datafile update is disabled if periodicDownloadInterval is zero
self.optimizely = [[OptimizelyClient alloc] initWithSdkKey:@"<Your_SDK_Key>"
                    logger:nil
                    eventDispatcher:nil
                    userProfileService:nil
                    periodicDownloadInterval:5*60
                    defaultLogLevel:OptimizelyLogLevelInfo];

func applicationWillEnterForeground(_ application: UIApplication) {
        optimizely.start { result in
            switch result {
            case .failure(let error):
                print("Optimizely SDK initialization failed: \(error)")
            case .success:
                print("Optimizely SDK initialized successfully!")
              	// retest your features or experiments?
            }
						
            self.startWithRootViewController()
        }
    }

optimizely = OptimizelyClient(sdkKey: "YOUR_SDK_KEY")

do {
	let localDatafilePath = Bundle.main.path(forResource: “datafileName”, ofType: "json")!
	let datafileJSON = try String(contentsOfFile: localDatafilePath, encoding: .utf8)
	try optimizely.start(datafile: datafileJSON)
	
	// Optimizely SDK initialized successfully
} catch {
	// Optimizely SDK initialization failed
}

self.optimizely = [[OptimizelyClient alloc] initWithSdkKey:@"<Your_SDK_Key>"];

NSString *filePath = [[NSBundle mainBundle] pathForResource:@“fileName” ofType:@"json"]
NSString *datafileJSON = [NSString stringWithContentsOfFile:filePath encoding:NSUTF8StringEncoding error:nil];

BOOL status = [self.optimizely startWithDatafile:datafileJSON error:nil];

let odpSettings = OptimizelySdkSettings(segmentsCacheSize: 1000,
                                        segmentsCacheTimeoutInSecs: 30*60,
                                        disableOdp: false)
        
let optimizely = OptimizelyClient(sdkKey: "<YOUR_SDK_KEY>",
                                  settings: odpSettings)

// Here are sample codes for synchronous and asynchronous SDK initializations with multiple options

// [Synchronous]
        
// [S1] Synchronous initialization
//      1. The Swift SDK is initialized instantly with a cached (or bundled) datafile.
//      2. A new datafile can be downloaded in the background and cached after the SDK is initialized.
//         The cached datafile is used only when the Swift SDK re-starts in the next session.

optimizely = OptimizelyClient(sdkKey: "YOUR_SDK_KEY)
try? optimizely.start(datafile: localDatafile)
user = optimizely.createUserContext(userId: userId)
let decision = user.decide(key: "flagKey")
let variationKey = decision.variationKey        
        
// [S2] Synchronous initialization
//      1. The Swift SDK is initialized instantly with a cached (or bundled) datafile.
//      2. A new datafile can be downloaded in the background and cached after the SDK is initialized.
//         The cached datafile is used immediately to update the SDK project config.
        
optimizely = OptimizelyClient(sdkKey: "YOUR_SDK_KEY")
try? optimizely.start(datafile: localDatafile,
                              doUpdateConfigOnNewDatafile: true)
user = optimizely.createUserContext(userId: userId)
let decision = user.decide(key: flagKey)
let variationKey = decision.variationKey        
        
// [S3] Synchronous initialization
//      1. The Swift SDK is initialized instantly with a cached (or bundled) datafile.
//      2. A new datafile can be downloaded in the background and cached after the SDK is initialized.
//         The cached datafile is used immediately to update the SDK project config.
//      3. Polling datafile periodically.
//         The cached datafile is used immediately to update the SDK project config.
        
optimizely = OptimizelyClient(sdkKey: "YOUR_SDK_KEY",
                                      periodicDownloadInterval: 60)
try? optimizely.start(datafile: localDatafile)
user = optimizely.createUserContext(userId: userId)
let decision = user.decide(key: flagKey)
let variationKey = decision.variationKey        
        
// [Asynchronous]
        
// [A1] Asynchronous initialization
//      1. A datafile is downloaded from the server and the Swift SDK is initialized with the datafile.

optimizely = OptimizelyClient(sdkKey: "YOUR_SDK_KEY")
optimizely.start { result in
		user = optimizely.createUserContext(userId: userId)
		let decision = user.decide(key: flagKey)
		let variationKey = decision.variationKey        
}
        
// [A2] Asynchronous initialization
//      1. A datafile is downloaded from the server and the Swift SDK is initialized with the datafile
//      2. Polling datafile periodically.
//         The cached datafile is used immediately to update the SDK project config.
        
optimizely = OptimizelyClient(sdkKey: "YOUR_SDK_KEY",
                                      periodicDownloadInterval: 60)
optimizely.start { result in
		user = optimizely.createUserContext(userId: userId)
		let decision = user.decide(key: flagKey)
		let variationKey = decision.variationKey        
}

// [A3] Asynchronous initialization (async-await)
//      1. A datafile is downloaded from the server and the Swift SDK is initialized with the datafile
//      2. Polling datafile periodically.
//         The cached datafile is used immediately to update the SDK project config.
optimizely = OptimizelyClient(sdkKey: "YOUR_SDK_KEY",
                              periodicDownloadInterval: 60)
if #available(iOS 13, *) {
  Task { [optimizely] in
        do {
          try await optimizely.start()
        } catch {
          print("Optimizely SDK initialization failed: \(error)")
        }
       }
}