Periodically refresh using a Family's argument.

[LeoBound]

I want to update widgets by polling a data source.
If possible I would like to use a syntax like:
final value = ref.watch(DataProvider(duration));
to indicate that a widget should refresh every "duration".
This has a couple of issues, namely:

• overriding DataProvider must be done for each duration in ProviderScopes' overrides
• if two listeners have different durations they will poll more often than required. (This isn't riverpod specific I suppose but I'm unsure how best to collapse synchronised watches in the context of riverpod).

I may be missing some already existing functionality, or this might be considered an anti-pattern so I'm open to any other solutions.

Thanks :)

[snapsl]

In general, here is an example on how to implement a refresh timer. link

I'm unsure if a familyprovider fits your needs, due to the issues that you've already discovered.
You could instead create a new provider, which would set the refresh duration for the dataProvider.

// alt. implement as class in order to modify
@riverpod
Duration refreshDuration(..) => const Duration(seconds: 5);

@riverpod
Data dataProvider(..) async {
  Timer? timer;

  final data = await fetchData();

  ref.listen(
    refreshDurationProvider,
    (previous, next) => timer = Timer(next, () => ref.invalidateSelf());,
    fireImmediately: true,
  );
  
  ref.onDispose(timer?.cancel);
  
  return data;
}

[LeoBound]

Thanks for the quick reply.
With the above solution the refresh duration is global so if dataProvider was itself a family, each instance (thing created by passing a different argument - I'm not sure of the proper term) would refresh with the same frequency.

As an example of what I'd like to do:

@riverpod
Response periodicHttpFetcher(ref, url, duration) {
// Fetches data from the url every duration
}

ref.watch(periodicHttpFetcherProvider("one.value.com", Duration(seconds: 5)));
ref.watch(periodicHttpFetcherProvider("one.value.com", Duration(seconds: 10)));
ref.watch(periodicHttpFetcherProvider("two.value.com", Duration(seconds: 7)));

I could split each one into a different provider but if they were only known at runtime this wouldn't be possible.

I suppose this is a bit of a different case to the original question - but do you have any ideas?

Thanks again

[snapsl]

Yes, this is looks quite different and using a family provider is probably useful.
I would suggest to keep track using a global map(url, duration) or all family provider instances to avoid fetching the same url, but I guess there is no goto solution.

[rrousselGit]

You're not really supposed to have a generic "http fetcher" provider. Consider making one provider per http request.

Then those providers can define their own refresh timer.

@riverpod
Future<Example> example(ExampleRef ref) {
  final timer = Timer(duration, () => ref.invalidateSelf());
  ref.onDispose(timer.cancel);

  return http.get(...);
}

[LeoBound]

This is probably a bit hacky but you can do something like the following with Riverpod 3:

@riverpod
T periodicData<T>(PeriodicDataRef ref, ProviderBase<T> prov, Duration d) {
  final val = ref.watch(prov);
  final timer = Timer(d, () => ref.invalidate(prov));
  ref.onDispose(timer.cancel);
  return val;
}

// Call it like this:
ref.watch(PeriodicDataProvider(DataProvider(args), Duration(seconds: 5)))

// Override the value
class MockData extends Data {

@override
build(args) =>// return the mock data here.
}

DataProvider(args).overrideWith(()=>MockData());

This solves the override issue by only overriding the 'data' part and not overriding the periodic fetcher.
@rrousselGit I assume this sort of thing is considered the wrong way to do it?
Is there some other way to factor out the periodic fetching code?
Is this roughly the right way to override an instance of a family (Making a mock class and overriding with it)?