Experiment Android SDK

Official documentation for Amplitude Experiment's Client-side Android SDK implementation.

Install¶

Add to the dependencies in your Android project's build.gradle file.

dependencies {
  implementation 'com.amplitude:experiment-android-client:<VERSION>'
}

public class MyApplication extends Application {

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

        // (1) Initialize the experiment client
        ExperimentConfig config = new ExperimentConfig();
        ExperimentClient client = Experiment.initialize(this, "<DEPLOYMENT_KEY>", config);

        // (2) Fetch variants for a user
        ExperimentUser user = ExperimentUser.builder()
            .userId("user@company.com")
            .deviceId("abcdefg")
            .userProperty("premium", true)
            .build();
        try {
            client.fetch(user).get();
        } catch (Exception e) {
            e.printStackTrace();
        }

        // (3) Lookup a flag's variant
        Variant variant = client.variant("<FLAG_KEY>");
        if (variant.is("on")) {
            // Flag is on
        } else {
            // Flag is off
        }
    }
}

class MyApplication : Application() {

    override fun onCreate() {
        super.onCreate()

        // (1) Initialize the experiment client
        val config = ExperimentConfig()
        val client = initialize(this, "<DEPLOYMENT_KEY>", config)

        // (2) Fetch variants for a user
        val user = builder()
            .userId("user@company.com")
            .deviceId("abcdefg")
            .userProperty("premium", true)
            .build()
        try {
            client.fetch(user).get()
        } catch (e: Exception) {
            e.printStackTrace()
        }

        // (3) Lookup a flag's variant
        val variant = client.variant("<FLAG_KEY>")
        if (variant.value == "on") {
            // Flag is on
        } else {
            // Flag is off
        }
    }
}

Core functions¶

The following functions make up the core of the Experiment client-side SDK.

Initialize¶

The SDK client should be initialized in your application on startup. The deployment key argument passed into the apiKey parameter must live within the same project that you are sending analytics events to.

fun initialize(application: Application, apiKey: String, config: ExperimentConfig)

The initializer returns a singleton instance, so subsequent initializations for the same instance name will always return the initial instance. To create multiple instances, use the instanceName configuration.

ExperimentClient experiment = Experiment.initialize(
    context, "<DEPLOYMENT_KEY>", new ExperimentConfig());

val experiment = Experiment.initialize(context, "<DEPLOYMENT_KEY>", ExperimentConfig())

Integrations¶

If you use either Amplitude or Segment Analytics SDKs to track events into Amplitude, you'll want to set up an integration on initialization. Integrations automatically implement provider interfaces to enable a more streamlined developer experience by making it easier to manage user identity and track exposures events.

Amplitude.getInstance().init("<API_KEY>");
ExperimentClient experiment = Experiment.initializeWithAmplitudeAnalytics(
    context, "<DEPLOYMENT_KEY>", new ExperimentConfig());

Amplitude.getInstance().init("<API_KEY>")
val experiment = Experiment.initializeWithAmplitudeAnalytics(
    context,
    "<DEPLOYMENT_KEY>",
    ExperimentConfig(),
)

class SegmentExposureTrackingProvider implements ExposureTrackingProvider {
    private Analytics analytics;
    public SegmentExposureTrackingProvider(Analytics analytics) {
        this.analytics = analytics;
    }
    @Override
    public void track(Exposure exposure) {
        analytics.track(
                "$exposure",
                new Properties()
                    .putValue("flag_key", exposure.flagKey)
                    .putValue("variant", exposure.variant));
    }
}

class SegmentExposureTrackingProvider(
    private val analytics: Analytics
): ExposureTrackingProvider {

    override fun track(exposure: Exposure) {
        analytics.track(
            "\$exposure",
            Properties()
                .putValue("flag_key", exposure.flagKey)
                .putValue("variant", exposure.variant),
        )
    }
}

Analytics analytics = // Initialize segment analytics
ExperimentConfig config = ExperimentConfig.builder()
    .exposureTrackingProvider(new SegmentExposureTrackingProvider(analytics))
    .build();
ExperimentClient experiment = Experiment.initialize(context, "<DEPLOYMENT_KEY>", config);

val analytics = // Initialize segment analytics
val config = ExperimentConfig.builder()
    .exposureTrackingProvider(SegmentExposureTrackingProvider(analytics))
    .build()
val experiment = Experiment.initialize(context, "<DEPLOYMENT_KEY>", config)

String userId = analytics.getAnalyticsContext().traits().userId();
String deviceId = analytics.getAnalyticsContext().traits().anonymousId();
try {
    ExperimentUser user = ExperimentUser.builder()
        .userId(userId)
        .deviceId(deviceId)
        .build();
    experiment.fetch(user).get();
} catch (Exception e) {
    e.printStackTrace();
}

val userId = analytics.analyticsContext.traits().userId()
val deviceId = analytics.analyticsContext.traits().anonymousId()
try {
    val user = ExperimentUser.builder()
        .userId(userId)
        .deviceId(deviceId)
        .build()
    experiment.fetch(user).get()
} catch (e: Exception) {
    e.printStackTrace()
}

Configuration¶

The SDK client can be configured once on initialization.

Fetch¶

Fetches variants for a user and store the results in the client for fast access. This function remote evaluates the user for flags associated with the deployment used to initialize the SDK client.

fun fetch(user: ExperimentUser? = null, options: FetchOptions? = null): Future<ExperimentClient>

