/// loadBuffer方法用于加载图片数据并返回ImageStreamCompleter对象。
@override
ImageStreamCompleter loadBuffer(
    image_provider.ExtendedNetworkImageProvider key,
    DecoderBufferCallback decode) {
  // Ownership of this controller is handed off to [_loadAsync]; it is that
  // method's responsibility to close the controller's stream when the image
  // has been loaded or an error is thrown.
  final StreamController<ImageChunkEvent> chunkEvents =
      StreamController<ImageChunkEvent>();

  return MultiFrameImageStreamCompleter(
    codec: _loadAsync(
      key as ExtendedNetworkImageProvider,
      chunkEvents,
      decode,
    ),
    scale: key.scale,
    chunkEvents: chunkEvents.stream,
    debugLabel: key.url,
    informationCollector: () {
      return <DiagnosticsNode>[
        DiagnosticsProperty<ImageProvider>('Image provider', this),
        DiagnosticsProperty<image_provider.ExtendedNetworkImageProvider>(
            'Image key', key),
      ];
    },
  );
}

/// _loadAsync方法是实际加载图片数据的核心逻辑。它首先尝试从缓存中加载图片数据，如果缓存中不存在，则从网络加载图片数据。
Future<ui.Codec> _loadAsync(
  ExtendedNetworkImageProvider key,
  StreamController<ImageChunkEvent> chunkEvents,
  DecoderBufferCallback decode,
) async {
  assert(key == this);
  final String md5Key = cacheKey ?? keyToMd5(key.url);
  ui.Codec? result;
  if (cache) {
    try {
      final Uint8List? data = await _loadCache(  /// _loadCache方法用于从缓存中加载图片数据。
        key,
        chunkEvents,
        md5Key,
      );
      if (data != null) {
        result = await instantiateImageCodec(data, decode);
      }
    } catch (e) {
      if (printError) {
        print(e);
      }
    }
  }

  if (result == null) {
    try {
      final Uint8List? data = await _loadNetwork(
        key,
        chunkEvents,
      );
      if (data != null) {
        result = await instantiateImageCodec(data, decode);
      }
    } catch (e) {
      if (printError) {
        print(e);
      }
    }
  }

  //Failed to load
  if (result == null) {
    //result = await ui.instantiateImageCodec(kTransparentImage);
    return Future<ui.Codec>.error(StateError('Failed to load $url.'));
  }

  return result;
}

/// _loadCache方法用于从缓存中加载图片数据。
/// Get the image from cache folder.
Future<Uint8List?> _loadCache(
  ExtendedNetworkImageProvider key,
  StreamController<ImageChunkEvent>? chunkEvents,
  String md5Key,
) async {
  final Directory _cacheImagesDirectory = Directory(
      join((await getTemporaryDirectory()).path, cacheImageFolderName));
  Uint8List? data;
  // exist, try to find cache image file
  if (_cacheImagesDirectory.existsSync()) { /// existsSync是一个同步方法，用于检查具有该路径的文件系统实体是否存在。
    final File cacheFlie = File(join(_cacheImagesDirectory.path, md5Key));
    if (cacheFlie.existsSync()) {  /// existsSync是一个同步方法，用于检查具有该路径的文件系统实体是否存在。
      if (key.cacheMaxAge != null) {
        final DateTime now = DateTime.now();
        final FileStat fs = cacheFlie.statSync();
        if (now.subtract(key.cacheMaxAge!).isAfter(fs.changed)) {
          cacheFlie.deleteSync(recursive: true);
        } else {
          data = await cacheFlie.readAsBytes();
        }
      } else {
        data = await cacheFlie.readAsBytes();
      }
    }
  }
  // create folder
  else {
    await _cacheImagesDirectory.create();
  }
  // load from network
  if (data == null) {
    data = await _loadNetwork(
      key,
      chunkEvents,
    );
    if (data != null) {
      // cache image file
      await File(join(_cacheImagesDirectory.path, md5Key)).writeAsBytes(data);
    }
  }

  return data;
}

int b = 10;
String s = "hello";
var a = 1;
dynamic c = 0.5;

dynamic obj = {};
if (obj is Map) {
  // 进过类型判断后，Dart 知道 obj 是一个 Map，所以这里再不用强制转换 obj 的类型为Map。
  obj['foo'] = 42;
}

// 虽然 Dart 也提供了 as 让我们进行类型的强制转换，但为了进来更安全的转换，更推荐使用 is
var map = obj as Map;

int.parse("100");
123.toString();

// 写法1：声明返回值(推荐)
int add(int a, int b) {
  return a + b;
}

// 写法2：不声明返回值（不加返回值的函数同样可以正常工作）
add2(int a, int b) {
  return a + b;
}

