22760640003

Committed 06 Mar 2026 11:03AM UTC coverage: 85.786% (-1.3%) from 87.113%

Build # 22760640003

Build Type

Pull #98

github

Committed by

web-flow

Commit Message

Merge d65a9d81b into 89bbc6d21

Pull Request Pull Request #98: fix: ensure FlutterResult and invokeMethod are always called on main thread (iOS 16)

Coverage Stats

40 of 50 new or added lines in 2 files covered. (80.0%)

688 of 802 relevant lines covered (85.79%)

1.61 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

96.09

/lib/src/optimizely_client_wrapper.dart

/// **************************************************************************
/// Copyright 2022-2023, Optimizely, Inc. and contributors                   *
///                                                                          *
/// Licensed under the Apache License, Version 2.0 (the "License");          *
/// you may not use this file except in compliance with the License.         *
/// You may obtain a copy of the License at                                  *
///                                                                          *
///    http://www.apache.org/licenses/LICENSE-2.0                            *
///                                                                          *
/// Unless required by applicable law or agreed to in writing, software      *
/// distributed under the License is distributed on an "AS IS" BASIS,        *
/// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. *
/// See the License for the specific language governing permissions and      *
/// limitations under the License.                                           *
///**************************************************************************/

import 'dart:async';
import 'package:flutter/foundation.dart';
import 'package:flutter/services.dart';
import 'package:optimizely_flutter_sdk/optimizely_flutter_sdk.dart';
import 'package:optimizely_flutter_sdk/package_info.dart';
import 'package:optimizely_flutter_sdk/src/data_objects/activate_listener_response.dart';
import 'package:optimizely_flutter_sdk/src/data_objects/activate_response.dart';
import 'package:optimizely_flutter_sdk/src/data_objects/base_response.dart';
import 'package:optimizely_flutter_sdk/src/data_objects/get_variation_response.dart';
import 'package:optimizely_flutter_sdk/src/data_objects/get_vuid_response.dart';
import 'package:optimizely_flutter_sdk/src/data_objects/optimizely_config_response.dart';
import 'package:optimizely_flutter_sdk/src/utils/constants.dart';
import 'package:optimizely_flutter_sdk/src/utils/utils.dart';

enum ListenerType { activate, track, decision, logEvent, projectConfigUpdate }

enum ClientPlatform { iOS, android }

typedef ActivateNotificationCallback = void Function(
    ActivateListenerResponse msg);
typedef DecisionNotificationCallback = void Function(
    DecisionListenerResponse msg);
typedef TrackNotificationCallback = void Function(TrackListenerResponse msg);
typedef LogEventNotificationCallback = void Function(
    LogEventListenerResponse msg);
typedef MultiUseCallback = void Function(dynamic msg);

/// The internal client class for the Optimizely Flutter SDK used by the main OptimizelyFlutterSdk class.
class OptimizelyClientWrapper {
  static const MethodChannel _channel = MethodChannel('optimizely_flutter_sdk');
  static int nextCallbackId = 0;
  static Map<String, Map<int, ActivateNotificationCallback>>
      activateCallbacksById = {};
  static Map<String, Map<int, DecisionNotificationCallback>>
      decisionCallbacksById = {};
  static Map<String, Map<int, TrackNotificationCallback>> trackCallbacksById =
      {};
  static Map<String, Map<int, LogEventNotificationCallback>>
      logEventCallbacksById = {};
  static Map<String, Map<int, MultiUseCallback>> configUpdateCallbacksById = {};

