Android SDK

implementation 'io.split.client:android-client:3.1.0'

import io.split.android.client.SplitClient;
import io.split.android.client.SplitClientConfig;
import io.split.android.client.SplitFactory;
import io.split.android.client.SplitFactoryBuilder;
import io.split.android.client.api.Key;

//API Key
String apikey = "YOUR_API_KEY";

// Build SDK configuration by default
SplitClientConfig config = SplitClientConfig.builder()
  .build();

// Create a new user key to be evaluated
String matchingKey = "key";
Key k = new Key(matchingKey);

// Create factory
SplitFactory splitFactory = SplitFactoryBuilder.build(apikey, k, config, getApplicationContext());

// Get Split Client instance
SplitClient client = splitFactory.client();

import io.split.android.client.SplitClient
import io.split.android.client.SplitClientConfig
import io.split.android.client.SplitFactory
import io.split.android.client.SplitFactoryBuilder
import io.split.android.client.api.Key

//API Key
val apiKey = "YOUR_API_KEY"

// Build default SDK configuration
val config: SplitClientConfig = SplitClientConfig.builder().build()

// Create a new user key to be evaluated
val matchingKey = "key"
val key: Key = Key(matchingKey)

// Create factory
val splitFactory: SplitFactory =
    SplitFactoryBuilder.build(apiKey, key, config, applicationContext)

// Get Split Client instance
val client: SplitClient = splitFactory.client()

  client.on(SplitEvent.SDK_READY, new SplitEventTask() {
    @Override
    public void onPostExecution(SplitClient client) {
      // Logic in background here
    }

    @Override
    public void onPostExecutionView(SplitClient client) {
      // Execute logic in main thread here
      String treatment = client.getTreatment("SPLIT_NAME");
      if (treatment.equals("on")) {
        // insert code here to show on treatment
      } else if (treatment.equals("off")) {
          // insert code here to show off treatment
      } else {
          // insert your control treatment code here
      }
    }
});

