Provider

https://pub.dev/packages/provider
Admin
A wrapper around Flutter's InheritedWidget to simplify state management, making it easier to use,...
Tokens:4,620
Snippets:61
Trust Score:9.9
Update:1 month ago
Show doc for...
Tokens:
Raw
### Migrate FutureProvider to Null-Safety

Source: https://pub.dev/packages/provider/changelog

Examples showing the transition from non-null-safe FutureProvider usage to the required null-safe syntax.

```dart
FutureProvider<int>(
  create: (context) => Future.value(42),
  child: MyApp(),
)

Widget build(BuildContext context) {
  final value = context.watch<int>();
  return Text('$value');
}
```

```dart
FutureProvider<int?>(
  initialValue: null,
  create: (context) => Future.value(42),
  child: MyApp(),
)

Widget build(BuildContext context) {
  // be sure to specify the ? in watch<int?>
  final value = context.watch<int?>();
  return Text('$value');
}
```

--------------------------------

### Define providers with nullability differences

Source: https://pub.dev/packages/provider/changelog

Example of a MultiProvider configuration that is no longer supported due to nullability ambiguity.

```dart
MultiProvider(
  providers: [
    Provider<Model>(...),
    Provider<Model?>(...)
  ]
)
```

--------------------------------

### Static Analysis Type Shadowing Issue

Source: https://pub.dev/packages/provider/score

Example of a type shadowing issue identified during static analysis in the provider package.

```dart
    ╷
418 │   static void Function<T>(T value)? debugCheckInvalidValueType = <T>(T value) {
    │                        ^
    ╵
```

--------------------------------

### Compare Selector and context.select

Source: https://pub.dev/packages/provider/changelog

Demonstrates the reduction in verbosity when using the new context.select extension compared to the traditional Selector widget.

```dart
Widget build(BuildContext context) {
  return Selector<Person, String>(
    selector: (_, p) => p.name,
    builder: (_, name, __) {
      return Text(name);
    },
  ),
}
```

```dart
Widget build(BuildContext context) {
  final name = context.select((Person p) => p.name);
  return Text(name);
}
```

--------------------------------

### Implement State Management with Provider

Source: https://pub.dev/packages/provider/example

Uses MultiProvider to inject a ChangeNotifier into the widget tree and demonstrates context.read and context.watch for state access.

```dart
import 'package:flutter/foundation.dart';
import 'package:flutter/material.dart';
import 'package:provider/provider.dart';

/// This is a reimplementation of the default Flutter application using provider + [ChangeNotifier].

void main() {
  runApp(
    /// Providers are above [MyApp] instead of inside it, so that tests
    /// can use [MyApp] while mocking the providers
    MultiProvider(
      providers: [
        ChangeNotifierProvider(create: (_) => Counter()),
      ],
      child: const MyApp(),
    ),
  );
}

/// Mix-in [DiagnosticableTreeMixin] to have access to [debugFillProperties] for the devtool
// ignore: prefer_mixin
class Counter with ChangeNotifier, DiagnosticableTreeMixin {
  int _count = 0;

  int get count => _count;

  void increment() {
    _count++;
    notifyListeners();
  }

  /// Makes `Counter` readable inside the devtools by listing all of its properties
  @override
  void debugFillProperties(DiagnosticPropertiesBuilder properties) {
    super.debugFillProperties(properties);
    properties.add(IntProperty('count', count));
  }
}

class MyApp extends StatelessWidget {
  const MyApp({Key? key}) : super(key: key);

  @override
  Widget build(BuildContext context) {
    return const MaterialApp(
      home: MyHomePage(),
    );
  }
}

class MyHomePage extends StatelessWidget {
  const MyHomePage({Key? key}) : super(key: key);

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: const Text('Example'),
      ),
      body: const Center(
        child: Column(
          mainAxisSize: MainAxisSize.min,
          mainAxisAlignment: MainAxisAlignment.center,
          children: <Widget>[
            Text('You have pushed the button this many times:'),

            /// Extracted as a separate widget for performance optimization.
            /// As a separate widget, it will rebuild independently from [MyHomePage].
            ///
            /// This is totally optional (and rarely needed).
            /// Similarly, we could also use [Consumer] or [Selector].
            Count(),
          ],
        ),
      ),
      floatingActionButton: FloatingActionButton(
        key: const Key('increment_floatingActionButton'),

        /// Calls `context.read` instead of `context.watch` so that it does not rebuild
        /// when [Counter] changes.
        onPressed: () => context.read<Counter>().increment(),
        tooltip: 'Increment',
        child: const Icon(Icons.add),
      ),
    );
  }
}

class Count extends StatelessWidget {
  const Count({Key? key}) : super(key: key);

  @override
  Widget build(BuildContext context) {
    return Text(
      /// Calls `context.watch` to make [Count] rebuild when [Counter] changes.
      '${context.watch<Counter>().count}',
      key: const Key('counterState'),
      style: Theme.of(context).textTheme.headlineMedium,
    );
  }
}
```

