138 lines
3.3 KiB
Dart
138 lines
3.3 KiB
Dart
import 'dart:convert';
|
|
import 'dart:developer';
|
|
import 'dart:math' as m;
|
|
import 'dart:typed_data';
|
|
|
|
import 'package:flutter/cupertino.dart';
|
|
import 'package:mnemo_cards/features/packs/images_holder.dart';
|
|
import 'package:mnemo_cards/theme/themes.dart';
|
|
|
|
import '../../../di/locator.dart';
|
|
|
|
class TestImageWidget extends StatefulWidget {
|
|
final TestImage _testImage;
|
|
|
|
const TestImageWidget(this._testImage, {super.key});
|
|
|
|
@override
|
|
State<StatefulWidget> createState() => _TestImageWidgetState();
|
|
}
|
|
|
|
class _TestImageWidgetState extends State<TestImageWidget> {
|
|
TestImage get _testImage => widget._testImage;
|
|
bool same = false;
|
|
Widget? cached;
|
|
|
|
@override
|
|
void didUpdateWidget(TestImageWidget oldWidget) {
|
|
super.didUpdateWidget(oldWidget);
|
|
same = oldWidget._testImage == _testImage;
|
|
}
|
|
|
|
Future<Widget> _preloadImage() async {
|
|
try {
|
|
// final cache = _TestImageCache();
|
|
// final cachedImage = cache.image(_testImage);
|
|
// if (cachedImage != null) {
|
|
// return cachedImage;
|
|
// }
|
|
final imageProvider = await _testImage.loadImage();
|
|
if (imageProvider == null) {
|
|
return SizedBox.shrink();
|
|
}
|
|
// cache.setImage(_testImage, imageProvider);
|
|
return Image(image: imageProvider);
|
|
} catch (e) {
|
|
log('Cant load image ${_testImage}packId: $e');
|
|
}
|
|
return SizedBox();
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
// final cache = _TestImageCache();
|
|
if (same && cached != null) {
|
|
return cached!;
|
|
}
|
|
return FutureBuilder(
|
|
future: _preloadImage(),
|
|
// initialData: cache.image(_testImage),
|
|
builder: (_, s) {
|
|
if (s.data == null) {
|
|
return Container(
|
|
alignment: Alignment.center,
|
|
);
|
|
}
|
|
cached = Container(
|
|
clipBehavior: Clip.antiAlias,
|
|
decoration: BoxDecoration(
|
|
color: white,
|
|
borderRadius: BorderRadius.circular(12),
|
|
),
|
|
child: s.data,
|
|
);
|
|
return cached!;
|
|
},
|
|
);
|
|
}
|
|
}
|
|
|
|
class TestImage {
|
|
final String data;
|
|
final String key;
|
|
|
|
TestImage({
|
|
required this.data,
|
|
required this.key,
|
|
});
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
return other is TestImage && key == other.key;
|
|
}
|
|
|
|
Future<ImageProvider?> loadImage() async {
|
|
if (data.length > 50) {
|
|
Uint8List? bytes;
|
|
try {
|
|
bytes = base64Decode(data);
|
|
return MemoryImage(bytes);
|
|
} catch (e) {
|
|
log('Cant decode base64 test image');
|
|
return null;
|
|
}
|
|
} else if (data.contains(':')) {
|
|
final packId = data.split(':').first;
|
|
final path = data.split(':').last;
|
|
return await locator.testManager.loadImage(packId, path);
|
|
} else {
|
|
return data.memoryImage;
|
|
}
|
|
}
|
|
|
|
TestImage.image(String image)
|
|
: data = image,
|
|
key = image.substring(0, m.min(image.length, 50));
|
|
}
|
|
|
|
// class _TestImageCache {
|
|
// static final _instance = _TestImageCache._();
|
|
//
|
|
// _TestImageCache get instance => _instance;
|
|
//
|
|
// factory _TestImageCache() => _instance;
|
|
//
|
|
// _TestImageCache._();
|
|
//
|
|
// Map<TestImage, Image> _images = {};
|
|
//
|
|
// Image? image(TestImage key) {
|
|
// return _images[key];
|
|
// }
|
|
//
|
|
// Image? setImage(TestImage key, ImageProvider provider) {
|
|
// return _images[key] = Image(image: provider);
|
|
// }
|
|
//
|
|
// void clear() => _images.clear();
|
|
// }
|