chore: optimize pwa icon generation

Do not collect all generated icons
into memory, but instead write
each icon to disc flushing the cache
to not use so much memory.

Author: caalador

flow-build-tools/src/main/java/com/vaadin/flow/server/frontend/TaskGeneratePWAIcons.java

@@ -17,6 +17,9 @@
 
 import javax.imageio.ImageIO;
 
+import java.awt.Color;
+import java.awt.Graphics2D;
+import java.awt.Image;
 import java.awt.image.BufferedImage;
 import java.io.File;
 import java.io.IOException;
@@ -45,6 +48,11 @@
 /**
  * Generates necessary PWA icons.
  * <p>
+ * Icons are processed in parallel but each thread draws, writes the PNG
+ * directly to disk, and immediately flushes the scaled image. This avoids
+ * accumulating all icon data in memory while still benefiting from concurrent
+ * I/O and image scaling.
+ * <p>
  * For internal use only. May be renamed or removed in a future release.
  */
 public class TaskGeneratePWAIcons implements FallibleCommand {
@@ -94,8 +102,7 @@ public void execute() throws ExecutionFailedException {
             ExecutorService executor = Executors.newFixedThreadPool(4);
             CompletableFuture<?>[] iconsGenerators = PwaRegistry
                     .getIconTemplates(pwaConfiguration.getIconPath()).stream()
-                    .map(icon -> new InternalPwaIcon(icon, baseImage))
-                    .map(this::generateIcon)
+                    .map(icon -> generateIconTask(icon, baseImage))
                     .map(task -> CompletableFuture.runAsync(task, executor))
                     .toArray(CompletableFuture[]::new);
             try {
@@ -115,6 +122,7 @@ public void execute() throws ExecutionFailedException {
             } finally {
                 executor.shutdown();
             }
+            baseImage.flush();
         } finally {
             if (headless == null) {
                 System.clearProperty(HEADLESS_PROPERTY);
@@ -173,30 +181,51 @@ private URL findIcon(PwaConfiguration pwaConfiguration) {
         return iconURL;
     }
 
-    private Runnable generateIcon(InternalPwaIcon icon) {
-        Path iconPath = generatedIconsPath.resolve(icon.getRelHref()
-                .substring(1).replace('/', File.separatorChar));
+    private Runnable generateIconTask(PwaIcon icon, BufferedImage baseImage) {
+        String relHref = "/" + icon.getHref().split("\\?")[0];
+        Path iconPath = generatedIconsPath
+                .resolve(relHref.substring(1).replace('/', File.separatorChar));
+        int targetWidth = icon.getWidth();
+        int targetHeight = icon.getHeight();
         return () -> {
+            BufferedImage scaled = drawIconImage(baseImage, targetWidth,
+                    targetHeight);
             try (OutputStream os = Files.newOutputStream(iconPath)) {
-                icon.write(os);
+                ImageIO.write(scaled, "png", os);
             } catch (IOException e) {
                 throw new UncheckedIOException(e);
+            } finally {
+                scaled.flush();
             }
         };
     }
 
-    private static class InternalPwaIcon extends PwaIcon {
-        private final BufferedImage baseImage;
+    private static BufferedImage drawIconImage(BufferedImage baseImage,
+            int targetWidth, int targetHeight) {
+        int bgColor = baseImage.getRGB(0, 0);
 
-        public InternalPwaIcon(PwaIcon icon, BufferedImage baseImage) {
-            super(icon);
-            this.baseImage = baseImage;
-        }
+        BufferedImage bimage = new BufferedImage(targetWidth, targetHeight,
+                BufferedImage.TYPE_INT_ARGB);
+        Graphics2D graphics = bimage.createGraphics();
+        try {
+            graphics.setBackground(new Color(bgColor, true));
+            graphics.clearRect(0, 0, targetWidth, targetHeight);
 
-        @Override
-        protected BufferedImage getBaseImage() {
-            return baseImage;
-        }
+            float ratio = Math.max((float) baseImage.getWidth() / targetWidth,
+                    (float) baseImage.getHeight() / targetHeight);
+            ratio = Math.max(ratio, 1.0f);
+
+            int newWidth = Math.round(baseImage.getHeight() / ratio);
+            int newHeight = Math.round(baseImage.getWidth() / ratio);
 
+            graphics.drawImage(
+                    baseImage.getScaledInstance(newWidth, newHeight,
+                            Image.SCALE_SMOOTH),
+                    (targetWidth - newWidth) / 2,
+                    (targetHeight - newHeight) / 2, null);
+        } finally {
+            graphics.dispose();
+        }
+        return bimage;
     }
 }