client.on(SplitEvent.SDK_READY_TIMED_OUT, new SplitEventTask() {
  @Override
  public void onPostExecution(SplitClient client) {
    // handle for timeouts here
  }

  @Override
  public void onPostExecutionView(SplitClient client) {
    // handle for timeouts here
  }
}  

  client.on(SplitEvent.SDK_READY, object : SplitEventTask() {

    override fun onPostExecution(client: SplitClient) {
        // Execute background logic here
        when (client.getTreatment("SPLIT_NAME")) {
            "on" -> {
                // insert code here to show on treatment
            }
            "off" -> {
                // insert code here to show off treatment
            }
            else -> {
                // insert your control treatment code here
            }
        }
    }

    override fun onPostExecutionView(client: SplitClient) {
        // Execute main thread logic here
        when (client.getTreatment("SPLIT_NAME")) {
            "on" -> {
                // insert code here to show on treatment
            }
            "off" -> {
                // insert code here to show off treatment
            }
            else -> {
                // insert your control treatment code here
            }
        }
    }
})

client.on(SplitEvent.SDK_READY_FROM_CACHE, new SplitEventTask() {
  @Override
  public void onPostExecution(SplitClient client) {
    //Background Code in Here
  }

  @Override
  public void onPostExecutionView(SplitClient client) {
    //UI Code in Here
    String treatment = client.getTreatment("SPLIT_NAME");

    if (treatment.equals("on")) {
        // insert code here to show on treatment
    } else if (treatment.equals("off")) {
        // insert code here to show off treatment
    } else {
        // insert your control treatment code here
    }
  }

});

client.on(SplitEvent.SDK_READY_FROM_CACHE, object : SplitEventTask() {
    override fun onPostExecution(client: SplitClient) {
        // Execute background logic here
    }

    override fun onPostExecutionView(client: SplitClient) {
        // Execute logic in main thread here
        when (client.getTreatment("SPLIT_NAME")) {
            "on" -> {
                // insert code here to show on treatment
            }
            "off" -> {
                // insert code here to show off treatment
            }
            else -> {
                // insert your control treatment code here
            }
        }
    }
})

client.destroy();

client.destroy()

List<String> splitNames = Lists.newArrayList("SPLIT_NAME_1", "SPLIT_NAME_2");
Map<String, String> treatments = client.getTreatments(splitNames, null);

// Treatments will have the following form:
// {
//   "SPLIT_NAME_1": "on",
//   "SPLIT_NAME_2": "visa"
// }

val splitNames: List<String> = listOf("SPLIT_NAME_1", "SPLIT_NAME_2")
val treatments: Map<String, String> = client.getTreatments(splitNames, null)

// Treatments will have the following form:
// {
//   "SPLIT_NAME_1": "on",
//   "SPLIT_NAME_2": "visa"
// }

import java.util.Map;
import java.util.HashMap;
import java.util.Date;

Map<String, Object> attributes = new HashMap<String, Object>();
attributes.put("plan_type", "growth");
attributes.put("registered_date", System.currentTimeMillis());
attributes.put("deal_size", 1000);
attributes.put("paying_customer", true);
String[] perms = {"read", "write"};
attributes.put("permissions",perms);

// See client initialization above
String treatment = client.getTreatment("SPLIT_NAME", attributes);

if (treatment.equals("on")) {
    // insert on code here
} else if (treatment.equals("off")) {
    // insert off code here
} else {
    // insert control code here
}

val attributes = mapOf(
    "plan_type" to "growth",
    "registered_date" to System.currentTimeMillis(),
    "deal_size" to 1000,
    "paying_customer" to true,
    "permissions" to arrayOf("read", "write")
)

// See client initialization above
when (client.getTreatment("SPLIT_NAME", attributes)) {
    "on" -> {
        // insert on code here
    }
    "off" -> {
        // insert off code here
    }
    else -> {
        // insert control code here
    }
}

public interface AttributesManager {
    /**
    * Set one single attribute and returns true unless there is an issue storing it. 
    * If `persistentAttributesEnabled` config is enabled, the attribute is also written to the persistent cache.
    */
    boolean setAttribute(String attributeName, Object value);

    /**
    * Retrieves the value of a given attribute stored in cache.
    */
    @Nullable
    Object getAttribute(String attributeName);

    /**
     * Set multiple attributes and returns true unless there is an issue storing them. 
     * If `persistentAttributesEnabled` config is enabled, the attributes are also written to the persistent cache.
     */
    boolean setAttributes(Map<String, Object> attributes);

    /**
    * Retrieves a Map with the values of all attributes stored in cache.
    */
    @NonNull
    Map<String, Object> getAllAttributes();

    /**
     * Remove one single attribute and returns true unless there is an issue deleting it. 
     * If `persistentAttributesEnabled` config is enabled, the attribute is also deleted from the persistent cache and won't be available in a subsequent session.
     */
    boolean removeAttribute(String attributeName);

    /**
     * Clear the whole attribute cache and return true unless there is an issue with the operation and some attributes might still be cached. 
     * If `persistentAttributesEnabled` config is enabled, the attributes are also deleted from the persistent cache and won't be available in a subsequent session.
     */
    boolean clearAttributes();
}

interface AttributesManager {
    /**
     * Set one single attribute and returns true unless there is an issue storing it.
     * If `persistentAttributesEnabled` config is enabled, the attribute is also written to the persistent cache.
     */
    fun setAttribute(attributeName: String, value: Any): Boolean

    /**
     * Retrieves the value of a given attribute stored in cache.
     */
    fun getAttribute(attributeName: String): Any?

    /**
     * Set multiple attributes and returns true unless there is an issue storing them.
     * If `persistentAttributesEnabled` config is enabled, the attributes are also written to the persistent cache.
     */
    fun setAttributes(attributes: Map<String, Any>): Boolean

    /**
     * Retrieves a Map with the values of all attributes stored in cache.
     */
    fun getAllAttributes(): Map<String, Any>

    /**
     * Removes one single attribute and returns true unless there is an issue deleting it.
     * If `persistentAttributesEnabled` config is enabled, the attribute is also deleted from the persistent cache and won't be available in a subsequent session.
     */
    fun removeAttribute(attributeName: String): Boolean

    /**
     * Clears the whole attribute cache and returns true unless there is an issue with the operation and some attributes might still be cached.
     * If `persistentAttributesEnabled` config is enabled, the attributes are also deleted from the persistent cache and won't be available in a subsequent session.
     */
    fun clearAttributes(): Boolean
}

import java.util.Map;
import java.util.HashMap;
import java.util.Date;

  // Prepare a Map with several attributes
  Map<String, Object> attributes = new HashMap<String, Object>();
  attributes.put("plan_type", "growth");
  attributes.put("registered_date", System.currentTimeMillis());
  attributes.put("deal_size", 1000);
  // Now set these on the client
  client.setAttributes(attributes);

  // Set one attribute
  boolean result = client.setAttribute("plan_type", "growth");

  // Get an attribute
  Object planType = client.getAttribute("plan_type");

  // Get all attributes
  Map<String, Object> allAttributes = client.getAllAttributes();

  // Remove an attribute
  boolean result = client.removeAttribute("deal_size");

  // Remove all attributes
  boolean result = client.clearAttributes();

// Set multiple attributes
client.setAttributes(
    mapOf(
        "plan_type" to "growth",
        "registered_date" to System.currentTimeMillis(),
        "deal_size" to 1000
    )
)

// Set one attribute
val result = client.setAttribute("plan_type", "growth")

// Get an attribute
val planType = client.getAttribute("plan_type")

// Get all attributes
val allAttributes = client.allAttributes

// Remove an attribute
val result = client.removeAttribute("deal_size")

// Remove all attributes
val result = client.clearAttributes()

SplitResult result = cli.getTreatmentWithConfig("new_boxes", attributes);
Gson gson = new Gson();
Map map = gson.fromJson(result.config(), Map.class);
String treatment = result.treatment();

val result: SplitResult = client.getTreatmentWithConfig("new_boxes", attributes)
val config: String = result.config()
val treatment: String = result.treatment()

List<String> splitNames = Lists.newArrayList("SPLIT_NAME_1", "SPLIT_NAME_2");
Map<String, String> treatments = client.getTreatmentsWithConfig(splitNames, null);

// treatments will have the following form:
// {
//   "SPLIT_NAME_1": { "treatment": "on", "config": "{ \"color\":\"red\" }" },
//   "SPLIT_NAME_2": { "treatment": "visa", "config": "{ \"color\":\"red\" }" }
// }

val splitNames: List<String> = listOf("SPLIT_NAME_1", "SPLIT_NAME_2")
val treatments: Map<String, SplitResult> = client.getTreatmentsWithConfig(splitNames, null)

// treatments will have the following form:
// {
//   "SPLIT_NAME_1": { "treatment": "on", "config": "{ \"color\":\"red\" }" },
//   "SPLIT_NAME_2": { "treatment": "visa", "config": "{ \"color\":\"red\" }" }
// }

// Event without a value
boolean trackEvent = client.track("TRAFFIC_TYPE", "EVENT_TYPE");
// Example
boolean trackEvent = client.track("user", "page_load_time");

// Associate value to an event
boolean trackEvent = client.track("TRAFFIC_TYPE", "EVENT_TYPE", VALUE);
// Example  
boolean trackEvent = client.track("user", "page_load_time", 83.334);

// If you would like to send an event but you've already defined the traffic type in the config of the client
boolean trackEvent = client.track("EVENT_TYPE");
// Example
boolean trackEvent = client.track("page_load_time");

// If you would like to associate a value to an event and you've already defined the traffic type in the config of the client
boolean trackEvent = client.track("EVENT_TYPE", VALUE);
// Example  
boolean trackEvent = client.track("page_load_time", 83.334);

// If you would like to associate a value and properties to an event
boolean trackEvent = client.track("key", "TRAFFIC_TYPE", "EVENT_TYPE", VALUE, {PROPERTIES});
// Example  
HashMap<String, Object> properties = new HashMap<>();
properties.put("package", "premium");
properties.put("admin", true);
properties.put("discount", 50);

boolean trackEvent = client.track("john@doe.com", "user", "page_load_time", 83.334, properties);

// If you would like to associate just properties to an event
boolean trackEvent = client.track("key", "TRAFFIC_TYPE", "EVENT_TYPE", null, {PROPERTIES});
// Example  
HashMap<String, Object> properties = new HashMap<>();
properties.put("package", "premium");
properties.put("admin", true);
properties.put("discount", 50);

boolean trackEvent = client.track("john@doe.com", "user", "page_load_time", null, properties);

// Event without a value
val trackEvent = client.track("user", "page_load_time")

// Associate value to an event
val trackEvent = client.track("user", "page_load_time", 83.334)

// If you would like to send an event but you've already defined the traffic type in the config of the client
val trackEvent = client.track("page_load_time")

// If you would like to associate a value to an event and you've already defined the traffic type in the config of the client
val trackEvent = client.track("page_load_time", 83.334)

// If you would like to associate a value and properties to an event
val trackEvent = client.track(
    "john@doe.com",
    "user",
    "page_load_time",
    83.334,
    mapOf(
        "package" to "premium",
        "admin" to true,
        "discount" to 50
    )
)

// If you would like to associate just properties to an event
val trackEvent = client.track(
    "john@doe.com",
    "user",
    "page_load_time",
    null,
    mapOf(
        "package" to "premium",
        "admin" to true,
        "discount" to 50
    )
)

import io.split.android.client.*;
import java.util.Arrays;

SplitFilter splitFilter = SplitFilter.byName(Arrays.asList("SPLIT_NAME_1", "SPLIT_NAME_2"));

SplitClientConfig config = SplitClientConfig.builder()
                            .impressionsRefreshRate(60)
                            .connectionTimeout(15000)
                            .readTimeout(15000)
                            .syncConfig(SyncConfig.builder()
                                .addSplitFilter(splitFilter)
                                .build())
                            .build();

//API Key
String apikey = "YOUR_API_KEY";

// Create a new user key to be evaluated
String matching = "key";
String bucketingKey = null;
Key k = new Key(matchingKey,bucketingKey);

// Create factory
SplitFactory splitFactory = SplitFactoryBuilder.build(apikey, k, config, getApplicationContext());

// Get Split Client instance
SplitClient client = splitFactory.client();

val splitFilter: SplitFilter = SplitFilter.byName(listOf("SPLIT_NAME_1", "SPLIT_NAME_2"))

val config: SplitClientConfig = SplitClientConfig.builder()
    .impressionsRefreshRate(60)
    .connectionTimeout(15000)
    .readTimeout(15000)
    .syncConfig(
        SyncConfig.builder()
            .addSplitFilter(splitFilter)
            .build()
    )
    .build()

val splitFactory: SplitFactory = SplitFactoryBuilder
    .build(
        "api_key",
        Key("key"),
        config,
        applicationContext
    )

val client: SplitClient = splitFactory.client()

// Overwrites the initial consent status of the factory instance, which is 'GRANTED' by default.
// 'UNKNOWN' status represents that the user has neither granted nor declined consent for tracking data, 
// so the SDK will locally track data but not send it to Split cloud until consent is changed to 'GRANTED'.
SplitClientConfig config = SplitClientConfig.builder()
        .userConsent(UserConsent.UNKNOWN)
        .build();

try {
    SplitFactory factory = SplitFactoryBuilder.build("API_KEY_HERE",
            new Key(mUserKey, null),
            config, context);

    // Changed User Consent status to 'GRANTED'. Data will not be sent to Split cloud.
    factory.setUserConsent(true);
    // Changed User Consent status to 'DECLINED'. Data will not be sent to Split cloud.
    factory.setUserConsent(false);

    // The 'getUserConsent' method returns User Consent status.
    // We expose the constants for customer checks and tracking.
    if (factory.getUserConsent() == UserConsent.DECLINED) {
        Log.i(TAG, "USER CONSENT DECLINED");
    }
    if (factory.getUserConsent() == UserConsent.GRANTED) {
        Log.i(TAG, "USER CONSENT GRANTED");
    }
    if (factory.getUserConsent() == UserConsent.UNKNOWN) {
        Log.i(TAG, "USER CONSENT UNKNOWN");
    }

} catch (Exception e) {
}

# - feature_name:
#     treatment: "treatment_applied_to_this_entry"
#     keys: "single_key_or_list"
#     config: "{\"desc\" : \"this applies only to ON treatment\"}"

- my_feature:
    treatment: "on"
    keys: "key"
    config: "{\"desc\" : \"this applies only to ON treatment\"}"
- some_other_feature:
    treatment: "off"
- my_feature:
    treatment: "off"
- other_feature:
    treatment: "off"
    keys: ["key_1", "key_2"]
    config: "{\"desc\" : \"this overrides multiple keys and returns off treatment for those keys\"}"

import io.split.android.client.SplitClient;
import io.split.android.client.SplitFactoryBuilder;
import io.split.android.client.api.Key;

// Create a new user key to be evaluated
String matching = "key";
Key k = new Key(matchingKey);

SplitClient client = SplitFactoryBuilder.build("localhost", k, getApplicationContext()).client();

import io.split.android.client.SplitFactoryBuilder
import io.split.android.client.api.Key

// Create a new user key to be evaluated
val key = Key("key")

val client = SplitFactoryBuilder.build(
    "localhost",
    key,
    applicationContext
).client()

# this is a comment

# sdk.getTreatment(*, reporting_v2) will return 'on'
reporting_v2=on

double_writes_to_cassandra=off

new-navigation=v3

SplitFactory splitFactory = SplitFactoryBuilder.build("YOUR_API_KEY");
SplitManager manager = splitFactory.manager();

val splitFactory: SplitFactory = SplitFactoryBuilder.build(
    "api_key",
    Key("key"),
    applicationContext
)

val manager: SplitManager = splitFactory.manager()

/**
 * Retrieves the Splits that are currently registered with the
 * SDK.
 *
 * @return a List of SplitView or empty.
 */
List<SplitView> splits();

/**
 * Returns the Splits registered with the SDK of this name.
 *
 * @return SplitView or null
 */
SplitView split(String SplitName);

/**
 * Returns the names of features (or Splits) registered with the SDK.
 *
 * @return a List of String (Split Feature Names) or empty
 */
List<String> splitNames();

/**
 * Retrieves the Splits that are currently registered with the
 * SDK.
 *
 * @return a List of SplitView or empty.
 */
fun splits(): List<SplitView>

/**
 * Returns the Splits registered with the SDK of this name.
 *
 * @return SplitView or null
 */
fun split(SplitName: String): SplitView?

/**
 * Returns the names of features (or Splits) registered with the SDK.
 *
 * @return a List of String (Split Feature Names) or empty
 */
fun splitNames(): List<String>

public class SplitView {
    public String name;
    public String trafficType;
    public boolean killed;
    public List<String> treatments;
    public long changeNumber;
}

class SplitView(
    var name: String?,
    var trafficType: String?,
    var killed: Boolean,
    var treatments: List<String>?,
    var changeNumber: Long
)

SplitClientConfig config = SplitClientConfig.builder()
                        .impressionListener(new MyImpressionListener())
                        .build();

class MyImpressionListener implements ImpressionListener {
    @Override
    public void log(Impression impression) {
        // Do something on UI thread
        new Thread(new Runnable() {
            public void run() {
                // Do something in another thread (use this most of the time!)
            }
        }).start();
    }

    @Override
    public void close() {
    }
}

class MyImpressionListener : ImpressionListener {
    override fun log(impression: Impression) {
        // Do something on UI thread
        Thread {
            // Do something in another thread (use this most of the time!)
        }.start()
    }

    override fun close() {

    }
}

val config = SplitClientConfig.builder()
    .impressionListener(MyImpressionListener())
    .build()

    String key();
    String bucketingKey();
    String split();
    String treatment();
    Long time();
    String appliedRule();
    Long changeNumber();
    Map<String, Object> attributes();
    Long previousTime();

    key(): String?
    bucketingKey(): String?
    split(): String?
    treatment(): String?
    time(): Long?
    appliedRule(): String?
    changeNumber(): Long?
    attributes(): Map<String, Any?>?
    previousTime(): Long?

client.flush();

client.flush()

// Create factory
Key key = new Key("anonymous_user");
SplitClientConfig config = SplitClientConfig.builder().build();
SplitFactory splitFactory = SplitFactoryBuilder.build("yourAuthKey", key, config, getApplicationContext());

// Now when you call factory.client(), the SDK will create a client
// using the Key you passed in during the factory creation
SplitClient anonymousClient = splitFactory.client();

// To create another client for a user instead, just pass in a different Key or id
SplitClient userClient = splitFactory.client("user_id");

// Add events handler for each client to be notified when SDK is ready
anonymousClient.on(SplitEvent.SDK_READY, new SplitEventTask() {
    @Override
    public void onPostExecutionView(SplitClient client) {
        // Check treatment for account-permissioning and anonymousClient
        String accountPermissioningTreatment = anonymousClient.getTreatment("account-permissioning");
    }
});

userClient.on(SplitEvent.SDK_READY, new SplitEventTask() {
    @Override
    public void onPostExecutionView(SplitClient client) {
        // Check treatment for user-poll and userClient
        String userPollTreatment = userClient.getTreatment("user-poll");
    }
});

// Create factory
val key = Key("anonymous_user")
val config = SplitClientConfig.builder().build()
val splitFactory = SplitFactoryBuilder.build("yourAuthKey", key, config, getApplicationContext())

// Now when you call factory.client(), the SDK will create a client
// using the Key you passed in during the factory creation
val anonymousClient = splitFactory.client()

// To create another client for a user instead, just pass in a different Key or id
val userClient = splitFactory.client("user_id")

// Add events handler for each client to be notified when SDK is ready
anonymousClient.on(SplitEvent.SDK_READY, object : SplitEventTask() {
    override fun onPostExecutionView(client: SplitClient) {
        // Check treatment for account-permissioning and anonymousClient
        val accountPermissioningTreatment = anonymousClient.getTreatment("account-permissioning")
    }
})

userClient.on(SplitEvent.SDK_READY, object : SplitEventTask() {
    override fun onPostExecutionView(client: SplitClient) {
        // Check treatment for user-poll and userClient
        val userPollTreatment = userClient.getTreatment("user-poll")
    }
})

public class SplitEventTask {
    public void onPostExecution(SplitClient client) { }
    public void onPostExecutionView(SplitClient client) { }
}

open class SplitEventTask {

    open fun onPostExecution(client: SplitClient) {

    }

    open fun onPostExecutionView(client: SplitClient) {

    }
}

client.on(SplitEvent.SDK_READY, new SplitEventTask() {
  @Override
  public void onPostExecution(SplitClient client) {
    // Background Code in Here
  }

  @Override
  public void onPostExecutionView(SplitClient client) {
    // UI Code in Here
  }
});

// When definitions and any bound attributes were loaded from cache
client.on(SplitEvent.SDK_READY_FROM_CACHE, new SplitEventTask() {
  @Override
  public void onPostExecution(SplitClient client) {
    // Background Code in Here
  }

  @Override
  public void onPostExecutionView(SplitClient client) {
    // UI Code in Here
  }
});

// When the SDK couldn't fetch definitions before *config.ready* time
client.on(SplitEvent.SDK_READY_TIMED_OUT, new SplitEventTask() {
  @Override
  public void onPostExecution(SplitClient client) {
    // Background Code in Here
  }

  @Override
  public void onPostExecutionView(SplitClient client) {
    // UI Code in Here
  }
});

// When definitions have changed
client.on(SplitEvent.SDK_READY_UPDATE, new SplitEventTask() {
  @Override
  public void onPostExecution(SplitClient client) {
    // Background Code in Here
  }

  @Override
  public void onPostExecutionView(SplitClient client) {
    // UI Code in Here
  }
});

client.on(SplitEvent.SDK_READY, object : SplitEventTask() {
    override fun onPostExecution(client: SplitClient) {
        // Background Code in Here
    }

    override fun onPostExecutionView(client: SplitClient) {
        // UI Code in Here
    }
})

// When definitions were loaded from cache
client.on(SplitEvent.SDK_READY_FROM_CACHE, object : SplitEventTask() {
    override fun onPostExecution(client: SplitClient) {
        // Background Code in Here
    }

    override fun onPostExecutionView(client: SplitClient) {
        // UI Code in Here
    }
})

// When the SDK couldn't fetch definitions before *config.ready* time
client.on(SplitEvent.SDK_READY_TIMED_OUT, object : SplitEventTask() {
    override fun onPostExecution(client: SplitClient) {
        // Background Code in Here
    }

    override fun onPostExecutionView(client: SplitClient) {
        // UI Code in Here
    }
})

// When definitions have changed
client.on(SplitEvent.SDK_UPDATE, object : SplitEventTask() {
    override fun onPostExecution(client: SplitClient) {
        // Background Code in Here
    }

    override fun onPostExecutionView(client: SplitClient) {
        // UI Code in Here
    }
})