review changes

packages/image_picker/image_picker_for_web/lib/image_resizer.dart

@@ -4,6 +4,7 @@
 
 import 'dart:async';
 import 'dart:math';
+import 'dart:ui';
 import 'package:image_picker_for_web/image_resizer_utils.dart';
 import 'package:image_picker_platform_interface/image_picker_platform_interface.dart';
 import 'dart:html' as html;
@@ -19,44 +20,60 @@ class ImageResizer {
       //TODO Implement maxWidth and maxHeight for image/gif
       return file;
     }
-    final imageLoadCompleter = Completer();
+    final imageElement = await loadImage(file.path);
+    if (imageElement == null) {
+      return file;
+    }
+    final canvas = resizeImageElement(imageElement, maxWidth, maxHeight);
+    return writeCanvasToFile(file, canvas, imageQuality);
+  }
+
+  /// function that loads the blobUrl into an imageElement
+  /// returns null if error comes while loading the image
+  Future<html.ImageElement?> loadImage(String blobUrl) {
+    final imageLoadCompleter = Completer<html.ImageElement?>();
     final imageElement = html.ImageElement();
-    imageElement.src = file.path;
-    bool hasError = false;
+    imageElement.src = blobUrl;
 
     imageElement.onLoad.listen((event) {
-      html.Url.revokeObjectUrl(file.path);
-      imageLoadCompleter.complete();
+      html.Url.revokeObjectUrl(blobUrl);
+      imageLoadCompleter.complete(imageElement);
     });
     imageElement.onError.listen((event) {
-      imageLoadCompleter.complete();
-      hasError = true;
+      imageLoadCompleter.complete(null);
     });
-    await imageLoadCompleter.future;
-    if (hasError) {
-      return file;
-    }
-    final newImageSize = calculateSizeOfScaledImage(
-        imageElement.width!.toDouble(),
-        imageElement.height!.toDouble(),
+    return imageLoadCompleter.future;
+  }
+
+  /// Draws image to a canvas while resizing the image to fit the [maxWidth],[maxHeight] constraints
+  html.CanvasElement resizeImageElement(
+      html.ImageElement source, double? maxWidth, double? maxHeight) {
+    final newImageSize = calculateSizeOfDownScaledImage(
+        Size(source.width!.toDouble(), source.height!.toDouble()),
         maxWidth,
         maxHeight);
     final canvas = html.CanvasElement();
     canvas.width = newImageSize.width.toInt();
     canvas.height = newImageSize.height.toInt();
     final context = canvas.context2D;
     if (maxHeight == null && maxWidth == null) {
-      context.drawImage(imageElement, 0, 0);
+      context.drawImage(source, 0, 0);
     } else {
-      context.drawImageScaled(
-          imageElement, 0, 0, canvas.width!, canvas.height!);
+      context.drawImageScaled(source, 0, 0, canvas.width!, canvas.height!);
     }
+    return canvas;
+  }
+
+  /// function that converts a canvas element to Xfile
+  /// [imageQuality] is only supported for jpeg and webp images.
+  Future<XFile> writeCanvasToFile(
+      XFile originalFile, html.CanvasElement canvas, int? imageQuality) async {
     final calculatedImageQuality = ((min(imageQuality ?? 100, 100)) / 100.0);
-    final blob = await canvas.toBlob(file.mimeType,
-        calculatedImageQuality); // Image quality only works for jpeg and webp images
+    final blob =
+        await canvas.toBlob(originalFile.mimeType, calculatedImageQuality);
     return XFile(html.Url.createObjectUrlFromBlob(blob),
-        mimeType: file.mimeType,
-        name: "scaled_" + file.name,
+        mimeType: originalFile.mimeType,
+        name: "scaled_" + originalFile.name,
         lastModified: DateTime.now(),
         length: blob.size);
   }

packages/image_picker/image_picker_for_web/lib/image_resizer_utils.dart

@@ -7,33 +7,25 @@ import 'dart:ui';
 
 ///a function that checks if an image needs to be resized or not
 bool imageResizeNeeded(double? maxWidth, double? maxHeight, int? imageQuality) {
-  bool resizeNeeded =
-      (maxWidth != null || maxHeight != null || imageQuality != null);
-  if (resizeNeeded) {
-    if (imageQuality != null) {
-      return isImageQualityValid(imageQuality);
-    } else {
-      return true;
-    }
-  } else {
-    return false;
-  }
+  return imageQuality != null
+      ? isImageQualityValid(imageQuality)
+      : (maxWidth != null || maxHeight != null);
 }
 
 /// a function that checks if image quality is between 0 to 100
 bool isImageQualityValid(int imageQuality) {
   return (imageQuality >= 0 && imageQuality <= 100);
 }
 
-/// a functions that calculates the size of the scaled image.
+/// a functions that calculates the size of the downScaled image.
 /// imageWidth is the width of the image
 /// imageHeight is the height of  the image
 /// maxWidth is the maximum width of the scaled image
 /// maxHeight is the maximum height of the scaled image
-Size calculateSizeOfScaledImage(double imageWidth, double imageHeight,
-    double? maxWidth, double? maxHeight) {
-  double originalWidth = imageWidth;
-  double originalHeight = imageHeight;
+Size calculateSizeOfDownScaledImage(
+    Size imageSize, double? maxWidth, double? maxHeight) {
+  double originalWidth = imageSize.width;
+  double originalHeight = imageSize.height;
 
   bool hasMaxWidth = maxWidth != null;
   bool hasMaxHeight = maxHeight != null;

packages/image_picker/image_picker_for_web/test/image_resizer_utils_test.dart

@@ -12,30 +12,33 @@ void main() {
       test(
           "scaled image height and width are same if max width and max height are same as image's width and height",
           () {
-        expect(calculateSizeOfScaledImage(500, 300, 500, 300), Size(500, 300));
+        expect(calculateSizeOfDownScaledImage(Size(500, 300), 500, 300),
+            Size(500, 300));
       });
 
       test(
           "scaled image height and width are same if max width and max height are null",
           () {
-        expect(
-            calculateSizeOfScaledImage(500, 300, null, null), Size(500, 300));
+        expect(calculateSizeOfDownScaledImage(Size(500, 300), null, null),
+            Size(500, 300));
       });
 
       test("image size is scaled when maxWidth is set", () {
         final imageSize = Size(500, 300);
         final maxWidth = 400;
-        final scaledSize = calculateSizeOfScaledImage(
-            imageSize.width, imageSize.height, maxWidth.toDouble(), null);
+        final scaledSize = calculateSizeOfDownScaledImage(
+            Size(imageSize.width, imageSize.height), maxWidth.toDouble(), null);
         expect(scaledSize.height <= imageSize.height, true);
         expect(scaledSize.width <= maxWidth, true);
       });
 
       test("image size is scaled when maxHeight is set", () {
         final imageSize = Size(500, 300);
         final maxHeight = 400;
-        final scaledSize = calculateSizeOfScaledImage(
-            imageSize.width, imageSize.height, null, maxHeight.toDouble());
+        final scaledSize = calculateSizeOfDownScaledImage(
+            Size(imageSize.width, imageSize.height),
+            null,
+            maxHeight.toDouble());
         expect(scaledSize.height <= maxHeight, true);
         expect(scaledSize.width <= imageSize.width, true);
       });
@@ -44,8 +47,10 @@ void main() {
         final imageSize = Size(1120, 2000);
         final maxHeight = 1200;
         final maxWidth = 99;
-        final scaledSize = calculateSizeOfScaledImage(imageSize.width,
-            imageSize.height, maxWidth.toDouble(), maxHeight.toDouble());
+        final scaledSize = calculateSizeOfDownScaledImage(
+            Size(imageSize.width, imageSize.height),
+            maxWidth.toDouble(),
+            maxHeight.toDouble());
         expect(scaledSize.height <= maxHeight, true);
         expect(scaledSize.width <= maxWidth, true);
       });