import com.eyeofcloud.ab.Eyeofcloud;

// Initialize an Eyeofcloud client
eyeofcloudClient = Eyeofcloud.builder(datafile, myEventHandler).build();

// Activate user in an experiment
Variation variation = eyeofcloudClient.activate("my_experiment", user_id);

if (variation != null) {
  if (variation.is("control")) {
    // Execute code for variation A
  } else if (variation.is("treatment")) {
    // Execute code for variation B
  }
} else {
  // Execute default code
}

// Track conversion event
eyeofcloudClient.track("my_conversion", user_id);

import com.eyeofcloud.ab.Eyeofcloud;

// Get an Eyeofcloud client
EyeofcloudClient eyeofcloudClient = eyeofcloudManager.getEyeofcloud();

// Activate user in an experiment
Variation variation = eyeofcloudClient.activate("my_experiment", "user_id");

if (variation != null) {
  if (variation.is("control")) {
    // Execute code for variation A
  } else if (variation.is("treatment")) {
    // Execute code for variation B
  }
} else {
  // Execute default code
}

// Track conversion event
eyeofcloudClient.track("my_conversion", user_id);

require "eyeofcloud"

# Initialize an Eyeofcloud client
eyeofcloud_client = Eyeofcloud::Project.new(datafile)

# Activate user in an experiment
variation = eyeofcloud_client.activate("my_experiment", user_id)

if variation == 'control'
  # Execute code for variation A
elsif variation == 'treatment'
  # Execute code for variation B
else
  # Execute default code
end

# Track conversion event
eyeofcloud_client.track("my_conversion", user_id)

var eyeofcloud = require('eyeofcloud-server-sdk');

// Initialize an Eyeofcloud client
var eyeofcloudClient = eyeofcloud.createInstance({ datafile: datafile });

// Activate user in an experiment
var variation = eyeofcloudClient.activate("my_experiment", userId);

if (variation === 'control') {
  // Execute code for variation A
} else if (variation === 'treatment') {
  // Execute code for variation B
} else {
  // Execute default code
}

// Track conversion event
eyeofcloudClient.track("my_conversion", userId);

var eyeofcloud = require('eyeofcloud-client-sdk');

// Initialize an Eyeofcloud client
var eyeofcloudClientInstance = eyeofcloud.createInstance({ datafile: datafile });


// ALTERNATIVELY, if you don't use CommonJS or npm, you can install the minified snippet and use the globally exported varible as follows:
var eyeofcloudClientInstance = window.eyeofcloudClient.createInstance({ datafile: datafile });


// Activate user in an experiment
var variation = eyeofcloudClientInstance.activate("my_experiment", userId);

if (variation === 'control') {
  // Execute code for variation A
} else if (variation === 'treatment') {
  // Execute code for variation B
} else {
  // Execute default code
}

// Track conversion event
eyeofcloudClientInstance.track("my_conversion", userId);

use Eyeofcloud\Eyeofcloud;

// Initialize an Eyeofcloud client
$eyeofcloudClient = new Eyeofcloud($datafile);

// Activate user in an experiment
$variation = $eyeofcloudClient->activate('my_experiment', $userId);

if ($variation == 'control') {
  // Execute code for variation A
} elseif ($variation == 'treatment') {
  // Execute code for variation B
} else {
  // Execute default code
}

// Track conversion event
$eyeofcloudClient->track('my_conversion', $userId);

var eocmanager = require('eyeofcloud-client-sdk');

onLoad: function(){
  var that = this;
  app.getOpenId(function(openId){

    // Initialize an Eyeofcloud client
    eocmanager.getInstance().then(function(eyeofcloudClientInstance){

      // Activate user in an experiment
      var variation = eyeofcloudClientInstance.activate('experiment',openId);

      if ('variationA' == variation) {
        // Execute code for variation A
      } else if ('variationB' == variation) {
        // Execute code for variation B
      } else {
        // Execute default code
      }

      // Track conversion event
      eyeofcloud.track("my_conversion", userId);
    })   
  })
}