--------------------------------

### Read provider with context

Source: https://pub.dev/packages/provider/changelog

Shows the standard way to read a provider, which throws an exception if the provider is not found.

```dart
context.watch<Model>()
```

--------------------------------

### Exposing a new object instance

Source: https://pub.dev/packages/provider

Use the default constructor to create and expose a new object instance within a provider.

```dart
Provider(
  create: (_) => MyModel(),
  child: ...
)
```

--------------------------------

### Simplify Provider with builder

Source: https://pub.dev/packages/provider/changelog

Shows how the builder parameter simplifies access to BuildContext within a provider compared to using a nested Builder widget.

```dart
Provider(
  create: (_) => Something(),
  child: Builder(
    builder: (context) {
      final name = context.select((Something s) => s.name);
      return Text(name);
    },
  ),
)
```

```dart
Provider(
  create: (_) => Something(),
  builder: (context, child) {
    final name = context.select((Something s) => s.name);
    return Text(name);
  },
)
```

--------------------------------

### Handle Provider access in initState

Source: https://pub.dev/packages/provider

Avoid listening to providers in initState; use build with context.watch for updates or context.read for one-time access.

```dart
initState() {
  super.initState();
  print(context.watch<Foo>().value);
}
```

```dart
Value value;

Widget build(BuildContext context) {
  final value = context.watch<Foo>().value;
  if (value != this.value) {
    this.value = value;
    print(value);
  }
}
```

```dart
initState() {
  super.initState();
  print(context.read<Foo>().value);
}
```

--------------------------------

### Using ProxyProvider for changing variables

Source: https://pub.dev/packages/provider

Use ProxyProvider to correctly handle dependencies on variables that change over time.

```dart
int count;

ProxyProvider0(
  update: (_, __) => MyModel(count),
  child: ...
)
```

--------------------------------

### Manage Large Provider Counts

Source: https://pub.dev/packages/provider

Use conditional mounting in MultiProvider or avoid MultiProvider entirely to prevent StackOverflowErrors when using many providers.

```dart
MultiProvider(
  providers: [
    if (step1) ...[
      <lots of providers>,
    ],
    if (step2) ...[
      <some more providers>
    ]
  ],
),
```

```dart
bool step1 = false;
bool step2 = false;
@override
initState() {
  super.initState();
  Future(() {
    setState(() => step1 = true);
    Future(() {
      setState(() => step2 = true);
    });
  });
}
```

--------------------------------

### Combine providers with ProxyProvider

Source: https://pub.dev/packages/provider

ProxyProvider allows creating an object that depends on other providers, updating automatically when dependencies change.

```dart
Widget build(BuildContext context) {
  return MultiProvider(
    providers: [
      ChangeNotifierProvider(create: (_) => Counter()),
      ProxyProvider<Counter, Translations>(
        update: (_, counter, __) => Translations(counter.value),
      ),
    ],
    child: Foo(),
  );
}

class Translations {
  const Translations(this._value);

  final int _value;

  String get title => 'You clicked $_value times';
}
```

--------------------------------

### Add provider dependency via CLI

Source: https://pub.dev/packages/provider/install

Use this command in your terminal to add the package to your Flutter project.

```bash
$ flutter pub add provider
```

--------------------------------

### Read providers with nullability

Source: https://pub.dev/packages/provider/changelog

Comparison of reading providers with and without nullability to handle ProviderNotFoundException.

```dart
context.watch<Model>()
```

```dart
context.watch<Model?>()
```

--------------------------------

### Optimize Rebuilds with context.select and Consumer

Source: https://pub.dev/packages/provider

Use context.select or Consumer with a child argument to limit widget rebuilds to specific property changes or sub-trees.

```dart
Widget build(BuildContext context) {
  final person = context.watch<Person>();
  return Text(person.name);
}
```

