provider_architecture.dart

void main() {
  setupLocator();
  runApp(const MyApp());
}

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

  // This widget is the root of your application.
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter Demo',
      theme: ThemeData(
        primarySwatch: Colors.blue,
      ),
      home: const Scaffold(),
    );
  }
}

class HomeScreenProvider extends ChangeNotifier {
  String username = 'James Bond';
  bool isBusy = false;
  _setBusyForObject(Object object, bool value){
    object = value;
  }
  setBusy(bool value){
    _setBusyForObject(isBusy, value);
    notifyListeners();
  }
}

class TaskScreenProvider extends ChangeNotifier{
  final HomeScreenProvider _homeScreenProvider = locator<HomeScreenProvider>()..setBusy(true);
  void printName(){
    print(_homeScreenProvider.username);
  }

}

class HomeScreen extends StatelessWidget {
  const HomeScreen({Key? key}) : super(key: key);
  @override
  Widget build(BuildContext context) {
    return Scaffold(
      body: ViewModelBuilder<HomeScreenProvider>(
        disposeModel: false,
        viewModelBuilder: () => locator<HomeScreenProvider>(),
        builder: (context, HomeScreenProvider model, child) {
          return Container();
        },
      ),
    );
  }
}

typedef BuilderFunc<T extends ChangeNotifier> = Widget Function(
    BuildContext context, T model, Widget? child);

class ViewModelBuilder<T extends ChangeNotifier> extends StatefulWidget {
  final T Function() viewModelBuilder;
  final Function(T model)? onModelReady;
  final BuilderFunc<T> builder;
  final bool disposeModel;
  final Widget? staticChild;

  const ViewModelBuilder(
      {Key? key,
        required this.viewModelBuilder,
        this.onModelReady,
        required this.builder,
        this.disposeModel = true,
        this.staticChild})
      : super(key: key);

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

class _ViewModelBuilderState<T extends ChangeNotifier>
    extends State<ViewModelBuilder<T>> {
  T? _viewModel;
  @override
  void initState() {
    _viewModel = widget.viewModelBuilder();
    super.initState();
  }

  @override
  Widget build(BuildContext context) {
    if (widget.disposeModel) {
      return ChangeNotifierProvider(
        create: (_) => _viewModel!,
        child: Consumer<T>(
          builder: widget.builder,
        ),
      );
    }
    return ChangeNotifierProvider<T>.value(
      value: _viewModel!,
      child: widget.builder(context, _viewModel!, widget.staticChild!),
    );
  }

  @override
  void dispose() {
    super.dispose();
  }
}


typedef FactoryFunc<T> = T Function();
class Locator{
  Locator._internal();

  final Map<dynamic ,dynamic> _items = {};

  static final Locator _instance = Locator._internal();

  factory Locator()=>_instance;

  registerSingleton<T extends Object>(FactoryFunc<T> factoryFunc){
    _items.putIfAbsent(T, () => factoryFunc());
  }

  T get <T>(){
    return _items[T];
  }

  T call<T>(){
    return _items[T];
  }
}
Locator locator = Locator();


setupLocator(){
  locator.registerSingleton<HomeScreenProvider>(() => HomeScreenProvider());
}