// Initialize an Eyeofcloud manager
EOCManager *eocManager = [EOCManager init:^(EOCManagerBuilder * _Nullable builder) {
    builder.projectId = @"projectId";
}];

// Initialize an Eyeofcloud client by asynchronously downloading the datafile
[eocManager initializeWithCallback:^(NSError * _Nullable error, EOCClient * _Nullable client) {
    // Activate user in an experiment
    EOCVariation *variation = [client activate:@"my_experiment" userId:@"userId"];

    if ([variation.variationKey isEqualToString:@"control"]) {
        // Execute code for the control
    } else if ([variation.variationKey isEqualToString:@"treatment"]) {
        // Execute code for the treatment
    } else {
        // Execute default code
    }

    // Track conversion event
    [client track:@"my_conversion" userId:@"userId"];
}];

// Initialize an Eyeofcloud manager
let eyeofcloudManager : EOCManager? = EOCManager.init {(builder) in
    builder!.projectId = "projectId"
}

// Initialize an Eyeofcloud client by asynchronously downloading the datafile
eyeofcloudManager?.initialize(callback: { [weak self] (error, eyeofcloudClient) in

    // Activate user in an experiment
    if let variation = eyeofcloudClient?.activate("my_experiment", userId: "userId")
    {
        if (variation.variationKey == "control") {
            // Execute code for the control
        }
        else if (variation.variationKey == "treatment") {
            // Execute code for the treatment
        }
    } else {
        // execute default code
    }

    // Track conversion event
    eyeofcloudClient?.track("my_conversion", userId: "userId")
})

// Use this code to get the URL of the datafile to fetch
[EOCDatafileManagerUtility projectConfigURLPath:@"<PROJ-ID-STRING>"];

// Use this code to get the URL of the datafile to fetch
EOCDatafileManagerUtility.projectConfigURLPath("<PROJ-ID-STRING>")

// Use this code to get the URL of the datafile to fetch
EyeofcloudManager.getDatafileUrl(PROJECT_ID);

public class MyApplication extends Application {

  private EyeofcloudManager eyeofcloudManager;

  public EyeofcloudManager getEyeofcloudManager() {
    return eyeofcloudManager;
  }

  @Override public void onCreate() {
    super.onCreate();

    eyeofcloudManager = EyeofcloudManager.builder()
      .withEventHandlerDispatchInterval(1, TimeUnit.DAYS)
      .withDataFileDownloadInterval(1, TimeUnit.DAYS)
      .build();
  }
}

EOCDatafileManagerDefault *datafileManager = [EOCDatafileManagerDefault initWithBuilderBlock:^(EOCDatafileManagerBuilder * _Nullable builder) {
  builder.projectId = @"1234";
  builder.datafileFetchInterval = kDatafileDownloadInterval;
}];

EOCManager *eocManager = [EOCManager initWithBuilderBlock:^(EOCManagerBuilder * _Nullable builder) {
  builder.projectId = @"1234";
  builder.datafileManager = datafileManager;
}];

let datafileManager: EOCDatafileManagerDefault? = EOCDatafileManagerDefault.initWithBuilderBlock({ (builder) in
  builder!.projectId = "1234"
  builder!.datafileFetchInterval = kDatafileDownloadInterval
})

let eyeofcloudManager: EOCManager? = EOCManager.initWithBuilderBlock({ (builder) in
  builder!.projectId = "1234"
  builder!.datafileManager = datafileManager
})

public class FirstActivity extends Activity {

  @Override protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_first);

    EyeofcloudManager eyeofcloudManager =
        ((MyApplication) getApplication()).getEyeofcloudManager();

    eyeofcloudManager.initialize(this, new EyeofcloudStartListener()  {
      @Override public void onStart(EyeofcloudClient eyeofcloud) {
          assert eyeofcloud == eyeofcloudManager.getEyeofcloud();
          Intent intent = new Intent(FirstActivity.this, SubsequentActivity.class);
          startActivity(intent);
      }
    });
  }
}

public class FirstActivitySynchronousStart extends Activity {

