Flutter笔记：状态提升、控制器模式、GetX控制器和服务

class Counter with ChangeNotifier {
  int _count = 0;
  int get count => _count;
  void increment() {
    _count++;
    notifyListeners();
  }
}

class CounterWidget extends StatelessWidget {
  final Counter counter;
  CounterWidget({@required this.counter});
  @override
  Widget build(BuildContext context) {
    return ListenableBuilder(
      listenable: counter,
      builder: (context, _) {
        return Text('Count: ${counter.count}');
      },
    );
  }
}

/// 计数器控制器类
/// 
/// - 存储计数器状态；
/// - 提供改变状态的方法作为外部改变状态的接口。
class CounterController with ChangeNotifier {
  int _count = 0;
  int get count => _count;
  void increment() {
    _count++;
    notifyListeners();
  }
}

class CounterController extends GetxController {
  int count = 0;
  void increment() {
    count++;
    update();
  }
}

class CounterWidget extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    final counterController = Get.put(CounterController());
    return Scaffold(
      appBar: AppBar(title: Text('Counter')),
      body: Center(
        child: GetBuilder<CounterController>(
          builder: (controller) => Text('Count: ${controller.count}'),
        ),
      ),
      floatingActionButton: FloatingActionButton(
        child: Icon(Icons.add),
        onPressed: counterController.increment,
      ),
    );
  }
}

// 控制器类
class CounterController extends GetxController {
  RxInt count = 0.obs;
  void increment() {
    count++;
  }
}

// 界面组件
class CounterView extends StatelessWidget {
  final CounterController controller = Get.put(CounterController());
  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text('Counter App with GetX'),
      ),
      body: Center(
        child: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          children: [
            Obx(() => Text('Count: ${controller.count}')),
            ElevatedButton(
              onPressed: () => controller.increment(),
              child: Text('Increment'),
            ),
          ],
        ),
      ),
    );
  }
}

class CounterService extends GetxService {
  var count = 0.obs;
  void increment() {
    count.value++;
  }
}

class CounterWidget extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    final counterService = Get.put(CounterService());
    return Scaffold(
      appBar: AppBar(title: Text('Counter')),
      body: Center(
        child: Obx(() => Text('Count: ${counterService.count.value}')),
      ),
      floatingActionButton: FloatingActionButton(
        child: Icon(Icons.add),
        onPressed: counterService.increment,
      ),
    );
  }
}

class AuthService extends GetxService {
  Future<AuthService> init() async {
    // Initialize your class
  }
}

void userLogout() {
  // ...其他的注销逻辑...
  // 重置应用状态
  Get.reset();
}

void userLogout() {
  // ...其他的注销逻辑...
  // 重置CounterService的状态
  Get.find<CounterService>().reset();
}

/// 一个维护监听器列表的对象。
///
/// 监听器通常用于通知客户端对象已经更新。
///
/// 这个接口有两个变体：
///
///  * [ValueListenable]，一个增强了[Listenable]接口的接口，
///    增加了_当前值_的概念。
///
///  * [Animation]，一个增强了[ValueListenable]接口的接口，
///    增加了方向（前进或后退）的概念。
///
/// Flutter API中的许多类使用或实现了这些接口。以下子类特别相关：
///
///  * [ChangeNotifier]，可以被子类化或混入以创建实现[Listenable]接口的对象。
///
///  * [ValueNotifier]，实现了[ValueListenable]接口，具有一个可变值，
///    当修改时触发通知。
///
/// "通知客户端"，"发送通知"，"触发通知"，
/// 和"发出通知"这些术语可以互换使用。
///
/// 另请参阅：
///
///  * [AnimatedBuilder]，一个在给定的[Listenable]触发通知时使用构建器回调重建的小部件。
///    这个小部件通常与[Animation]子类一起使用，因此得名，但绝不仅限于动画，
///    因为它可以与任何[Listenable]一起使用。它是[AnimatedWidget]的子类，
///    可以用来创建由[Listenable]驱动的小部件。
///  * [ValueListenableBuilder]，一个在[ValueListenable]对象触发通知时使用构建器回调重建的小部件，
///    向构建器提供对象的值。
///  * [InheritedNotifier]，一个抽象的超类，用于使用[Listenable]的通知触发在它们上声明依赖关系的后代小部件的重建，
///    使用[InheritedWidget]机制。
///  * [Listenable.merge]，创建一个[Listenable]，当任何一个给定的[Listenable]触发通知时触发。
abstract class Listenable {
  /// 抽象的const构造函数。这个构造函数使子类能够提供const构造函数，
  /// 以便它们可以在const表达式中使用。
  const Listenable();
  /// 返回一个[Listenable]，当任何给定的[Listenable]自身触发时触发。
  ///
  /// 在调用此方法后，列表不能更改。这样做会导致内存泄漏或异常。
  ///
  /// 列表可能包含null；它们会被忽略。
  factory Listenable.merge(List<Listenable?> listenables) = _MergingListenable;
  /// 注册一个闭包，当对象通知其监听器时调用。
  void addListener(VoidCallback listener);
  /// 从对象通知的闭包列表中删除一个先前注册的闭包。
  void removeListener(VoidCallback listener);
}

