New features and improvements

example/macos/Flutter/GeneratedPluginRegistrant.swift

@@ -11,6 +11,7 @@ import gal
 import pasteboard
 import path_provider_foundation
 import url_launcher_macos
+import video_player_avfoundation
 
 func RegisterGeneratedPlugins(registry: FlutterPluginRegistry) {
   DeviceInfoPlusMacosPlugin.register(with: registry.registrar(forPlugin: "DeviceInfoPlusMacosPlugin"))
@@ -19,4 +20,5 @@ func RegisterGeneratedPlugins(registry: FlutterPluginRegistry) {
   PasteboardPlugin.register(with: registry.registrar(forPlugin: "PasteboardPlugin"))
   PathProviderPlugin.register(with: registry.registrar(forPlugin: "PathProviderPlugin"))
   UrlLauncherPlugin.register(with: registry.registrar(forPlugin: "UrlLauncherPlugin"))
+  FVPVideoPlayerPlugin.register(with: registry.registrar(forPlugin: "FVPVideoPlayerPlugin"))
 }

flutter_quill_extensions/lib/embeds/builders.dart

@@ -20,13 +20,14 @@ import 'widgets/video_app.dart';
 import 'widgets/youtube_video_app.dart';
 
 class ImageEmbedBuilder extends EmbedBuilder {
-  const ImageEmbedBuilder({
+  ImageEmbedBuilder({
     this.onImageRemovedCallback,
     this.shouldRemoveImageCallback,
+    this.forceUseMobileOptionMenu = false,
   });
-
-  final ImageEmbedBuilderOnRemovedCallback? onImageRemovedCallback;
-  final ImageEmbedBuilderWillRemoveCallback? shouldRemoveImageCallback;
+  final ImageEmbedBuilderWillRemoveCallback? onImageRemovedCallback;
+  final ImageEmbedBuilderOnRemovedCallback? shouldRemoveImageCallback;
+  final bool forceUseMobileOptionMenu;
 
   @override
   String get key => BlockEmbed.imageType;
@@ -79,7 +80,7 @@ class ImageEmbedBuilder extends EmbedBuilder {
       imageSize = OptionalSize((image as Image).width, image.height);
     }
 
-    if (!readOnly && base.isMobile()) {
+    if (!readOnly && (base.isMobile() || forceUseMobileOptionMenu)) {
       return GestureDetector(
         onTap: () {
           showDialog(
@@ -136,12 +137,18 @@ class ImageEmbedBuilder extends EmbedBuilder {
 
                     final imageFile = File(imageUrl);
 
-                    // Call the remove check callback if set
-                    if (await shouldRemoveImageCallback?.call(imageFile) ==
-                        false) {
-                      return;
+                    final shouldRemoveImageEvent = shouldRemoveImageCallback;
+
+                    var shouldRemoveImage = true;
+                    if (shouldRemoveImageEvent != null) {
+                      shouldRemoveImage = await shouldRemoveImageEvent(
+                        imageFile,
+                      );
                     }
 
+                    if (!shouldRemoveImage) {
+                      return;
+                    }
                     final offset = getEmbedNode(
                       controller,
                       controller.selection.start,
@@ -152,25 +159,39 @@ class ImageEmbedBuilder extends EmbedBuilder {
                       '',
                       TextSelection.collapsed(offset: offset),
                     );
-
-                    // Call the post remove callback if set
-                    await onImageRemovedCallback?.call(imageFile);
+                    final afterRemoveImageEvent = onImageRemovedCallback;
+                    if (afterRemoveImageEvent != null) {
+                      await afterRemoveImageEvent(imageFile);
+                    }
                   },
                 );
                 return Padding(
                   padding: const EdgeInsets.fromLTRB(50, 0, 50, 0),
                   child: SimpleDialog(
                       shape: const RoundedRectangleBorder(
                           borderRadius: BorderRadius.all(Radius.circular(10))),
-                      children: [resizeOption, copyOption, removeOption]),
+                      children: [
+                        if (base.isMobile()) resizeOption,
+                        copyOption,
+                        removeOption,
+                      ]),
                 );
               });
         },
         child: image,
       );
     }
 
-    if (!readOnly || !base.isMobile() || isImageBase64(imageUrl)) {
+    if (!readOnly || isImageBase64(imageUrl)) {
+      // To enforce using it on the web, desktop and other platforms
+      // and that is up to the developer
+      if (!base.isMobile() && forceUseMobileOptionMenu) {
+        return _menuOptionsForReadonlyImage(
+          context,
+          imageUrl,
+          image,
+        );
+      }
       return image;
     }
 
@@ -239,7 +260,7 @@ class VideoEmbedBuilder extends EmbedBuilder {
     assert(!kIsWeb, 'Please provide video EmbedBuilder for Web');
 
     final videoUrl = node.value.data;
-    if (videoUrl.contains('youtube.com') || videoUrl.contains('youtu.be')) {
+    if (isYouTubeUrl(videoUrl)) {
       return YoutubeVideoApp(
           videoUrl: videoUrl, context: context, readOnly: readOnly);
     }

flutter_quill_extensions/lib/embeds/embed_types.dart

@@ -45,10 +45,10 @@ class QuillFile {
   final Uint8List bytes;
 }
 
-typedef ImageEmbedBuilderWillRemoveCallback = Future<bool> Function(
+typedef ImageEmbedBuilderWillRemoveCallback = Future<void> Function(
   File imageFile,
 );
 
-typedef ImageEmbedBuilderOnRemovedCallback = Future<void> Function(
+typedef ImageEmbedBuilderOnRemovedCallback = Future<bool> Function(
   File imageFile,
 );

flutter_quill_extensions/lib/embeds/utils.dart

@@ -15,8 +15,28 @@ bool isBase64(String str) {
   return _base64.hasMatch(str);
 }
 
+bool isHttpBasedUrl(String url) {
+  try {
+    final uri = Uri.parse(url.trim());
+    return uri.isScheme('HTTP') || uri.isScheme('HTTPS');
+  } catch (_) {
+    return false;
+  }
+}
+
+bool isYouTubeUrl(String videoUrl) {
+  try {
+    final uri = Uri.parse(videoUrl);
+    return uri.host == 'www.youtube.com' ||
+        uri.host == 'youtube.com' ||
+        uri.host == 'youtu.be';
+  } catch (_) {
+    return false;
+  }
+}
+
 bool isImageBase64(String imageUrl) {
-  return !imageUrl.startsWith('http') && isBase64(imageUrl);
+  return !isHttpBasedUrl(imageUrl) && isBase64(imageUrl);
 }
 
 enum SaveImageResultMethod { network, localStorage }

flutter_quill_extensions/lib/flutter_quill_extensions.dart

@@ -1,6 +1,7 @@
 library flutter_quill_extensions;
 
 import 'package:flutter/material.dart';
+import 'package:flutter_quill/extensions.dart';
 import 'package:flutter_quill/flutter_quill.dart';
 
 import 'embeds/builders.dart';
@@ -22,29 +23,41 @@ export 'embeds/utils.dart';
 class FlutterQuillEmbeds {
   /// Returns a list of embed builders for QuillEditor.
   ///
+  /// This method provides a collection of embed builders to enhance the
+  /// functionality
+  /// of a QuillEditor. It offers customization options for
+  /// handling various types of
+  /// embedded content, such as images, videos, and formulas.
+  ///
   /// **Note:** This method is not intended for web usage.
-  /// For web-specific embeds, use [webBuilders].
+  /// For web-specific embeds,
+  /// use [webBuilders].
   ///
-  /// [onVideoInit] is called when a video is initialized.
+  /// [onVideoInit] is a callback function that gets triggered when
+  ///  a video is initialized.
+  /// You can use this to perform actions or setup configurations related
+  ///  to video embedding.
   ///
-  /// [onImageRemovedCallback] is called when an image
-  ///  is removed from the editor. This can be used to
-  /// delete the image from storage, for example:
+  /// [onImageRemovedCallback] is called when an image is
+  ///  removed from the editor.
+  /// By default, [onImageRemovedCallback] deletes the
+  ///  temporary image file if
+  /// the platform is mobile and if it still exists. You
+  ///  can customize this behavior
+  /// by passing your own function that handles the removal process.
   ///
+  /// Example of [onImageRemovedCallback] customization:
   /// ```dart
-  /// (imageFile) async {
-  ///   final fileExists = await imageFile.exists();
-  ///   if (fileExists) {
-  ///     await imageFile.delete();
-  ///   }
-  /// },
+  /// afterRemoveImageFromEditor: (imageFile) async {
+  ///   // Your custom logic here
+  ///   // or leave it empty to do nothing
+  /// }
   /// ```
   ///
-  /// [shouldRemoveImageCallback] is called when the user
-  /// attempts to remove an image
-  /// from the editor. It allows you to control whether the image
-  /// should be removed
-  /// based on your custom logic.
+  /// [shouldRemoveImageCallback] is a callback
+  ///  function that is invoked when the
+  /// user attempts to remove an image from the editor. It allows you to control
+  /// whether the image should be removed based on your custom logic.
   ///
   /// Example of [shouldRemoveImageCallback] customization:
   /// ```dart
@@ -54,23 +67,78 @@ class FlutterQuillEmbeds {
   ///     context: context,
   ///     options: const YesOrCancelDialogOptions(
   ///       title: 'Deleting an image',
-  ///       message: 'Are you sure you want to delete this image
-  ///       from the editor?',
+  ///       message: 'Are you sure you want' ' to delete this
+  ///      image from the editor?',
   ///     ),
   ///   );
   ///
   ///   // Return `true` to allow image removal if the user confirms, otherwise `false`
   ///   return isShouldRemove;
   /// }
   /// ```
+  ///
+  /// [forceUseMobileOptionMenuForImageClick] is a boolean
+  /// flag that, when set to `true`,
+  /// enforces the use of the mobile-specific option menu for image clicks in
+  /// other platforms like web and desktop, this option doesn't affect mobile.
+  ///  This option
+  /// can be used to override the default behavior based on the platform.
+  ///
+  /// The method returns a list of [EmbedBuilder] objects that can be used with
+  ///  QuillEditor
+  /// to enable embedded content features like images, videos, and formulas.
+  ///
+  /// Example usage:
+  /// ```dart
+  /// final embedBuilders = QuillEmbedBuilders.builders(
+  ///   onVideoInit: (videoContainerKey) {
+  ///     // Custom video initialization logic
+  ///   },
+  ///   // Customize other callback functions as needed
+  /// );
+  ///
+  /// final quillEditor = QuillEditor(
+  ///   // Other editor configurations
+  ///   embedBuilders: embedBuilders,
+  /// );
+  /// ```
   static List<EmbedBuilder> builders({
     void Function(GlobalKey videoContainerKey)? onVideoInit,
-    ImageEmbedBuilderOnRemovedCallback? onImageRemovedCallback,
-    ImageEmbedBuilderWillRemoveCallback? shouldRemoveImageCallback,
+    ImageEmbedBuilderWillRemoveCallback? onImageRemovedCallback,
+    ImageEmbedBuilderOnRemovedCallback? shouldRemoveImageCallback,
+    bool forceUseMobileOptionMenuForImageClick = false,
   }) =>
       [
         ImageEmbedBuilder(
-          onImageRemovedCallback: onImageRemovedCallback,
+          forceUseMobileOptionMenu: forceUseMobileOptionMenuForImageClick,
+          onImageRemovedCallback: onImageRemovedCallback ??
+              (imageFile) async {
+                final mobile = isMobile();
+                // If the platform is not mobile, return void;
+                // Since the mobile OS gives us a copy of the image
+
+                // Note: We should remove the image on Flutter web
+                // since the behavior is similar to how it is on mobile,
+                // but since this builder is not for web, we will ignore it
+                if (!mobile) {
+                  return;
+                }
+
+                // On mobile OS (Android, iOS), the system will not give us
+                // direct access to the image; instead,
+                // it will give us the image
+                // in the temp directory of the application. So, we want to
+                // remove it when we no longer need it.
+
+                // but on desktop we don't want to touch user files
+                // especially on macOS, where we can't even delete it without
+                // permission
+
+                final isFileExists = await imageFile.exists();
+                if (isFileExists) {
+                  await imageFile.delete();
+                }
+              },
           shouldRemoveImageCallback: shouldRemoveImageCallback,
         ),
         VideoEmbedBuilder(onVideoInit: onVideoInit),