  @Override protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_first);

    EyeofcloudManager eyeofcloudManager =
        ((MyApplication) getApplication()).getEyeofcloudManager();
    assert eyeofcloudManager.getEyeofcloud() == null;

    EyeofcloudClient eyeofcloud = eyeofcloudManager.initialize(MyActivity.this, R.raw.data_file);
    assert eyeofcloud != null;
  }
}

public class SubsequentActivity extends Activity {

  @Override protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_subsequent);

    final EyeofcloudManager eyeofcloudManager =
        ((MyApplication) getApplication()).getEyeofcloudManager();

    EyeofcloudClient eyeofcloud = eyeofcloudManager.getEyeofcloud();
    assert eyeofcloud != null;
  }
}

String experimentKey = "my_experiment";
String userId = "user123";

Map<String, String> attributes = new HashMap<String, String>();
attributes.put("DEVICE", "iPhone");
attributes.put("AD_SOURCE", "my_campaign");

// Conditionally activate an experiment for the provided user
Variation variation = eyeofcloud.activate(experimentKey, userId, attributes);

EyeofcloudClient eyeofcloud = eyeofcloudManager.getEyeofcloud();

String experimentKey = "my_experiment";
String userId = "user123";

Map<String, String> attributes = new HashMap<String, String>();
attributes.put("DEVICE", "Nexus 6P");
attributes.put("AD_SOURCE", "my_campaign");

// Conditionally activate a experiment for the provided user
Variation variation = eyeofcloud.activate(experimentKey, userId, attributes);

experiment_key = 'my_experiment'
user_id = 'user123'
attributes = {'DEVICE' => 'iPhone', 'AD_SOURCE' => 'my_campaign'}

# Conditionally activate an experiment for the provided user
variation = eyeofcloud_client.activate(experiment_key, user_id, attributes)

var experimentKey = 'my_experiment';
var userId = 'user123';
var attributes = { 'device': 'iphone', 'ad_source': 'my_campaign' };

// Conditionally activate an experiment for the provided user
var variation = eyeofcloud.activate(experimentKey, userId, attributes);

var experimentKey = 'my_experiment';
var userId = 'user123';
var attributes = { 'device': 'iphone', 'ad_source': 'my_campaign' };

// Conditionally activate an experiment for the provided user
var variation = eyeofcloudClientInstance.activate(experimentKey, userId, attributes);

$experimentKey = 'my_experiment';
$userId = 'user123';
$attributes = [
    'device' => 'iphone',
    'ad_source' => 'my_campaign'
];

// Conditionally activate an experiment for the provided user
$variation = $eyeofcloudClient->activate($experimentKey, $userId, $attributes);

var experimentKey = 'my_experiment';
var userId = 'user123';
var attributes = { 'device': 'iphone', 'ad_source': 'my_campaign' };

// Conditionally activate an experiment for the provided user
var variation = eyeofcloudClientInstance.activate(experimentKey, userId, attributes);

NSDictionary *attributes = @{@"device" : @"iPhone", @"ad_source" : @"my_campaign"};

EOCVariation *variation = [eyeofcloud activate:@"my_experiment"
                                          userId:@"user123"
                                      attributes:attributes];

let attributes = ["device" : "iPhone", "ad_source" : "my_campaign"]

let variation: EOCVariation? = eyeofcloud?.activate("my_experiment", userId:"user123", attributes:attributes)

String experimentKey = "my_experiment";
String userId = "user123";

Eyeofcloud eyeofcloudClient = eyeofcloudManager.getEyeofcloud();

// Get the active variation for the provided user
Variation variation = eyeofcloudClient.getVariation(experimentKey, userId);

String experimentKey = "my_experiment";
String userId = "user123";

// Get the active variation for the provided user
Variation variation = eyeofcloudClient.getVariation(experimentKey, userId);

experiment_key = 'my_experiment'
user_id = 'user123'

# Get the active variation for the provided user
variation = eyeofcloud_client.get_variation(experiment_key, user_id)

$experimentKey = 'my_experiment';
$userId = 'user123';

