Flutter SDK

kameleoon_client_flutter: ^3.0.0

import 'package:kameleoon_client_flutter/kameleoon_client_flutter.dart';

class _HomePage extends State<HomePage> {
    KameleoonClient kameleoonClient

    @override
    void initState() {
            super.initState();

            try {
                // pass client configuration and visitorCode as arguments
                final config = KameleoonClientConfig(
                    refreshIntervalMinutes: 15, // 60 minutes by default, optional
                    defaultTimeoutMilliseconds: 10000,  // 10_000 milliseconds by default, optional
                    dataExpirationIntervalMinutes: 1440 * 365, // infinity by default, optional
                    trackingIntervalMilliseconds: 500, // 1000 milliseconds by default, optional
                    environment: "staging",  // optional
                    isUniqueIdentifier: false, // false by default, optional
                    domain: "example.com", // web only option, optional
                    networkDomain: "company.com", //  web only option, optional
                    defaultDataFile: "{...}" // optional
                );

                final visitorCode = "yourVisitorCode";
                final kameleoonClient = KameleoonClientFactory.create(siteCode, visitorCode: visitorCode, config: config);
                // or, if you want, visitor code will be generated automatically
                final kameleoonClient = KameleoonClientFactory.create(siteCode, config: config);
            } on SiteCodeIsEmpty catch (ex) {
                // Exception indicates that the provided siteCode is empty
            } on VisitorCodeInvalid catch (ex) {
                // Exception indicates that the provided visitorCode is invalid
            } on Exception catch (ex) {
                // Any other error
            }
    }
}

try {
    await kameleoonClient.addData(CustomData.withIndex(index, values: ["newVisitorCode"]))
} on KameleoonException {
    // Generic exception in native plugin integration occurred.
}

// The `none` log level does not allow logging.
KameleoonLogger.setLogLevel(LogLevel.none);

// The `error` log level only allows logging issues that may affect the SDK's main behaviour.
KameleoonLogger.setLogLevel(LogLevel.error);

// The `warning` log level allows logging issues which may require additional attention.
// It extends the `error` log level.
// The `warning` log level is a default log level.
KameleoonLogger.setLogLevel(LogLevel.warning);

// The `info` log level allows logging general information on the SDK's internal processes.
// It extends the `warning` log level.
KameleoonLogger.setLogLevel(LogLevel.info);

// The `DEBUG` level logs additional details about the SDK’s internal processes and extends the `INFO` level
// with more granular. diagnostic output.
// This information is not intended for end-user interpretation but can be sent to support
// to assist with internal troubleshooting.
KameleoonLogger.setLogLevel(LogLevel.debug);

import 'package:logging/logging.dart' as logging;

class CustomLogger extends Logger {
  final logger = logging.Logger("CustomLogger");
  // `log` method accepts logs from the SDK
  @override
  void log(LogLevel level, String message) {
    // Custom log handling logic here. For example:
    switch (level) {
      case LogLevel.error:
        logger.severe(message);
        break;
      case LogLevel.warning:
        logger.warning(message);
        break;
      case LogLevel.info:
        logger.info(message);
        break;
      case LogLevel.debug:
        logger.fine(message);
        break;
      default:
        break;
    }
  }
}

// Log level filtering is applied separately from log handling logic.
// The custom logger will only accept logs that meet or exceed the specified log level.
// Ensure the log level is set correctly.
KameleoonLogger.setLogLevel(LogLevel.debug); // Optional, defaults to `LogLevel.warning`.
KameleoonLogger.setLogger(CustomLogger());

try {
    // Calling a method of the SDK
} on KameleoonException {
    // Handling expected exceptions
} on Exception {
    // Any other error
}

import 'package:kameleoon_client_flutter/kameleoon_client_flutter.dart'


final siteCode = "a8st4f59bj";
try {
    // pass client configuration and visitorCode as arguments
    final config = KameleoonClientConfig(
      refreshIntervalMinutes: 15, // 60 minutes by default, optional
      defaultTimeoutMilliseconds: 10000, // 10_000 milliseconds by default, optional
      dataExpirationIntervalMinutes: 1440 * 365, // infinity by default, optional
      trackingIntervalMilliseconds: 500, // 1000 milliseconds by default, optional
      environment: "staging",  // optional
      isUniqueIdentifier: false, // false by default, optional
      domain: "example.com" // web only option, optional
      networkDomain: "company.com", //  web only option, optional
      defaultDataFile: "{...}" // optional
    );
    final visitorCode = "yourVisitorCode";
    final kameleoonClient = KameleoonClientFactory.create(siteCode, visitorCode: visitorCode, config: config);
} on SiteCodeIsEmpty catch (ex) {
     // Exception indicates that the provided siteCode is empty
} on VisitorCodeInvalid catch (ex) {
    // Exception indicates that the provided visitorCode is invalid
} on Exception catch (ex) {
    // Any other error
}