  /// Starts Optimizely SDK (Synchronous) with provided sdkKey and options.
  static Future<BaseResponse> initializeClient(
      String sdkKey,
      EventOptions eventOptions,
      int datafilePeriodicDownloadInterval,
      Map<ClientPlatform, DatafileHostOptions> datafileHostOptions,
      Set<OptimizelyDecideOption> defaultDecideOptions,
      OptimizelyLogLevel defaultLogLevel,
      SDKSettings sdkSettings,
      CmabConfig? cmabConfig,
      OptimizelyLogger? logger) async {
    _channel.setMethodCallHandler(methodCallHandler);
    final convertedOptions = Utils.convertDecideOptions(defaultDecideOptions);
    final convertedLogLevel = Utils.convertLogLevel(defaultLogLevel);
    const sdkVersion = PackageInfo.version;

    Map<String, dynamic> requestDict = {
      Constants.sdkKey: sdkKey,
      Constants.sdkVersion: sdkVersion,
      Constants.datafilePeriodicDownloadInterval:
          datafilePeriodicDownloadInterval,
      Constants.optimizelyDecideOption: convertedOptions,
      Constants.defaultLogLevel: convertedLogLevel,
      Constants.eventBatchSize: eventOptions.batchSize,
      Constants.eventTimeInterval: eventOptions.timeInterval,
      Constants.eventMaxQueueSize: eventOptions.maxQueueSize,
    };

    // Odp Request params
    Map<String, dynamic> optimizelySdkSettings = {
      Constants.segmentsCacheSize: sdkSettings.segmentsCacheSize,
      Constants.segmentsCacheTimeoutInSecs:
          sdkSettings.segmentsCacheTimeoutInSecs,
      Constants.timeoutForSegmentFetchInSecs:
          sdkSettings.timeoutForSegmentFetchInSecs,
      Constants.timeoutForOdpEventInSecs: sdkSettings.timeoutForOdpEventInSecs,
      Constants.disableOdp: sdkSettings.disableOdp,
      Constants.enableVuid: sdkSettings.enableVuid,
    };
    requestDict[Constants.optimizelySdkSettings] = optimizelySdkSettings;

    // CMAB Config params
    if (cmabConfig != null) {
      Map<String, dynamic> cmabConfigMap = {
        Constants.cmabCacheSize: cmabConfig.cacheSize,
        Constants.cmabCacheTimeoutInSecs: cmabConfig.cacheTimeoutInSecs,
      };
      if (cmabConfig.predictionEndpoint != null) {
        cmabConfigMap[Constants.cmabPredictionEndpoint] =
            cmabConfig.predictionEndpoint;
      }
      requestDict[Constants.cmabConfig] = cmabConfigMap;
    }

    // clearing notification listeners, if they are mapped to the same sdkKey.
    activateCallbacksById.remove(sdkKey);
    decisionCallbacksById.remove(sdkKey);
    trackCallbacksById.remove(sdkKey);
    logEventCallbacksById.remove(sdkKey);
    configUpdateCallbacksById.remove(sdkKey);

    datafileHostOptions.forEach((platform, datafileoptions) {
      // Pass datafile host only if non empty value for current platform is provided
      if (platform.name == defaultTargetPlatform.name &&
          datafileoptions.datafileHostPrefix.isNotEmpty &&
          datafileoptions.datafileHostSuffix.isNotEmpty) {
        requestDict[Constants.datafileHostPrefix] =
            datafileoptions.datafileHostPrefix;
        requestDict[Constants.datafileHostSuffix] =
            datafileoptions.datafileHostSuffix;
      }
    });

    final result = await _invoke(Constants.initializeMethod, requestDict);
    return BaseResponse(result);
  }

  /// Use the activate method to start an experiment.
  ///  The activate call will conditionally activate an experiment for a user based on the provided experiment key and a randomized hash of the provided user ID.
  ///  If the user satisfies audience conditions for the experiment and the experiment is valid and running, the function returns the variation the user is bucketed into.
  ///  Otherwise, activate returns empty variationKey. Make sure that your code adequately deals with the case when the experiment is not activated (e.g. execute the default variation).
  static Future<ActivateResponse> activate(
      String sdkKey, String experimentKey, String userId,
      [Map<String, dynamic> attributes = const {}]) async {
    final result = await _invoke(Constants.activate, {
      Constants.sdkKey: sdkKey,
      Constants.experimentKey: experimentKey,
      Constants.userId: userId,
      Constants.attributes: Utils.convertToTypedMap(attributes)
    });
    return ActivateResponse(result);
  }

