Это произошло после обновления флаттера
Сообщение компилятора:
../../../../../Developer/flutter/.pub-cache/hosted/pub.dartlang.org/flutter_advanced_networkimage-0.5.0/lib/src/provide
r/flutter_advanced_networkimage.dart:143:24: Error: The method 'AdvancedNetworkImage.load' has fewer positional
arguments than those of overridden method 'ImageProvider.load'.
ImageStreamCompleter load(AdvancedNetworkImage key) {
^
../../../../../Developer/flutter/packages/flutter/lib/src/painting/image_provider.dart:403:24: Context: This is the
overridden method ('load').
ImageStreamCompleter load(T key, DecoderCallback decode);
^
Target kernel_snapshot failed: Exception: Errors during snapshot creation: null
Failed to build bundle.
Ошибка запуска приложения на iPhone 11 Pro Max. Ниже мой код
import 'dart:async';
import 'dart:io';
import 'dart:typed_data';
import 'dart:ui' as ui show Codec;
import 'dart:ui' show Size, Locale, TextDirection, hashValues;
import 'package:flutter/foundation.dart';
import 'package:flutter/services.dart';
import '_network_image_io.dart'
if (dart.library.html) '_network_image_web.dart' as network_image;
import 'binding.dart';
import 'image_cache.dart';
import 'image_stream.dart';
@immutable
class ImageConfiguration {
const ImageConfiguration({
this.bundle,
this.devicePixelRatio,
this.locale,
this.textDirection,
this.size,
this.platform,
});
ImageConfiguration copyWith({
AssetBundle bundle,
double devicePixelRatio,
Locale locale,
TextDirection textDirection,
Size size,
String platform,
}) {
return ImageConfiguration(
bundle: bundle ?? this.bundle,
devicePixelRatio: devicePixelRatio ?? this.devicePixelRatio,
locale: locale ?? this.locale,
textDirection: textDirection ?? this.textDirection,
size: size ?? this.size,
platform: platform ?? this.platform,
);
}
/// The preferred [AssetBundle] to use if the [ImageProvider] needs one and
/// does not have one already selected.
final AssetBundle bundle;
/// The device pixel ratio where the image will be shown.
final double devicePixelRatio;
/// The language and region for which to select the image.
final Locale locale;
/// The reading direction of the language for which to select the image.
final TextDirection textDirection;
/// The size at which the image will be rendered.
final Size size;
final TargetPlatform platform;
static const ImageConfiguration empty = ImageConfiguration();
@override
bool operator ==(dynamic other) {
if (other.runtimeType != runtimeType)
return false;
final ImageConfiguration typedOther = other;
return typedOther.bundle == bundle
&& typedOther.devicePixelRatio == devicePixelRatio
&& typedOther.locale == locale
&& typedOther.textDirection == textDirection
&& typedOther.size == size
&& typedOther.platform == platform;
}
@override
int get hashCode => hashValues(bundle, devicePixelRatio, locale, size, platform);
@override
String toString() {
final StringBuffer result = StringBuffer();
result.write('ImageConfiguration(');
bool hasArguments = false;
if (bundle != null) {
if (hasArguments)
result.write(', ');
result.write('bundle: $bundle');
hasArguments = true;
}
if (devicePixelRatio != null) {
if (hasArguments)
result.write(', ');
result.write('devicePixelRatio: ${devicePixelRatio.toStringAsFixed(1)}');
hasArguments = true;
}
if (locale != null) {
if (hasArguments)
result.write(', ');
result.write('locale: $locale');
hasArguments = true;
}
if (textDirection != null) {
if (hasArguments)
result.write(', ');
result.write('textDirection: $textDirection');
hasArguments = true;
}
if (size != null) {
if (hasArguments)
result.write(', ');
result.write('size: $size');
hasArguments = true;
}
if (platform != null) {
if (hasArguments)
result.write(', ');
result.write('platform: ${describeEnum(platform)}');
hasArguments = true;
}
result.write(')');
return result.toString();
}
}
typedef DecoderCallback = Future<ui.Codec> Function(Uint8List bytes, {int cacheWidth, int cacheHeight});
@optionalTypeArgs
abstract class ImageProvider<T> {
/// Abstract const constructor. This constructor enables subclasses to provide
/// const constructors so that they can be used in const expressions.
const ImageProvider();
ImageStream resolve(ImageConfiguration configuration) {
assert(configuration != null);
final ImageStream stream = ImageStream();
T obtainedKey;
bool didError = false;
Future<void> handleError(dynamic exception, StackTrace stack) async {
if (didError) {
return;
}
didError = true;
await null; // wait an event turn in case a listener has been added to the image stream.
final _ErrorImageCompleter imageCompleter = _ErrorImageCompleter();
stream.setCompleter(imageCompleter);
imageCompleter.setError(
exception: exception,
stack: stack,
context: ErrorDescription('while resolving an image'),
silent: true, // could be a network error or whatnot
informationCollector: () sync* {
yield DiagnosticsProperty<ImageProvider>('Image provider', this);
yield DiagnosticsProperty<ImageConfiguration>('Image configuration', configuration);
yield DiagnosticsProperty<T>('Image key', obtainedKey, defaultValue: null);
},
);
}
final Zone dangerZone = Zone.current.fork(
specification: ZoneSpecification(
handleUncaughtError: (Zone zone, ZoneDelegate delegate, Zone parent, Object error, StackTrace stackTrace) {
handleError(error, stackTrace);
}
)
);
dangerZone.runGuarded(() {
Future<T> key;
try {
key = obtainKey(configuration);
} catch (error, stackTrace) {
handleError(error, stackTrace);
return;
}
key.then<void>((T key) {
obtainedKey = key;
final ImageStreamCompleter completer = PaintingBinding.instance.imageCache.putIfAbsent(
key,
() => load(key, PaintingBinding.instance.instantiateImageCodec),
onError: handleError,
);
if (completer != null) {
stream.setCompleter(completer);
}
}).catchError(handleError);
});
return stream;
}
Future<bool> evict({ ImageCache cache, ImageConfiguration configuration = ImageConfiguration.empty }) async {
cache ??= imageCache;
final T key = await obtainKey(configuration);
return cache.evict(key);
}
Future<T> obtainKey(ImageConfiguration configuration);
@protected
ImageStreamCompleter load(T key, DecoderCallback decode);
@override
String toString() => '$runtimeType()';
}
@immutable
class AssetBundleImageKey {
const AssetBundleImageKey({
@required this.bundle,
@required this.name,
@required this.scale,
}) : assert(bundle != null),
assert(name != null),
assert(scale != null);
final AssetBundle bundle;
/// The key to use to obtain the resource from the [bundle]. This is the
/// argument passed to [AssetBundle.load].
final String name;
/// The scale to place in the [ImageInfo] object of the image.
final double scale;
@override
bool operator ==(dynamic other) {
if (other.runtimeType != runtimeType)
return false;
final AssetBundleImageKey typedOther = other;
return bundle == typedOther.bundle
&& name == typedOther.name
&& scale == typedOther.scale;
}
@override
int get hashCode => hashValues(bundle, name, scale);
@override
String toString() => '$runtimeType(bundle: $bundle, name: "$name", scale: $scale)';
}
/// A subclass of [ImageProvider] that knows about [AssetBundle]s.
///
/// This factors out the common logic of [AssetBundle]-based [ImageProvider]
/// classes, simplifying what subclasses must implement to just [obtainKey].
abstract class AssetBundleImageProvider extends ImageProvider<AssetBundleImageKey> {
/// Abstract const constructor. This constructor enables subclasses to provide
/// const constructors so that they can be used in const expressions.
const AssetBundleImageProvider();
/// Converts a key into an [ImageStreamCompleter], and begins fetching the
/// image using [loadAsync].
@override
ImageStreamCompleter load(AssetBundleImageKey key, DecoderCallback decode) {
return MultiFrameImageStreamCompleter(
codec: _loadAsync(key, decode),
scale: key.scale,
informationCollector: () sync* {
yield DiagnosticsProperty<ImageProvider>('Image provider', this);
yield DiagnosticsProperty<AssetBundleImageKey>('Image key', key);
},
);
}
/// Fetches the image from the asset bundle, decodes it, and returns a
/// corresponding [ImageInfo] object.
///
/// This function is used by [load].
@protected
Future<ui.Codec> _loadAsync(AssetBundleImageKey key, DecoderCallback decode) async {
final ByteData data = await key.bundle.load(key.name);
if (data == null)
throw 'Unable to read data';
return await decode(data.buffer.asUint8List());
}
}
class _SizeAwareCacheKey {
const _SizeAwareCacheKey(this.providerCacheKey, this.width, this.height);
final Object providerCacheKey;
final int width;
final int height;
@override
bool operator ==(Object other) {
if (other.runtimeType != runtimeType)
return false;
final _SizeAwareCacheKey typedOther = other;
return providerCacheKey == typedOther.providerCacheKey
&& width == typedOther.width
&& height == typedOther.height;
}
@override
int get hashCode => hashValues(providerCacheKey, width, height);
}
/// Instructs Flutter to decode the image at the specified dimensions
/// instead of at its native size.
///
/// This allows finer control of the size of the image in [ImageCache] and is
/// generally used to reduce the memory footprint of [ImageCache].
///
/// The decoded image may still be displayed at sizes other than the
/// cached size provided here.
class ResizeImage extends ImageProvider<_SizeAwareCacheKey> {
/// Creates an ImageProvider that decodes the image to the specified size.
///
/// The cached image will be directly decoded and stored at the resolution
/// defined by `width` and `height`. The image will lose detail and
/// use less memory if resized to a size smaller than the native size.
const ResizeImage(
this.imageProvider, {
this.width,
this.height,
}) : assert(width != null || height != null);
/// The [ImageProvider] that this class wraps.
final ImageProvider imageProvider;
/// The width the image should decode to and cache.
final int width;
/// The height the image should decode to and cache.
final int height;
/// Composes the `provider` in a [ResizeImage] only when `cacheWidth` and
/// `cacheHeight` are not both null.
///
/// When `cacheWidth` and `cacheHeight` are both null, this will return the
/// `provider` directly.
static ImageProvider<dynamic> resizeIfNeeded(int cacheWidth, int cacheHeight, ImageProvider<dynamic> provider) {
if (cacheWidth != null || cacheHeight != null) {
return ResizeImage(provider, width: cacheWidth, height: cacheHeight);
}
return provider;
}
@override
ImageStreamCompleter load(_SizeAwareCacheKey key, DecoderCallback decode) {
final DecoderCallback decodeResize = (Uint8List bytes, {int cacheWidth, int cacheHeight}) {
assert(
cacheWidth == null && cacheHeight == null,
'ResizeImage cannot be composed with another ImageProvider that applies cacheWidth or cacheHeight.'
);
return decode(bytes, cacheWidth: width, cacheHeight: height);
};
return imageProvider.load(key.providerCacheKey, decodeResize);
}
@override
Future<_SizeAwareCacheKey> obtainKey(ImageConfiguration configuration) async {
final Object providerCacheKey = await imageProvider.obtainKey(configuration);
return _SizeAwareCacheKey(providerCacheKey, width, height);
}
}
/// Fetches the given URL from the network, associating it with the given scale.
///
/// The image will be cached regardless of cache headers from the server.
///
/// When a network image is used on the Web platform, the [cacheWidth] and
/// [cacheHeight] parameters of the [DecoderCallback] are ignored as the Web
/// engine delegates image decoding of network images to the Web, which does
/// not support custom decode sizes.
///
/// See also:
///
/// * [Image.network] for a shorthand of an [Image] widget backed by [NetworkImage].
// TODO(ianh): Find some way to honor cache headers to the extent that when the
// last reference to an image is released, we proactively evict the image from
// our cache if the headers describe the image as having expired at that point.
abstract class NetworkImage extends ImageProvider<NetworkImage> {
/// Creates an object that fetches the image at the given URL.
///
/// The arguments [url] and [scale] must not be null.
const factory NetworkImage(String url, { double scale, Map<String, String> headers }) = network_image.NetworkImage;
/// The URL from which the image will be fetched.
String get url;
/// The scale to place in the [ImageInfo] object of the image.
double get scale;
/// The HTTP headers that will be used with [HttpClient.get] to fetch image from network.
///
/// When running flutter on the web, headers are not used.
Map<String, String> get headers;
@override
ImageStreamCompleter load(NetworkImage key, DecoderCallback decode);
}
/// Decodes the given [File] object as an image, associating it with the given
/// scale.
///
/// See also:
///
/// * [Image.file] for a shorthand of an [Image] widget backed by [FileImage].
class FileImage extends ImageProvider<FileImage> {
/// Creates an object that decodes a [File] as an image.
///
/// The arguments must not be null.
const FileImage(this.file, { this.scale = 1.0 })
: assert(file != null),
assert(scale != null);
/// The file to decode into an image.
final File file;
/// The scale to place in the [ImageInfo] object of the image.
final double scale;
@override
Future<FileImage> obtainKey(ImageConfiguration configuration) {
return SynchronousFuture<FileImage>(this);
}
@override
ImageStreamCompleter load(FileImage key, DecoderCallback decode) {
return MultiFrameImageStreamCompleter(
codec: _loadAsync(key, decode),
scale: key.scale,
informationCollector: () sync* {
yield ErrorDescription('Path: ${file?.path}');
},
);
}
Future<ui.Codec> _loadAsync(FileImage key, DecoderCallback decode) async {
assert(key == this);
final Uint8List bytes = await file.readAsBytes();
if (bytes.lengthInBytes == 0)
return null;
return await decode(bytes);
}
@override
bool operator ==(dynamic other) {
if (other.runtimeType != runtimeType)
return false;
final FileImage typedOther = other;
return file?.path == typedOther.file?.path
&& scale == typedOther.scale;
}
@override
int get hashCode => hashValues(file?.path, scale);
@override
String toString() => '$runtimeType("${file?.path}", scale: $scale)';
}
/// Decodes the given [Uint8List] buffer as an image, associating it with the
/// given scale.
///
/// The provided [bytes] buffer should not be changed after it is provided
/// to a [MemoryImage]. To provide an [ImageStream] that represents an image
/// that changes over time, consider creating a new subclass of [ImageProvider]
/// whose [load] method returns a subclass of [ImageStreamCompleter] that can
/// handle providing multiple images.
///
/// See also:
///
/// * [Image.memory] for a shorthand of an [Image] widget backed by [MemoryImage].
class MemoryImage extends ImageProvider<MemoryImage> {
/// Creates an object that decodes a [Uint8List] buffer as an image.
///
/// The arguments must not be null.
const MemoryImage(this.bytes, { this.scale = 1.0 })
: assert(bytes != null),
assert(scale != null);
/// The bytes to decode into an image.
final Uint8List bytes;
/// The scale to place in the [ImageInfo] object of the image.
final double scale;
@override
Future<MemoryImage> obtainKey(ImageConfiguration configuration) {
return SynchronousFuture<MemoryImage>(this);
}
@override
ImageStreamCompleter load(MemoryImage key, DecoderCallback decode) {
return MultiFrameImageStreamCompleter(
codec: _loadAsync(key, decode),
scale: key.scale,
);
}
Future<ui.Codec> _loadAsync(MemoryImage key, DecoderCallback decode) {
assert(key == this);
return decode(bytes);
}
@override
bool operator ==(dynamic other) {
if (other.runtimeType != runtimeType)
return false;
final MemoryImage typedOther = other;
return bytes == typedOther.bytes
&& scale == typedOther.scale;
}
@override
int get hashCode => hashValues(bytes.hashCode, scale);
@override
String toString() => '$runtimeType(${describeIdentity(bytes)}, scale: $scale)';
}
/// Fetches an image from an [AssetBundle], associating it with the given scale.
///
/// This implementation requires an explicit final [assetName] and [scale] on
/// construction, and ignores the device pixel ratio and size in the
/// configuration passed into [resolve]. For a resolution-aware variant that
/// uses the configuration to pick an appropriate image based on the device
/// pixel ratio and size, see [AssetImage].
///
/// ## Fetching assets
///
/// When fetching an image provided by the app itself, use the [assetName]
/// argument to name the asset to choose. For instance, consider a directory
/// `icons` with an image `heart.png`. First, the [pubspec.yaml] of the project
/// should specify its assets in the `flutter` section:
///
/// ```yaml
/// flutter:
/// assets:
/// - icons/heart.png
/// ```
///
/// Then, to fetch the image and associate it with scale `1.5`, use
///
/// ```dart
/// AssetImage('icons/heart.png', scale: 1.5)
/// ```
///
/// ## Assets in packages
///
/// To fetch an asset from a package, the [package] argument must be provided.
/// For instance, suppose the structure above is inside a package called
/// `my_icons`. Then to fetch the image, use:
///
/// ```dart
/// AssetImage('icons/heart.png', scale: 1.5, package: 'my_icons')
/// ```
///
/// Assets used by the package itself should also be fetched using the [package]
/// argument as above.
///
/// If the desired asset is specified in the `pubspec.yaml` of the package, it
/// is bundled automatically with the app. In particular, assets used by the
/// package itself must be specified in its `pubspec.yaml`.
///
/// A package can also choose to have assets in its 'lib/' folder that are not
/// specified in its `pubspec.yaml`. In this case for those images to be
/// bundled, the app has to specify which ones to include. For instance a
/// package named `fancy_backgrounds` could have:
///
/// ```
/// lib/backgrounds/background1.png
/// lib/backgrounds/background2.png
/// lib/backgrounds/background3.png
/// ```
///
/// To include, say the first image, the `pubspec.yaml` of the app should specify
/// it in the `assets` section:
///
/// ```yaml
/// assets:
/// - packages/fancy_backgrounds/backgrounds/background1.png
/// ```
///
/// The `lib/` is implied, so it should not be included in the asset path.
///
/// See also:
///
/// * [Image.asset] for a shorthand of an [Image] widget backed by
/// [ExactAssetImage] when using a scale.
class ExactAssetImage extends AssetBundleImageProvider {
/// Creates an object that fetches the given image from an asset bundle.
///
/// The [assetName] and [scale] arguments must not be null. The [scale] arguments
/// defaults to 1.0. The [bundle] argument may be null, in which case the
/// bundle provided in the [ImageConfiguration] passed to the [resolve] call
/// will be used instead.
///
/// The [package] argument must be non-null when fetching an asset that is
/// included in a package. See the documentation for the [ExactAssetImage] class
/// itself for details.
const ExactAssetImage(
this.assetName, {
this.scale = 1.0,
this.bundle,
this.package,
}) : assert(assetName != null),
assert(scale != null);
/// The name of the asset.
final String assetName;
/// The key to use to obtain the resource from the [bundle]. This is the
/// argument passed to [AssetBundle.load].
String get keyName => package == null ? assetName : 'packages/$package/$assetName';
/// The scale to place in the [ImageInfo] object of the image.
final double scale;
/// The bundle from which the image will be obtained.
///
/// If the provided [bundle] is null, the bundle provided in the
/// [ImageConfiguration] passed to the [resolve] call will be used instead. If
/// that is also null, the [rootBundle] is used.
///
/// The image is obtained by calling [AssetBundle.load] on the given [bundle]
/// using the key given by [keyName].
final AssetBundle bundle;
/// The name of the package from which the image is included. See the
/// documentation for the [ExactAssetImage] class itself for details.
final String package;
@override
Future<AssetBundleImageKey> obtainKey(ImageConfiguration configuration) {
return SynchronousFuture<AssetBundleImageKey>(AssetBundleImageKey(
bundle: bundle ?? configuration.bundle ?? rootBundle,
name: keyName,
scale: scale,
));
}
@override
bool operator ==(dynamic other) {
if (other.runtimeType != runtimeType)
return false;
final ExactAssetImage typedOther = other;
return keyName == typedOther.keyName
&& scale == typedOther.scale
&& bundle == typedOther.bundle;
}
@override
int get hashCode => hashValues(keyName, scale, bundle);
@override
String toString() => '$runtimeType(name: "$keyName", scale: $scale, bundle: $bundle)';
}
// A completer used when resolving an image fails sync.
class _ErrorImageCompleter extends ImageStreamCompleter {
_ErrorImageCompleter();
void setError({
DiagnosticsNode context,
dynamic exception,
StackTrace stack,
InformationCollector informationCollector,
bool silent = false,
}) {
reportError(
context: context,
exception: exception,
stack: stack,
informationCollector: informationCollector,
silent: silent,
);
}
}
/// The exception thrown when the HTTP request to load a network image fails.
class NetworkImageLoadException implements Exception {
/// Creates a [NetworkImageLoadException] with the specified http status
/// [code] and the [uri]
NetworkImageLoadException({@required this.statusCode, @required this.uri})
: assert(uri != null),
assert(statusCode != null),
_message = 'HTTP request failed, statusCode: $statusCode, $uri';
/// The HTTP status code from the server.
final int statusCode;
/// A human-readable error message.
final String _message;
/// Resolved URL of the requested image.
final Uri uri;
@override
String toString() => _message;
}