try {
    // generate visitorCode automatically and use default Kameleoon client config
    final kameleoonClient = KameleoonClientFactory.create(siteCode);
} on SiteCodeIsEmpty catch (ex) {
     // Exception indicates that the provided siteCode is empty
} on Exception catch (ex) {
    // Any other error
}

final ready = kameleoonClient.isReadyAsync();

kameleoonClient.runWhenReady((ready) async {
    final defaultProductsNumber = 5;
    if (ready) {
        late int recommendedProductsNumber;
        try {
            recommendedProductsNumber = await kameleoonClient.getFeatureVariable("feature_key", "product_number");
        } on Exception {
            recommendedProductsNumber = defaultProductsNumber;
        }
    } else {
        recommendedProductsNumber = defaultProductsNumber;
    }

    setState(() {
        _recommendedProductsNumber = recommendedProductsNumber;
    });
}, 2000);

String featureKey = "new_checkout";
bool hasNewCheckout = false;

try {
  hasNewCheckout = await kameleoonClient.isFeatureActive(featureKey);
} on SDKNotReady {
  // Exception indicates that the SDK has not completed its initialization yet.
} on FeatureNotFound {
  // The error has occurred; feature flag isn't found in current configuration.
} on KameleoonException {
  // Generic exception in native plugin integration occurred.
} on Exception {
  // Any other error
}
if (hasNewCheckout) {
  // Implement new checkout code here
}

final String featureKey = "featureKey";
Variation? variation;
try {
    variation = await client.getVariation(featureKey);
    // disabling tracking
    variation = await client.getVariation(featureKey, track: false);
} on SDKNotReady {
    // Exception indicating that the SDK has not completed its initialization yet.
} on FeatureNotFound {
    // The feature key is not in the configuration file that has been fetched by the SDK.
} on FeatureEnvironmentDisabled {
    // The feature flag is disabled for the environment.
}

String? title = variation?.variables['title']?.value;

switch (variation?.key) {
    case "on":
        // Main variation key is selected for visitorCode
        break;
    case "alternative_variation":
        // Alternative variation key
        break;
    default:
        // Default variation key
        break;
}

try {
    Map<String, Variation> variations = await kameleoonClient.getVariations();
    // only active variations
    Map<String, Variation> variations = await kameleoonClient.getVariations(onlyActive: true);
    // disable tracking
    Map<String, Variation> variations = await kameleoonClient.getVariations(onlyActive: false, track: false);
} on SDKNotReady {
    // Exception indicating that the SDK has not completed its initialization yet.
}

try {
    final allFeatureFlagKeys = await kameleoonClient.getFeatureList();
} on KameleoonException {
    // Generic exception in native plugin integration occurred.
}

try {
    final dataFile = await kameleoonClient.getDataFile();
    final dateModified = dataFile.dateModified;
} on KameleoonException {
    // Generic exception in native plugin integration occurred.
}

final experimentId = 9516;
try {
    // Forcing the variation "on" for the experiment 9516 for the visitor
    await kameleoonClient.setForcedVariation(experimentId, "on")

    // Forcing the variation "on" while preserving segmentation and targeting conditions during the experiment
    await kameleoonClient.setForcedVariation(experimentId, "on", forceTargeting: false)

    // Resetting the forced variation for the experiment 9516 for the visitor
    await kameleoonClient.setForcedVariation(experimentId, null);
} on KameleoonException {
  // Handling the exception
}

try {
    await kameleoonClient.evaluateAudiences();
} on KameleoonException {
  // Handling the exception
}

kameleoonClient.trackConversion(goalId); // default revenue
kameleoonClient.trackConversion(goalId, 10); // provided revenue == 10

