Android Suite

implementation 'io.split.client:android-suite:1.2.1'

// Split SDK key
String sdkKey = "YOUR_SDK_KEY";

// Build Suite configuration by default
SplitSuiteConfiguration config = SplitSuiteConfiguration.builder().build();

// Create a new user key to be evaluated
// key represents your internal user id, or the account id that 
// the user belongs to
String matchingKey = "key";
Key k = new Key(matchingKey);

// Create Suite
SplitSuite suite = SplitSuiteBuilder.build(sdkKey, k, config, getApplicationContext());

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

// Split SDK key
val sdkKey = "YOUR_SDK_KEY"

// Build Suite configuration by default
val config: SplitSuiteConfiguration = SplitSuiteConfiguration.builder().build()

// Create a new user key to be evaluated
// key represents your internal user id, or the account id that 
// the user belongs to
val matchingKey = "key"
val key: Key = Key(matchingKey)

// Create Suite
val splitFactory: SplitSuite =
    SplitSuiteBuilder.build(sdkKey, 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("FEATURE_FLAG_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, object : SplitEventTask() {

    override fun onPostExecution(client: SplitClient) {
        // Logic in background here
    }

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

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("FEATURE_FLAG_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("FEATURE_FLAG_NAME", attributes)) {
    "on" -> {
        // insert on code here
    }
    "off" -> {
        // insert off code here
    }
    else -> {
        // insert control code here
    }
}

// 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()

// Getting treatments by feature flag names
List<String> featureFlagNames = Lists.newArrayList("FEATURE_FLAG_NAME_1", "FEATURE_FLAG_NAME_2");
Map<String, String> treatments = client.getTreatments(featureFlagNames, null);

// Getting treatments by set
Map<String, String> treatmentsByFlagSet = client.getTreatmentsByFlagSet("frontend", null);

// Getting treatments for the union of multiple sets
List<String> flagSets = Lists.newArrayList("frontend", "client_side");
Map<String, String> treatmentsByFlagSets = client.getTreatmentsByFlagSets(flagSets);

// Treatments will have the following form:
// {
//   "FEATURE_FLAG_NAME_1": "on",
//   "FEATURE_FLAG_NAME_2": "visa"
// }

// Getting treatments by feature flag names
val featureFlagNames: List<String> = listOf("FEATURE_FLAG_NAME_1", "FEATURE_FLAG_NAME_2")
val treatments: Map<String, String> = client.getTreatments(featureFlagNames, null)

// Getting treatments by set
val treatmentsByFlagSet = client.getTreatmentsByFlagSet("frontend", null)

// Getting treatments for the union of multiple sets
val flagSets = listOf("frontend", "client_side")
val treatmentsByFlagSets = client.getTreatmentsByFlagSets(flagSets)

// Treatments have the following form:
// {
//   "FEATURE_FLAG_NAME_1": "on",
//   "FEATURE_FLAG_NAME_2": "visa"
// }

SplitResult result = client.getTreatmentWithConfig("new_boxes", attributes);

String config = result.config();
String treatment = result.treatment();

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

val config: String = result.config()
val treatment: String = result.treatment()

SplitResult treatmentResult = client.getTreatmentWithConfig("FEATURE_FLAG_NAME", attributes);
String configs = treatmentResult.config();
String treatment = treatmentResult.treatment();

if (treatment.equals("on")) {
  // insert on code here and use configs here as necessary
} else if (treatment.equals("off")) {
  // insert off code here and use configs here as necessary
} else {
  // insert control code here
}

val treatmentResult: SplitResult = client.getTreatmentWithConfig("FEATURE_FLAG_NAME", attributes)
val configs: String? = treatmentResult.config()
val treatment: String = treatmentResult.treatment()

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

// Getting treatments by feature flag names
List<String> featureFlagNames = Lists.newArrayList("FEATURE_FLAG_NAME_1", "FEATURE_FLAG_NAME_2");
Map<String, String> treatments = client.getTreatments(featureFlagNames, null);

// Getting treatments by set
Map<String, String> treatmentsByFlagSet = client.getTreatmentsByFlagSet("frontend", null);

// Getting treatments for the union of multiple sets
List<String> flagSets = Lists.newArrayList("frontend", "client_side");
Map<String, String> treatmentsByFlagSets = client.getTreatmentsByFlagSets(flagSets);

// Treatments will have the following form:
// {
//   "FEATURE_FLAG_NAME_1": "on",
//   "FEATURE_FLAG_NAME_2": "visa"
// }

// Getting treatments by feature flag names
val featureFlagNames: List<String> = listOf("FEATURE_FLAG_NAME_1", "FEATURE_FLAG_NAME_2")
val treatments: Map<String, String> = client.getTreatments(featureFlagNames, null)

// Getting treatments by set
val treatmentsByFlagSet = client.getTreatmentsByFlagSet("frontend", null)

// Getting treatments for the union of multiple sets
val flagSets = listOf("frontend", "client_side")
val treatmentsByFlagSets = client.getTreatmentsByFlagSets(flagSets)

// Treatments have the following form:
// {
//   "FEATURE_FLAG_NAME_1": "on",
//   "FEATURE_FLAG_NAME_2": "visa"
// }

SplitClient client = suite.client();

// The expected parameters are:
client.track(TRAFFIC_TYPE, EVENT_TYPE, eventValue, eventProperties);

// Example with both a value and properties
Map<String, Object> properties = new HashMap<>();
properties.put("package", "premium");
properties.put("admin", true);
properties.put("discount", 50);
client.track("user", "screen_load_time", 83.334, properties);

// Example with only properties
Map<String, Object> properties = new HashMap<>();
properties.put("package", "premium");
properties.put("admin", true);
properties.put("discount", 50L);
client.track("user", "screen_load_time", properties);

val client = suite.client()

// The expected parameters are:
client.track(TRAFFIC_TYPE, EVENT_TYPE, eventValue, eventProperties)

// Example with both a value and properties
val properties = mapOf(
  "package" to "premium",
  "admin" to true,
  "discount" to 50L
)
client.track("user", "screen_load_time", 83.334, properties)

// Example with only properties
val properties = mapOf(
  "package" to "premium",
  "admin" to true,
  "discount" to 50L
)
client.track("user", "screen_load_time", properties)

// The expected parameters are:
suite.track('EVENT_TYPE', eventValue, eventProperties);

// Example with both a value and properties
Map<String, Object> properties = new HashMap();
properties.put("package", "premium");
properties.put("admin", true);
properties.put("discount", 50L);
suite.track("screen_ad_time", 83.334, properties);

// Example with only properties
Map<String, Object> properties = new HashMap();
properties.put("package", "premium");
properties.put("admin", true);
properties.put("discount", 50L);
suite.track("screen_load_time", null, properties);

// The expected parameters are:
suite.track('EVENT_TYPE', eventValue, eventProperties)

// Example with both a value and properties
val properties = mapOf(
  "package" to "premium",
  "admin" to true,
  "discount" to 50L
)
suite.track("screen_ad_time", 83.334, properties)

// Example with only properties
val properties = mapOf(
  "package" to "premium",
  "admin" to true,
  "discount" to 50L
)
suite.track("screen_load_time", null, properties);

suite.destroy();

suite.destroy()

SplitSuite suite = SplitSuiteBuilder.build(
    sdkKey,
    new Key("user_id"),
    SplitClientConfig
        .builder()
        .featuresRefreshRate(30)
        .segmentsRefreshRate(30)
        .impressionsRefreshRate(30)
        .impressionsQueueSize(30000)
        .eventFlushInterval(60)
        .eventsQueueSize(500)
        .telemetryRefreshRate(3600)
        .logLevel(SplitLogLevel.VERBOSE)
        .build(),
    applicationContext);

val suite: SplitSuite = SplitSuiteBuilder.build(
    sdkKey,
    Key("user_id"),
    SplitClientConfig
        .builder()
        .featuresRefreshRate(30)
        .segmentsRefreshRate(30)
        .impressionsRefreshRate(30)
        .impressionsQueueSize(30000)
        .eventFlushInterval(60)
        .eventsQueueSize(500)
        .telemetryRefreshRate(3600)
        .logLevel(SplitLogLevel.VERBOSE)
        .build(),
    applicationContext)

# - 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 matchingKey = "key";
Key key = new Key(matchingKey);

SplitClient client = SplitSuiteBuilder.build("localhost", key, 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 = SplitSuiteBuilder.build(
    "localhost",
    key,
    applicationContext
).client()

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 feature flags that are currently registered with the
 * Suite.
 *
 * @return a List of SplitView or empty.
 */
List<SplitView> splits();

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

/**
 * Returns the names of feature flags registered with the Suite.
 *
 * @return a List of String (Split feature names) or empty
 */
List<String> splitNames();

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

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

/**
 * Returns the names of features flags registered with the Suite.
 *
 * @return a List of String (feature flag 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;
    public Map<String, String> configs;
    public String defaultTreatment;
    public List<String> sets;
}

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

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()

// This setting type is `SplitLogLevel`. 
// The available values are DEBUG, INFO, WARNING, ERROR, ASSERT and NONE
SplitClientConfig.Builder builder = SplitClientConfig.builder()
    .logLevel(SplitLogLevel.VERBOSE)
SplitClientConfig config = builder.build();

  ...

// Create factory
Key key = new Key("anonymous_user");
SplitClientConfig config = SplitClientConfig.builder().build();
SplitSuite suite = SplitSuiteBuilder.build("yourAuthKey", key, config, getApplicationContext());
// Now when you call suite.client(), the Suite will create a client
// using the Key you passed in during the factory creation
SplitClient anonymousClient = suite.client();
// To create another client for a user instead, just pass in a different Key or id
SplitClient userClient = suite.client("user_id");
// Add events handler for each client to be notified when Suite 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 suite = SplitSuiteBuilder.build("yourAuthKey", key, config, getApplicationContext())
// Now when you call suite.client(), the Suite will create a client
// using the Key you passed in during the factory creation
val anonymousClient = suite.client()
// To create another client for a user instead, just pass in a different Key or id
val userClient = suite.client("user_id")
// Add events handler for each client to be notified when Suite 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 Suite 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 Suite 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
    }
})

// Overwrites the initial consent status of the Suite instance, which is 'GRANTED' by default.
// 'UNKNOWN' status represents that the user has neither granted nor declined consent for tracking data, 
// so the Suite locally tracks data but not send it to Split cloud until consent is changed to 'GRANTED'.
SplitClientConfig config = SplitClientConfig.builder()
    .userConsent(UserConsent.UNKNOWN)
    .build();
SplitSuite suite = SplitSuiteBuilder.build("YOUR_SDK_KEY",
        new Key(mUserKey, null),
        config, context);
// Changed User Consent status to 'GRANTED'. Data is sent to Split cloud.
suite.setUserConsent(true);
// Changed User Consent status to 'DECLINED'. Data is not sent to Split cloud.
suite.setUserConsent(false);
// The 'getUserConsent' method returns User Consent status.
// We expose the constants for customer checks and tracking.
if (suite.getUserConsent() == UserConsent.DECLINED) {
    Log.i(TAG, "USER CONSENT DECLINED");
} else if (suite.getUserConsent() == UserConsent.GRANTED) {
    Log.i(TAG, "USER CONSENT GRANTED");
} else if (suite.getUserConsent() == UserConsent.UNKNOWN) {
    Log.i(TAG, "USER CONSENT UNKNOWN");
}

// Overwrites the initial consent status of the Suite instance, which is 'GRANTED' by default.
// 'UNKNOWN' status represents that the user has neither granted nor declined consent for tracking data, 
// so the Suite locally tracks data but not send it to Split cloud until consent is changed to 'GRANTED'.
val config: SplitClientConfig = SplitClientConfig.builder()
    .userConsent(UserConsent.UNKNOWN)
    .build()
val suite: SplitSuite = SplitSuiteBuilder.build("YOUR_SDK_KEY",
        Key(mUserKey, null),
        config, context)
// Changed User Consent status to 'GRANTED'. Data is sent to Split cloud.
suite.setUserConsent(true)
// Changed User Consent status to 'DECLINED'. Data is not sent to Split cloud.
suite.setUserConsent(false)
// The 'getUserConsent' method returns User Consent status.
// We expose the constants for customer checks and tracking.
if (suite.getUserConsent() == UserConsent.DECLINED) {
    Log.i(TAG, "USER CONSENT DECLINED")
} else if (suite.getUserConsent() == UserConsent.GRANTED) {
    Log.i(TAG, "USER CONSENT GRANTED")
} else if (suite.getUserConsent() == UserConsent.UNKNOWN) {
    Log.i(TAG, "USER CONSENT UNKNOWN")
}

// Optionally create feature flagging configuration
SplitClientConfig splitClientConfig = SplitClientConfig
    .builder()
    .logLevel(SplitLogLevel.VERBOSE)
    .build();

// Create a SplitSuiteConfiguration builder
SplitSuiteConfigurationBuilder suiteConfigurationBuilder = SplitSuiteConfiguration.builder();

// Specify a prefix for the Suite events
suiteConfigurationBuilder = suiteConfigurationBuilder.setPrefix("myprefix_");

// Create the SplitSuiteConfiguration, passing the optional SplitClientConfig for feature flagging
SplitSuiteConfiguration splitSuiteConfiguration = suiteConfigurationBuilder
    .build(splitClientConfig);

// Instantiate the Suite passing in the SplitSuiteConfiguration
SplitSuite suite = SplitSuiteBuilder.build(
    "YOUR_SDK_KEY",
    new Key("key1"),
    splitSuiteConfiguration,
    applicationContext);

// Optionally create feature flagging configuration
val splitClientConfig: SplitClientConfig = SplitClientConfig
    .builder()
    .logLevel(SplitLogLevel.VERBOSE)
    .build()

// Create a SplitSuiteConfiguration builder
var suiteConfigurationBuilder = SplitSuiteConfiguration.builder()

// Specify a prefix for the Suite events
suiteConfigurationBuilder = suiteConfigurationBuilder.setPrefix("myprefix_")

// Create the SplitSuiteConfiguration, passing the optional SplitClientConfig for feature flagging
val splitSuiteConfiguration: SplitSuiteConfiguration = suiteConfigurationBuilder
    .build(splitClientConfig)

// Instantiate the Suite passing in the SplitSuiteConfiguration
val suite: SplitSuite = SplitSuiteBuilder.build(
    "YOUR_SDK_KEY",
    Key("key1"),
    splitSuiteConfiguration,
    applicationContext
)