FeatureClient constructor

FeatureClient({ required ClientMetadata metadata, required HookManager hookManager, Iterable<Hook> apiHooksResolver()?, required EvaluationContext defaultContext, EvaluationContext? apiContext, EvaluationContext apiContextResolver()?, FeatureProvider? provider, FeatureProvider providerResolver()?, ProviderState providerStatusResolver(FeatureProvider)?, TransactionContextManager? transactionManager, Stream<OpenFeatureEvent>? eventStream, EventScope? eventScope, })

Implementation

FeatureClient({
  required this.metadata,
  required HookManager hookManager,
  Iterable<Hook> Function()? apiHooksResolver,
  required EvaluationContext defaultContext,
  EvaluationContext? apiContext,
  EvaluationContext Function()? apiContextResolver,
  FeatureProvider? provider,
  FeatureProvider Function()? providerResolver,
  ProviderState Function(FeatureProvider)? providerStatusResolver,
  TransactionContextManager? transactionManager,
  Stream<OpenFeatureEvent>? eventStream,
  EventScope? eventScope,
}) : _hookManager = hookManager,
     _apiHooksResolver = apiHooksResolver,
     _defaultContext = defaultContext,
     _apiContext = apiContext ?? const EvaluationContext(attributes: {}),
     _apiContextResolver = apiContextResolver,
     _fallbackProvider = provider ?? InMemoryProvider({}),
     _providerResolver = providerResolver,
     _providerStatusResolver = providerStatusResolver,
     _transactionManager = transactionManager ?? TransactionContextManager() {
  if (eventScope != null) {
    _eventScope = eventScope;
  } else {
    final dispatcher = _ownedEventDispatcher = EventDispatcher();
    _eventScope = dispatcher.scope(
      provider: () => this.provider,
      domain: metadata.domain,
      legacyMetadataMatching: providerResolver == null,
      current: (type) sync* {
        final currentType = switch (providerStatus) {
          ProviderState.READY => OpenFeatureEventType.PROVIDER_READY,
          ProviderState.ERROR ||
          ProviderState.FATAL => OpenFeatureEventType.PROVIDER_ERROR,
          ProviderState.STALE => OpenFeatureEventType.PROVIDER_STALE,
          ProviderState.SYNCHRONIZING =>
            OpenFeatureEventType.PROVIDER_RECONCILING,
          _ => null,
        };
        if (type == currentType) {
          yield OpenFeatureEvent(
            type,
            'Current provider state',
            provider: this.provider,
            providerMetadata: this.provider.metadata,
            errorCode: providerStatus == ProviderState.FATAL
                ? ErrorCode.PROVIDER_FATAL
                : null,
          );
        }
      },
    );
  }
  if (_providerResolver == null &&
      providerStatus == ProviderState.NOT_READY) {
    unawaited(
      this.provider.initialize().catchError((Object error, StackTrace stack) {
        _logger.severe(
          'Provider initialization failed: $error',
          error,
          stack,
        );
      }),
    );
  }

  if (eventStream != null) {
    _eventSubscription = eventStream.listen((event) {
      _ownedEventDispatcher?.emit(event);
    });
  }
}