@capgo/capacitor-printer 8.1.1 → 8.1.3

package/android/src/main/java/com/capgo/printer/Printer.java

@@ -14,6 +14,7 @@ import android.print.PageRange;
 import android.print.PrintAttributes;
 import android.print.PrintDocumentAdapter;
 import android.print.PrintDocumentInfo;
+import android.print.PrintJob;
 import android.print.PrintManager;
 import android.util.Base64;
 import android.webkit.WebView;
@@ -26,9 +27,26 @@ import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
 
 public class Printer {
 
+    /**
+     * Reports the end of a print session back to the caller.
+     */
+    public interface OnPrintFinishCallback {
+        /**
+         * Invoked once the print session has ended, whether the user printed or cancelled.
+         */
+        void onFinish();
+
+        /**
+         * Invoked when the job could not be started at all.
+         */
+        void onError(String message);
+    }
+
     private final Context context;
     private final Activity activity;
 
@@ -168,6 +186,19 @@ public class Printer {
     }
 
     public void printWebView(WebView webView, String name) throws Exception {
+        printWebView(webView, name, null);
+    }
+
+    /**
+     * Prints the current content of the web view.
+     *
+     * <p>The adapter returned by {@link WebView#createPrintDocumentAdapter(String)} renders lazily
+     * from the live web view, so callers must keep that content in place until {@code callback}
+     * reports the session has finished.
+     *
+     * @param callback notified once the print session ends, or null for fire-and-forget printing.
+     */
+    public void printWebView(WebView webView, String name, OnPrintFinishCallback callback) throws Exception {
         if (webView == null) {
             throw new Exception("WebView not available");
         }
@@ -175,7 +206,15 @@ public class Printer {
             new Runnable() {
                 @Override
                 public void run() {
-                    createWebPrintJob(webView, name);
+                    try {
+                        createWebPrintJob(webView, name, callback);
+                    } catch (Exception e) {
+                        // The job is created asynchronously on the UI thread, so failures here
+                        // cannot surface through the throws clause above.
+                        if (callback != null) {
+                            callback.onError(e.getMessage());
+                        }
+                    }
                 }
             }
         );
@@ -229,13 +268,60 @@ public class Printer {
     }
 
     private void createWebPrintJob(WebView webView, String name) {
+        try {
+            createWebPrintJob(webView, name, null);
+        } catch (Exception e) {
+            // Preserves the previous silent behaviour for callers without a callback.
+        }
+    }
+
+    private void createWebPrintJob(WebView webView, String name, OnPrintFinishCallback callback) throws Exception {
         PrintManager printManager = (PrintManager) context.getSystemService(Context.PRINT_SERVICE);
         if (printManager == null) {
-            return;
+            throw new Exception("Print service not available");
         }
 
         PrintDocumentAdapter printAdapter = webView.createPrintDocumentAdapter(name);
-        printManager.print(name, printAdapter, new PrintAttributes.Builder().build());
+
+        if (callback == null) {
+            printManager.print(name, printAdapter, new PrintAttributes.Builder().build());
+            return;
+        }
+
+        // Populated right after print() returns. We are on the UI thread here and the adapter
+        // callbacks are dispatched to that same thread, so none of them can run before the
+        // reference is set.
+        AtomicReference<PrintJob> printJob = new AtomicReference<>();
+
+        // The framework calls onFinish() on the wrapped adapter once the print session ends,
+        // which is the earliest point at which the web view content is no longer needed.
+        PrintDocumentAdapter proxy = new PrintFinishAdapter(printAdapter, () -> {
+            PrintJob job = printJob.get();
+
+            // Layout and write failures are reported to the framework's own result callbacks,
+            // which cannot be intercepted — PrintDocumentAdapter.LayoutResultCallback and
+            // WriteResultCallback are not subclassable outside android.print. The resulting job
+            // state is the only signal available to us, and it is best effort: a job that fails
+            // after the session ends (offline printer) settles too late to be seen here.
+            if (job != null && job.isFailed()) {
+                callback.onError("Print job failed");
+                return;
+            }
+
+            callback.onFinish();
+        });
+
+        PrintJob job = printManager.print(name, proxy, new PrintAttributes.Builder().build());
+
+        // print() is documented to return null on failure (despite its @NonNull annotation) and
+        // does so when the print feature is missing or the print dialog cannot be started. The
+        // adapter is never invoked in that case, so onFinish() would never arrive.
+        if (job == null) {
+            callback.onError("Failed to start print job");
+            return;
+        }
+
+        printJob.set(job);
     }
 
     private File saveTempFile(byte[] data, String mimeType) throws IOException {
@@ -282,6 +368,61 @@ public class Printer {
         }
     }
 
+    /**
+     * Delegating adapter that additionally notifies when the print session has finished.
+     */
+    private static class PrintFinishAdapter extends PrintDocumentAdapter {
+
+        private final PrintDocumentAdapter delegate;
+        private final Runnable onFinished;
+        private final AtomicBoolean notified = new AtomicBoolean(false);
+
+        PrintFinishAdapter(@NonNull PrintDocumentAdapter delegate, @NonNull Runnable onFinished) {
+            this.delegate = delegate;
+            this.onFinished = onFinished;
+        }
+
+        @Override
+        public void onStart() {
+            delegate.onStart();
+        }
+
+        @Override
+        public void onLayout(
+            PrintAttributes oldAttributes,
+            PrintAttributes newAttributes,
+            CancellationSignal cancellationSignal,
+            LayoutResultCallback callback,
+            Bundle extras
+        ) {
+            delegate.onLayout(oldAttributes, newAttributes, cancellationSignal, callback, extras);
+        }
+
+        @Override
+        public void onWrite(
+            PageRange[] pages,
+            ParcelFileDescriptor destination,
+            CancellationSignal cancellationSignal,
+            WriteResultCallback callback
+        ) {
+            delegate.onWrite(pages, destination, cancellationSignal, callback);
+        }
+
+        @Override
+        public void onFinish() {
+            try {
+                // Let the WebView adapter release its own resources first.
+                delegate.onFinish();
+            } finally {
+                // Runs even if the delegate throws during teardown, so the caller is always
+                // notified exactly once.
+                if (notified.compareAndSet(false, true)) {
+                    onFinished.run();
+                }
+            }
+        }
+    }
+
     // Custom PrintDocumentAdapter for PDF files
     private class PdfDocumentAdapter extends PrintDocumentAdapter {
 

package/android/src/main/java/com/capgo/printer/PrinterPlugin.java

@@ -9,7 +9,7 @@ import com.getcapacitor.annotation.CapacitorPlugin;
 @CapacitorPlugin(name = "Printer")
 public class PrinterPlugin extends Plugin {
 
-    private final String pluginVersion = "8.1.1";
+    private final String pluginVersion = "8.1.3";
 
     private Printer implementation;
 
@@ -120,8 +120,25 @@ public class PrinterPlugin extends Plugin {
         String name = call.getString("name", "Document");
 
         try {
-            implementation.printWebView(getBridge().getWebView(), name);
-            call.resolve();
+            // Resolve once the print session ends rather than once the job is handed to the
+            // system: the WebView still backs the print adapter until then, so resolving early
+            // lets callers navigate away while pages are still being rendered.
+            implementation.printWebView(
+                getBridge().getWebView(),
+                name,
+                new Printer.OnPrintFinishCallback() {
+                    @Override
+                    public void onFinish() {
+                        // A cancelled job is a normal outcome, not a failure.
+                        call.resolve();
+                    }
+
+                    @Override
+                    public void onError(String message) {
+                        call.reject("Failed to print web view: " + message);
+                    }
+                }
+            );
         } catch (Exception e) {
             call.reject("Failed to print web view: " + e.getMessage(), e);
         }

package/ios/Sources/PrinterPlugin/Printer.swift

@@ -10,6 +10,7 @@ import WebKit
         case unsupportedMimeType
         case printingNotAvailable
         case invalidData
+        case presentationFailed
     }
 
     /// Print base64 encoded data
@@ -175,10 +176,15 @@ import WebKit
     }
 
     /// Print web view content
+    ///
+    /// `completion` is invoked once the print interaction has been dismissed, whether the user
+    /// printed or cancelled. `viewPrintFormatter()` renders lazily from the live web view, so
+    /// callers must keep that content in place until `completion` fires.
     public func printWebView(
         webView: WKWebView,
         name: String,
-        presentingViewController: UIViewController?
+        presentingViewController: UIViewController?,
+        completion: ((Bool, Error?) -> Void)? = nil
     ) throws {
         let printInfo = UIPrintInfo(dictionary: nil)
         printInfo.jobName = name
@@ -190,7 +196,8 @@ import WebKit
             printInfo: printInfo,
             printFormatter: formatter,
             printItem: nil,
-            presentingViewController: presentingViewController
+            presentingViewController: presentingViewController,
+            completion: completion
         )
     }
 
@@ -200,7 +207,8 @@ import WebKit
         printInfo: UIPrintInfo,
         printFormatter: UIPrintFormatter?,
         printItem: Any?,
-        presentingViewController: UIViewController?
+        presentingViewController: UIViewController?,
+        completion: ((Bool, Error?) -> Void)? = nil
     ) throws {
         guard UIPrintInteractionController.isPrintingAvailable else {
             throw PrinterError.printingNotAvailable
@@ -219,21 +227,41 @@ import WebKit
             printController.printingItem = item
         }
 
+        // Only build a handler when a caller asked for one, so callers that opted out keep the
+        // existing fire-and-forget behaviour.
+        var handler: UIPrintInteractionController.CompletionHandler?
+
+        if let completion = completion {
+            handler = { _, completed, error in
+                completion(completed, error)
+            }
+        }
+
         // Present print controller
+        let presented: Bool
+
         if UIDevice.current.userInterfaceIdiom == .pad {
             // For iPad, present as popover
-            printController.present(
+            presented = printController.present(
                 from: viewController.view.bounds,
                 in: viewController.view,
                 animated: true,
-                completionHandler: nil
+                completionHandler: handler
             )
         } else {
             // For iPhone, present modally
-            printController.present(
+            presented = printController.present(
                 animated: true,
-                completionHandler: nil
+                completionHandler: handler
             )
         }
+
+        // A false return means nothing was shown and the completion handler will never be
+        // scheduled — for example when another print interaction is already presented, since
+        // UIPrintInteractionController.shared is a singleton. Callers waiting on that handler
+        // would otherwise never hear back.
+        if !presented {
+            throw PrinterError.presentationFailed
+        }
     }
 }

package/ios/Sources/PrinterPlugin/PrinterPlugin.swift

@@ -3,7 +3,7 @@ import Capacitor
 
 @objc(PrinterPlugin)
 public class PrinterPlugin: CAPPlugin, CAPBridgedPlugin {
-    private let pluginVersion: String = "8.1.1"
+    private let pluginVersion: String = "8.1.3"
     public let identifier = "PrinterPlugin"
     public let jsName = "Printer"
     public let pluginMethods: [CAPPluginMethod] = [
@@ -159,12 +159,21 @@ public class PrinterPlugin: CAPPlugin, CAPBridgedPlugin {
             }
 
             do {
+                // Resolve from the print interaction's completion handler rather than straight
+                // after presenting: the web view still backs the print formatter until the sheet
+                // is dismissed, so resolving early lets callers navigate away mid-render.
                 try self.implementation.printWebView(
                     webView: webView,
                     name: name,
                     presentingViewController: self.bridge?.viewController
-                )
-                call.resolve()
+                ) { _, error in
+                    if let error = error {
+                        call.reject("Failed to print web view: \(error.localizedDescription)")
+                    } else {
+                        // A user-cancelled sheet is a normal outcome, not a failure.
+                        call.resolve()
+                    }
+                }
             } catch {
                 call.reject("Failed to print web view: \(error.localizedDescription)")
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capgo/capacitor-printer",
-  "version": "8.1.1",
+  "version": "8.1.3",
   "description": "Capacitor plugin for printing documents, HTML, PDFs, images and web views",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",