Flutter确保初始化插件ensure_initialized的使用

ensure_initialized 是一个Flutter包，用于确保对象在使用前已经完成初始化。这个包特别适用于需要进行耗时初始化的对象。以下是该包的基本用法和示例代码。

用法

添加Mixin到类中

首先，将 EnsureInitializedMixin 或 EnsureInitializedResultMixin<T> 添加到你的类中：

class YourObject with EnsureInitializedMixin {
  // 类的具体实现
}

等待初始化完成

你可以通过 await object.ensureInitialized 来等待对象完成初始化：

final object = YourObject();

await object.ensureInitialized;

object.doSomethingAfterItIsReady();

如果你的初始化有返回值，可以使用 EnsureInitializedResultMixin<T>：

class YourObjectWithResult with EnsureInitializedResultMixin<int> {
  // 类的具体实现
}

final objectWithResult = YourObjectWithResult();

final result = await objectWithResult.ensureInitialized;

print(result);

检查是否已初始化

你可以通过 isInitialized 属性来检查对象是否已完成初始化：

final object = YourObject();

print(object.isInitialized); // false

await object.init(); // 调用初始化方法

print(object.isInitialized); // true

成功初始化

调用 initializedSuccessfully() 方法表示初始化成功：

Future<void> init() async {
  await Future.delayed(const Duration(seconds: 3));
  
  initializedSuccessfully();
}

如果有返回值，传递相应类型的值：

initializedSuccessfully(5);

初始化失败

如果初始化失败，调用 initializedWithError 方法：

Future<void> init() async {
  try {
    await Future.delayed(const Duration(seconds: 3));
    
    initializedSuccessfully();
  } on Exception catch (e, s) {
    initializedWithError(error: e, stackTrace: s);
  }
}

流处理

whenInitialized 和 whenUninitialized 可以用来监听对象的初始化状态变化：

object.whenInitialized.listen((_) {
  print('My object was initialized!');
});

重新初始化

可以通过 markAsUninitialized() 方法标记对象为未初始化状态：

class UserService with EnsureInitializedMixin {
  Future signIn(credentials) async {
    // 登录逻辑
    
    initializedSuccessfully();
  }
  
  Future signOut() async {
    // 登出逻辑
    
    markAsUninitialized();
  }
}

示例代码

以下是一个完整的示例代码，展示了如何使用 ensure_initialized 包：

import 'dart:async';
import 'package:ensure_initialized/ensure_initialized.dart';

Future main(List<String> args) async {
  print('=== W/O Result ===\n');
  final heavyInitialComputations = HeavyInitialComputations();

  heavyInitialComputations.whenInitialized.listen(
    (_) {
      print('\nWhen Initialized is Fired!\n');
    },
  );

  try {
    print('Calling doSomething ...');

    final data = await heavyInitialComputations.doSomething();

    print('doSomething result: $data');
  } on Exception catch (e, s) {
    print('Unable to do something');
    print(e);
    print(s);
  }

  await Future.delayed(Duration(milliseconds: 500));

  print('\n=== W/ Result ===\n');

  final heavyInitialComputationsResult = HeavyInitialComputationsResult();
  heavyInitialComputationsResult.whenInitialized.listen(
    (result) {
      print('\nWhen Initialized with result is Fired! The result is: $result\n');
    },
  );

  try {
    print('Calling doSomething ...');

    final data = await heavyInitialComputationsResult.doSomething();

    print('doSomething result: $data');
  } on Exception catch (e, s) {
    print('Unable to do something');
    print(e);
    print(s);
  }
}

class HeavyInitialComputations with EnsureInitializedMixin {
  HeavyInitialComputations() {
    _init();
  }

  Future<void> _heavyComputations() async {
    await Future.delayed(const Duration(seconds: 3));
  }

  Future<void> _init() async {
    try {
      await _heavyComputations();
      initializedSuccessfully();
    } on Exception catch (e, s) {
      initializedWithError(error: e, stackTrace: s);
    }
  }

  Future<int> doSomething() async {
    await ensureInitialized;
    return 25;
  }
}

class HeavyInitialComputationsResult with EnsureInitializedResultMixin<String> {
  HeavyInitialComputationsResult() {
    _init();
  }

  Future<String> _heavyComputations() async {
    await Future.delayed(const Duration(seconds: 3));
    return 'I am initialized!';
  }

  Future<void> _init() async {
    try {
      final result = await _heavyComputations();
      initializedSuccessfully(result);
    } on Exception catch (e, s) {
      initializedWithError(error: e, stackTrace: s);
    }
  }

  Future<String> doSomething() async {
    final initResult = await ensureInitialized;
    return 'Upper cased: ${initResult.toUpperCase()}';
  }
}

以上示例展示了如何在Flutter应用中使用 ensure_initialized 包来确保对象在使用前已经完成初始化，并且能够处理初始化成功和失败的情况。