OptimizelyUserContext for the Android SDK

class OptimizelyUserContext(optimizely: Optimizely,
                            userId: String,
                            attributes: Map<String, Any?>?) {
    val userId: String
    val attributes: MutableMap<String?, Any?>

    // set an attribute for the user
    fun setAttribute(key: String, value: Any?)

    // make a decision about which flag variation the user buckets into for the flag key
    fun decide(key: String,
               options: List<OptimizelyDecideOption?>? = emptyList()): OptimizelyDecision

    // make decisions about which flag variations the user buckets into for flag keys
    fun decideForKeys(keys: List<String?>?,
                      options: List<OptimizelyDecideOption?>? = emptyList()): Map<String, OptimizelyDecision>

    // make decisions about which flag variations the user buckets into for all flags
    fun decideAll(options: List<OptimizelyDecideOption?>? = emptyList()): Map<String, OptimizelyDecision>

    // track user event
    fun trackEvent(eventName: String,
                   eventTags: Map<String?, *>? = emptyMap<String?, Any>())

    // sets a forced decision (variationKey) for a given decision context
    fun setForcedDecision(optimizelyDecisionContext: OptimizelyDecisionContext,
                          optimizelyForcedDecision: OptimizelyForcedDecision): Boolean

    // returns the forced decision (variationKey) for a given decision context
    fun getForcedDecision(optimizelyDecisionContext: OptimizelyDecisionContext): OptimizelyForcedDecision?

    // removes the forced decision (variationKey) for a given decision context
    fun removeForcedDecision(optimizelyDecisionContext: OptimizelyDecisionContext): Boolean

    // removes all the forced decisions (variationKeys) for the user context
    fun removeAllForcedDecisions(): Boolean
  
    //
    // The following methods require Real-Time Segments for Feature Experimentation enabled. 
    // See note below code sample. 
    //

    // An array of segment names that the user is qualified for. 
    // The result of **fetchQualifiedSegments()** will be saved here. 
    // Can be nil if not properly updated with fetchQualifiedSegments(). 
    // 
    //  You can read and write directly to the qualified segments array. 
    //  This allows for bypassing the remote fetching process from 
    //  Optimizely Data Platform or for utilizing your own fetching service.   
    val qualifiedSegments: MutableMap<String?, Any?>

    // Fetch all qualified segments for the user context. 
    ///
    /// The segments fetched will be saved in **qualifiedSegments** and can be accessed any time.
    /// On failure, **qualifiedSegments** will be nil and one of these errors will be returned:
    /// - OptimizelyError.invalidSegmentIdentifier
    /// - OptimizelyError.fetchSegmentsFailed(String)
    ///
    /// - Parameters:
    ///   - options: A set of options for fetching qualified segments (optional).
    ///   - completionHandler: A completion handler to be called with the fetch result. On success, it'll pass a non-nil segments array (can be empty) with a nil error. On failure, it'll pass a non-nil error with a nil segments array.
    fun fetchQualifiedSegments(options: [OptimizelySegmentOption] = [],
                                     completionHandler: ([String], OptimizelyError?) -> Void)


    //  Check is the user qualified for the given segment. 
    /// - Parameter segment: the segment name to check qualification for.
    /// - Returns: true if qualified.
    fun isQualifiedFor(segment: String) -> Bool
}

public class OptimizelyUserContext {
    public String getUserId()
    public Map<String, Object> getAttributes()

    public OptimizelyUserContext(Optimizely optimizely, 
                                 String userId, 
                                 Map<String, Object> attributes)
      
    // set an attribute for the user
    public void setAttribute(String key, Object value)
    
    // make a decision about which flag variation the user buckets into for the flag key
    public OptimizelyDecision decide(String key, 
                                     List<OptimizelyDecideOption> options)
    
    // make decisions about which flag variations the user buckets into for flag keys  
    public Map<String, OptimizelyDecision> decideForKeys(List<String> keys, 
                                      List<OptimizelyDecideOption> options)
    
    // make decisions about which flag variations the user buckets into for all flags  
    public Map<String, OptimizelyDecision> decideAll(List<OptimizelyDecideOption> options)
    
    // track user event  
    public void trackEvent(String eventName, Map<String, ?> eventTags)
  
    // sets a forced decision (variationKey) for a given decision context
    public Boolean setForcedDecision(OptimizelyDecisionContext context, OptimizelyForcedDecision decision)

    // returns the forced decision (variationKey) for a given decision context
    public OptimizelyForcedDecision getForcedDecision(OptimizelyDecisionContext context)

    // removes the forced decision (variationKey) for a given decision context
    public Boolean removeForcedDecision(OptimizelyDecisionContext context)

    // removes all the forced decisions (variationKeys) for the user context
    public Boolean removeAllForcedDecisions()
    
      //
    // The following methods require the Audience targeting with Optimizely Data Platform 
    // integration enabled. See note below code sample. 
    //

    // An array of segment names that the user is qualified for. 
    // The result of **fetchQualifiedSegments()** will be saved here. 
    // Can be nil if not properly updated with fetchQualifiedSegments(). 
    // 
    //  You can read and write directly to the qualified segments array. 
    //  This allows for bypassing the remote fetching process from ODP 
    //  or for utilizing your own fetching service.   
    public var qualifiedSegments: [String]? 

    // Fetch all qualified segments for the user context. 
    ///
    /// The segments fetched will be saved in **qualifiedSegments** and can be accessed any time.
    /// On failure, **qualifiedSegments** will be nil and one of these errors will be returned:
    /// - OptimizelyError.invalidSegmentIdentifier
    /// - OptimizelyError.fetchSegmentsFailed(String)
    ///
    /// - Parameters:
    ///   - options: A set of options for fetching qualified segments (optional).
    ///   - completionHandler: A completion handler to be called with the fetch result. On success, it'll pass a non-nil segments array (can be empty) with a nil error. On failure, it'll pass a non-nil error with a nil segments array.
    public func fetchQualifiedSegments(options: [OptimizelySegmentOption] = [],
                                     completionHandler: @escaping ([String]?, OptimizelyError?) -> Void)


    //  Check is the user qualified for the given segment. 
    /// - Parameter segment: the segment name to check qualification for.
    /// - Returns: true if qualified.
    public func isQualifiedFor(segment: String) -> Bool
    
}