// 写法3：你还可以用`=>`代替return语句（=>是return语句的简写）
// 此写法只能执行单行
add3(a, b) => a + b; 

main() {
  print(add(1, 2)); 	// 3
  print(add2(2, 3)); 	// 5
  print(add3(1, 2)); 	// 3
}

Class A {
	int method1(int x);			// 实例方法
	
	static int method2(int y); // 类方法
}

// 调用
a = A().method1(1);
b = A.method2(2);

void main() {
  print(defalut_foo1(1, 2)); // 结果为3
}

// 这种常见的写法，参数默认都是必填的，而且没法给默认值
int defalut_foo1(int x, int y) {
  return x + y;
}

void main() {
  print(option_foo1(1));	 			// 结果为1,		x
  print(option_foo1(1, 1)); 		// 结果为11，	 x+10y，而不会是x+100z
  print(option_foo1(1, 1, 1)); 	// 结果为111,	x+10y+100z
}

// 可选参数
// 使用可选参数的函数写法1：含可选参数的函数
int option_foo1(int x, [int y, int z]) {
  int iResult = x;
  if (y != null) { // 是的，int 也可以是 null
    iResult += 10*y;
  }
  
  if (z != null) { // 是的，int 也可以是 null
    iResult += 100*z;
  }
  
  return iResult;
}

// 使用可选参数的函数写法2：可选参数支持有默认值
int option_foo2(int x, [int y = 0]) {
  return x + y;
}

// 具名参数（named parameters）的用法，调用时候具名参数的顺序可以是任意的
// 使用具名参数的函数参数写法1：
int named_foo1({int x, int y}) {
  return x + y;
}


// 使用具名参数的函数参数写法2：所有的具名参数本身就都是可选的，而且具名参数也可以有默认参数
int named_foo2({int x = 0, int y = 0}) {
  return x + y;
}

void main() {
  // 具名参数的顺序可以是任意的
  print(named_foo1(x: 1, y: 2));
  print(named_foo1(y: 3, x: 4));
  print(named_foo1()); //错误：会导致 foo() 在运行时抛异常
  print(named_foo2(x: 1, y: 2));
  print(named_foo2()); // 正确：不会导致 foo() 在运行时抛异常
}

// 必须参数(如果想告诉用户某个具名参数是必须的，可以使用注解 @require)
// 不是具名参数，默认就是 @required 必填。
int require_foo1(@required int x, @required int y) {
  return x + y;
}

// 是具名参数，默认就是 非必填，非 @required
int require_foo2({@required int x, @required int y}) {
  return x + y;
}

void main() {
  print(require_foo1(1, 2)); // 结果为3
  
  print(require_foo2(x:1, y:2)); // 结果为3
}

// 用typedef用于定义函数类型的别名
typedef ClickCallBack = int Function(int x, int y);

// 实例：将a和b两个数，经过指定的操作返回
String onButtonPress1(int a, int b, ClickCallBack callback) {
  int iResult = callback(a, b);
  return iResult.toString();
}

void main() {
  String string = onButtonPress1(1,  2, (x, y) {
    return x + y;
  });
  print("string = " + string);
}

// 用typedef用于定义函数类型的别名
typedef Adder = int Function(int, int);

String Function(String msg) cancelHandle;// 实际场景中的应用

Adder makeAdder1(int extra) {
  int adder(int x, int y) {
    return x + y + extra;
  }
  return adder;
}

// Dart 里面不仅变量支持类型推断，lambda 的参数也支持自动推断。上面的代码还可以进一步简化为：
Adder makeAdder2(int extra) {
  // 我们要返回的类型是 Adder，所以 Dart 知道 x, y 都是 int
  return (x, y) => x + y + extra;
}

void main() {
  var adder1 = makeAdder1(2);
  print(adder1(1, 2));
    
  var adder2 = makeAdder2(2);
  print(adder2(1, 2));
}

printNum(int a) {
  print("$a");
}

test(Function callback) {
  callback("hello");
}


main() {
  var f1 = printNum;
  Function f2 = printNum;
  var f3 = (int a) => print("a = $a");
  f1(1);
  f2(2);
  f3(6);
}

class User {
  // 成员变量写法1：
  String name;
  int age;
  String gender;
  // 成员变量写法2：使用getter/setter声明的成员变量
  String get uid => "24210853532539238";
  set right(String uid) => left = value - width;
  
  // 通过创建一个与其类同名的函数来声明构造函数。如果您未声明构造函数，则会为您提供默认构造函数。默认构造函数没有参数，并在超类中调用无参数构造函数。
  // 构造方法写法1:跟类名相同的构造方法
  User(this.name, this.age, this.gender);
  // 构造方法写法2:命名的构造方法
  User.defaultUser() {
    name = "dvlp";
    age = 20;
  }
  
  // 成员方法写法1:有方法体(是非抽象方法)
  sayHello() {
    print("hello, this is $name, I am $age years old, I am a $gender");
  }
  // 成员方法写法2:没有方法体(是抽象方法，需要子类去实现)
  void doSomething();
}

// 抽象类（无法实例化的类）,如果希望抽象类看起来是可实例化的，请定义工厂构造函数。
// 抽象类通常有抽象方法，如下：
// 此类声明为abstract，因此是抽象类，即也就无法实例化
abstract class Test {
  //定义构造函数，字段，方法...
    
  // 抽象方法
  void test();
}

User(String name, int age, String gender) {
    this.name = name;
    this.age = age;
    this.gender = gender;
}

// 使用getter/setter声明的成员变量
class Rectangle {
  num left, top, width, height;

  // 构造方法传入left, top, width, height几个参数
  Rectangle(this.left, this.top, this.width, this.height);

  // right, bottom两个成员变量提供getter/setter方法
  num get right => left + width;
  set right(num value) => left = value - width;
  num get bottom => top + height;
  set bottom(num value) => top = value - height;
}

main() {
  var user1 = new Person("zhangsan", 20, "male");
  user.age = 30;
  user.gender = "female";
  user.sayHello();
    
  var user2 = new Person.defaultUser()
}

class Test {
  // 除非你重写noSuchMethod，否则使用不存在的成员会导致NoSuchMethodError
  // Unless you override noSuchMethod, using a
  // non-existent member results in a NoSuchMethodError.
  @override
  void noSuchMethod(Invocation invocation) {
    print('You tried to use a non-existent member: ' +
        '${invocation.memberName}');
  }
}

class Developer extends User {
  // 实现了父类的抽象方法
  void doSomething() {
    print("I'm developing...");
  }
}

class FlutterDeveloper extends Developer {
  @override	// 表示doSomething是重写父类的方法
  void doSomething() {
    super.doSomething();
    print("I'm developing Flutter...");
  }
}

class iOSDeveloper extends Developer {
  @override // 表示doSomething是重写父类的方法
  void doSomething() {
    super.doSomething();
    print("I'm developing iOS...");
  }
}

class FullStackDeveloper extends Developer with iOSDeveloper with FlutterDeveloper {
  @override	// 表示doSomething是重写父类的方法
  void doSomething() {
    super.doSomething();
    print("I'm developing...");
  }
}

class A {
  a() {
    print("A's a()");
  }
}

class B {
  b() {
    print("B's b()");
  }
}

// 使用with关键字，表示类C是由类A和类B混合而构成
class C = A with B;

main() {
  C c = new C();
  c.a(); // A's a()
  c.b(); // B's b()
}

// 用import语句来导入某个包
// 如果你想导入自己写的某个代码文件，使用相对路径即可
import './util.dart';

// 你可以使用as关键字为导入的某个包设置一个前缀，或者说别名
import 'package:lib2/lib2.dart' as lib2;

// 导入包时使用deferred as可以让这个包懒加载，懒加载的包只会在该包被使用时得到加载，而不是一开始就加载，比如
import 'package:greetings/hello.dart' deferred as hello;

import 'package:lib1/lib1.dart';
import 'package:lib2/lib2.dart' as lib2;

// Uses Element from lib1.
Element element1 = Element();

// Uses Element from lib2.
lib2.Element element2 = lib2.Element();

// 只导入lib1中的foo功能
import 'package:lib1/lib1.dart' show foo;

// 导入lib2中的除了foo外的所有其他部分
import 'package:lib2/lib2.dart' hide foo;

class Person {
  eat() {
    print("I am eating...");
  }

  sleep() {
    print("I am sleeping...");
  }

  study() {
    print("I am studying...");
  }
}

main() {
  // 依次打印
  //  I am eating...
  //  I am sleeping...
  //  I am studying...
  new Person()..eat()
      ..sleep()
      ..study();
}

// switch语句
  String a = "hello";
  // case语句中的数据类型必须是跟switch中的类型一致
  switch (a) {
    case "hello":
      print("haha");
      break;
    case "world":
      print("heihei");
      break;
    default:
      print("WTF");
  }

Future<String> checkVersion() async {
  var version = await lookUpVersion();
  return version;
}

// 类的静态成员变量和静态成员方法
class Cons {
  static const name = "zhangsan";
  static sayHello() {
    print("hello, this is ${Cons.name}");
  }
}

main() {
  Cons.sayHello(); // hello, this is zhangsan
  print(Cons.name); // zhangsan
}

var names = List<String>();