Amplitude Experiment recommends calling fetch() during application start up so that the user gets the most up-to-date variants for the application session. Furthermore, you'll need to wait for the fetch request to return a result before rendering the user experience to avoid the interface "flickering".

try {
    ExperimentUser user = ExperimentUser.builder()
        .userId("user@company.com")
        .userProperty("premium", true)
        .build();
    experiment.fetch(user).get();
} catch (Exception e) {
    e.printStackTrace();
}

try {
    val user = ExperimentUser.builder()
        .userId("user@company.com")
        .userProperty("premium", true)
        .build()
    experiment.fetch(user).get()
} catch (e: Exception) {
    e.printStackTrace()
}

If you're using an integration or a custom user provider then you can fetch without inputting the user.

experiment.fetch(null);

experiment.fetch()

Variant¶

Access a variant for a flag or experiment from the SDK client's local store.

fun variant(key: String, fallback: Variant? = null): Variant

When determining which variant a user has been bucketed into, you'll want to compare the variant value to a well-known string.

Variant variant = client.variant("<FLAG_KEY>");
if (variant.is("on")) {
    // Flag is on
} else {
    // Flag is off
}

Variant variant = client.variant("<FLAG_KEY>");
if (variant.value == "on") {
    // Flag is on
} else {
    // Flag is off
}

Variant variant = experiment.variant("<FLAG_KEY>");
if (variant.is("on") && variant.payload != null) {
    try {
        String value = ((JSONObject) variant.payload).getString("key");
    } catch (Exception e) {
        e.printStackTrace();
    }
}

val variant = experiment.variant("<FLAG_KEY>")
if (variant.value == "on") {
    try {
        val value = (variant.payload as JSONObject).getString("key")
    } catch (e: Exception) {
        e.printStackTrace()
    }
}

A null variant value means that the user hasn't been bucketed into a variant. You may use the built in fallback parameter to provide a variant to return if the store doesn't contain a variant for the given flag key.

Variant variant = experiment.variant("<FLAG_KEY>", new Variant("control"));
if (variant.is("control")) {
    // Control
} else if (variant.is("treatment")) {
    // Treatment
}

val variant = experiment.variant("<FLAG_KEY>", Variant("control"))
if (variant.value == "control") {
    // Control
} else if (variant.value == "treatment") {
    // Treatment
}

All¶

Access all variants stored by the SDK client.

fun all(): Map<String, Variant>

Clear¶

Clear all variants in the cache and storage.

fun clear()

You can call clear after user logout to clear the variants in cache and storage.

experiment.clear();

experiment.clear()

Exposure¶

Manually track an exposure event for the current variant of the given flag key through configured integration or custom exposure tracking provider. Generally used in conjunction with setting the automaticExposureTracking configuration optional to false.

fun exposure(key: String)

Variant variant = experiment.variant("<FLAG_KEY>");

// Do other things...

experiment.exposure("<FLAG_KEY>");
if (variant.is("control")) {
    // Control
} else if (variant.is("treatment")) {
    // Treatment
}

val variant = experiment.variant("<FLAG_KEY>")

// Do other things...

experiment.exposure("<FLAG_KEY>")
if (variant.value == "control") {
    // Control
} else if (variant.value == "treatment") {
    // Treatment
}

Providers¶

Provider implementations enable a more streamlined developer experience by making it easier to manage user identity and track exposures events.

User provider¶

The user provider is used by the SDK client to access the most up-to-date user information only when it's needed (for example, when fetch() is called). This provider is optional, but helps if you have a user information store already set up in your application. This way, you don't need to manage two separate user info stores in parallel, which may result in a divergent user state if the application user store is updated and experiment isn't (or vice versa).

interface ExperimentUserProvider {
    fun getUser(): ExperimentUser
}

To use your custom user provider, set the userProvider configuration option with an instance of your custom implementation on SDK initialization.

ExperimentConfig config = ExperimentConfig.builder()
    .userProvider(new CustomUserProvider())
    .build();
ExperimentClient experiment = Experiment.initialize(
    context, "<DEPLOYMENT_KEY>", config);

val config = ExperimentConfig.builder()
    .userProvider(CustomUserProvider())
    .build()
val experiment = Experiment.initialize(context, "<DEPLOYMENT_KEY>", config)

Exposure tracking provider¶

Implementing an exposure tracking provider is highly recommended. Exposure tracking increases the accuracy and reliability of experiment results and improves visibility into which flags and experiments a user is exposed to.

interface ExposureTrackingProvider {
    fun track(exposure: Exposure)
}

The implementation of track() should track an event of type $exposure (a.k.a name) with two event properties, flag_key and variant, corresponding to the two fields on the Exposure object argument. Finally, the event tracked must eventually end up in Amplitude Analytics for the same project that the [deployment] used to initialize the SDK client lives within, and for the same user that variants were fetched for.

To use your custom user provider, set the exposureTrackingProvider configuration option with an instance of your custom implementation on SDK initialization.

ExperimentConfig config = ExperimentConfig.builder()
    .exposureTrackingProvider(new CustomExposureTrackingProvider())
    .build();
ExperimentClient experiment = Experiment.initialize(
    context, "<DEPLOYMENT_KEY>", config);

val config = ExperimentConfig.builder()
    .exposureTrackingProvider(CustomExposureTrackingProvider())
    .build()
val experiment = Experiment.initialize(context, "<DEPLOYMENT_KEY>", config)