  /// Get variation for experiment and user ID with user attributes.
  static Future<GetVariationResponse> getVariation(
      String sdkKey, String experimentKey, String userId,
      [Map<String, dynamic> attributes = const {}]) async {
    final result = await _invoke(Constants.getVariation, {
      Constants.sdkKey: sdkKey,
      Constants.experimentKey: experimentKey,
      Constants.userId: userId,
      Constants.attributes: Utils.convertToTypedMap(attributes)
    });
    return GetVariationResponse(result);
  }

  /// Get forced variation for experiment and user ID.
  static Future<GetVariationResponse> getForcedVariation(
      String sdkKey, String experimentKey, String userId) async {
    final result = await _invoke(Constants.getForcedVariation, {
      Constants.sdkKey: sdkKey,
      Constants.experimentKey: experimentKey,
      Constants.userId: userId,
    });
    return GetVariationResponse(result);
  }

  /// Set forced variation for experiment and user ID to variationKey.
  static Future<BaseResponse> setForcedVariation(
      String sdkKey, String experimentKey, String userId,
      [String variationKey = ""]) async {
    Map<String, dynamic> request = {
      Constants.sdkKey: sdkKey,
      Constants.experimentKey: experimentKey,
      Constants.userId: userId,
    };
    if (variationKey != "") {
      request[Constants.variationKey] = variationKey;
    }
    final result = await _invoke(Constants.setForcedVariation, request);
    return BaseResponse(result);
  }

  /// Returns a snapshot of the current project configuration.
  static Future<OptimizelyConfigResponse> getOptimizelyConfig(
      String sdkKey) async {
    final result = await _invoke(
        Constants.getOptimizelyConfigMethod, {Constants.sdkKey: sdkKey});
    return OptimizelyConfigResponse(result);
  }

  /// Send an event to the ODP server.
  static Future<BaseResponse> sendOdpEvent(String sdkKey, String action,
      {String? type,
      Map<String, String> identifiers = const {},
      Map<String, dynamic> data = const {}}) async {
    Map<String, dynamic> request = {
      Constants.sdkKey: sdkKey,
      Constants.action: action,
      Constants.identifiers: identifiers,
      Constants.data: Utils.convertToTypedMap(data)
    };
    if (type != null) {
      request[Constants.type] = type;
    }

    final result = await _invoke(Constants.sendOdpEventMethod, request);
    return BaseResponse(result);
  }

  /// Returns the device vuid (read only)
  static Future<GetVuidResponse> getVuid(String sdkKey) async {
    final result = await _invoke(Constants.getVuidMethod, {
      Constants.sdkKey: sdkKey,
    });
    return GetVuidResponse(result);
  }

  /// Remove notification listener by notification id.
  static Future<BaseResponse> removeNotificationListener(
      String sdkKey, int id) async {
    Map<String, dynamic> request = {Constants.sdkKey: sdkKey, Constants.id: id};

    activateCallbacksById[sdkKey]?.remove(id);
    decisionCallbacksById[sdkKey]?.remove(id);
    logEventCallbacksById[sdkKey]?.remove(id);
    configUpdateCallbacksById[sdkKey]?.remove(id);
    trackCallbacksById[sdkKey]?.remove(id);

    final result = await _invoke(
        Constants.removeNotificationListenerMethod, request);
    return BaseResponse(result);
  }

  /// Remove notification listeners by notification type.
  static Future<BaseResponse> clearNotificationListeners(
      String sdkKey, ListenerType listenerType) async {
    var callbackIds = _clearAllCallbacks(sdkKey, listenerType);
    Map<String, dynamic> request = {
      Constants.sdkKey: sdkKey,
      Constants.type: listenerType.name,
      Constants.callbackIds: callbackIds
    };
    final result = await _invoke(
        Constants.clearNotificationListenersMethod, request);
    return BaseResponse(result);
  }

