handle deleting instances

Author: AhmedAbdoElhawary

lib/features/sorting/base/view/sorting_page.dart

@@ -14,16 +14,24 @@ part '../widgets/control_buttons.dart';
 part '../widgets/size_draggable.dart';
 part '../widgets/speed_draggable.dart';
 
-class SortingPage extends StatelessWidget {
+class SortingPage extends ConsumerWidget {
   const SortingPage({required this.instance, required this.title, super.key});
   final StateNotifierProvider<SortingNotifier, SortingNotifierState> instance;
   final String title;
 
   @override
-  Widget build(BuildContext context) {
-    return Scaffold(
-      appBar: appBar(),
-      body: _BuildBody(instance: instance),
+  Widget build(BuildContext context, WidgetRef ref) {
+    return PopScope(
+      onPopInvokedWithResult: (didPop, result) async {
+        if (didPop) {
+          await ref.read(instance.notifier).cancelSorting();
+          ref.invalidate(instance); // deletes current instance and resets
+        }
+      },
+      child: Scaffold(
+        appBar: appBar(),
+        body: _BuildBody(instance: instance),
+      ),
     );
   }
 

lib/features/sorting/base/view_model/sorting_notifier.dart

@@ -104,18 +104,23 @@ abstract class SortingNotifier extends StateNotifier<SortingNotifierState> {
     generateAgain();
   }
 
-  void stopSorting() {
-    _cancelableSort?.cancel();
+  Future<void> cancelSorting() async {
+   await _cancelableSort?.cancel();
+  }
+
+  Future<void> stopSorting() async {
+   await _cancelableSort?.cancel();
     if (_getOperation == SortingEnum.played) _setOperation = SortingEnum.stopped;
   }
 
-  Future<void> playSorting() async {
+  Future<void> playSorting(BuildContext context) async {
     if (_getOperation == SortingEnum.played) return;
     _setOperation = SortingEnum.played;
 
     await _startSelectedSorting();
 
-    _setOperation = SortingEnum.none;
+// to avoid error of mounted when popup while the sorting algorithm still running
+    if (context.mounted) _setOperation = SortingEnum.none;
   }
 
   Future<void> generateAgain() async {

lib/features/sorting/base/widgets/control_buttons.dart

@@ -7,7 +7,7 @@ class _SortingControlButtons extends ConsumerWidget {
   @override
   Widget build(BuildContext context, ref) {
     return SortingControlButtons(
-      playSorting: () => ref.read(instance.notifier).playSorting(),
+      playSorting: () => ref.read(instance.notifier).playSorting(context),
       stopSorting: () => ref.read(instance.notifier).stopSorting(),
       generateAgain: () => ref.read(instance.notifier).generateAgain(),
     );

lib/features/sorting/comparison/view/comparison_sort_page.dart

@@ -24,63 +24,65 @@ class ComparisonSortPage extends ConsumerStatefulWidget {
 
 class _ComparisonSortPageState extends ConsumerState<ComparisonSortPage> {
   @override
-  void deactivate() {
-    ref.invalidate(_notifierProvider); // deletes current instance and resets
-
-    ComparisonSortNotifier.sortingAlgorithms.values.toList().forEach(
-      (element) {
-        try {
-          ref.invalidate(element.provider);
-        } catch (e) {
-          //
+  Widget build(BuildContext context) {
+    return PopScope(
+      onPopInvokedWithResult: (didPop, result) async {
+        if (didPop) {
+          await ref.read(_notifierProvider.notifier).cancelSorting(ref);
+
+          ComparisonSortNotifier.sortingAlgorithms.values.toList().forEach(
+            (element) {
+              try {
+                ref.invalidate(element.provider);
+              } catch (e) {
+                //
+              }
+            },
+          );
+          ref.invalidate(_notifierProvider); // deletes current instance and resets
         }
       },
-    );
-    super.deactivate();
-  }
-
-  @override
-  Widget build(BuildContext context) {
-    return Scaffold(
-      appBar: appBar(),
-      drawer: const _DrawerMenu(),
-      body: SafeArea(
-        child: Column(
-          children: [
-            const Flexible(child: _BuildComparisonLists()),
-            const RSizedBox(height: 15),
-            Padding(
-              padding: REdgeInsets.symmetric(horizontal: 0),
-              child: Align(
-                alignment: AlignmentDirectional.bottomCenter,
-                child: Column(
-                  mainAxisAlignment: MainAxisAlignment.end,
-                  spacing: 10,
-                  children: [
-                    SortingControlButtons(
-                      playSorting: () => ref.read(_notifierProvider.notifier).playSorting(ref),
-                      stopSorting: () => ref.read(_notifierProvider.notifier).stopSorting(ref),
-                      generateAgain: () => ref.read(_notifierProvider.notifier).generateAgain(ref),
-                    ),
-                    SymmetricPadding(
-                      horizontal: 15,
-                      child: Row(
-                        mainAxisAlignment: MainAxisAlignment.spaceBetween,
-                        children: [
-                          SpeedDraggable(
-                            onChanged: (persent) {
-                              ref.read(_notifierProvider.notifier).changeSpeed(persent, ref);
-                            },
-                          ),
-                          _SizeDraggable(ref: ref),
-                        ],
+      child: Scaffold(
+        appBar: appBar(),
+        drawer: const _DrawerMenu(),
+        body: SafeArea(
+          child: Column(
+            children: [
+              const Flexible(child: _BuildComparisonLists()),
+              const RSizedBox(height: 15),
+              Padding(
+                padding: REdgeInsets.symmetric(horizontal: 0),
+                child: Align(
+                  alignment: AlignmentDirectional.bottomCenter,
+                  child: Column(
+                    mainAxisAlignment: MainAxisAlignment.end,
+                    spacing: 10,
+                    children: [
+                      SortingControlButtons(
+                        playSorting: () => ref.read(_notifierProvider.notifier).playSorting(context, ref),
+                        stopSorting: () => ref.read(_notifierProvider.notifier).stopSorting(ref),
+                        generateAgain: () => ref.read(_notifierProvider.notifier).generateAgain(ref),
+                      ),
+                      SymmetricPadding(
+                        horizontal: 15,
+                        child: Row(
+                          mainAxisAlignment: MainAxisAlignment.spaceBetween,
+                          children: [
+                            SpeedDraggable(
+                              onChanged: (persent) {
+                                ref.read(_notifierProvider.notifier).changeSpeed(persent, ref);
+                              },
+                            ),
+                            _SizeDraggable(ref: ref),
+                          ],
+                        ),
                       ),
-                    ),
-                  ],
+                    ],
+                  ),
                 ),
               ),
-            ),
-          ],
+            ],
+          ),
         ),
       ),
     );

lib/features/sorting/comparison/view_model/comparison_sort_notifier.dart

@@ -11,6 +11,7 @@ import 'package:algorithm_visualizer/features/sorting/radix/view_model/radix_sor
 import 'package:algorithm_visualizer/features/sorting/selection/view_model/selection_sort_notifier.dart';
 import 'package:algorithm_visualizer/features/sorting/shell/view_model/shell_sort_notifier.dart';
 import 'package:collection/collection.dart';
+import 'package:flutter/cupertino.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 part 'comparison_sort_state.dart';
 
@@ -138,20 +139,27 @@ class ComparisonSortNotifier extends StateNotifier<ComparisonSortingNotifierStat
     _setOperation = SortingEnum.none;
   }
 
-  Future<void> playSorting(WidgetRef ref) async {
+  Future<void> playSorting(BuildContext context, WidgetRef ref) async {
     if (_getOperation == SortingEnum.played) return;
 
-    final playSorting = state.selectedAlgorithms.map((e) => ref.read(e.provider.notifier).playSorting());
+    final playSorting =
+        state.selectedAlgorithms.map((e) => ref.read(e.provider.notifier).playSorting(context));
     _setOperation = SortingEnum.played;
 
     await Future.wait(playSorting.toList());
-    _setOperation = SortingEnum.none;
+    if (context.mounted) _setOperation = SortingEnum.none;
   }
 
-  void stopSorting(WidgetRef ref) {
-    for (var element in state.selectedAlgorithms) {
-      ref.read(element.provider.notifier).stopSorting();
-    }
+  Future<void> stopSorting(WidgetRef ref) async {
+    final stopSorting = state.selectedAlgorithms.map((e) => ref.read(e.provider.notifier).stopSorting());
+    _setOperation = SortingEnum.played;
+
+    await Future.wait(stopSorting.toList());
+
     if (_getOperation == SortingEnum.played) _setOperation = SortingEnum.stopped;
   }
+  Future<void> cancelSorting(WidgetRef ref) async {
+    final cancelSorting = state.selectedAlgorithms.map((e) => ref.read(e.provider.notifier).cancelSorting());
+    await Future.wait(cancelSorting.toList());
+  }
 }