// Add metadata
kameleoonClient.trackConversionWithOptParams(goalId, metadata: [CustomData.withIndex(1, values: ["true"])]);
kameleoonClient.trackConversionWithOptParams(goalId, revenue: 10, metadata: [CustomData.withIndex(1, values: ["true"])]);

kameleoonClient.onUpdateConfiguration((timestamp) {
    // timestamp value contains the value of Unix time (number of seconds elapsed since January 1, 1970) when configuration was updated.
});

final visitorCode = await kameleoonClient.getVisitorCode();

try {
    await kameleoonClient.addData([
        Device(Devices.phone),
        CustomData.withIndex(1, values: ["some custom value"]),
        Conversion(32, 10f, false),
    ]);
} on KameleoonException {
    // Generic exception in native plugin integration occurred.
}

kameleoonClient.flush(); // Interval tracking (most performant tracking method)

kameleoonClient.flush(instant: true); // Instant tracking

try {
    final data = await kameleoonClient.getRemoteData("test");
} on KameleoonException {
    // Generic exception in native plugin integration occurred.
} on Exception {
    // Any other error (including network issues).
}

// Visitor data will be fetched and automatically added for `visitorCode`.
try {
    final visitorData = await kameleoonClient.getRemoteVisitorData();
} on KameleoonException {
    // Generic exception in native plugin integration occurred.
} on Exception {
    // Any other error (including network issues).
}

// If you only want to fetch data and add it yourself manually, set addData == `false`.
try {
    final visitorData = await kameleoonClient.getRemoteVisitorData(addData: false);
} on KameleoonException {
    // Generic exception in native plugin integration occurred.
} on Exception {
    // Any other error (including network issues).
}

// If you want to fetch custom list of data types
final filter = RemoteVisitorDataFilter.withValues(
    previousVisitAmount: 25,
    currentVisit: true,
    conversions: true,
);
try {
    final visitorData = await kameleoonClient.getRemoteVisitorData(filter: filter, addData: false);
} on KameleoonException {
    // Generic exception in native plugin integration occurred.
} on Exception {
    // Any other error (including network issues).
}

try {
    final customData = await kameleoonClient.getVisitorWarehouseAudience(customDataIndex);
} on KameleoonException {
    // Generic exception in native plugin integration occurred.
} on Exception {
    // Any other error (including network issues).
}

// If you need to specify warehouse key
try {
    final customData = await kameleoonClient.getVisitorWarehouseAudience(customDataIndex, "warehouseKey");
} on KameleoonException {
    // Generic exception in native plugin integration occurred.
} on Exception {
    // Any other error (including network issues).
}

try {
    final customData = await kameleoonClient.setLegalConsent(true);
} on KameleoonException {
    // Generic exception in native plugin integration occurred.
} on Exception {
    // Any other error (including network issues).
}

try {
    final conversion = Conversion(32, 10);
    final conversionMetadata = Conversion(32, 10, false, [CustomData.withIndex(1, values: ["true"])]);
    final conversionOptParams = Conversion.withOptParams(32, metadata: [CustomData.withIndex(1, values: ["true"])]);

    await kameleoonClient.addData([conversion, conversionMetadata, conversionOptParams]);
} on KameleoonException {
    // Generic exception in native plugin integration occurred.
}

try {
    await kameleoonClient.addData([CustomData.withIndex(1, values: ["some custom value"])]);

    // With several values
    await kameleoonClient.addData(CustomData.withIndex(1, values: ["value 1", "value 2"]))

    // To set the 'overwrite' flag to false
    await kameleoonClient.addData(CustomData.withIndex(1, overwrite: false, values: ["first value", "second value"]))

    // To use a name instead of the index
    await kameleoonClient.addData(CustomData.withName("my-custom-data", values: ["value"]))
} on KameleoonException {
    // Generic exception in native plugin integration occurred.
}

try {
    await kameleoonClient.addData([Device(Devices.phone)]);
} on KameleoonException {
    // Generic exception in native plugin integration occurred.
}

try {
    await kameleoonClient.addData([Geolocation("France", region: "Île-de-France", city: "Paris")]);
} on KameleoonException {
    // Generic exception in native plugin integration occurred.
}

try {
    await kameleoonClient.addData([Browser(Browsers.chrome)]);

    await kameleoonClient.addData([Browser(Browsers.chrome, 10.0)]);
} on KameleoonException {
    // Generic exception in native plugin integration occurred.
}