# Get the active variation for the provided user
$variation = $eyeofcloudClient->getVariation($experimentKey, $userId);

var experimentKey = 'my_experiment';
var userId = 'user123';

// Get the active variation for the provided user
var variation = eyeofcloudClientInstance.getVariation(experimentKey, userId);

var experimentKey = 'my_experiment';
var userId = 'user123';

// Get the active variation for the provided user
var variation = eyeofcloudClient.getVariation(experimentKey, userId);

var experimentKey = 'my_experiment';
var userId = 'user123';

// Get the active variation for the provided user
var variation = eyeofcloudClientInstance.getVariation(experimentKey, userId);

// Get the active variation for an experiment for the provided user
EOCVariation *variation = [eyeofcloud variation:@"my_experiment"
                                           userId:@"user123"];

// Get the active variation for an experiment for the provided user
let variation: EOCVariation? = eyeofcloud?.variation("my_experiment", userId:"user123")

String eventKey = "my_conversion";
String userId = "user123";

Map<String, String> attributes = new HashMap<String, String>();
attributes.put("DEVICE", "iPhone");
attributes.put("AD_SOURCE", "my_campaign");

Map<String, Object> eventTags = new HashMap<String, Object>();
eventTags.put("purchasePrice", 64.32f);
eventTags.put("category", "shoes");

// reserved "revenue" keyword,
eventTags.put("revenue", 100);

eyeofcloud.track(eventKey, userId, attributes, eventTags);

event_key = 'my_conversion'
user_id = 'user123'

attributes = {
  'device' => 'iPhone',
  'adSource' => 'my_campaign'
}

event_tags = {
  'category' => 'shoes',
  'purchasePrice' => 64.32,
  'revenue' => 100  # reserved "revenue" keyword
}

# track event with user attributes and event tags 
eyeofcloud_client.track(event_key, user_id, attributes, event_tags)

# track event with event tags and without user attributes
eyeofcloud_client.track(event_key, user_id, nil, event_tags)

$eventKey = 'my_conversion';
$userId = 'user123';

$attributes = [
    'device' => 'iphone',
    'ad_source' => 'my_campaign'
];

$eventTags = [
    'category' => 'shoes',
    'purchasePrice' => 64.32,
    'revenue' => 500 # reserved "revenue" keyword
];

# track event with user attributes and event tags
$eyeofcloudClient->track($eventKey, $userId, $attributes, $eventTags);

# track event with event tags and without user attributes
$eyeofcloudClient->track($eventKey, $userId, null, $eventTags);

var eventKey = "my_conversion";
var userId = "user123";

var attributes = {
  DEVICE: 'iPhone',
  AD_SOURCE: 'my_campaign'
};

var eventTags = {
  category: 'shoes',
  purchasePrice: 64.32,
  revenue: 100 // reserved "revenue" keyword
};

eyeofcloud.track(eventKey, userId, attributes, eventTags);

var eventKey = "my_conversion";
var userId = "user123";

var attributes = {
  DEVICE: 'iPhone',
  AD_SOURCE: 'my_campaign'
};

var eventTags = {
  category: 'shoes',
  purchasePrice: 64.32,
  revenue: 100 // reserved "revenue" keyword
};

eyeofcloud.track(eventKey, userId, attributes, eventTags);

var eventKey = "my_conversion";
var userId = "user123";

var attributes = {
  DEVICE: 'iPhone',
  AD_SOURCE: 'my_campaign'
};

var eventTags = {
  category: 'shoes',
  purchasePrice: 64.32,
  revenue: 100 // reserved "revenue" keyword
};

eyeofcloud.track(eventKey, userId, attributes, eventTags);

import com.eyeofcloud.ab.Eyeofcloud;
import com.eyeofcloud.ab.config.parser.ConfigParseException;
import com.eyeofcloud.ab.event.AsyncEventHandler;
import com.eyeofcloud.ab.event.EventHandler;

// Creates an async event handler with a max buffer of
// 20,000 events and a single dispatcher thread
EventHandler eventHandler = new AsyncEventHandler(20000, 1);

