Configure the event dispatcher

import com.optimizely.ab.android.sdk.OptimizelyManager;
import com.optimizely.ab.event.EventHandler;
import com.optimizely.ab.android.event_handler.EventRescheduler;

// Using an anonymous class here to implement the EventHandler interface. 
// Feel free to create an explicit class that implements the interface instead.
EventHandler eventHandler = new EventHandler() {
    @Override
    public void dispatchEvent(LogEvent logEvent) throws Exception {
        // Send event to our log endpoint as documented in https://developers.optimizely.com/x/events/api/index.html
    }
};

// Build a manager
optimizelyManager = OptimizelyManager.builder()
  .withSDKKey("SDK_KEY_HERE")
  .withEventDispatchInterval(60L * 10L)
  .withEventHandler(eventHandler)
  .withDatafileDownloadInterval(60L * 10L)
  .build(getApplicationContext());

/** 
 * With the new Android O differences, you need to register the
 * service for the intent filter you desire in code instead of 
 * in the manifest.
 */
EventRescheduler eventRescheduler = new EventRescheduler();

getApplicationContext().registerReceiver(eventRescheduler, new IntentFilter(WifiManager.SUPPLICANT_CONNECTION_CHANGE_ACTION));

using OptimizelySDK;
using OptimizelySDK.Event.Dispatcher;

// Create an Optimizely client with the default event dispatcher
	Optimizely OptimizelyClient = new Optimizely(
			datafile: datafile,
			eventDispatcher: new DefaultEventDispatcher(new OptimizelySDK.Logger.DefaultLogger()));

import com.optimizely.ab.Optimizely;
import com.optimizely.ab.config.parser.ConfigParseException;
import com.optimizely.ab.event.AsyncEventHandler;
import com.optimizely.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);

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

var defaultEventDispatcher = require('@optimizely/optimizely-sdk/lib/plugins/event_dispatcher/index.browser');

// Create an Optimizely client with the default event dispatcher
var optimizelyClientInstance = optimizely.createInstance({
  datafile: datafile,
  eventDispatcher: defaultEventDispatcher
});

// Client with defaultEventDispatcher
const defaultEventDispatcher = require("@optimizely/optimizely-sdk/lib/plugins/event_dispatcher/index.node");

// Create an Optimizely client with the default event dispatcher
var optimizelyClientWithDefaultDispatcher = optimizely.createInstance({
  datafile,
  eventDispatcher: defaultEventDispatcher
});

CustomEventDispatcher *customEventDispatcher = [[CustomEventDispatcher alloc] init];

/** 
 * Initialize your Manager 
 *  (settings will propagate to OPTLYClient and Optimizely)
 */
  OPTLYManager *manager = [[OPTLYManager alloc] initWithBuilder:[OPTLYManagerBuilder  builderWithBlock:^(OPTLYManagerBuilder * _Nullable builder) {
      builder.sdkKey = @"SDK_KEY_HERE";
			builder.eventDispatcher = customEventDispatcher;
    }]];

use Optimizely\Event\Dispatcher\DefaultEventDispatcher;

/** 
 * Create an Optimizely client with the default event dispatcher.
 * Please note, if not provided it will default to this event dispatcher.
 */
$optimizelyClient = new Optimizely($datafile, new DefaultEventDispatcher());

/**
 * You can provide your own implementation of the event dispatcher
 * for sending events to Optimizely. It should however implement
 * Optimizely\Event\Dispatcher\EventDispatcherInterface.
 */

from optimizely.event_dispatcher import EventDispatcher as event_dispatcher
from optimizely import optimizely

# Create an Optimizely client with the default event dispatcher
optimizely_client = optimizely.Optimizely(datafile,
                                          event_dispatcher=event_dispatcher)

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

let customEventDispatcher: CustomEventDispatcher = CustomEventDispatcher.init()

/**
 * Initialize your Manager 
 * (settings will propagate to OPTLYClient and Optimizely)
 */
 let manager = OPTLYManager(builder: OPTLYManagerBuilder(block: { (builder) in
  builder?.sdkKey = "SDK_KEY_HERE"
  builder?.eventDispatcher = customEventDispatcher
 }))

  <!--
    Add these lines to your manifest if you want the event handler background services to schedule 
    themselves again after a boot or package replace.
  -->
  <receiver
      android:name="com.optimizely.ab.android.event_handler.EventRescheduler"
      android:enabled="true"
      android:exported="false">
      <intent-filter>
          <action android:name="android.intent.action.MY_PACKAGE_REPLACED" />
          <action android:name="android.intent.action.BOOT_COMPLETED" />
          <action android:name="android.net.wifi.supplicant.CONNECTION_CHANGE" />
      </intent-filter>
  </receiver>