  /// Removes all notification listeners.
  static Future<BaseResponse> clearAllNotificationListeners(
      String sdkKey) async {
    var callbackIds = _clearAllCallbacks(sdkKey);
    Map<String, dynamic> request = {
      Constants.sdkKey: sdkKey,
      Constants.callbackIds: callbackIds
    };
    final result = await _invoke(
        Constants.clearAllNotificationListenersMethod, request);
    return BaseResponse(result);
  }

  /// Returns a success true if optimizely client closed successfully.
  static Future<BaseResponse> close(String sdkKey) async {
    final result = await _invoke(
        Constants.close, {Constants.sdkKey: sdkKey});
    return BaseResponse(result);
  }

  /// Creates a context of the user for which decision APIs will be called.
  ///
  /// A user context will only be created successfully when the SDK is fully configured using initializeClient.
  static Future<OptimizelyUserContext?> createUserContext(String sdkKey,
      {String? userId, Map<String, dynamic> attributes = const {}}) async {
    Map<String, dynamic> request = {
      Constants.sdkKey: sdkKey,
      Constants.attributes: Utils.convertToTypedMap(attributes)
    };
    if (userId != null) {
      request[Constants.userId] = userId;
    }
    final result = await _invoke(Constants.createUserContextMethod, request);

    if (result[Constants.responseSuccess] == true) {
      final response =
          Map<String, dynamic>.from(result[Constants.responseResult]);
      return OptimizelyUserContext(
          sdkKey, response[Constants.userContextId], _channel);
    }
    return null;
  }

  static List<int> _clearAllCallbacks(String sdkKey,
      [ListenerType? listenerType]) {
    var callbackIds = <int>[];
    if (listenerType == null || listenerType == ListenerType.activate) {
      if (activateCallbacksById.containsKey(sdkKey)) {
        callbackIds.addAll(activateCallbacksById[sdkKey]!.keys);
        activateCallbacksById[sdkKey]!.clear();
      }
    }
    if (listenerType == null || listenerType == ListenerType.decision) {
      if (decisionCallbacksById.containsKey(sdkKey)) {
        callbackIds.addAll(decisionCallbacksById[sdkKey]!.keys);
        decisionCallbacksById[sdkKey]!.clear();
      }
    }
    if (listenerType == null || listenerType == ListenerType.logEvent) {
      if (logEventCallbacksById.containsKey(sdkKey)) {
        callbackIds.addAll(logEventCallbacksById[sdkKey]!.keys);
        logEventCallbacksById[sdkKey]!.clear();
      }
    }
    if (listenerType == null ||
        listenerType == ListenerType.projectConfigUpdate) {
      if (configUpdateCallbacksById.containsKey(sdkKey)) {
        callbackIds.addAll(configUpdateCallbacksById[sdkKey]!.keys);
        configUpdateCallbacksById[sdkKey]!.clear();
      }
    }
    if (listenerType == null || listenerType == ListenerType.track) {
      if (trackCallbacksById.containsKey(sdkKey)) {
        callbackIds.addAll(trackCallbacksById[sdkKey]!.keys);
        trackCallbacksById[sdkKey]!.clear();
      }
    }
    return callbackIds;
  }

  static bool checkCallBackExist(String sdkKey, dynamic callback) {
    if (activateCallbacksById.containsKey(sdkKey)) {
      for (var k in activateCallbacksById[sdkKey]!.keys) {
        if (activateCallbacksById[sdkKey]![k] == callback) {
          return true;
        }
      }
    }
    if (decisionCallbacksById.containsKey(sdkKey)) {
      for (var k in decisionCallbacksById[sdkKey]!.keys) {
        if (decisionCallbacksById[sdkKey]![k] == callback) {
          return true;
        }
      }
    }
    if (trackCallbacksById.containsKey(sdkKey)) {
      for (var k in trackCallbacksById[sdkKey]!.keys) {
        if (trackCallbacksById[sdkKey]![k] == callback) {
          return true;
        }
      }
    }
    if (logEventCallbacksById.containsKey(sdkKey)) {
      for (var k in logEventCallbacksById[sdkKey]!.keys) {
        if (logEventCallbacksById[sdkKey]![k] == callback) {
          return true;
        }
      }
    }
    if (configUpdateCallbacksById.containsKey(sdkKey)) {
      for (var k in configUpdateCallbacksById[sdkKey]!.keys) {
        if (configUpdateCallbacksById[sdkKey]![k] == callback) {
          return true;
        }
      }
    }
    return false;
  }

