refreshValue<T> method

Future<T> refreshValue<T>(AsyncProvider<T> provider, { bool keepPrevious = true, })

Implementation

Future<T> refreshValue<T>(
  AsyncProvider<T> provider, {
  bool keepPrevious = true,
}) {
  _checkNotDisposed();
  final actualProvider = _providerOverrides[provider.key] ?? provider;
  final node = _ensureNode(provider) as _AsyncNode;
  final prev = (node.state as AsyncValue<dynamic>).valueOrNull;

  node.runDisposers();
  _attachDependencyListener(provider.key, node);
  node._sub?.cancel();
  node._sub = null;

  if (keepPrevious && prev != null) {
    node.state = AsyncData<T>(prev as T, isRefreshing: true);
  } else {
    node.state = AsyncLoading<T>(previous: prev as T?);
  }

  final deps = <ProviderKey>{};
  final ref = _RefCore._(
    this,
    provider.key,
    depsCollector: deps,
  );
  final buildId = ++node._buildId;
  try {
    final res = (actualProvider as AsyncProvider<T>)._buildWithCore(ref);
    if (res is Future<T>) {
      return res.then(
        (value) {
          if (node._buildId == buildId) {
            node.state = AsyncData<T>(value);
          }
          _setDependencies(provider.key, deps);
          return value;
        },
        onError: (e, st) {
          if (node._buildId == buildId) {
            node.state = AsyncError<T>(e, st, previous: prev as T?);
          }
          _notifyDidFail(actualProvider, e, st);
          _setDependencies(provider.key, deps);
          return Future<T>.error(e, st);
        },
      );
    } else {
      if (node._buildId == buildId) {
        node.state = AsyncData<T>(res);
      }
      _setDependencies(provider.key, deps);
      return Future<T>.value(res);
    }
  } catch (e, st) {
    if (node._buildId == buildId) {
      node.state = AsyncError<T>(e, st, previous: prev as T?);
    }
    _notifyDidFail(actualProvider, e, st);
    _setDependencies(provider.key, deps);
    return Future<T>.error(e, st);
  }
}