Ahmed Hnewa
2 years ago
parent
0b49baf489
commit
8fc5333543
4 changed files with 373 additions and 21 deletions
@ -0,0 +1,251 @@ |
||||
import 'dart:io' show Directory, File, Platform; |
||||
|
||||
import 'package:flutter/foundation.dart'; |
||||
import 'package:flutter_quill/flutter_quill.dart' as quill; |
||||
import 'package:path/path.dart' as path; |
||||
|
||||
import '../flutter_quill_extensions.dart'; |
||||
|
||||
class QuillUtilities { |
||||
const QuillUtilities._(); |
||||
|
||||
/// Saves a list of images to a specified directory. |
||||
/// |
||||
/// This function is designed to work efficiently on |
||||
/// mobile platforms, but it can also be used on other platforms. |
||||
/// |
||||
/// When you have a list of cached image paths |
||||
/// from a Quill document and you want to save them, |
||||
/// you can use this function. |
||||
/// It takes a list of image paths and copies each image to the specified |
||||
/// directory. If the image |
||||
/// path does not exist, it returns an |
||||
/// empty string for that item. |
||||
/// |
||||
/// Make sure that the image paths provided in the [images] |
||||
/// list exist, and handle the cases where images are not found accordingly. |
||||
/// |
||||
/// [images]: List of image paths to be saved. |
||||
/// [deleteThePreviousImages]: Indicates whether to delete the |
||||
/// original cached images after copying. |
||||
/// [saveDirectory]: The directory where the images will be saved. |
||||
/// |
||||
/// Returns a list of paths to the newly saved images. |
||||
/// For images that do not exist, their paths are returned as empty strings. |
||||
/// |
||||
/// Example usage: |
||||
/// ```dart |
||||
/// final documentsDir = await getApplicationDocumentsDirectory(); |
||||
/// final savedImagePaths = await saveImagesToDirectory( |
||||
/// images: cachedImagePaths, |
||||
/// deleteThePreviousImages: true, |
||||
/// saveDirectory: documentsDir, |
||||
/// ); |
||||
/// ``` |
||||
static Future<List<String>> saveImagesToDirectory({ |
||||
required Iterable<String> images, |
||||
required deleteThePreviousImages, |
||||
required Directory saveDirectory, |
||||
}) async { |
||||
final newImagesFutures = images.map((cachedImagePath) async { |
||||
final previousImageFile = File(cachedImagePath); |
||||
final isPreviousImageFileExists = await previousImageFile.exists(); |
||||
|
||||
if (!isPreviousImageFileExists) { |
||||
return ''; |
||||
} |
||||
|
||||
final newImageFileExtensionWithDot = path.extension(cachedImagePath); |
||||
|
||||
final dateTimeAsString = DateTime.now().toIso8601String(); |
||||
// TODO: You might want to make it easier for the developer to change |
||||
// the newImageFileName, but he can rename it anyway |
||||
final newImageFileName = |
||||
'quill-image-$dateTimeAsString$newImageFileExtensionWithDot'; |
||||
final newImagePath = path.join(saveDirectory.path, newImageFileName); |
||||
final newImageFile = await previousImageFile.copy(newImagePath); |
||||
if (deleteThePreviousImages) { |
||||
await previousImageFile.delete(); |
||||
} |
||||
return newImageFile.path; |
||||
}); |
||||
// Await for the saving process for each image |
||||
final newImages = await Future.wait(newImagesFutures); |
||||
return newImages; |
||||
} |
||||
|
||||
/// Deletes all local images referenced in a Quill document. |
||||
/// |
||||
/// This function removes local images from the |
||||
/// file system that are referenced in the provided [document]. |
||||
/// |
||||
/// [document]: The Quill document from which images will be deleted. |
||||
/// |
||||
/// Throws an [Exception] if any errors occur during the deletion process. |
||||
/// |
||||
/// Example usage: |
||||
/// ```dart |
||||
/// try { |
||||
/// await deleteAllLocalImagesOfDocument(myQuillDocument); |
||||
/// } catch (e) { |
||||
/// print('Error deleting local images: $e'); |
||||
/// } |
||||
/// ``` |
||||
static Future<void> deleteAllLocalImagesOfDocument( |
||||
quill.Document document, |
||||
) async { |
||||
final imagesPaths = getImagesPathsFromDocument( |
||||
document, |
||||
onlyLocalImages: true, |
||||
); |
||||
for (final image in imagesPaths) { |
||||
final imageFile = File(image); |
||||
final fileExists = await imageFile.exists(); |
||||
if (!fileExists) { |
||||
return; |
||||
} |
||||
final deletedFile = await imageFile.delete(); |
||||
final deletedFileStillExists = await deletedFile.exists(); |
||||
if (deletedFileStillExists) { |
||||
throw Exception( |
||||
'We have successfully deleted the file and it is still exists!!', |
||||
); |
||||
} |
||||
} |
||||
} |
||||
|
||||
/// Retrieves paths to images embedded in a Quill document. |
||||
/// |
||||
/// This function parses the [document] and returns a list of image paths. |
||||
/// |
||||
/// [document]: The Quill document from which image paths will be retrieved. |
||||
/// [onlyLocalImages]: If `true`, |
||||
/// only local (non-web) image paths will be included. |
||||
/// |
||||
/// Returns an iterable of image paths. |
||||
/// |
||||
/// Example usage: |
||||
/// ```dart |
||||
/// final quillDocument = _controller.document; |
||||
/// final imagePaths |
||||
/// = getImagesPathsFromDocument(quillDocument, onlyLocalImages: true); |
||||
/// print('Image paths: $imagePaths'); |
||||
/// ``` |
||||
/// |
||||
/// Note: This function assumes that images are |
||||
/// embedded as block embeds in the Quill document. |
||||
static Iterable<String> getImagesPathsFromDocument( |
||||
quill.Document document, { |
||||
required bool onlyLocalImages, |
||||
}) { |
||||
final images = document.root.children |
||||
.whereType<quill.Line>() |
||||
.where((node) { |
||||
if (node.isEmpty) { |
||||
return false; |
||||
} |
||||
final firstNode = node.children.first; |
||||
if (firstNode is! quill.Embed) { |
||||
return false; |
||||
} |
||||
|
||||
if (firstNode.value.type != quill.BlockEmbed.imageType) { |
||||
return false; |
||||
} |
||||
final imageSource = firstNode.value.data; |
||||
if (imageSource is! String) { |
||||
return false; |
||||
} |
||||
if (onlyLocalImages && isHttpBasedUrl(imageSource)) { |
||||
return false; |
||||
} |
||||
return imageSource.trim().isNotEmpty; |
||||
}) |
||||
.toList() |
||||
.map((e) => (e.children.first as quill.Embed).value.data as String); |
||||
return images; |
||||
} |
||||
|
||||
/// Determines if an image file is cached based on the platform. |
||||
/// |
||||
/// On mobile platforms (Android and iOS), images are typically |
||||
/// cached in temporary directories. |
||||
/// This function helps identify whether the given image file path |
||||
/// is a cached path on supported platforms. |
||||
/// |
||||
/// [imagePath] is the path of the image file to check for caching. |
||||
/// |
||||
/// Returns `true` if the image is cached, `false` otherwise. |
||||
/// On other platforms it will always return false |
||||
static bool isImageCached(String imagePath) { |
||||
// Determine if the image path is a cached path based on platform |
||||
if (kIsWeb) { |
||||
// For now this will not work for web |
||||
return false; |
||||
} |
||||
if (Platform.isAndroid) { |
||||
return imagePath.contains('cache'); |
||||
} |
||||
if (Platform.isIOS) { |
||||
// Don't use isAppleOS() since macOS has different behavior |
||||
return imagePath.contains('tmp'); |
||||
} |
||||
// On other platforms like desktop |
||||
// The image is not cached and we will get a direct |
||||
// access to the image |
||||
return false; |
||||
} |
||||
|
||||
/// Retrieves cached image paths from a Quill document, |
||||
/// primarily for mobile platforms. |
||||
/// |
||||
/// This function scans a Quill document to identify |
||||
/// and return paths to locally cached images. |
||||
/// It is specifically designed for mobile |
||||
/// operating systems (Android and iOS). |
||||
/// |
||||
/// [document] is the Quill document from which to extract image paths. |
||||
/// |
||||
/// [replaceUnexistentImagesWith] is an optional parameter. |
||||
/// If provided, it replaces non-existent image paths |
||||
/// with the specified value. If not provided, non-existent |
||||
/// image paths are removed from the result. |
||||
/// |
||||
/// Returns a list of cached image paths found in the document. |
||||
/// On non-mobile platforms, this function returns an empty list. |
||||
static Future<Iterable<String>> getCachedImagePathsFromDocument( |
||||
quill.Document document, { |
||||
String? replaceUnexistentImagesWith, |
||||
}) async { |
||||
final imagePaths = getImagesPathsFromDocument( |
||||
document, |
||||
onlyLocalImages: true, |
||||
); |
||||
|
||||
// We don't want the not cached images to be saved again for example. |
||||
final cachesImagePaths = imagePaths.where((imagePath) { |
||||
final isCurrentImageCached = isImageCached(imagePath); |
||||
return isCurrentImageCached; |
||||
}).toList(); |
||||
|
||||
// Remove all the images that doesn't exists |
||||
for (final imagePath in cachesImagePaths) { |
||||
final file = File(imagePath); |
||||
final exists = await file.exists(); |
||||
if (!exists) { |
||||
final index = cachesImagePaths.indexOf(imagePath); |
||||
if (index == -1) { |
||||
continue; |
||||
} |
||||
cachesImagePaths.removeAt(index); |
||||
if (replaceUnexistentImagesWith != null) { |
||||
cachesImagePaths.insert( |
||||
index, |
||||
replaceUnexistentImagesWith, |
||||
); |
||||
} |
||||
} |
||||
} |
||||
return cachesImagePaths; |
||||
} |
||||
} |
||||
Loading…
Reference in new issue