Eyeofcloud eyeofcloudClient;
try {
    // Create an Eyeofcloud client with the default event dispatcher
    eyeofcloudClient = Eyeofcloud.builder(datafile,
                                          eventHandler).build();
} catch (ConfigParseException e) {
    // Handle exception gracefully
    return;
}

var defaultEventDispatcher = require('eyeofcloud-client-sdk/lib/plugins/event_dispatcher');

// Create an Eyeofcloud client with the default event dispatcher
var eyeofcloudClientInstance = eyeofcloud.createInstance({
  datafile: datafile,
  eventDispatcher: defaultEventDispatcher
});

EventHandler eventHandler = YourEventHandler.getInstance();

// Create an Eyeofcloud client with your own event handler
Eyeofcloud eyeofcloudClient = Eyeofcloud.builder(datafile,
                                                 eventHandler).build();

# Create an Eyeofcloud client with the default event dispatcher
eyeofcloud_client = Eyeofcloud::Project.new(datafile,
                                            Eyeofcloud::EventDispatcher.new)

var defaultEventDispatcher = require('eyeofcloud-server-sdk/lib/plugins/event_dispatcher');

// Create an Eyeofcloud client with the default event dispatcher
var eyeofcloudClient = eyeofcloud.createInstance({
  datafile: datafile,
  eventDispatcher: defaultEventDispatcher
});

var defaultEventDispatcher = require('eyeofcloud-client-sdk/lib/plugins/event_dispatcher');

// Create an Eyeofcloud client with the default event dispatcher
var eyeofcloudClientInstance = eyeofcloud.createInstance({
  datafile: datafile,
  eventDispatcher: defaultEventDispatcher
});

use Eyeofcloud\Event\Dispatcher\DefaultEventDispatcher;

// Create an Eyeofcloud client with the default event dispatcher
$eyeofcloudClient = new Eyeofcloud($datafile, new DefaultEventDispatcher());

CustomEventDispatcher<EOCEventDispatcher> *customEventDispatcher = [[CustomEventDispatcher alloc] init];

// initialize your Manager (settings will propagate to EOCClient and Eyeofcloud)
EOCManager *manager = [EOCManager init:^(EOCManagerBuilder * _Nullable builder) {
  builder.projectId = kProjectId;
  builder.eventDispatcher = eventDispatcher;
}];

let customEventDispatcher: CustomEventDispatcher = CustomEventDispatcher.init()

// initialize your Manager (settings will propagate to EOCClient and Eyeofcloud)
let manager: EOCManager? =  EOCManager.init({ (builder) in
  builder!.datafile = datafile
  builder!.eventDispatcher = customEventDispatcher
})

eyeofcloud_client = Eyeofcloud::Project.new(datafile,
                                            Eyeofcloud::EventDispatcher.new,
                                            Eyeofcloud::NoOpLogger.new)

var defaultLogger = require('eyeofcloud-server-sdk/lib/plugins/logger');

var eyeofcloudClient = eyeofcloud.createInstance({
  datafile: datafile,
  eventDispatcher: defaultEventDispatcher,
  logger: defaultLogger.createLogger(),
});

var defaultLogger = {
  log: function(message) {
    console.log(message);
  },
};

// custom logger
var eyeofcloudClientInstance = eyeofcloud.createInstance({
  datafile: datafile,
  eventDispatcher: defaultEventDispatcher,
  logger: defaultLogger,
});

// custom logLevel (2, DEBUG) with default logger
var eyeofcloudClientInstance = eyeofcloud.createInstance({
  datafile: datafile,
  logLevel: 2,
});

use Eyeofcloud\Logger\DefaultLogger;

$eyeofcloudClient = new Eyeofcloud($datafile, null, new DefaultLogger());

var defaultLogger = {
  log: function(message) {
    console.log(message);
  },
};

// custom logger
var eyeofcloudClientInstance = eyeofcloud.createInstance({
  datafile: datafile,
  eventDispatcher: defaultEventDispatcher,
  logger: defaultLogger,
});