  static Future<int> addActivateNotificationListener(
      String sdkKey, ActivateNotificationCallback callback) async {
    _channel.setMethodCallHandler(methodCallHandler);

    if (checkCallBackExist(sdkKey, callback)) {
      // ignore: avoid_print
      return -1;
    }

    int currentListenerId = nextCallbackId++;
    activateCallbacksById.putIfAbsent(sdkKey, () => {});
    activateCallbacksById[sdkKey]?[currentListenerId] = callback;
    final listenerTypeStr = ListenerType.activate.name;
    await _invoke(Constants.addNotificationListenerMethod, {
      Constants.sdkKey: sdkKey,
      Constants.id: currentListenerId,
      Constants.type: listenerTypeStr
    });
    // Returning an id that allows the user to remove the added notification listener.
    return currentListenerId;
  }

  static Future<int> addDecisionNotificationListener(
      String sdkKey, DecisionNotificationCallback callback) async {
    _channel.setMethodCallHandler(methodCallHandler);

    if (checkCallBackExist(sdkKey, callback)) {
      // ignore: avoid_print
      print("callback already exists.");
      return -1;
    }

    int currentListenerId = nextCallbackId++;
    decisionCallbacksById.putIfAbsent(sdkKey, () => {});
    decisionCallbacksById[sdkKey]?[currentListenerId] = callback;
    final listenerTypeStr = ListenerType.decision.name;
    await _invoke(Constants.addNotificationListenerMethod, {
      Constants.sdkKey: sdkKey,
      Constants.id: currentListenerId,
      Constants.type: listenerTypeStr
    });
    // Returning an id that allows the user to remove the added notification listener
    return currentListenerId;
  }

  static Future<int> addTrackNotificationListener(
      String sdkKey, TrackNotificationCallback callback) async {
    _channel.setMethodCallHandler(methodCallHandler);

    if (checkCallBackExist(sdkKey, callback)) {
      // ignore: avoid_print
      return -1;
    }

    int currentListenerId = nextCallbackId++;
    trackCallbacksById.putIfAbsent(sdkKey, () => {});
    trackCallbacksById[sdkKey]?[currentListenerId] = callback;
    final listenerTypeStr = ListenerType.track.name;
    await _invoke(Constants.addNotificationListenerMethod, {
      Constants.sdkKey: sdkKey,
      Constants.id: currentListenerId,
      Constants.type: listenerTypeStr
    });
    // Returning an id that allows the user to remove the added notification listener
    return currentListenerId;
  }

  static Future<int> addLogEventNotificationListener(
      String sdkKey, LogEventNotificationCallback callback) async {
    _channel.setMethodCallHandler(methodCallHandler);

    if (checkCallBackExist(sdkKey, callback)) {
      // ignore: avoid_print
      return -1;
    }

    int currentListenerId = nextCallbackId++;
    logEventCallbacksById.putIfAbsent(sdkKey, () => {});
    logEventCallbacksById[sdkKey]?[currentListenerId] = callback;
    final listenerTypeStr = ListenerType.logEvent.name;
    await _invoke(Constants.addNotificationListenerMethod, {
      Constants.sdkKey: sdkKey,
      Constants.id: currentListenerId,
      Constants.type: listenerTypeStr
    });
    // Returning an id that allows the user to remove the added notification listener
    return currentListenerId;
  }

