Flutter图片加载与缓存机制的深入探究

前言

今天来学习一下 flutter 自身是如何加载图片和管理图片的。

flutter 提供了一个图片控件 image，image 定义了若干中加载图片的方式，包括 image.asset、image.file、image.network、image.memory。

image内部维护了一个 imageprovider对象，imageprovider则真正维护整个图片加载的工作。widget 本身内部是体现在 rawimage中：​

图片控件

// image
widget result = rawimage(
      image: _imageinfo?.image,
      debugimagelabel: _imageinfo?.debuglabel,
      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,
      invertcolors: _invertcolors,
      isantialias: widget.isantialias,
      filterquality: widget.filterquality,
    );
return result;

这里可以看到 _imageinfo 决定 rawimage如何展示图片。

_imageinfo 则会在图片的每一帧进行重新赋值：

// image.dart
void _handleimageframe(imageinfo imageinfo, bool synchronouscall) {
 	setstate(() {
    _imageinfo = imageinfo;
  }
}

那么图片信息是从哪里来的呢，它是由 _resolveimage 这个方法发起的。这个方法会在 _imagestate 的 didchangedependencies、 didupdatewidget和 reassemble方法进行调用。

也就是控件发生变化刷新状态的时候，就会重新去解析图片。

图片解析

_resolveimage 逻辑如下：

void _resolveimage() {
	final scrollawareimageprovider provider = scrollawareimageprovider<dynamic>(
      context: _scrollawarecontext,
      imageprovider: widget.image,
    );
	final imagestream newstream =
      provider.resolve(createlocalimageconfiguration(
        context,
        size: widget.width != null && widget.height != null ? size(widget.width, widget.height) : null,
      ));
	_updatesourcestream(newstream);
}

这里会用 scrollawareimageprovider 包装一下，scrollawareimageprovider 的功能我们后面会介绍，这里先跳过。

//imageprovider# resolve
imagestream resolve(imageconfiguration configuration) {
	_createerrorhandlerandkey(configuration,(t key, imageerrorlistener errorhandler) {
        resolvestreamforkey(configuration, stream, key, errorhandler);
      },
		(t? key, dynamic exception, stacktrace? stack) async {
        await null; // wait an event turn in case a listener has been added to the image stream.
        final _errorimagecompleter imagecompleter = _errorimagecompleter();
        stream.setcompleter(imagecompleter);
        informationcollector? collector;
        assert(() {
          collector = () sync* {
            yield diagnosticsproperty<imageprovider>('image provider', this);
            yield diagnosticsproperty<imageconfiguration>('image configuration', configuration);
            yield diagnosticsproperty<t>('image key', key, defaultvalue: null);
          };
          return true;
        }());
        imagecompleter.seterror(
          exception: exception,
          stack: stack,
          context: errordescription('while resolving an image'),
          silent: true, // could be a network error or whatnot
          informationcollector: collector,
        );
      }
	);
}

resolve 方法调用 _createerrorhandlerandkey 来处理图片加载的异常情况。当图片正常加载的时候，会执行 resolvestreamforkey。

//resolvestreamforkey
void resolvestreamforkey(imageconfiguration configuration, imagestream stream, t key, imageerrorlistener handleerror) {
	if (stream.completer != null) {
		final imagestreamcompleter? completer = paintingbinding.instance!.imagecache!.putifabsent(
        key,
        () => stream.completer!,
        onerror: handleerror,
      );
		return;
	}

	final imagestreamcompleter? completer = paintingbinding.instance!.imagecache!.putifabsent(
		key,
      () => load(key, paintingbinding.instance!.instantiateimagecodec),
      onerror: handleerror,
		);

	if (completer != null) {
      stream.setcompleter(completer);
    }
}

flutter 会把图片缓存相关的逻辑维护在 imagecache这个对象。

缓存管理

imagecache里面有 3 个 map:

分别表示

• 正在加载的图片
• 缓存在内存的图片
• 表示正活跃的图片，widget 状态变化后可能会清空

​新增缓存

新增缓存的时候会设置 map 的 key， key 由 imageprovider 对象提供。例如：

• assetimage  当包名和bundle一样的时候，key可以认为是一样的。
• networkimage 当图片 url 和比例一样的时候，key可以认为是一样的。

imagecache 实际上是一个单例对象。也就是 flutter 的图片缓存管理是全局的。imagecache 最重要的方法就是 putifabsent：

// 整理过核心逻辑的代码
imagestreamcompleter? putifabsent(object key, imagestreamcompleter loader(), { imageerrorlistener? onerror }) {
  // 根据key从正在加载的map里获取缓存，如果有直接返回
  	imagestreamcompleter? result = _pendingimages[key]?.completer;
  	if (result != null) {
      return result;
    }
  
  // 检查内存缓存，存在的话更新存活map
  final _cachedimage? image = _cache.remove(key);
  if (image != null) {
    _trackliveimage(key, _liveimage(image.completer, image.sizebytes, () => _liveimages.remove(key)));
    _cache[key] = image;
    return image.completer;
  }
  
  // 没有缓存，从 _live 里面取
  final _cachedimage? liveimage = _liveimages[key];
  if (liveimage != null) {
    // 更新缓存
    _touch(key, liveimage, timelinetask);
    return liveimage.completer;
  }
  
  // 3 个 map 都没有获取到缓存的图片
  result = loader(); // 加载
  _trackliveimage(key, _liveimage(result, null, () => _liveimages.remove(key)));
  
	_pendingimage? untrackedpendingimage;

  //定义一个listener
	void listener(imageinfo? info, bool synccall) {
		// 加载的监听
	}
  
  // 包装一个listener
	final imagestreamlistener streamlistener = imagestreamlistener(listener);
	if (maximumsize > 0 && maximumsizebytes > 0) {
		// 放入缓存
		_pendingimages[key] = _pendingimage(result, streamlistener);
	} else {
		untrackedpendingimage = _pendingimage(result, streamlistener);
	}
	// 添加监听
	result.addlistener(streamlistener);
	return result;
}

listener 回调的逻辑：

在 image 状态改变的时候，会触发对 liveimages 的修改：

// image
_imagestream.removelistener(_getlistener());

// imagestream
void removelistener(imagestreamlistener listener) {
  for (final voidcallback callback in _onlastlistenerremovedcallbacks) {
    callback();
  }
  _onlastlistenerremovedcallbacks.clear();
}

而在 _trackliveimage 的时候，_liveimage 都注册了上面的这个 callback:

_trackliveimage(key, _liveimage(image.completer, image.sizebytes, () => _liveimages.remove(key)));

这时候改图片会从 _liveimages 里面移除。

由此可见，缓存的优先级为 pending -> cache -> live -> load，图片缓存和获取的流程如下图所示：

缓存清理

在更新缓存大小的时候，还会进行缓存大小的检查：

void _checkcachesize(timelinetask? timelinetask) {
  while (_currentsizebytes > _maximumsizebytes || _cache.length > _maximumsize) {
    final object key = _cache.keys.first;
    final _cachedimage image = _cache[key]!;
    _currentsizebytes -= image.sizebytes!;
    _cache.remove(key);
  }
}

当当前缓存总容量大于最大容量或者缓存数量大于最大数量的时候，就会进行缓存的清理。

所以上面使用缓存的过程中，多次访问的缓存就会把key往后放，避免一上来就被清理掉。

所以 flutter 自身的缓存清理算法也是遵循了 “最近最少使用” 的。

图片缓存的逻辑如下图所示：

图片加载

图片加载主要依赖上面的 load方法进行。不同的 imageprovider 子类有自己的实现。例如

assetimage

return multiframeimagestreamcompleter(
      codec: _loadasync(key, decode),
      scale: key.scale,
      debuglabel: key.name,
      informationcollector: collector
    );

networkimage

final streamcontroller<imagechunkevent> chunkevents =
        streamcontroller<imagechunkevent>();

    return multiframeimagestreamcompleter(
        chunkevents: chunkevents.stream,
        codec: _loadasync(key as networkimage, decode, chunkevents),
        scale: key.scale,
        debuglabel: key.url,
        informationcollector: _imagestreaminformationcollector(key));

逻辑基本一样，具体特异的流程体现在 loadasync里面：

// assetimage _loadasync
try {
      data = await key.bundle.load(key.name);
    } on fluttererror {
      paintingbinding.instance!.imagecache!.evict(key);
      rethrow;
    }

if (data == null) {
// 加载数据是null，清掉这个key的缓存
	paintingbinding.instance!.imagecache!.evict(key);
	throw stateerror('unable to read data');
}

return await decode(data.buffer.asuint8list());


/// networkimage _loadasync
future<ui.codec> _loadasync(
      networkimage key,
      image_provider.decodercallback decode,
      streamcontroller<imagechunkevent> chunkevents) {

	final uri resolved = uri.base.resolve(key.url);
	return ui.webonlyinstantiateimagecodecfromurl(resolved, // ignore: undefined_function
        chunkcallback: (int bytes, int total) {
      chunkevents.add(imagechunkevent(
          cumulativebytesloaded: bytes, expectedtotalbytes: total));
    }) as future<ui.codec>;
}

这里分别会从 bundle 里加载图片和从网络拉取图片。

滑动中处理

还记得上面提到的 scrollawareimageprovider吗，这里会有一个关于滑动中的判断：

if (scrollable.recommenddeferredloadingforcontext(context.context)) {
  schedulerbinding.instance.scheduleframecallback((_) {
		schedulemicrotask(() => resolvestreamforkey(configuration, stream, key, handleerror));
	 });
	return;
}

当 if 里的逻辑成立，就把解析图片的工作放到下一帧。recommenddeferredloadingforcontext 的具体逻辑：

static bool recommenddeferredloadingforcontext(buildcontext context) {
	
	final _scrollablescope widget =
		context.getelementforinheritedwidgetofexacttype<_scrollablescope>()?.widget as _scrollablescope;
	if (widget == null) {
      return false;
    }
	// 存在滑动的widget
	return widget.position.recommenddeferredloading(context);
}

这个会找到 widget 树里面最近的 _scrollablescope。如果 scrollablescope 处于快速滑动的时候，就返回true。所以 flutter 在快速滑动的列表中是不会加载图片的。

总结

到这里 flutter 图片的加载和缓存管理就介绍完了。我们可以认识到几个问题

• flutter 本身是有图片的内存缓存。也是按照 lru 的算法去管理缓存的。并且缓存池有阈值，我们可以自己去设置我们想要的内存阈值。
  
• flutter 本身没有提供图片的磁盘缓存，app 重启之后图片加载流程是会重新走的。

到此这篇关于flutter图片加载与缓存机制的文章就介绍到这了,更多相关flutter图片加载与缓存机制内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！