// custom logLevel (2, DEBUG) with default logger
var eyeofcloudClientInstance = eyeofcloud.createInstance({
  datafile: datafile,
  logLevel: 2,
});

CustomLogger *customLogger = [[CustomLogger alloc] init];

EOCManager *manager = [EOCManager init:^(EOCManagerBuilder * _Nullable builder) {
  builder.projectId = kProjectId;
  builder.logger = customLogger;
}];

EOCLoggerDefault *eocLogger = [[EOCLoggerDefault alloc] initWithLogLevel:EyeofcloudLogLevelAll];
EOCManager *manager = [EOCManager init:^(EOCManagerBuilder * _Nullable builder) {
  builder.projectId = kProjectId;
  builder.logger = eocLogger;
}];

let customLogger: CustomLogger? = CustomLogger()

let manager: EOCManager? =  EOCManager.init({ (builder) in
  builder!.projectId = projectId
  builder!.logger = customLogger
})

let eocLogger: EOCLoggerDefault? = EOCLoggerDefault.init(logLevel: EyeofcloudLogLevel.All)
let manager: EOCManager? =  EOCManager.init({ (builder) in
  builder!.projectId = projectId
  builder!.logger = eocLogger
})

# android-logger.properties example

# Core
logger.com.eyeofcloud.ab.Eyeofcloud=DEBUG:Optly.core
logger.com.eyeofcloud.ab.annotations=DEBUG:Optly.annotations
logger.com.eyeofcloud.ab.bucketing=DEBUG:Optly.bucketing
logger.com.eyeofcloud.ab.config=DEBUG:Optly.config
logger.com.eyeofcloud.ab.error=DEBUG:Optly.error
logger.com.eyeofcloud.ab.event=DEBUG:Optly.event
logger.com.eyeofcloud.ab.internal=DEBUG:Optly.internal

# Android
logger.com.eyeofcloud.ab.android.sdk=DEBUG:Optly.androidSdk
logger.com.eyeofcloud.ab.android.event_handler=DEBUG:Optly.eventHandler
logger.com.eyeofcloud.ab.android.shared=DEBUG:Optly.shared
logger.com.eyeofcloud.ab.android.user_profile=DEBUG:Optly.userProfile

# Disable most SDK logs by commenting all other lines and uncommenting below
#logger.com.eyeofcloud.ab=ASSERT:Optly

import com.eyeofcloud.ab.Eyeofcloud;
import com.eyeofcloud.ab.error.ErrorHandler;
import com.eyeofcloud.ab.error.RaiseExceptionErrorHandler;
import com.eyeofcloud.ab.event.AsyncEventHandler;
import com.eyeofcloud.ab.event.EventHandler;

EventHandler eventHandler = new AsyncEventHandler(20000, 1);

// Default handler that raises exceptions
ErrorHandler errorHandler = new RaiseExceptionErrorHandler();

Eyeofcloud eyeofcloudClient;
try {
    // Create an Eyeofcloud client with the default event dispatcher
    eyeofcloudClient = Eyeofcloud.builder(datafile, eventHandler).
                           .withErrorHandler(errorHandler)
                           .build();
} catch (ConfigParseException e) {
    // Handle exception gracefully
    return;
}

// Event handler is required to make Eyeofcloud
EventHandler eventHandler = YourEventHandler.getInstance();

// You can optionally provide an error handler
ErrorHandler errorHandler = YourErrorHandler.getInstance();

Eyeofcloud eyeofcloudClient = Eyeofcloud.builder(datafile, eventHandler)
    .withErrorHandler(errorHandler)
    .build();

eyeofcloud_client = Eyeofcloud::Project.new(datafile,
                                            Eyeofcloud::EventDispatcher.new,
                                            Eyeofcloud::NoOpLogger.new,
                                            Eyeofcloud::NoOpErrorHandler.new)

var defaultErrorHandler = require('eyeofcloud-server-sdk/lib/plugins/error_handler');

eyeofcloudClient = eyeofcloud.createInstance({
  datafile: datafile,
  errorHandler: defaultErrorHandler,
  eventDispatcher: defaultEventDispatcher,
  logger: defaultLogger.createLogger(),
});