  /// Allows user to listen to supported notifications.
  static Future<int> addConfigUpdateNotificationListener(
      String sdkKey, MultiUseCallback callback) async {
    _channel.setMethodCallHandler(methodCallHandler);

    if (checkCallBackExist(sdkKey, callback)) {
      // ignore: avoid_print
      return -1;
    }

    int currentListenerId = nextCallbackId++;
    configUpdateCallbacksById.putIfAbsent(sdkKey, () => {});
    configUpdateCallbacksById[sdkKey]?[currentListenerId] = callback;
    final listenerTypeStr = ListenerType.projectConfigUpdate.name;
    await _invoke(Constants.addNotificationListenerMethod, {
      Constants.sdkKey: sdkKey,
      Constants.id: currentListenerId,
      Constants.type: listenerTypeStr
    });
    // Returning an id that allows the user to remove the added notification listener
    return currentListenerId;
  }

  /// Safe wrapper around [MethodChannel.invokeMethod].
  ///
  /// Returns a [Map<String, dynamic>] in all cases — never throws.
  /// - If native returns `null` (e.g. dropped response on iOS 16 when
  ///   FlutterResult is called from a background thread), returns a
  ///   `{success: false}` map instead of crashing with [TypeError].
  /// - If native throws [PlatformException], returns `{success: false}`
  ///   instead of propagating an unhandled exception to the caller.
  ///
  /// Every [MethodChannel.invokeMethod] call in this class must go through
  /// [_invoke] so that new methods added in future automatically inherit
  /// these safety guarantees.
  static Future<Map<String, dynamic>> _invoke(
      String method, [dynamic args]) async {
    try {
      final raw = await _channel.invokeMethod(method, args);
      if (raw == null) {
        return {
          Constants.responseSuccess: false,
          Constants.responseReason:
              'Native channel returned null for method: $method',
        };
      }
      return Map<String, dynamic>.from(raw);
    } on PlatformException catch (e) {
      return {
        Constants.responseSuccess: false,
        Constants.responseReason: e.message ?? e.toString(),
      };
    }
  }

  static Future<void> methodCallHandler(MethodCall call) async {
    final id = call.arguments[Constants.id];
    final sdkKey = call.arguments[Constants.sdkKey];
    final payload = call.arguments[Constants.payload];
    if (id is int && payload != null) {
      switch (call.method) {
        case Constants.activateCallBackListener:
          final response =
              ActivateListenerResponse(Map<String, dynamic>.from(payload));
          if (activateCallbacksById.containsKey(sdkKey) &&
              activateCallbacksById[sdkKey]!.containsKey(id)) {
            activateCallbacksById[sdkKey]![id]!(response);
          }
          break;
        case Constants.decisionCallBackListener:
          final response =
              DecisionListenerResponse(Map<String, dynamic>.from(payload));
          if (decisionCallbacksById.containsKey(sdkKey) &&
              decisionCallbacksById[sdkKey]!.containsKey(id)) {
            decisionCallbacksById[sdkKey]![id]!(response);
          }
          break;
        case Constants.trackCallBackListener:
          final response =
              TrackListenerResponse(Map<String, dynamic>.from(payload));
          if (trackCallbacksById.containsKey(sdkKey) &&
              trackCallbacksById[sdkKey]!.containsKey(id)) {
            trackCallbacksById[sdkKey]![id]!(response);
          }
          break;
        case Constants.logEventCallbackListener:
          final response =
              LogEventListenerResponse(Map<String, dynamic>.from(payload));
          if (logEventCallbacksById.containsKey(sdkKey) &&
              logEventCallbacksById[sdkKey]!.containsKey(id)) {
            logEventCallbacksById[sdkKey]![id]!(response);
          }
          break;
        case Constants.configUpdateCallBackListener:
          if (configUpdateCallbacksById.containsKey(sdkKey) &&
              configUpdateCallbacksById[sdkKey]!.containsKey(id)) {
            configUpdateCallbacksById[sdkKey]![id]!(payload);
          }
          break;
        default:
          // ignore: avoid_print
          print('Method ${call.method} not implemented.');
      }
    }
  }
}

optimizely / optimizely-flutter-sdk / 22760640003

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous