一、初识flutter image

在讲解源码之前，我们先看下面几个例子，回顾一下flutter加载图片资源的方式。

1.1、显示一张图片

Flutter应用程序包含两部分：代码和assets，其中assets最终会打包在apk的assets/flutter_assets目录下，可以在程序运行的过程中访问。我们知道flutter中是通过pubspec.xml文件来配置应用所需的依赖，图片资源也类似。比如想显示一个名为a.png的图片，只需要两步：
1、将图片a.png拷贝到xxx目录下，并在pubspec.yaml中配置assets依赖：

flutter:
  assets:
    - xxx/a.png

2、在代码中通过Image.asset构造函数加载图片，参数为在pubspec.xml配置的图片路径：

Image.asset("xxx/a.png");

1.2、加载不同分辨率的图片

flutter在加载图片时会根据手机的分辨率选择最合适的图片进行显示，要实现这种映射关系，需要根据特定的目录结构来存放图片：

…xxx/Mx/image.png
…xxx/Nx/image.png

其中M和N是数字标识符，对应于其中包含的图像的分辨率。

举个简单的例子，现在有两张a.png的图片分别对应着dpi为2.0和3.0，使用时，在图片目录下创建两个文件夹：2.0x和3.0x，将对应的图片拷贝进去，并在pubspec.yaml配置对应图片资源的key：

flutter:
  assets:
    - xxx/a.png

在flutter中会将对应资源项（这里是xxx/a.png）所在的目录的二级目录中与资源项名字相同的图片认为是统一资源，在打包的过程中会将资源项按照key-value的形式存入apk的assets/flutter_assets/AssetManifest.json文件中，flutter在加载资源是首先会先解析这个文件，后再选择最适合的图片进行显示，其中AssetManifest.json的具体格式如下：

{"xxx/a.png":["xxx/2.0x/a.png","xxx/3.0x/a.png"]}

在flutter中可以将通过目录的方式配置assets，需要注意的是它只会打包当前目录的文件，二级目录不会进行打包除非在assets中手动配置，例如想要要打包a目录下的所有文件，只需要pubspec.yaml配置目录即可：

flutter:
  assets:
    - a/

需要主要的这种用法只针对文件，对于目录是无效的，比如a目录下的b目录并不会被打入apk中，需要手动指定，具体的原因参照第三部分。

1.3、加载packages中的图片

假设开发的package test中包含应用需要的图片，那在应用程序中如何加载这些图片那？

有下面两种方式：

1、如果package的pubspec.yaml中已经声明了这张图片，在应用程序中不需要做任何操作，只需要在通过AssetImage加载时加入包名即可：

Image.asset("xxx/a.png",package:"test");

2、如果test的pubspec.yaml文件中没有声明对图片的依赖，flutter默认会将package的lib目录作为包的依赖目录，我们可以将图片放在lib/文件夹中，这种情况下，需要在应用程序的pubspec.yaml中进行声明：

flutter:
  assets:
    - packages/test/xxx/a.png

有一点需要注意，这两种方式引入package不能通过本地依赖的方式，这是因为flutter_tools 打包包资源的过程中会判断依赖的目录是否以file开头，如果不是就不进行解析，具体的逻辑参考第三章flutter打包解析。通过上面的介绍，我们大致知道在flutter中本地资源如何使用，下面从源码上分析资源的加载和打包过程。

二、资源加载源码分析

上面一节已经介绍过，加载本地图片需要用到Image控件的asset构造函数，flutter对Image控件提供了丰富的加载图片的api：

Image.network   从网络加载图片
Image.file      从file加载图片
Image.asset     从本地assets目录加载图片
Image.memory    从缓存中加载图片

这里只分析Image.asset的源码，其他的思路是一样的。

我们就看Image.asset干了什么。

 Image.asset({...}) : image = scale != null
         ? new ExactAssetImage(name, bundle: bundle, scale: scale, package: package)
         : new AssetImage(name, bundle: bundle, package: package);

Image继承于StatefulWidget类，构造函数比较简单，主要是用于设置成员变量，其中一个重要的变量是image，它是ImageProvider类型的对象，是加载图片资源的入口，对于不同的图片加载方式（网路、文件）对应着不同类型的ImageProvider对象，这里首先判断是不是需要对图片进行缩放操作来决定image是AssetImage还是ExactAssetImage类型，假设这里正常显示，image为AssetImage类型的对象。

由于Image继承于StatefulWidget类型的对象，所以widget的build的逻辑在对应的State中，接下来我们看一下Image对应的State类：

class _ImageState extends State<Image> {
  //用于处理image resource,它里面存有两个成员变量：ImageStreamCompleter(图片解析器)和_ImageListenerPair(类似于java的Pair对象，有两个成员函数：listener和errorListener分别对应图片加载成功和失败的回调)，用于存储图片解析完成和失败的回调。
  ImageStream _imageStream;
  //包含了图片的真正数据信息，成员变量有：scale(压缩比)、ui.Iamge(ARGB像素数据，通过Canvas.draw可以将其画到画布上)
  ImageInfo _imageInfo;
  bool _isListeningToStream = false;
  //在initState后调用，在组件的初始化阶段调用
  @override
  void didChangeDependencies() {
    //解析图片
    _resolveImage();
    //设置和移除监听图片成功的回调
    if (TickerMode.of(context))
      _listenToStream();
    else
      _stopListeningToStream();
    super.didChangeDependencies();
  }

  //组件状态发生变化时调用(比如说调用了setState函数)
  @override
  void didUpdateWidget(Image oldWidget) {
    super.didUpdateWidget(oldWidget);
    //如果组件的图片来源发生了变化，则调用_resolveImage函数重新获取最新的图片
    if (widget.image != oldWidget.image)
      _resolveImage();
  }
  //debug期间组件重组时调用（比如热更新）
  @override
  void reassemble() {
    _resolveImage();
    super.reassemble();
  }

  void _resolveImage() {
  //根据ImageConfiguration调用ImageProvider的resolve函数获得ImageStream对象，ImageStream
    final ImageStream newStream =
      widget.image.resolve(createLocalImageConfiguration(
          context,
          size: widget.width != null && widget.height != null ? new Size(widget.width, widget.height) : null
      ));
    _updateSourceStream(newStream);
  }
    //图片加载成功的回调，更新数据信息，重绘界面
  void _handleImageChanged(ImageInfo imageInfo, bool synchronousCall) {
    setState(() {
      _imageInfo = imageInfo;
    });
  }

  //更新state中的ImageStream对象
  void _updateSourceStream(ImageStream newStream) {
    if (_imageStream?.key == newStream?.key)
      return;

    if (_isListeningToStream)
      _imageStream.removeListener(_handleImageChanged);

    if (!widget.gaplessPlayback)
      setState(() { _imageInfo = null; });

    _imageStream = newStream;
    if (_isListeningToStream)
      _imageStream.addListener(_handleImageChanged);
  }

  void _listenToStream() {
    if (_isListeningToStream)
      return;
    _imageStream.addListener(_handleImageChanged);
    _isListeningToStream = true;
  }

  void _stopListeningToStream() {
    if (!_isListeningToStream)
      return;
    _imageStream.removeListener(_handleImageChanged);
    _isListeningToStream = false;
  }

  @override
  void dispose() {
    _stopListeningToStream();
    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
  //RawImage渲染图片的控件，用于显示ImageInfo中
    final RawImage image = new RawImage(
      image: _imageInfo?.image,
      width: widget.width,
      height: widget.height,
      scale: _imageInfo?.scale ?? 1.0,
      color: widget.color,
      colorBlendMode: widget.colorBlendMode,
      fit: widget.fit,
      alignment: widget.alignment,
      repeat: widget.repeat,
      centerSlice: widget.centerSlice,
      matchTextDirection: widget.matchTextDirection,
    );
    if (widget.excludeFromSemantics)
      return image;
    return new Semantics(
      container: widget.semanticLabel != null,
      image: true,
      label: widget.semanticLabel == null ? '' : widget.semanticLabel,
      child: image,
    );
  }
}

从上面的代码中可以看出，在控件刚创建或者是状态更新时都会调用ImageProvider的resolve函数获得ImageStream。

接着我们看一下AssetImage的resolve方法：

 ImageStream resolve(ImageConfiguration configuration) {
    final ImageStream stream = new ImageStream();
    T obtainedKey;
    obtainKey(configuration).then<void>((T key) {
      obtainedKey = key;
      stream.setCompleter(PaintingBinding.instance.imageCache.putIfAbsent(key, () => load(key)));
    }).catchError(
      (dynamic exception, StackTrace stack) async {
        ...
     });
    return stream;
  }

obtainKey是一个抽象方法，在AssetImage中返回一个Future<AssetBundleImageKey>的对象，并作为PaintingBinding.instance.imageCache缓存的key，将load(key)加入到cache中。PaintingBinding.instance.imageCache是ImageCache类型的变量，是flutter的图片存储池，在dart在初始化时设置的，生命周期和整个dart虚拟机相同，默认缓存池的大小为100M，图片总量为1000个。通过上面的方法，知道在resolve函数最重要的两个方法为obtainKey和load，下面我们挨个分析，首先是AssetImage的obtainKey函数：

 @override
  Future<AssetBundleImageKey> obtainKey(ImageConfiguration configuration) {
    final AssetBundle chosenBundle = bundle ?? configuration.bundle ?? rootBundle;
    Completer<AssetBundleImageKey> completer;
    Future<AssetBundleImageKey> result;
    
    chosenBundle.loadStructuredData<Map<String, List<String>>>(_kAssetManifestFileName, _manifestParser).then<void>(
      (Map<String, List<String>> manifest) {
        final String chosenName = _chooseVariant(
          keyName,
          configuration,
          manifest == null ? null : manifest[keyName]
        );
        final double chosenScale = _parseScale(chosenName);
        final AssetBundleImageKey key = new AssetBundleImageKey(
          bundle: chosenBundle,
          name: chosenName,
          scale: chosenScale
        );
        if (completer != null) {
          completer.complete(key);
        } else {
          result = new SynchronousFuture<AssetBundleImageKey>(key);
        }
      }
    ).catchError((dynamic error, StackTrace stack) {
      ....
    });
    ...
    completer = new Completer<AssetBundleImageKey>();
    return completer.future;
  }

从上面的代码可知，首先从configuration得到AssetBundle对象，AssetBundle是flutter加载资源功能类，通过上面介绍_ImageState我们知道这个对象是通过createLocalImageConfiguration函数创建，通过跟踪源码可知我们bundle的类型为PlatformAssetBundle，由于代码比较简单，这就不做介绍有兴趣的同学可以自行看代码。接着会调用对应的AssetBundle的loadStructuredData函数,这个函数的功能是获取_kAssetManifestFileName字符串对应文件的内容，并交给_manifestParser函数进行解析，并将结果封装成future返回。其中_kAssetManifestFileName对应的字符串为AssetManifest.json，下面看源码：

@override
  Future<T> loadStructuredData<T>(String key, Future<T> parser(String value)) {
    //_structuredDataCache是一个map，用来缓存查找结果，如果如果已经缓存过数据，就将其返回，假设这里是第一次加载，这里为false，就会走到下面方法
    if (_structuredDataCache.containsKey(key))
      return _structuredDataCache[key];
    Completer<T> completer;
    Future<T> result;
    //这里首先调用loadString函数获取key文件对应的文本信息的future，然后将加载的数据缓存到map中
    loadString(key, cache: false).then<T>(parser).then<void>((T value) {
      result = new SynchronousFuture<T>(value);
      _structuredDataCache[key] = result;
     
    });
    ....
    return completer.future;
  }
  
  Future<String> loadString(String key, { bool cache = true }) async {
    //这里调用load方法获取获取key对应的二进制数据流
    final ByteData data = await load(key);
    //将数据流转化为string对象
    ...
    return compute(_utf8decode, data, debugLabel: 'UTF8 decode for "$key"');
  }
  
    @override
  Future<ByteData> load(String key) async {
    //将string转会为Uint8List对象，通过上面可知key为AssetManifest.json
    final Uint8List encoded = utf8.encoder.convert(new Uri(path: Uri.encodeFull(key)).path);
    //BinaryMessages通过platform plugins发送二进制数据，对应的plugin的名车个为flutter/assets，message为：AssetManifest.json
    final ByteData asset =
        await BinaryMessages.send('flutter/assets', encoded.buffer.asByteData());
  
    return asset;
  }
}
//BinaryMessages send方法继而调用_sendPlatformMessage方法
 static Future<ByteData> send(String channel, ByteData message) {
    ...
    return _sendPlatformMessage(channel, message);
  }
  //最后会进入ui.window.sendPlatformMessage方法
   static Future<ByteData> _sendPlatformMessage(String channel, ByteData message) {
    final Completer<ByteData> completer = new Completer<ByteData>();
    ui.window.sendPlatformMessage(channel, message, ...);
    return completer.future;
  }
 //最后会调到_sendPlatformMessage方法
  String _sendPlatformMessage(String name,
                              PlatformMessageResponseCallback callback,
                              ByteData data) native 'Window_sendPlatformMessage';

_sendPlatformMessage函数是一个用native关键字声明的方法，后面紧跟一个字符串(这个是native声明的函数的标示)，这种类型的函数用于dart调用native的方法，dart虚拟机在启动时会将调用DartLibraryNatives的Register方法将对应的函数名称和函数指针注册进去，这样dart端就可以根据函数名称调用对应的native方法，比如C++端Windows RegisterNatives方法：

void Window::RegisterNatives(tonic::DartLibraryNatives* natives) {
  natives->Register({
      {"Window_defaultRouteName", DefaultRouteName, 1, true},
      {"Window_scheduleFrame", ScheduleFrame, 1, true},
      {"Window_sendPlatformMessage", _SendPlatformMessage, 4, true},
      {"Window_respondToPlatformMessage", _RespondToPlatformMessage, 3, true},
      {"Window_render", Render, 2, true},
      {"Window_updateSemantics", UpdateSemantics, 2, true},
  });

所以上面的dart函数最终会调到native的Window下_SendPlatformMessage方法，接着进入C++中Window的SendPlatformMessage方法：

Dart_Handle 
SendPlatformMessage(Dart_Handle window,
                                const std::string& name,
                                Dart_Handle callback,
                                const tonic::DartByteData& data) {
  UIDartState* dart_state = UIDartState::Current();
  ...
    const uint8_t* buffer = static_cast<const uint8_t*>(data.data());
    dart_state->window()->client()->HandlePlatformMessage(
        fml::MakeRefCounted<PlatformMessage>(
            name, std::vector<uint8_t>(buffer, buffer + data.length_in_bytes()),
            response));
  return Dart_Null();
}

跟这源码一步步往下走，最后会走到Engine的HandlePlatformMessage方法，Engine类是flutter中很重要的一个类，dart和android交互的功能基本都在这个类中，HandlePlatformMessage函数：

void Engine::HandlePlatformMessage(
    fml::RefPtr<blink::PlatformMessage> message) {
    //kAssetChannel是一个字符串，值“flutter/assets”
  if (message->channel() == kAssetChannel) {
    HandleAssetPlatformMessage(std::move(message));
  } else {
    delegate_.OnEngineHandlePlatformMessage(*this, std::move(message));
  }
}

void Engine::HandleAssetPlatformMessage(
    fml::RefPtr<blink::PlatformMessage> message) {
  fml::RefPtr<blink::PlatformMessageResponse> response = message->response();
  if (!response) {
    return;
  }
  const auto& data = message->data();
  std::string asset_name(reinterpret_cast<const char*>(data.data()),
                         data.size());

  if (asset_manager_) {
    std::unique_ptr<fml::Mapping> asset_mapping =
        asset_manager_->GetAsMapping(asset_name);
    if (asset_mapping) {
      response->Complete(std::move(asset_mapping));
      return;
    }
  }

  response->CompleteEmpty();
}

HandlePlatformMessage函数首先会判断channel是不是"flutter/assets"，由上面dart的代码可知这里为true，接着就会调用HandleAssetPlatformMessage函数来读取相应的文件名的内容，这个函数比较简单会调用AssetManager的GetAsMapping函数读取AssetManifest.json文件的内容，其中AssetManager是一个资源读取的代理类，最终会走到APKAssetProvider的GetAsMapping函数：

std::unique_ptr<fml::Mapping> APKAssetProvider::GetAsMapping(
    const std::string& asset_name) const {
  std::stringstream ss;
  ss << directory_.c_str() << "/" << asset_name;
  AAsset* asset =
      AAssetManager_open(assetManager_, ss.str().c_str(), AASSET_MODE_BUFFER);
  if (!asset) {
    return nullptr;
  }

  return std::make_unique<APKAssetMapping>(asset);
}

assetManager_是对应AssetManager的java指针，这里就是调用android虚拟机中 AAssetManager_open的方法读取asset目录下的文件，传入的名称为AssetManifest.json

综上所述，AssetBundle中loadStrig函数最终会通过Android的AssetManager读取assets目录下的AssetManifest.json文件并将结果返回。

接着AssetBundle会调用_manifestParser解析loadString的返回的内容，_manifestParser函数：

static Future<Map<String, List<String>>> _manifestParser(String jsonData) {
    if (jsonData == null)
      return null;
    final Map<String, dynamic> parsedJson = json.decode(jsonData);
    final Iterable<String> keys = parsedJson.keys;
    final Map<String, List<String>> parsedManifest =
        new Map<String, List<String>>.fromIterables(keys,
          keys.map((String key) => new List<String>.from(parsedJson[key])));
    return new SynchronousFuture<Map<String, List<String>>>(parsedManifest);
  }

我们在第一节就介绍过AssetManifest.json的文件格式，它是一个json结构体，key为我们在pub配置的文件名，value对应这不同分辨率文件路径的列表。_manifestParser就是这些json对象解析成Map<String, List<String>的对象，其中key为对象我们在pub中配置的图片名称，value是对应不同分辨率对应的文件路径的列表。

回到AssetImage obtainKey函数，接着回调用_chooseVariant函数，根据key值获取最佳的图片路径：

 String _chooseVariant(String main, ImageConfiguration config, List<String> candidates) {
    ...
    //二叉排序树的map
    final SplayTreeMap<double, String> mapping = new SplayTreeMap<double, String>();
    for (String candidate in candidates)
      mapping[_parseScale(candidate)] = candidate;
    return _findNearest(mapping, config.devicePixelRatio);
  }
  
  String _findNearest(SplayTreeMap<double, String> candidates, double value) {
    //如果候选者里面包含对目标应分辨率的图片，直接返回
    if (candidates.containsKey(value))
      return candidates[value];
    //先找出接近目标分辨率最近的两个候选者分别为lower和upper
    final double lower = candidates.lastKeyBefore(value);
    final double upper = candidates.firstKeyAfter(value);
    //如果其中一个为空，则返回另外一个
    if (lower == null)
      return candidates[upper];
    if (upper == null)
      return candidates[lower];
      //如果两个都为空就选择一个离目标分辨率最近的一个
    if (value > (lower + upper) / 2)
      return candidates[upper];
    else
      return candidates[lower];
  }

这个方法首先通过_parseScale函数获取每一个候选图片路径对应的分辨率（这个方法比较简单，这里就不做讲解了，有兴趣的自行自行阅读），并存入到map中，后面会根据_findNearest函数和手机的分辨率得到最相近的图片路径，作为返回值。比如现在有两种2.0、3.0分辨率的图片，而手机的分辨率为1.6，这时系统会选择2.0的图片作为最终加载的图片资源。最后obtainKey函数会将得到的图片的路径、分辨率和AssetBundle封装成一个Key放回。整个obtainKey函数就分析完了。接着分析AssetImage的load函数：

  @override
  ImageStreamCompleter load(AssetBundleImageKey key) {
    return new MultiFrameImageStreamCompleter(
      codec: _loadAsync(key),
      scale: key.scale,
      informationCollector: (StringBuffer information) {
        information.writeln('Image provider: $this');
        information.write('Image key: $key');
      }
    );
  }

这个函数创建MultiFrameImageStreamCompleter（ImageStreamCompleter的子类）对，并调用_loadAsync函数，设置codec成员变量：

  @protected
  Future<ui.Codec> _loadAsync(AssetBundleImageKey key) async {
    final ByteData data = await key.bundle.load(key.name);
    return await ui.instantiateImageCodec(data.buffer.asUint8List());
  }

key.bundle就是上面介绍的AssetBundle类型的对象，load方法上面也介绍过，它通过platform读取android assets目录下的文件，在相当于读取目标图片的文件内容，接着调用ui.instantiateImageCodec获取Future<Codec>对象。最后调用ImageStreamCompleter的MultiFrameImageStreamCompleter构造函数：

MultiFrameImageStreamCompleter({@required Future<ui.Codec> codec,@required double scale, InformationCollector informationCollector})  {
    ...
    codec.then<void>(_handleCodecReady, onError: (...)
  }
 
  void _handleCodecReady(ui.Codec codec) {
    _codec = codec;
    _decodeNextFrameAndSchedule();
  }
  
   Future<Null> _decodeNextFrameAndSchedule() async {
    try {
      _nextFrame = await _codec.getNextFrame();
    } catch (exception, stack) {
      ...
    }
    if (_codec.frameCount == 1) {
      _emitFrame(new ImageInfo(image: _nextFrame.image, scale: _scale));
      return;
    }
    ...
  }
  void _emitFrame(ImageInfo imageInfo) {
    setImage(imageInfo);
    _framesEmitted += 1;
  }

通过codec.getNextFrame()获取下一帧图像，对于静态的图来说片frameCount始终是1，接着调用ImageInfo的构造函数组装image，并_emitFrame方法，这个方法里会调用setImage：

void setImage(ImageInfo image) {
    _currentImage = image;
    if (_listeners.isEmpty)
      return;
    final List<ImageListener> localListeners = _listeners.map<ImageListener>(
      (_ImageListenerPair listenerPair) => listenerPair.listener
    ).toList();
    for (ImageListener listener in localListeners) {
      try {
        listener(image, false);
      } catch (exception, stack) {
        ...
      }
    }
  }

这个方法会遍历监听图片完成的监听器，通知它们图片已经加载成功，可以刷新ui了。还记得在_ImageState调用ImageStream的addListener设置的回调吗？就是在这里被调用的，并将ImageInfo传入，后flutter会调用_ImageState的build方法，将图片渲染到界面上。到此整个图片加载过程就讲解完毕。

总结一下上面的过程：

1、Image继承于StatefulWidget，对应的_ImageState，它会在初始化和状态变化时调用AssetImage的resolve函数获取和解析图片，并且返回一个ImageStream对象给_ImageState，同时_ImageState也注册一个监听器给ImageStream，当图片加载完成会执行这个回调方法，更新ui。

2、在AssetImage的resolve函数中会调用obtainKey函数，在这个函数中会读取assets目录下AssetManifest.json文件，并根据手机的分辨率选择最合适的图片，接着将结果封装成 Future<AssetBundleImageKey>作为ImageCache的key。

3、AssetImage的load方法是真正加载图片的地方，创建MultiFrameImageStreamCompleter对象，并调用_loadAsync去加载assets目录下的图片。当图片加载完成就调用UI的回调方法，这里对应这_ImageState的_handleImageChanged方法，更新state的状态，重绘图片。

三、资源打包源码分析

在flutter中生成产物的入口为bundle.dart中bundle函数，这里只分析和图片资源相关函数，其余的有兴趣可以自行阅读：

final AssetBundle assets = await buildAssets(
    manifestPath: manifestPath,
    assetDirPath: assetDirPath,
    packagesPath: packagesPath,
    reportLicensedPackages: reportLicensedPackages,
  );
  if (assets == null)
    throwToolExit('Error building assets', exitCode: 1);

  await assemble(
    assetBundle: assets,
    kernelContent: kernelContent,
    snapshotFile: snapshotFile,
    privateKeyPath: privateKeyPath,
    assetDirPath: assetDirPath,
    buildSnapshot: buildSnapshot,
  );

参数解析如下：

manifestPath：pubspec.yaml的路径

assetDirPath：资源生成的路径，例如在android debug模式下对应的目录为/build/intermediates/flutter/debug/flutter_assets

packagesPath：包依赖文件路径（也就是.packages文件的路径），在flutter中会根据pubspec.yaml的配置的包依赖信息生成.packages文件，来声明依赖包的文件路径。其中文件的格式为：包名：本地文件路径。默认拉取的离线包都存在根目录下的.pub-cache文件夹下。

reportLicensedPackages:是否报告包许可证，默认为false

该函数首先调用buildAssets获得AssetBundle（flutter资源管理类）对象，后调用assemble函数将AssetBundle中的内容写入各个文件，下面挨个分析这两个函数。

首先是buildAssets函数：

Future<AssetBundle> buildAssets({String manifestPath,String assetDirPath,String packagesPath,bool includeDefaultFonts = true,bool reportLicensedPackages = false}) async {
  assetDirPath ??= getAssetBuildDirectory();
  packagesPath ??= fs.path.absolute(PackageMap.globalPackagesPath);
  final AssetBundle assetBundle = AssetBundleFactory.instance.createBundle();
  final int result = await assetBundle.build(
    manifestPath: manifestPath,
    assetDirPath: assetDirPath,
    packagesPath: packagesPath,
    includeDefaultFonts: includeDefaultFonts,
    reportLicensedPackages: reportLicensedPackages
  );
  return assetBundle;
}

这个函数首先判断assetDirPath和packagesPath是否为null，如果为null就设置为默认的路径，接着调用AssetBundleFactory的createBundle函数创建AssetBundle的实例，这里用到了工厂模式，通过代码发现，AssetBundleFactory.instance实例的createBundle函数会创建_ManifestAssetBundle实例，接着调用_ManifestAssetBundle的build方法来创建资源的配置信息。

_ManifestAssetBundle的build方法：

 @override
  Future<int> build({String manifestPath = defaultManifestPath,String assetDirPath,String packagesPath,bool includeDefaultFonts = true,bool reportLicensedPackages = false
  }) async {
    ...
    FlutterManifest flutterManifest;
    try {
      flutterManifest = await FlutterManifest.createFromPath(manifestPath);
    } catch (e) {
      ...
    }
    if (flutterManifest == null)
      return 1;

    if (flutterManifest.isEmpty) {
      entries[_assetManifestJson] = new DevFSStringContent('{}');
      return 0;
    }

    final String assetBasePath = fs.path.dirname(fs.path.absolute(manifestPath));
    _lastBuildTimestamp = new DateTime.now();
    final PackageMap packageMap = new PackageMap(packagesPath);
    final Map<_Asset, List<_Asset>> assetVariants = _parseAssets(
      packageMap,
      flutterManifest,
      assetBasePath,
      excludeDirs: <String>[assetDirPath, getBuildDirectory()]
    );

    ...
  }

该函数首先调用createFromPath函数获得FlutterManifest对象，FlutterManifest类型是pubspec.yaml在内存中的表现形式，它读取pubspec.yaml文件的内容，并将文件的各个资源名解析到对应的各个变量中。如果pubspec.yaml没有配置任何依赖就将entries中key为AssetManifest.json的值设置为"{}"。假设我们配置了图片信息，这里就不为空。接着，利用packagesPath参数创建PackageMap实例，PackageMap是.packages文件在内存中的表现形式，它读取和解析.packages文件的内容，并作为参数传递给_parseAssets函数，_parseAssets函数用于解析pubspec.yaml中assets的每一项资源，并封装成Map<_Asset, List<_Asset>>返回，其中key为assets中的资源项，value具有相同名字的资源列表。

_parseAssets函数：

Map<_Asset, List<_Asset>> _parseAssets(
  PackageMap packageMap,
  FlutterManifest flutterManifest,
  String assetBase, {
  List<String> excludeDirs = const <String>[],
  String packageName
}) {
  final Map<_Asset, List<_Asset>> result = <_Asset, List<_Asset>>{};

  final _AssetDirectoryCache cache = new _AssetDirectoryCache(excludeDirs);
  for (Uri assetUri in flutterManifest.assets) {
    if (assetUri.toString().endsWith('/')) {
      _parseAssetsFromFolder(packageMap, flutterManifest, assetBase,
          cache, result, assetUri,
          excludeDirs: excludeDirs, packageName: packageName);
    } else {
      _parseAssetFromFile(packageMap, flutterManifest, assetBase,
          cache, result, assetUri,
          excludeDirs: excludeDirs, packageName: packageName);
    }
  }
  ...
  return result;
}

该函数比较简单，遍历pubspec.yaml中assets的资源项，并根据资源是否为目录，分别调用_parseAssetsFromFolder和_parseAssetFromFile这两个方法，首先看_parseAssetFromFile方法：

void _parseAssetFromFile(PackageMap packageMap,FlutterManifest flutterManifest,
  String assetBase,_AssetDirectoryCache cache,Map<_Asset, List<_Asset>> result,Uri assetUri, {
  List<String> excludeDirs = const <String>[],
  String packageName
}) {
  final _Asset asset = _resolveAsset(
    packageMap,
    assetBase,
    assetUri,
    packageName,
  );
  final List<_Asset> variants = <_Asset>[];
  for (String path in cache.variantsFor(asset.assetFile.path)) {
    final String relativePath = fs.path.relative(path, from: asset.baseDir);
    final Uri relativeUri = fs.path.toUri(relativePath);
    final Uri entryUri = asset.symbolicPrefixUri == null
        ? relativeUri
        : asset.symbolicPrefixUri.resolveUri(relativeUri);

    variants.add(
      new _Asset(
        baseDir: asset.baseDir,
        entryUri: entryUri,
        relativeUri: relativeUri,
        )
    );
  }

  result[asset] = variants;
}

_parseAssetFromFile函数首先调用_resolveAsset获得资源的_Asset对象，_Asset是存储资源信息的实体类，它有三个成员变量，baseDir：资源所在的目录，relativeUri：相对目录，entryUri：在pubspec.yaml文件中资源名。接着调用variantsFor函数查找资源的变种列表资源，最后遍历第二步得到列表，根据每个资源的路径得到_Asset实例并加入到列表中。下面我们看一下variantsFor函数：

  List<String> variantsFor(String assetPath) {
    //获得资源的文件名
    final String assetName = fs.path.basename(assetPath);
     //获得资源的目录
    final String directory = fs.path.dirname(assetPath);
    
    if (!fs.directory(directory).existsSync())
      return const <String>[];
     //这里假设是第一次查找，_cache中自然是没有对应的缓存，所以判断为true
    if (_cache[directory] == null) {
      final List<String> paths = <String>[];
      //遍历directory下的二级目录的文件路径，并将其加入到paths中
      for (FileSystemEntity entity in fs.directory(directory).listSync(recursive: true)) {
        final String path = entity.path;
        if (fs.isFileSync(path) && !_excluded.any((String exclude) => path.startsWith(exclude)))
          paths.add(path);
      }
      //从对应的文件列表中找出了相同文件的文件路径，并将其存入到variants中，variants是map类型的变量，其中key为文件名，value为拥有相同文件名的文件路径列表
      final Map<String, List<String>> variants = <String, List<String>>{};
      for (String path in paths) {
        final String variantName = fs.path.basename(path);
        if (directory == fs.path.dirname(path))
          continue;
        variants[variantName] ??= <String>[];
        variants[variantName].add(path);
      }
      _cache[directory] = variants;
    }
    //返回assetName对应的文件路径的列表
    return _cache[directory][assetName] ?? const <String>[];
  }
}

通过上面的分析，可知上面的函数的作用就是在assetPath对应目录的二级目录中找到和assetPath相同文件名的文件，并分别加入到列表中返回。比如assets的路径如下：

assets/foo
assets/xxx/foo
assets/xxx/foo
assets/bar

那么variantsFor('assets/foo') 返回值为：['/assets/xxx/foo', '/assets/xxx/foo']，整个_parseAssetFromFile就解析完了，整个函数的功能就是根据assets中的资源项，找到其对应目录的二级目录中和其相同文件名的文件路径，加载到result变量中。下面接着看_parseAssetsFromFolder函数：

void _parseAssetsFromFolder(PackageMap packageMap,FlutterManifest flutterManifest,String assetBase,_AssetDirectoryCache cache,Map<_Asset, List<_Asset>> result,Uri assetUri, {List<String> excludeDirs = const <String>[],String packageName}) {
  final String directoryPath = fs.path.join(
      assetBase, assetUri.toFilePath(windows: platform.isWindows));
      
  if (!fs.directory(directoryPath).existsSync()) {
    printError('Error: unable to find directory entry in pubspec.yaml: $directoryPath');
    return;
  }
  final List<FileSystemEntity> lister = fs.directory(directoryPath).listSync();
  for (FileSystemEntity entity in lister) {
    if (entity is File) {
      final String relativePath = fs.path.relative(entity.path, from: assetBase);
      final Uri uri = new Uri.file(relativePath, windows: platform.isWindows);
      _parseAssetFromFile(packageMap, flutterManifest, assetBase, cache, result,
          uri, packageName: packageName);
    }
  }
}

_parseAssetsFromFolder这个函数首先判断assets中配置的资源对应的目录是否存在，如果不存在直接抛出异常，这里为false，接着会遍历这个目录中的所有文件并调用_parseAssetFromFile得到以文件路径为key的列表信息。这个就是我们在第一部分中提到的在pubspec.yaml中可以配置目录资源对应的源码。但是需要注意的是在pubspec.yaml中只支持配置单级目录，对于二级目录却是无能为力。原因是上述的代码中只识别了文件，对于目录没有做任何处理。到这里整个_parseAssets函数的功能就介绍完了。接着回到build函数继续往下看：

if (assetVariants == null)
    return 1;
    ...
for (String packageName in packageMap.map.keys) {
    final Uri package = packageMap.map[packageName];
    if (package != null && package.scheme == 'file') {
        final String packageManifestPath = fs.path.fromUri(package.resolve('../pubspec.yaml'));
        final FlutterManifest packageFlutterManifest = await FlutterManifest.createFromPath(packageManifestPath);
        if (packageFlutterManifest == null)
          continue;
        if (packageFlutterManifest.appName == flutterManifest.appName)
          continue;
        final String packageBasePath = fs.path.dirname(packageManifestPath);

        final Map<_Asset, List<_Asset>> packageAssets = _parseAssets(
          packageMap,
          packageFlutterManifest,
          packageBasePath,
          packageName: packageName,
        );

        if (packageAssets == null)
          return 1;
        assetVariants.addAll(packageAssets);
    }
}

for (_Asset asset in assetVariants.keys) {
    if (!asset.assetFileExists && assetVariants[asset].isEmpty) {
       ...
    }
if (asset.assetFileExists) {
    assert(!assetVariants[asset].contains(asset));
    assetVariants[asset].insert(0, asset);
    }
for (_Asset variant in assetVariants[asset]) {
    assert(variant.assetFileExists);
    entries[variant.entryUri.path] = new DevFSFileContent(variant.assetFile);
    }
}
    ...
entries[_assetManifestJson] = _createAssetManifest(assetVariants);
...
return 0;

首先它会遍历.packages文件的依赖列表，找到每个包下的pubspec.yaml文件，并调用_parseAssets函数对依赖包的资源进行解析（需要注意的是在遍历依赖列表时首先会判断依赖包的路径是够以file开头，由于本地依赖的package路径是相对路径，并不是以file开头，所以应用在引用本地package时不能加载其资源文件）并将解析的资源加入到列表中，接着，遍历assetVariants列表，如果assets中的配置想的文件存在就将其插入列表的第一个位置(通过这里的代码我们可知，在assets配置资源时可以配置一个不存在的文件作为资源项的key)，接着遍历特定资源项的变体列表，以资源路径为key，以DevFSFileContent为value加入到entries列表中，其中DevFSFileContent的参数是图片文件，DevFSFileContent继承于DevFSContent，用于读取文件内容。最后调用_createAssetManifest函数生成AssetManifest.json文件对应的DevFSContent对象：

DevFSContent _createAssetManifest(Map<_Asset, List<_Asset>> assetVariants) {
  final Map<String, List<String>> jsonObject = <String, List<String>>{};
  final List<_Asset> sortedKeys = assetVariants
      .keys.toList()
    ..sort(_byBasename);

  for (_Asset main in sortedKeys) {
    final List<String> variants = <String>[];
    for (_Asset variant in assetVariants[main])
      variants.add(variant.entryUri.path);
    jsonObject[main.entryUri.path] = variants;
  }
  return new DevFSStringContent(json.encode(jsonObject));
}

这个函数的主要功能是遍历assetVariants列表，并以资源为key，以图片列表为value形成一个json结构体，并将其封装成DevFSStringContent实例返回。整个buildAssets函数功能到此就结束了，接着回到bundle.dart的build函数看assemble函数，在这个函数中会调用writeBundle函数，将上面生成的entrys列表，写入到bundleDir目录中：

Future<void> writeBundle(
    Directory bundleDir, Map<String, DevFSContent> assetEntries) async {
  if (bundleDir.existsSync())
    bundleDir.deleteSync(recursive: true);
  bundleDir.createSync(recursive: true);

  await Future.wait(
      assetEntries.entries.map((MapEntry<String, DevFSContent> entry) async {
    final File file = fs.file(fs.path.join(bundleDir.path, entry.key));
    file.parent.createSync(recursive: true);
    await file.writeAsBytes(await entry.value.contentsAsBytes());
  }));

这个函数函数首先会判断文件输入目录bundleDir是否存在，如果不存在先建立该目录，接着，遍历assetEntries列表，将DevFSContent的contentsAsBytes()内容写入到对应的文件中。根据上面的资源介绍，我们知道这里写入的文件分别是各个分辨率对应的图片和AssetManifest.json文件。到此flutter资源加载和打包流程就分析完了。