var defaultErrorHandler = require('eyeofcloud-server-sdk/lib/plugins/error_handler');

var eyeofcloudClientInstance = eyeofcloud.createInstance({
  datafile: datafile,
  errorHandler: defaultErrorHandler,
  eventDispatcher: defaultEventDispatcher,
  logger: defaultLogger.createLogger(),
});

var defaultErrorHandler = require('eyeofcloud-server-sdk/lib/plugins/error_handler');

var eyeofcloudClientInstance = eyeofcloud.createInstance({
  datafile: datafile,
  errorHandler: defaultErrorHandler,
  eventDispatcher: defaultEventDispatcher,
  logger: defaultLogger.createLogger(),
});

use Eyeofcloud\ErrorHandler\DefaultErrorHandler;

$eyeofcloudClient = new Eyeofcloud($datafile, null, null, new DefaultErrorHandler());

CustomErrorHandler *customErrorHandler = [[CustomErrorHandler alloc] init];

EOCManager *manager = [EOCManager init:^(EOCManagerBuilder * _Nullable builder) {
  builder.projectId = kProjectId;
  builder.errorHandler = customErrorHandler;
}];

let customErrorHandler: CustomErrorHandler? = CustomErrorHandler()

let manager: EOCManager? =  EOCManager.init({ (builder) in
  builder!.projectId = projectId
  builder!.errorHandler = customErrorHandler
})

// Event handler is required to make Eyeofcloud
EventHandler eventHandler = YourEventHandler.getInstance();

// You can optionally provide a user profile
UserProfile userProfile = UserProfile.getInstance();

Eyeofcloud eyeofcloudClient = Eyeofcloud.builder(datafile, eventHandler)
    .withUserProfile(userProfile)
    .build();

CustomUserProfile<EOCUserProfile> *customUserProfile = [[CustomUserProfile alloc] init];

// initialize your Manager (settings will propagate to EOCClient and Eyeofcloud)
EOCManager *manager = [EOCManager init:^(EOCManagerBuilder * _Nullable builder) {
  builder.projectId = kProjectId;
  builder.userProfile = userProfile;
}];

let customUserProfile: CustomUserProfile? = CustomUserProfile.init()

// initialize your Manager (settings will propagate to EOCClient and Eyeofcloud)
let manager: EOCManager? =  EOCManager.init({ (builder) in
  builder!.projectId = projectId
  builder!.userProfile = customUserProfile
})

import com.eyeofcloud.ab.notification.NotificationListener;

// Create a new listener and override a method
NotificationListener listener = new NotificationListener() {
  @Override
  public void onExperimentActivated(Experiment experiment, String userId, Map<String, String> attributes, Variation variation) {
    Log.i(TAG, "Eyeofcloud experiment activated.");
  }
};

// Add a listener
Eyeofcloud eyeofcloudClient = eyeofcloudManager.getEyeofcloud();
eyeofcloudClient.addNotificationListener(listener);

// Remove a listener
eyeofcloudClient.removeNotificationListener(listener);

// Clear all listeners
eyeofcloudClient.clearNotificationListeners();

import com.eyeofcloud.ab.notification.NotificationListener;

// Create a new listener and override methods
NotificationListener listener = new NotificationListener() {
  @Override
  public void onEventTracked(String eventKey,
                             String userId,
                             Map<String, String> attributes,
                             Long eventValue,
                             LogEvent logEvent) {
    Log.i(TAG, "Eyeofcloud event tracked.");
  }

  @Override
  public void onExperimentActivated(Experiment experiment,
                                    String userId,
                                    Map<String, String> attributes,
                                    Variation variation) {
    Log.i(TAG, "Eyeofcloud experiment activated.");
  }
};

// Add a listener
Eyeofcloud eyeofcloudClient = eyeofcloudManager.getEyeofcloud();
eyeofcloudClient.addNotificationListener(listener);

// Remove a listener
eyeofcloudClient.removeNotificationListener(listener);

// Clear all listeners
eyeofcloudClient.clearNotificationListeners();