آموزش پیاده سازی معماری MVVM در فلاتر

abstract class StateData extends Equatable {
  const StateData();
}

abstract class ViewModel<T extends StateData> implements ValueListenable<T> {
  ViewModel(T initial) : _stateDataNotifier = ValueNotifier(initial);

  final ValueNotifier<T> _stateDataNotifier;

  @protected
  set stateData(T value) => _stateDataNotifier.value = value;

  @override
  T get value => _stateDataNotifier.value;

  @override
  void addListener(VoidCallback listener) {
    _stateDataNotifier.addListener(listener);
  }

  @override
  void removeListener(VoidCallback listener) {
    _stateDataNotifier.removeListener(listener);
  }

  @mustCallSuper
  void dispose() {
    _stateDataNotifier.dispose();
  }
}

  set value(T newValue) {
    if (_value == newValue)
      return;
    _value = newValue;
    notifyListeners();
  }

abstract class Screen extends StatefulWidget {
  const Screen({Key? key}) : super(key: key);

  @override
  ScreenState createState();
}

abstract class ScreenState<T extends Screen, T2 extends ViewModel<T3>,
    T3 extends StateData> extends State<T> {
  ScreenState();

  late final T2 viewModel;

  Widget buildScreen(BuildContext context);

  @override
  Widget build(BuildContext context) {
    return MultiProvider(
      providers: [
        ValueListenableProvider<T3>.value(value: viewModel),
      ],
      builder: (context, _) => buildScreen(context),
    );
  }

  @override
  @mustCallSuper
  void initState() {
    super.initState();
    viewModel = context.read<ViewModelFactory>().create<T2>();
  }

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

class HomeData extends StateData {
  const HomeData({
    required this.todoTiles,
    required this.showEmptyState,
    required this.showLoading,
  });

  const HomeData.initial()
      : todoTiles = const [],
        showLoading = false,
        showEmptyState = false;

  final List<TodoTileData> todoTiles;
  final bool showLoading;
  final bool showEmptyState;

  @override
  List<Object?> get props => [
        todoTiles,
        showLoading,
        showEmptyState,
      ];
}

@injectable
class HomeViewModel extends ViewModel<HomeData> {
  HomeViewModel(
    this._todoRepository,
  ) : super(const HomeData.initial());

  final TodoRepository _todoRepository;

  StreamSubscription<List<TodoTileData>>? _todoSub;

  void init() {
    _updateList();

    _todoSub = _todoRepository
        .observeTodoList()
        .map((todoList) => todoList.map(TodoTileData.fromTodo).toList())
        .listen(_onTodoChanged);
  }

  @override
  void dispose() {
    _todoSub?.cancel();
    super.dispose();
  }

  Future<void> changeTodoStatus(String id, bool isDone) async {
    await _todoRepository.updateTodoStatus(id, isDone);
  }

  void _updateState({
    List<TodoTileData>? tiles,
    bool? isLoading,
  }) {
    tiles ??= value.todoTiles;
    isLoading ??= value.showLoading;

    stateData = HomeData(
      todoTiles: tiles,
      showEmptyState: tiles.isEmpty && !isLoading,
      showLoading: isLoading,
    );
  }

  Future<void> _updateList() async {
    _updateState(isLoading: true);

    await _todoRepository.updateTodoList();

    _updateState(isLoading: false);
  }

  void _onTodoChanged(List<TodoTileData> tiles) {
    _updateState(tiles: tiles);
  }
}

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

  @override
  Widget build(BuildContext context) {
    return Selector<HomeData, bool>(
      selector: (_, data) => data.showLoading,
      builder: (context, showLoading, _) => Visibility(
        visible: showLoading,
        child: const CircularProgressIndicator(),
      ),
    );
  }
}

class HomeScreen extends Screen {
  const HomeScreen({Key? key}) : super(key: key);

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

class _HomeScreenState
    extends ScreenState<HomeScreen, HomeViewModel, HomeData> {
  @override
  void initState() {
    super.initState();
    viewModel.init();
  }

  @override
  Widget buildScreen(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: const Text('Todo List')),
      body: Stack(
        fit: StackFit.expand,
        children: [
          _TodoList(
            changeListener: _todoChangeListener,
          ),
          const Center(child: _ProgressBar()),
          const _EmptyState(),
        ],
      ),
      floatingActionButton: FloatingActionButton(
        onPressed: () {
          CreateTodoScreenRoute().push(context);
        },
        child: const Icon(Icons.add),
      ),
    );
  }

  void _todoChangeListener(TodoChange change) {
    viewModel.changeTodoStatus(change.id, change.isDone);
  }
}

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

  @override
  Widget build(BuildContext context) {
    return Selector<HomeData, bool>(
      selector: (_, data) => data.showLoading,
      builder: (context, showLoading, _) => Visibility(
        visible: showLoading,
        child: const CircularProgressIndicator(),
      ),
    );
  }
}

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

  @override
  Widget build(BuildContext context) {
    return Selector<HomeData, bool>(
      selector: (_, data) => data.showEmptyState,
      builder: (context, showEmptyState, _) => Visibility(
        visible: showEmptyState,
        child: Padding(
          padding: const EdgeInsets.symmetric(vertical: 8, horizontal: 16),
          child: Text(
            'Add something first',
            style: Theme.of(context).textTheme.headline4,
          ),
        ),
      ),
    );
  }
}

class _TodoList extends StatelessWidget {
  const _TodoList({
    Key? key,
    required this.changeListener,
  }) : super(key: key);

  final ValueChanged<TodoChange> changeListener;

  @override
  Widget build(BuildContext context) {
    return Selector<HomeData, List<TodoTileData>>(
      selector: (_, data) => data.todoTiles,
      builder: (context, todoTiles, _) {
        return ListView.separated(
          itemBuilder: (context, index) {
            final data = todoTiles[index];
            return TodoTile(
              key: ValueKey(data.id),
              data: data,
              changeListener: changeListener,
            );
          },
          separatorBuilder: (_, __) => const Divider(),
          itemCount: todoTiles.length,
        );
      },
    );
  }
}

abstract class ViewModelFactory {
  T create<T extends ViewModel>();
}

@Singleton(as: ViewModelFactory)
class ViewModelFactoryImpl implements ViewModelFactory {
  @override
  T create<T extends ViewModel>() => getIt.get<T>();
}

class GlobalProvider extends StatelessWidget {
  const GlobalProvider({
    Key? key,
    required this.child,
  }) : super(key: key);

  final Widget child;

  @override
  Widget build(BuildContext context) {
    return MultiProvider(
      providers: [
        Provider.value(value: getIt.get<ViewModelFactory>()),
      ],
      child: child,
    );
  }
}