/// 为[Listenable]的子类提供的接口，该接口暴露一个[value]。
///
/// 这个接口由[ValueNotifier<T>]和[Animation<T>]实现，并且
/// 允许其他API交替接受这两种实现。
///
/// 另请参见：
///
///  * [ValueListenableBuilder]，一个使用构建器回调的小部件，
///    每当[ValueListenable]对象触发其通知时重建，
///    并为构建器提供对象的值。
abstract class ValueListenable<T> extends Listenable {
  /// 抽象的const构造函数。这个构造函数使得子类可以提供
  /// const构造函数，以便它们可以在const表达式中使用。
  const ValueListenable();
  /// 对象的当前值。当值发生变化时，将调用
  /// 使用[addListener]注册的回调。
  T get value;
}

/// 一个可以被扩展或混入的类，它提供了一个使用[VoidCallback]进行通知的更改通知API。
///
/// 添加监听器的时间复杂度为O(1)，移除监听器和分发通知的时间复杂度为O(N)（其中N为监听器的数量）。
///
/// ## 使用ChangeNotifier子类作为数据模型
///
/// 一个数据结构可以扩展或混入[ChangeNotifier]来实现[Listenable]接口，从而可以与监听[Listenable]更改的小部件一起使用，例如[ListenableBuilder]。
///
/// {@tool dartpad}
/// 下面的示例实现了一个简单的计数器，它使用[ListenableBuilder]来限制只有包含计数的[Text]小部件重建。当前计数存储在[ChangeNotifier]子类中，当其值更改时，它会重建[ListenableBuilder]的内容。
///
/// ** 参见 examples/api/lib/widgets/transitions/listenable_builder.2.dart 中的代码 **
/// {@end-tool}
///
/// {@tool dartpad}
/// 在这种情况下，[ChangeNotifier]子类封装了一个列表，并在列表中添加任何项目时通知客户端。此示例仅支持添加项目；作为练习，考虑添加从列表中删除项目的按钮。
///
/// ** 参见 examples/api/lib/widgets/transitions/listenable_builder.3.dart 中的代码 **
/// {@end-tool}
///
/// 另请参见：
///
///  * [ValueNotifier]，它是一个包装单个值的[ChangeNotifier]。
mixin class ChangeNotifier implements Listenable {
  int _count = 0;
  // _listeners故意设置为固定长度的_GrowableList而不是const []。
  //
  // const []会创建一个_ImmutableList的实例，这与此类中其他地方使用的固定长度_GrowableList不同。
  // 在此类的生命周期中保持运行时类型相同，可以让编译器为此属性推断具体类型，从而提高性能。
  static final List<VoidCallback?> _emptyListeners = List<VoidCallback?>.filled(0, null);
  List<VoidCallback?> _listeners = _emptyListeners;
  int _notificationCallStackDepth = 0;
  int _reentrantlyRemovedListeners = 0;
  bool _debugDisposed = false;
  /// 如果为true，那么此实例的[ObjectCreated]事件已经被分派到[MemoryAllocations]。
  ///
  /// 由于[ChangedNotifier]被用作mixin，它没有构造函数，
  /// 所以我们使用[addListener]来分派事件。
  bool _creationDispatched = false;
  /// 由子类使用来断言[ChangeNotifier]尚未被处理。
  ///
  /// {@tool snippet}
  /// [debugAssertNotDisposed]函数应该只在断言中被调用，如下例所示。
  ///
  /// ```dart
  /// class MyNotifier with ChangeNotifier {
  ///   void doUpdate() {
  ///     assert(ChangeNotifier.debugAssertNotDisposed(this));
  ///     // ...
  ///   }
  /// }
  /// ```
  /// {@end-tool}
  // 这是静态的而不是实例方法，因为太多的人试图
  // 实现ChangeNotifier而不是扩展它（所以添加一个方法，特别是对于debug，是太破坏性的）。
  static bool debugAssertNotDisposed(ChangeNotifier notifier) {
    assert(() {
      if (notifier._debugDisposed) {
        throw FlutterError(
          'A ${notifier.runtimeType} was used after being disposed.\n'
          'Once you have called dispose() on a ${notifier.runtimeType}, it '
          'can no longer be used.',
        );
      }
      return true;
    }());
    return true;
  }
  /// 是否有任何监听器当前已注册。
  ///
  /// 客户端不应依赖此值来决定他们的行为，因为当一个监听器的逻辑在另一个监听器开始或停止
  /// 监听时发生变化，将导致极其难以追踪的错误。然而，子类可能会使用这个信息来决定当没有
  /// 监听器时是否做任何工作；例如，当添加一个监听器时恢复一个[Stream]，当一个监听器被移除时暂停它。
  ///
  /// 通常，这是通过覆盖[addListener]，在调用`super.addListener()`之前检查
  /// [hasListeners]是否为false，如果是，那么开始确定何时调用
  /// [notifyListeners]所需的任何工作；同样，通过覆盖[removeListener]，在调用
  /// `super.removeListener()`之后检查[hasListeners]是否为false，如果是，
  /// 那么停止同样的工作。
  ///
  /// 如果调用了[dispose]，此方法返回false。
  @protected
  bool get hasListeners => _count > 0;
  /// 将[object]创建的事件分派到[MemoryAllocations.instance]。
  ///
  /// 如果事件已经被分派或[kFlutterMemoryAllocationsEnabled]
  /// 为false，该方法是无操作的。
  ///
  /// 像leak_tracker这样的工具使用对象创建的事件来帮助
  /// 开发者识别对象的所有者，用于故障排除，通过在事件发生时获取堆栈跟踪。
  ///
  /// 但是，由于[ChangeNotifier]是mixin，它没有自己的构造函数。所以，它在第一次`addListener`中通知对象创建，这导致堆栈跟踪指向`addListener`，而不是构造函数。
  ///
  /// 为了使调试更容易，在类的构造函数中调用[ChangeNotifier.maybeDispatchObjectCreation]。
  /// 它将帮助
  /// 识别所有者。
  ///
  /// 确保以条件`if (kFlutterMemoryAllocationsEnabled) ...`
  /// 调用它，以便在标志为false时将该方法摇树剪掉。
  @protected
  static void maybeDispatchObjectCreation(ChangeNotifier object) {
    // 如果kFlutterMemoryAllocationsEnabled为false，树摇器不会包含此方法和MemoryAllocations类。
    if (kFlutterMemoryAllocationsEnabled && !object._creationDispatched) {
      MemoryAllocations.instance.dispatchObjectCreated(
        library: _flutterFoundationLibrary,
        className: '$ChangeNotifier',
        object: object,
      );
      object._creationDispatched = true;
    }
  }
  /// 注册一个闭包，当对象改变时调用。
  ///
  /// 如果给定的闭包已经注册，将添加一个额外的实例，
  /// 并且必须移除添加的次数相同的次数，才会停止调用。
  ///
  /// 在调用[dispose]之后，不得调用此方法。
  ///
  /// {@template flutter.foundation.ChangeNotifier.addListener}
  /// 如果一个监听器被添加两次，并且在迭代期间被移除一次
  /// （例如，响应通知），它仍然会被再次调用。如果，
  /// 另一方面，它被移除的次数与它被注册的次数相同，那么
  /// 它将不再被调用。这种奇怪的行为是[ChangeNotifier]无法确定
  /// 哪个监听器被移除的结果，因为它们是相同的，因此它会保守地仍然
  /// 在知道任何监听器仍然被注册时调用所有的监听器。
  ///
  /// 当在两个单独的对象上注册一个监听器，这两个对象都将所有
  /// 注册转发到一个公共的上游对象时，可以意外地观察到这种惊人的行为。
  /// {@endtemplate}
  ///
  /// 另请参见：
  ///
  ///  * [removeListener]，它从列表中移除一个先前注册的闭包，
  ///    当对象改变时，这些闭包会被通知。
  @override
  void addListener(VoidCallback listener) {
    assert(ChangeNotifier.debugAssertNotDisposed(this));
    if (kFlutterMemoryAllocationsEnabled) {
      maybeDispatchObjectCreation(this);
    }
    if (_count == _listeners.length) {
      if (_count == 0) {
        _listeners = List<VoidCallback?>.filled(1, null);
      } else {
        final List<VoidCallback?> newListeners =
            List<VoidCallback?>.filled(_listeners.length * 2, null);
        for (int i = 0; i < _count; i++) {
          newListeners[i] = _listeners[i];
        }
        _listeners = newListeners;
      }
    }
    _listeners[_count++] = listener;
  }
  void _removeAt(int index) {
    // 由于性能原因，持有监听器的列表不是可增长的。
    // 我们仍然希望在添加了很多监听器然后在notifyListeners迭代之外移除它们时缩小这个列表。
    // 我们只在监听器的实际数量是我们列表长度的一半时这样做。
    _count -= 1;
    if (_count * 2 <= _listeners.length) {
      final List<VoidCallback?> newListeners = List<VoidCallback?>.filled(_count, null);
      // 索引之前的监听器在同一位置。
      for (int i = 0; i < index; i++) {
        newListeners[i] = _listeners[i];
      }
      // 索引之后的监听器向列表的开始移动。
      for (int i = index; i < _count; i++) {
        newListeners[i] = _listeners[i + 1];
      }
      _listeners = newListeners;
    } else {
      // 当监听器的数量超过列表长度的一半时，我们只是
      // 移动我们的监听器，这样我们就可以避免为
      // 整个列表重新分配内存。
      for (int i = index; i < _count; i++) {
        _listeners[i] = _listeners[i + 1];
      }
      _listeners[_count] = null;
    }
  }
  /// 从列表中移除一个先前注册的闭包，当对象改变时，
  /// 这些闭包会被通知。
  ///
  /// 如果给定的监听器没有被注册，调用将被忽略。
  ///
  /// 如果调用了[dispose]，此方法立即返回。
  ///
  /// {@macro flutter.foundation.ChangeNotifier.addListener}
  ///
  /// 另请参见：
  ///
  ///  * [addListener]，它注册一个闭包，当对象
  ///    改变时调用。
  @override
  void removeListener(VoidCallback listener) {
    // 出于可用性原因，允许在处理实例后调用此方法。
    // 由于我们的帧调度逻辑在渲染对象和覆盖之间，
    // 这个实例的所有者通常会在监听器之前一帧被处理。
    // 允许在处理后调用此方法使监听器更容易正确清理。
    for (int i = 0; i < _count; i++) {
      final VoidCallback? listenerAtIndex = _listeners[i];
      if (listenerAtIndex == listener) {
        if (_notificationCallStackDepth > 0) {
          // 我们在notifyListeners迭代期间不调整列表的大小
          // 但是我们设置为null，我们想要移除的监听器。我们将
          // 在所有notifyListeners迭代结束后有效地调整列表的大小。
          _listeners[i] = null;
          _reentrantlyRemovedListeners++;
        } else {
          // 当我们在notifyListeners迭代之外时，我们可以
          // 有效地缩小列表。
          _removeAt(i);
        }
        break;
      }
    }
  }
  /// 丢弃对象使用的任何资源。在调用此方法后，对象
  /// 不处于可用状态，应该被丢弃（在对象被处理后调用
  /// [addListener]将抛出异常）。
  ///
  /// 此方法只应由对象的所有者调用。
  ///
  /// 此方法不会通知监听器，并在调用后清除监听器列表。
  /// 此类的消费者必须在处理前立即决定是否通知
  /// 监听器。
  @mustCallSuper
  void dispose() {
    assert(ChangeNotifier.debugAssertNotDisposed(this));
    assert(
      _notificationCallStackDepth == 0,
      '在调用"notifyListeners()"的过程中调用了"$this"的"dispose()"方法。'
      '这可能会导致错误，因为它在列表被使用的时候修改了监听器列表。',
    );
    assert(() {
      _debugDisposed = true;
      return true;
    }());
    if (kFlutterMemoryAllocationsEnabled && _creationDispatched) {
      MemoryAllocations.instance.dispatchObjectDisposed(object: this);
    }
    _listeners = _emptyListeners;
    _count = 0;
  }
  /// 调用所有注册的监听器。
  ///
  /// 每当对象改变时，调用此方法，以通知任何客户端
  /// 对象可能已经改变。在此迭代期间添加的监听器
  /// 将不会被访问。在此迭代期间被移除的监听器将
  /// 在被移除后不会被访问。
  ///
  /// 监听器抛出的异常将被捕获并使用
  /// [FlutterError.reportError]报告。
  ///
  /// 在调用[dispose]之后，不得调用此方法。
  ///
  /// 当重入地移除一个监听器（例如，
  /// 响应通知）已经被注册多次时，可能会出现意外的行为。
  /// 请参见[removeListener]的讨论。
  @protected
  @visibleForTesting
  @pragma('vm:notify-debugger-on-exception')
  void notifyListeners() {
    assert(ChangeNotifier.debugAssertNotDisposed(this));
    if (_count == 0) {
      return;
    }
    // 为了确保在此迭代期间被移除的监听器不被调用，
    // 我们将它们设置为null，但我们不会立即缩小列表。
    // 通过这样做，我们可以继续在我们的列表上迭代，直到它到达
    // 在调用此方法之前添加的最后一个监听器。
    // 为了允许潜在的监听器递归调用notifyListener，我们跟踪
    // 此方法被调用的次数在_notificationCallStackDepth中。
    // 一旦每个递归迭代完成（即，当_notificationCallStackDepth == 0时），
    // 我们可以安全地缩小我们的列表，以便它只包含不为null
    // 的监听器。
    _notificationCallStackDepth++;
    final int end = _count;
    for (int i = 0; i < end; i++) {
      try {
        _listeners[i]?.call();
      } catch (exception, stack) {
        FlutterError.reportError(FlutterErrorDetails(
          exception: exception,
          stack: stack,
          library: 'foundation library',
          context: ErrorDescription('while dispatching notifications for $runtimeType'),
          informationCollector: () => <DiagnosticsNode>[
            DiagnosticsProperty<ChangeNotifier>(
              'The $runtimeType sending notification was',
              this,
              style: DiagnosticsTreeStyle.errorProperty,
            ),
          ],
        ));
      }
    }
    _notificationCallStackDepth--;
    if (_notificationCallStackDepth == 0 && _reentrantlyRemovedListeners > 0) {
      // 当所有通知都完成时，我们真正地移除监听器。
      final int newLength = _count - _reentrantlyRemovedListeners;
      if (newLength * 2 <= _listeners.length) {
        // 如同_removeAt，我们只在真正的监听器数量是
        // 我们列表长度的一半时缩小列表。
        final List<VoidCallback?> newListeners = List<VoidCallback?>.filled(newLength, null);
        int newIndex = 0;
        for (int i = 0; i < _count; i++) {
          final VoidCallback? listener = _listeners[i];
          if (listener != null) {
            newListeners[newIndex++] = listener;
          }
        }
        _listeners = newListeners;
      } else {
        // 否则我们将所有的null引用放在最后。
        for (int i = 0; i < newLength; i += 1) {
          if (_listeners[i] == null) {
            // 我们将此项与下一个非null项交换。
            int swapIndex = i + 1;
            while (_listeners[swapIndex] == null) {
              swapIndex += 1;
            }
            _listeners[i] = _listeners[swapIndex];
            _listeners[swapIndex] = null;
          }
        }
      }
      _reentrantlyRemovedListeners = 0;
      _count = newLength;
    }
}

/// 一个持有单个值的[ChangeNotifier]。
///
/// 当[value]被替换为不等于旧值的东西时
/// 由等号运算符==评估，此类通知其监听器。
///
/// ## 限制
///
/// 因为这个类只在[value]的 _identity_ 改变时通知监听器，
/// 所以当值本身的可变状态改变时，监听器不会被通知。
///
/// 例如，当列表的 _内容_ 改变时。`ValueNotifier<List<int>>`不会通知其监听器
/// 
/// 因此，这个类最好只用于不可变的数据类型。
///
/// 对于可变的数据类型，考虑直接扩展[ChangeNotifier]。
class ValueNotifier<T> extends ChangeNotifier implements ValueListenable<T> {
  /// 创建一个包装此值的[ChangeNotifier]。
  ValueNotifier(this._value) {
    if (kFlutterMemoryAllocationsEnabled) {
      ChangeNotifier.maybeDispatchObjectCreation(this);
    }
  }
  /// 此通知器中存储的当前值。
  ///
  /// 当值被替换为不等于旧值的东西时
  /// 由等号运算符==评估，此类通知其监听器。
  @override
  T get value => _value;
  T _value;
  set value(T newValue) {
    if (_value == newValue) {
      return;
    }
    _value = newValue;
    notifyListeners();
  }
  @override
  String toString() => '${describeIdentity(this)}($value)';
}