try {
    await kameleoonClient.addData([PageView("https://url.com", "title", [3])]);
} on KameleoonException {
    // Generic exception in native plugin integration occurred.
}

try {
    await kameleoonClient.addData([OperatingSystem(OperatingSystem.linux)]);
} on KameleoonException {
    // Generic exception in native plugin integration occurred.
}

try {
    await kameleoonClient.addData([Cookie({
        "my_key1": "my_value1",
        "my_key2": "my_value2"
    })]);
} on KameleoonException {
    // Generic exception in native plugin integration occurred.
}

// Retrieves the map of feature flags from the DataFile.
// The map is keyed by feature flag identifiers, with each value being a FeatureFlag object.
final featureFlags = dataFile.featureFlags;

// Retrieves the last modification timestamp of the DataFile.
// The value is an int representing milliseconds since the Unix epoch.
final dateModified = dataFile.dateModified;

// Check whether the feature flag is enabled in the current environment
final isEnvironmentEnabled = featureFlag.environmentEnabled

// Retrieve the key of the default variation
final defaultVariationKey = featureFlag.defaultVariationKey

// Retrieve the default variation object
final defaultVariation = featureFlag.defaultVariation

// Retrieve all variations of the feature flag as a map (key = variation key, value = Variation object)
final variations = featureFlag.variations

// Retrieve all targeting rules associated with the feature flag
final rules = featureFlag.rules

// Retrieve all variations of the rule as a map (key = variation key, value = Variation object)
final variations = rule.variations

// Retrieving the variation name
var variationName = variation.name

// Retrieving the variation key
var variationKey = variation.key;

// Retrieving the variation id
var variationId = variation.id;

// Retrieving the experiment id
var experimentId = variation.experimentId;

// Retrieving the variables map
var variables = variation.variables;

// Retrieving the variables map
var variables = variation.variables;

// Variable type can be retrieved for further processing
var type = variables["isDiscount"]?.type ?? "";

// Retrieving the variable value by key
var isDiscount = variables["isDiscount"]?.value as bool? ?? false;

// Variable value can be of different types
var title = variables["title"]?.value as String? ?? "";

final ready = kameleoonClient.isReady();

String featureKey = "new_checkout";
String variationKey = "";

try {
    variationKey = await kameleoonClient.getFeatureVariationKey(featureKey);
} on SDKNotReady {
    // Exception indicates that the SDK has not completed its initialization yet.
} on FeatureNotFound {
    // The error has occurred; feature flag isn't found in current configuration.
} on FeatureEnvironmentDisabled {
    // The feature flag is disabled for the environment.
} on KameleoonException {
    // Generic exception in native plugin integration occurred.
} on Exception {
    // Any other error.
}

switch(variationKey) {
    case 'on':
        // Main variation key is selected for visitorCode
        break;
    case 'alternative_variation':
        // Alternative variation key
        break;
    default:
        // Default variation key
        break;
}

try {
    final activeFeatures = await kameleoonClient.getActiveFeatures();
} on KameleoonException {
    // Generic exception in native plugin integration occurred.
}

String featureKey = "feature_key";
String variableKey = "product_number";
int recommendedProductsNumber = 5;
try {
  recommendedProductsNumber = await kameleoonClient.getFeatureVariable(featureKey, variableKey);
} on SDKNotReady {
  // Exception indicates that the SDK has not completed its initialization yet.
} on FeatureNotFound {
  // The error has occurred; feature flag isn't found in current configuration.
} on FeatureEnvironmentDisabled {
  // The feature flag is disabled for the environment.
} on FeatureVariableNotFound {
  // Requested variable not defined in Kameleoon.
} on KameleoonException {
  // Generic exception in native plugin integration occurred.
} on Exception {
  // Any other error.
}

setState(() {
    _recommendedProductsNumber = recommendedProductsNumber;
});

final featureKey = "featureKey";
final variationKey = "variationKey";

try {
    final allVariables = await client.getFeatureVariationVariables(featureKey, variationKey);
} on SDKNotReady {
  // Exception indicates that the SDK has not completed its initialization yet.
} on FeatureNotFound {
    // The error has occurred; feature flag isn't found in current configuration.
} on FeatureEnvironmentDisabled {
    // The feature flag is disabled for the environment.
} on KameleoonException {
    // Generic exception in native plugin integration occurred.
} on Exception {
    // Any other error.
}