```dart
Widget build(BuildContext context) {
  final name = context.select((Person p) => p.name);
  return Text(name);
}
```

```dart
Foo(
  child: Consumer<A>(
    builder: (_, a, child) {
      return Bar(a: a, child: child);
    },
    child: Baz(),
  ),
)
```

--------------------------------

### Use Consumer inside MultiProvider

Source: https://pub.dev/packages/provider/changelog

Demonstrates nesting a Consumer within a MultiProvider to access values from other providers.

```dart
MultiProvider(
  providers: [
    Provider(builder: (_) => Foo()),
    Consumer<Foo>(
      builder: (context, foo, child) =>
        Provider.value(value: foo.bar, child: child),
    )
  ],
);
```

--------------------------------

### Read optional provider with nullable type

Source: https://pub.dev/packages/provider/changelog

Demonstrates reading a provider using a nullable generic type to return null instead of throwing an exception if the provider is missing.

```dart
context.watch<Model?>()
```

--------------------------------

### Add provider to pubspec.yaml

Source: https://pub.dev/packages/provider/install

Manually add this line to the dependencies section of your pubspec.yaml file.

```yaml
dependencies:
  provider: ^6.1.5+1
```

--------------------------------

### Consume Interfaces with Provider

Source: https://pub.dev/packages/provider

Provide an implementation while consuming an interface by specifying the interface type in the provider and the consumer.

```dart
abstract class ProviderInterface with ChangeNotifier {
  ...
}

class ProviderImplementation with ChangeNotifier implements ProviderInterface {
  ...
}

class Foo extends StatelessWidget {
  @override
  build(context) {
    final provider = Provider.of<ProviderInterface>(context);
    return ...
  }
}

ChangeNotifierProvider<ProviderInterface>(
  create: (_) => ProviderImplementation(),
  child: Foo(),
),
```

--------------------------------

### Implement MultiProvider with builder

Source: https://pub.dev/packages/provider/changelog

Utilize the builder parameter in MultiProvider to access provider values within the widget tree.

```dart
MultiProvider(
  providers: [
    ChangeNotifierProvider(create: (ct) => Counter()),
  ],
  builder: (ctx, child) {
    final counter = ctx.watch<Counter>();
    return Text('${counter.count}');
  },
);
```

--------------------------------

### Import provider in Dart

Source: https://pub.dev/packages/provider/install

Include this import statement at the top of your Dart files to access the provider library.

```dart
import 'package:provider/provider.dart';
```

--------------------------------

### Use StatefulWidget for State Management

Source: https://pub.dev/packages/provider

Alternative architecture using Provider.value with a StatefulWidget to manage state without ChangeNotifier.

```dart
class Example extends StatefulWidget {
  const Example({Key key, this.child}) : super(key: key);

  final Widget child;

  @override
  ExampleState createState() => ExampleState();
}

class ExampleState extends State<Example> {
  int _count;

  void increment() {
    setState(() {
      _count++;
    });
  }

  @override
  Widget build(BuildContext context) {
    return Provider.value(
      value: _count,
      child: Provider.value(
        value: this,
        child: widget.child,
      ),
    );
  }
}
```

```dart
return Text(context.watch<int>().toString());
```

```dart
return FloatingActionButton(
  onPressed: () => context.read<ExampleState>().increment(),
  child: Icon(Icons.plus_one),
);
```

--------------------------------

### Replace ValueListenableProvider with ValueListenableBuilder

Source: https://pub.dev/packages/provider/changelog

Alternative implementation for ValueListenableProvider using Provider and ValueListenableBuilder after the removal of the former.

```dart
ValueListenableBuilder<int>(
  valueListenable: myValueListenable,
  builder: (context, value, _) {
    return Provider<int>.value(
      value: value,
      child: MyApp(),
    );
  }
)
```

--------------------------------

### Reading a value with context.watch

Source: https://pub.dev/packages/provider

Use context.watch to obtain a value and listen for changes within a widget's build method.

```dart
class Home extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return Text(
      // Don't forget to pass the type of the object you want to obtain to `watch`!
      context.watch<String>(),
    );
  }
}
```

--------------------------------

### Reduce nesting with MultiProvider

Source: https://pub.dev/packages/provider

Use MultiProvider to flatten the hierarchy of nested Provider declarations.

