Decide methods for the Android SDK

// set global default decide options when initializing the client

var options: List<OptimizelyDecideOption>
options = Arrays.asList(OptimizelyDecideOption.DISABLE_DECISION_EVENT)
val optimizelyManager = OptimizelyManager.builder()
        .withSDKKey("<YOUR_SDK_KEY>")
        .withDefaultDecideOptions(options)
        .build(context)

// set additional options in a decide call

val optimizelyClient = optimizelyManager.initialize(context, R.raw.datafile)
val user = optimizelyClient.createUserContext("user123")
options = Arrays.asList(OptimizelyDecideOption.DISABLE_DECISION_EVENT, 
                        OptimizelyDecideOption.DISABLE_DECISION_EVENT)
val decisions = user!!.decideAll(options)

// set global default decide options when initializing the client

List<OptimizelyDecideOption> options;
options = Arrays.asList(OptimizelyDecideOption.DISABLE_DECISION_EVENT);
OptimizelyManager optimizelyManager = OptimizelyManager.builder()
      .withSDKKey("<YOUR_SDK_KEY>")
      .withDefaultDecideOptions(options)
      .build(context);

// set additional options in a decide call

OptimizelyClient optimizelyClient = optimizelyManager.initialize(context, R.raw.datafile);
OptimizelyUserContext user = optimizelyClient.createUserContext("user123");
options = Arrays.asList(OptimizelyDecideOption.DISABLE_DECISION_EVENT, 
                        OptimizelyDecideOption.DISABLE_DECISION_EVENT);
Map<String, OptimizelyDecision> decisions = user.decideAll(options);

// create the user and decide which flag rule & variation they bucket into
val attributes: MutableMap<String, Any> = HashMap()
attributes["logged_in"] = true
val user = optimizelyClient.createUserContext("user123", attributes)
val decision = user!!.decide("product_sort")

// variation. if null, decision fail with a critical error
val variationKey = decision.variationKey

// flag enabled state:
val enabled = decision.enabled

// all variable values
val variables = decision.variables

// String variable value
var vs: String? = null
try {
    vs = variables.getValue("sort_method", String::class.java)
} catch (e: JsonParseException) {
    e.printStackTrace()
}

// Boolean variable value
val vb = variables.toMap()!!["k_boolean"] as Boolean?

// flag key for which decision was made
val flagKey = decision.flagKey

// user for which the decision was made
val userContext = decision.userContext

// reasons for the decision
val reasons = decision.reasons

// create the user and decide which flag rule & variation they bucket into  

Map<String, Object> attributes = new HashMap<>();
attributes.put("logged_in", true);
OptimizelyUserContext user = optimizelyClient.createUserContext("user123", attributes);

OptimizelyDecision decision = user.decide("product_sort");

// variation. if null, decision fail with a critical error
String variationKey = decision.getVariationKey();

// flag enabled state:
boolean enabled = decision.getEnabled();

// all variable values
OptimizelyJSON variables = decision.getVariables();

// String variable value
String vs = null;
try {
	vs = variables.getValue("sort_method", String.class);
} catch (JsonParseException e) {
  e.printStackTrace();
}

// Boolean variable value
Boolean vb = (Boolean) variables.toMap().get("k_boolean");

// flag key for which decision was made
String flagKey = decision.getFlagKey();

// user for which the decision was made
OptimizelyUserContext userContext = decision.getUserContext();
   
// reasons for the decision
List<String> reasons = decision.getReasons();

// make decisions for all active (unarchived) flags in the project for a user
val options = Arrays.asList(OptimizelyDecideOption.ENABLED_FLAGS_ONLY)
val decisions = user!!.decideAll(options)
val allKeys: Set<String> = decisions.keys
val decisionForFlag1 = decisions["flag_1"]

// make decisions for all active (unarchived) flags in the project for a user
List<OptimizelyDecideOption> options = Arrays.asList(OptimizelyDecideOption.ENABLED_FLAGS_ONLY);
Map<String, OptimizelyDecision> decisions = user.decideAll(options);

Set<String> allKeys = decisions.keySet();
OptimizelyDecision decisionForFlag1 = decisions.get("flag_1");

// make decisions for specific flags
val keys = Arrays.asList("flag-1", "flag-2")
val decisions = user!!.decideForKeys(keys)
val decision1 = decisions["flag-1"]
val decision2 = decisions["flag-2"]

// make decisions for specific flags
List<String> keys = Arrays.asList("flag-1", "flag-2");
Map<String, OptimizelyDecision> decisions = user.decideForKeys(keys);
        
OptimizelyDecision decision1 = decisions.get("flag-1");
OptimizelyDecision decision2 = decisions.get("flag-2");