```dart
Provider<Something>(
  create: (_) => Something(),
  child: Provider<SomethingElse>(
    create: (_) => SomethingElse(),
    child: Provider<AnotherThing>(
      create: (_) => AnotherThing(),
      child: someWidget,
    ),
  ),
),
```

```dart
MultiProvider(
  providers: [
    Provider<Something>(create: (_) => Something()),
    Provider<SomethingElse>(create: (_) => SomethingElse()),
    Provider<AnotherThing>(create: (_) => AnotherThing()),
  ],
  child: someWidget,
)
```

--------------------------------

### Improve DevTools inspection with Diagnosticable

Source: https://pub.dev/packages/provider

Implement DiagnosticableTreeMixin or override toString to provide meaningful debug information in Flutter DevTools.

```dart
class MyClass with DiagnosticableTreeMixin {
  MyClass({this.a, this.b});

  final int a;
  final String b;

  @override
  void debugFillProperties(DiagnosticPropertiesBuilder properties) {
    super.debugFillProperties(properties);
    // list all the properties of your class here.
    // See the documentation of debugFillProperties for more information.
    properties.add(IntProperty('a', a));
    properties.add(StringProperty('b', b));
  }
}
```

```dart
class MyClass with DiagnosticableTreeMixin {
  MyClass({this.a, this.b});

  final int a;
  final String b;

  @override
  String toString() {
    return '$runtimeType(a: $a, b: $b)';
  }
}
```

--------------------------------

### Disabling lazy initialization

Source: https://pub.dev/packages/provider

Set the lazy parameter to false to force the provider to initialize immediately rather than on first request.

```dart
MyProvider(
  create: (_) => Something(),
  lazy: false,
)
```

--------------------------------

### Implement ReassembleHandler for Hot-Reload

Source: https://pub.dev/packages/provider

Implement the ReassembleHandler interface in your ChangeNotifier to execute logic during hot-reload events.

```dart
class Example extends ChangeNotifier implements ReassembleHandler {
  @override
  void reassemble() {
    print('Did hot-reload');
  }
}
```

```dart
ChangeNotifierProvider(create: (_) => Example()),
```

--------------------------------

### Reusing an existing object instance

Source: https://pub.dev/packages/provider

Use the .value constructor when providing an existing instance to prevent premature disposal.

```dart
MyChangeNotifier variable;

ChangeNotifierProvider.value(
  value: variable,
  child: ...
)
```

--------------------------------

### Incorrect reuse of an existing object

Source: https://pub.dev/packages/provider

Do not use the default constructor to provide an existing instance, as it may trigger disposal while the object is still in use.

```dart
MyChangeNotifier variable;

ChangeNotifierProvider(
  create: (_) => variable,
  child: ...
)
```

--------------------------------

### Avoid Duplicate Provider Types

Source: https://pub.dev/packages/provider

Use distinct types for nested providers to ensure the correct instance is retrieved by child widgets.

```dart
Provider<String>(
  create: (_) => 'England',
  child: Provider<String>(
    create: (_) => 'London',
    child: ...,
  ),
),
```

```dart
Provider<Country>(
  create: (_) => Country('England'),
  child: Provider<City>(
    create: (_) => City('London'),
    child: ...,
  ),
),
```

--------------------------------

### Incorrect object creation with .value

Source: https://pub.dev/packages/provider

Avoid using the .value constructor for creating new objects to prevent undesired side effects.

```dart
ChangeNotifierProvider.value(
  value: MyModel(),
  child: ...
)
```

--------------------------------

### Handle State Mutations Safely

Source: https://pub.dev/packages/provider

Avoid modifying ChangeNotifier during widget builds. Perform mutations in the constructor or asynchronously after the frame.

```dart
initState() {
  super.initState();
  context.read<MyNotifier>().fetchSomething();
}
```

```dart
class MyNotifier with ChangeNotifier {
  MyNotifier() {
    _fetchSomething();
  }

  Future<void> _fetchSomething() async {}
}
```

```dart
initState() {
  super.initState();
  Future.microtask(() =>
    context.read<MyNotifier>().fetchSomething(someValue);
  );
}
```

--------------------------------

### Incorrect object creation from changing variables

Source: https://pub.dev/packages/provider

Creating objects from variables that change over time will result in the object not updating when the source variable changes.

```dart
int count;

Provider(
  create: (_) => MyModel(count),
  child: ...
)
```
Tokens:
Raw