capacitor-native-video-compressor 2.0.0 → 2.1.0

package/README.md

@@ -164,7 +164,7 @@ Compressing a long video runs for minutes, so give the user a way out. Pass a
 `jobId` when starting, then cancel with the same id:
 
 ```typescript
-import { NativeVideoCompressor, CANCELLED } from 'capacitor-native-video-compressor';
+import { NativeVideoCompressor, CANCELLED, STORAGE_FULL, TOO_LARGE_FOR_WEB } from 'capacitor-native-video-compressor';
 
 const jobId = crypto.randomUUID();
 
@@ -179,6 +179,13 @@ try {
     // The user asked for this — no error toast, no retry prompt.
     return;
   }
+  if (error.code === TOO_LARGE_FOR_WEB) {
+    // Web only: WebCodecs is unavailable or failed, and the file is over the 200 MB ffmpeg.wasm limit.
+    // Upload the original, or ask for a shorter clip.
+  }
+  if (error.code === STORAGE_FULL) {
+    // Web only: the browser storage quota is full. Retryable once space is freed.
+  }
   throw error;
 }
 
@@ -205,7 +212,7 @@ different job was — it never throws.
 
 ### Quality Presets
 
-The `quality` parameter determines the output resolution and compression ratio. Depending on the original aspect ratio, the video will be scaled to match the following heights (or widths, preserving aspect ratio):
+The `quality` parameter determines the output resolution and compression ratio. Each tier caps the **short** side of the displayed video (the height of a landscape video, the width of a portrait one); the long side follows the aspect ratio. A source smaller than the tier is never upscaled. On Android both sides are rounded to multiples of 16, so 540 becomes 528.
 
 | Preset      | Target Resolution | Best For                                  |
 | ----------- | ----------------- | ----------------------------------------- |
@@ -216,7 +223,7 @@ The `quality` parameter determines the output resolution and compression ratio.
 | `360P`      | ~ 360p            | Very small files                          |
 | `VERY_LOW`  | ~ 240p            | Extreme compression, noticeably pixelated |
 
-> **Note on Web Platform**: On Web, lower qualities also aggressively reduce the Audio Bitrate (down to 48kbps for VERY_LOW) to maximize space savings. On Native, audio maintains steady quality.
+> **Bitrate**: The video bitrate never goes above the source's own bitrate, so a lean source is not inflated; the Web ffmpeg fallback is the exception, as it uses CRF only (iOS and Web WebCodecs allow 1.5× the source for HEVC, VP9 and AV1, which need less than H.264 for the same picture). On Web, the ffmpeg fallback lowers the audio bitrate with the tier (down to 48 kbps for VERY_LOW). On iOS, AAC audio is capped at the source rate and snapped down to 64, 96 or 128 kbps.
 
 ### Platform Differences for `sourcePath`
 
@@ -299,6 +306,9 @@ missed call leaves the device feeding an idle job until the hold expires.
 `released` is false when no job by that id was still being held, which is
 the normal outcome of a late or duplicate call, not an error.
 
+Web: deletes the compressed output instead, so call it only once the File
+is no longer needed (not before a retry).
+
 | Param         | Type                            |
 | ------------- | ------------------------------- |
 | **`options`** | <code>{ jobId: string; }</code> |

package/android/src/main/java/com/atomic/videocompressor/NativeVideoCompressor.java

@@ -1,11 +1,141 @@
 package com.atomic.videocompressor;
 
-import com.getcapacitor.Logger;
+import java.util.regex.Pattern;
 
+/**
+ * Output size, bitrate and leftover-file rules for one compress, kept free of
+ * android.* so they run as plain JVM unit tests. Same ladder as iOS
+ * (NativeVideoCompressorPlugin.swift) and the web QUALITY_LADDER.
+ */
 public class NativeVideoCompressor {
 
-    public String echo(String value) {
-        Logger.info("Echo", value);
-        return value;
+    /**
+     * LightCompressor 1.3.2 getMediaPath copies any source it can't resolve
+     * through MediaStore `_data` (file:// and Photo Picker URIs) to
+     * `dataDir/<System.currentTimeMillis()>` and never deletes it.
+     */
+    private static final Pattern SOURCE_COPY_NAME = Pattern.compile("\\d{13}");
+
+    static boolean isSourceCopyName(String name) {
+        return name != null && SOURCE_COPY_NAME.matcher(name).matches();
+    }
+
+    /**
+     * A copy older than `cutoff` (process start, or "now" on a WebView reload
+     * when every job is orphaned) can't belong to a live job.
+     */
+    static boolean isStaleSourceCopy(String name, long lastModified, long cutoff) {
+        return isSourceCopyName(name) && lastModified < cutoff;
+    }
+
+    /**
+     * Factors LightCompressor 1.3.2 applies to the source bitrate when no
+     * explicit bitrate is given (CompressorUtils.getBitrate), in VideoQuality
+     * order VERY_LOW, LOW, MEDIUM, HIGH, VERY_HIGH.
+     */
+    static final double[] SOURCE_FACTORS = { 0.1, 0.2, 0.3, 0.4, 0.6 };
+
+    static final class Target {
+
+        final int shortSide;
+        final long bitrate;
+
+        Target(int shortSide, long bitrate) {
+            this.shortSide = shortSide;
+            this.bitrate = bitrate;
+        }
+    }
+
+    static Target target(String quality) {
+        if (quality == null) quality = "MEDIUM";
+        switch (quality) {
+            case "VERY_HIGH":
+                return new Target(1080, 4_500_000);
+            case "HIGH":
+                return new Target(720, 2_500_000);
+            case "LOW":
+                return new Target(480, 1_000_000);
+            case "360P":
+                return new Target(360, 700_000);
+            case "VERY_LOW":
+                return new Target(240, 400_000);
+            default:
+                return new Target(540, 1_500_000);
+        }
+    }
+
+    /**
+     * {width, height} in the track's coded orientation, or null for an empty
+     * track. `shortSide` caps the shorter side and the long side keeps the
+     * aspect ratio. A 90/270 rotation only swaps the sides, and LightCompressor
+     * swaps explicit dimensions itself for those, so coded order is right.
+     * Unlike iOS, both sides are multiples of 16 (so 540 becomes 528). The long
+     * side follows the aligned short side and rounds to the nearest 16, so the
+     * aspect ratio drifts less than flooring each side on its own would.
+     */
+    static int[] outputSize(int width, int height, int shortSide) {
+        int sourceShort = Math.min(width, height);
+        if (sourceShort <= 0) return null;
+        int sourceLong = Math.max(width, height);
+        int outShort = align16(Math.min(shortSide, sourceShort));
+        long nearestLong = Math.round(((double) sourceLong * outShort) / sourceShort / 16) * 16;
+        int outLong = (int) Math.max(16, Math.min(nearestLong, align16(sourceLong)));
+        return width >= height ? new int[] { outLong, outShort } : new int[] { outShort, outLong };
+    }
+
+    // Some MediaTek and older Qualcomm AVC encoders fail configure or draw green
+    // edges off 16-pixel macroblocks; LightCompressor's own sizing aligns for that.
+    // Floor so it never upscales.
+    private static int align16(double value) {
+        return Math.max(16, (int) (value / 16) * 16);
+    }
+
+    static final class BitratePlan {
+
+        /** Whole Mbps for Configuration.videoBitrateInMbps, or null to scale the source instead. */
+        final Integer mbps;
+
+        /** Index into SOURCE_FACTORS when mbps is null. */
+        final int sourceFactorIndex;
+
+        BitratePlan(Integer mbps, int sourceFactorIndex) {
+            this.mbps = mbps;
+            this.sourceFactorIndex = sourceFactorIndex;
+        }
+    }
+
+    /**
+     * LightCompressor 1.3.2 only takes whole Mbps or a fixed fraction of the
+     * source bitrate, so pick whichever lands closest to the target, never
+     * above the source. Null when the source bitrate is unknown.
+     */
+    static BitratePlan bitrate(long target, long source) {
+        if (source <= 0) return null;
+        BitratePlan best = null;
+        long bestDistance = Long.MAX_VALUE;
+        long bestBps = 0;
+
+        // Down to 1, not just floor/ceil of the target: a source below the
+        // target should get the largest whole Mbps it still fits.
+        for (long mbps = target / 1_000_000 + 1; mbps >= 1; mbps--) {
+            long bps = mbps * 1_000_000;
+            if (bps > source) continue;
+            long distance = Math.abs(bps - target);
+            if (distance < bestDistance || (distance == bestDistance && bps < bestBps)) {
+                best = new BitratePlan((int) mbps, -1);
+                bestDistance = distance;
+                bestBps = bps;
+            }
+        }
+        for (int i = 0; i < SOURCE_FACTORS.length; i++) {
+            long bps = Math.round(source * SOURCE_FACTORS[i]);
+            long distance = Math.abs(bps - target);
+            if (distance < bestDistance || (distance == bestDistance && bps < bestBps)) {
+                best = new BitratePlan(null, i);
+                bestDistance = distance;
+                bestBps = bps;
+            }
+        }
+        return best;
     }
 }

package/android/src/main/java/com/atomic/videocompressor/NativeVideoCompressorPlugin.java

@@ -1,5 +1,6 @@
 package com.atomic.videocompressor;
 
+import android.media.MediaMetadataRetriever;
 import android.net.Uri;
 import android.util.Log;
 import androidx.annotation.NonNull;
@@ -21,6 +22,8 @@ import com.getcapacitor.annotation.CapacitorPlugin;
 import java.io.File;
 import java.util.Arrays;
 import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
@@ -38,12 +41,30 @@ public class NativeVideoCompressorPlugin extends Plugin {
 
     private static final String STORAGE_SUBFOLDER = "compressed_videos";
 
+    /** Gắn lên mọi work của plugin để dọn được job mồ côi của phiên WebView trước. */
+    private static final String WORK_TAG = "native-video-compressor";
+
+    /** Thứ tự khớp NativeVideoCompressor.SOURCE_FACTORS. */
+    private static final VideoQuality[] QUALITY_BY_SOURCE_FACTOR = {
+        VideoQuality.VERY_LOW,
+        VideoQuality.LOW,
+        VideoQuality.MEDIUM,
+        VideoQuality.HIGH,
+        VideoQuality.VERY_HIGH
+    };
+
     /**
      * Trần cho pha giữ-chờ-upload. Ngắn hơn mốc 10 phút mà WorkManager tự cắt,
      * để một caller chết giữa chừng không chiếm quota job tới tận phút cuối.
      */
     private static final long HOLD_FOR_UPLOAD_TIMEOUT_MINUTES = 8;
 
+    /**
+     * Mốc process này nạp plugin - trước mọi lần nén của nó. Bản sao nguồn cũ
+     * hơn mốc này là của một process đã chết.
+     */
+    private static final long PROCESS_START_MS = System.currentTimeMillis();
+
     /** The job compressVideo is running right now, for cancel({ jobId }). */
     private String currentJobId = null;
 
@@ -60,9 +81,93 @@ public class NativeVideoCompressorPlugin extends Plugin {
         call.resolve(ret);
     }
 
+    /** Bridge mới (Activity dựng lại): mọi job còn chạy thuộc phiên cũ. */
+    @Override
+    public void load() {
+        cancelOrphans(PROCESS_START_MS);
+    }
+
+    /**
+     * Bridge gọi hàm này ở onPageStarted (Bridge.reset), tức mỗi lần WebView
+     * tải lại trang - load() thì không chạy lại. JS cũ đã chết nên không còn
+     * ai nhận kết quả các job đang chạy.
+     *
+     * Mốc dọn là "bây giờ": JS mới chưa chạy nên mọi bản sao nguồn đều mồ
+     * côi, kể cả bản một job huỷ giữa pha chép vẫn đang ghi tiếp sau claim().
+     */
+    @Override
+    public void removeAllListeners() {
+        super.removeAllListeners();
+        cancelOrphans(System.currentTimeMillis());
+    }
+
+    /**
+     * Dừng job trong process trước, đồng bộ, rồi mới huỷ work. Huỷ work là bất
+     * đồng bộ: onStopped tới muộn sẽ gọi VideoCompressor.cancel() - vốn global
+     * - và giết luôn job đầu tiên của phiên mới. Dừng trước thì onStopped gặp
+     * job đã stopped và không làm gì.
+     *
+     * ponytail: cờ isRunning của LightCompressor là global; nếu phiên mới gọi
+     * start trước khi vòng nén cũ kịp đọc cờ (mỗi ~100 µs) thì job cũ chạy
+     * tiếp. JS boot mất cả giây nên gần như không xảy ra; cần chặt hơn thì
+     * phải bỏ LightCompressor.
+     */
+    private void cancelOrphans(long copiesOlderThan) {
+        VideoCompressionWorker.stopAll();
+        try {
+            WorkManager.getInstance(getContext()).cancelAllWorkByTag(WORK_TAG);
+        } catch (Exception e) {
+            Log.w(TAG, "Could not cancel orphaned work", e);
+        }
+        // Process bị kill giữa chừng thì không job nào kịp dọn bản sao của nó.
+        for (File copy : sourceCopies()) {
+            if (NativeVideoCompressor.isStaleSourceCopy(copy.getName(), copy.lastModified(), copiesOlderThan)) {
+                deleteQuietly(copy);
+            }
+        }
+    }
+
+    /** File thường ở gốc dataDir mang tên đúng 13 chữ số - xem NativeVideoCompressor.isSourceCopyName. */
+    private File[] sourceCopies() {
+        try {
+            File[] files = new File(getContext().getApplicationInfo().dataDir).listFiles(
+                (File f) -> f.isFile() && NativeVideoCompressor.isSourceCopyName(f.getName())
+            );
+            if (files != null) return files;
+        } catch (Exception e) {
+            Log.w(TAG, "Could not list source copies", e);
+        }
+        return new File[0];
+    }
+
+    private Set<String> sourceCopyNames() {
+        Set<String> names = new HashSet<>();
+        for (File copy : sourceCopies()) names.add(copy.getName());
+        return names;
+    }
+
     /**
-     * Stop the running compress. LightCompressor cancels its coroutine job and
-     * fires onCancelled, which is already wired below.
+     * Xoá bản sao xuất hiện sau `before`. Nếu job khác đang chạy song song mà
+     * bản sao của nó bị xoá theo cũng vô hại: LightCompressor 1.3.2 chỉ
+     * null-check đường dẫn đó, còn nén thì đọc thẳng từ Uri gốc.
+     */
+    private void deleteSourceCopiesSince(Set<String> before) {
+        for (File copy : sourceCopies()) {
+            if (!before.contains(copy.getName())) deleteQuietly(copy);
+        }
+    }
+
+    private void deleteQuietly(File file) {
+        try {
+            if (!file.delete()) Log.w(TAG, "Could not delete " + file);
+        } catch (Exception e) {
+            Log.w(TAG, "Could not delete " + file, e);
+        }
+    }
+
+    /**
+     * Stop the running compress. The job is stopped directly and answers
+     * CANCELLED itself; LightCompressor's own callbacks after that are no-ops.
      */
     @PluginMethod
     public void cancel(PluginCall call) {
@@ -79,11 +184,12 @@ public class NativeVideoCompressorPlugin extends Plugin {
         synchronized (this) {
             cancelled = currentJobId != null && (requested == null || requested.equals(currentJobId));
             if (cancelled) {
-                // Huỷ cả work: pha nén có thể chưa kịp bắt đầu, lúc đó
-                // VideoCompressor.cancel() không có gì để huỷ và work vẫn sẽ
-                // chạy sau đó. Huỷ work làm onStopped bắn và job tự kết thúc.
-                cancelWork(currentJobId);
-                VideoCompressor.cancel();
+                String jobId = currentJobId;
+                // Dừng job trực tiếp chứ không trông vào onStopped: work còn
+                // ENQUEUED thì huỷ xong WorkManager không hề dựng Worker, nên
+                // onStopped không bao giờ bắn và PluginCall sẽ treo.
+                if (!VideoCompressionWorker.stop(jobId)) VideoCompressor.cancel();
+                cancelWork(jobId);
             }
         }
 
@@ -131,34 +237,60 @@ public class NativeVideoCompressorPlugin extends Plugin {
 
         // Đọc quality từ Javascript (Mặc định là MEDIUM)
         String qualityString = call.getString("quality", "MEDIUM");
+        NativeVideoCompressor.Target target = NativeVideoCompressor.target(qualityString);
 
-        VideoQuality videoQuality = VideoQuality.MEDIUM;
-        if (qualityString != null) {
-            if (qualityString.equals("360P")) {
-                videoQuality = VideoQuality.LOW; // Map 360p to LOW quality on Android
-            } else if (qualityString.equals("LOW")) {
-                videoQuality = VideoQuality.VERY_LOW; // Adjusting others dynamically if needed
-            } else {
-                try {
-                    videoQuality = VideoQuality.valueOf(qualityString);
-                } catch (IllegalArgumentException e) {
-                    videoQuality = VideoQuality.MEDIUM;
-                }
-            }
+        // Kích thước + bitrate theo cùng bậc thang với iOS/web. Đọc metadata
+        // hỏng thì để null, LightCompressor tự chọn như trước.
+        int[] size = null;
+        NativeVideoCompressor.BitratePlan bitrate = null;
+        MediaMetadataRetriever retriever = new MediaMetadataRetriever();
+        try {
+            retriever.setDataSource(getContext(), srcUri);
+            int width = Integer.parseInt(retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_WIDTH));
+            int height = Integer.parseInt(retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_HEIGHT));
+            size = NativeVideoCompressor.outputSize(width, height, target.shortSide);
+            bitrate = NativeVideoCompressor.bitrate(
+                target.bitrate,
+                Long.parseLong(retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_BITRATE))
+            );
+        } catch (Exception e) {
+            // Containers without a bitrate tag (MKV, WebM, screen recordings) still keep the tier's size.
+            Log.w(TAG, "Could not read video metadata, using LightCompressor defaults for the rest", e);
+        } finally {
+            // release() khai báo IOException từ API 29; không dùng
+            // try-with-resources vì minSdk 24 chưa có AutoCloseable.
+            try {
+                retriever.release();
+            } catch (Exception ignored) {}
         }
 
-        Log.d(TAG, "====== VIDEO COMPRESSION QUALITY RECEIVED: " + qualityString + "+ video quality: " + videoQuality + " ======");
+        // Với bitrate tính theo nguồn, quality chỉ còn chọn hệ số nhân của
+        // LightCompressor; với Mbps tường minh hoặc metadata hỏng thì giữ MEDIUM.
+        VideoQuality videoQuality =
+            bitrate != null && bitrate.mbps == null ? QUALITY_BY_SOURCE_FACTOR[bitrate.sourceFactorIndex] : VideoQuality.MEDIUM;
+
+        Log.d(
+            TAG,
+            "Compress " +
+                qualityString +
+                ": size=" +
+                (size == null ? "default" : size[0] + "x" + size[1]) +
+                ", mbps=" +
+                (bitrate == null ? "default" : bitrate.mbps) +
+                ", quality=" +
+                videoQuality
+        );
 
         // 2. Cấu hình thông số nén (Dành riêng cho LightCompressor 1.3.2)
-        // Lưu ý: Java phải truyền đủ 9 tham số do thư viện gốc viết bằng Kotlin
+        // Thứ tự tham số theo Configuration.kt: height ĐỨNG TRƯỚC width.
         Configuration configuration = new Configuration(
             videoQuality, // Chất lượng nén
             false, // tắt tính năng giới hạn Bitrate tối thiểu của file gốc
-            null, // videoBitrateInMbps (Ép buộc giá trị Bitrate để đảm bảo file luôn nhẹ đi)
+            bitrate == null ? null : bitrate.mbps, // videoBitrateInMbps
             false, // disableAudio
             false, // keepOriginalResolution
-            null, // videoWidth
-            null, // videoHeight
+            size == null ? null : Double.valueOf(size[1]), // videoHeight
+            size == null ? null : Double.valueOf(size[0]), // videoWidth
             Arrays.asList(fileName) // videoNames
         );
 
@@ -179,6 +311,7 @@ public class NativeVideoCompressorPlugin extends Plugin {
 
         OneTimeWorkRequest request = new OneTimeWorkRequest.Builder(VideoCompressionWorker.class)
             .setInputData(new Data.Builder().putString(VideoCompressionWorker.KEY_JOB_ID, jobId).build())
+            .addTag(WORK_TAG)
             .build();
 
         try {
@@ -220,6 +353,9 @@ public class NativeVideoCompressorPlugin extends Plugin {
         /** True khi nén xong có kết quả dùng được, tức là có cái để upload. */
         private volatile boolean compressed = false;
 
+        /** Bản sao nguồn có sẵn trước job này; claim() xoá những cái mới hơn. */
+        private volatile Set<String> copiesBefore = null;
+
         private boolean started = false;
         private boolean stopped = false;
 
@@ -247,6 +383,7 @@ public class NativeVideoCompressorPlugin extends Plugin {
                 // stop() đã chạy trước khi worker kịp khởi động: đừng bắt đầu
                 // một lần nén mà không còn ai chờ kết quả.
                 if (!stopped) {
+                    copiesBefore = sourceCopyNames();
                     VideoCompressor.start(
                         getContext(),
                         Collections.singletonList(srcUri), // Nhận vào một List chứa đường dẫn
@@ -305,19 +442,21 @@ public class NativeVideoCompressorPlugin extends Plugin {
             // chờ finishUpload nữa.
             released.countDown();
 
-            if (wasRunning) {
-                // onCancelled của LightCompressor sẽ mở chốt; không tự gọi
-                // deliverCancelled ở đây để nhánh dọn file tạm vẫn chạy.
+            // Đã trả kết quả (đang giữ cho upload) thì không còn gì của job này
+            // để huỷ - cancel() global lúc đó chỉ giết job khác đang nén.
+            if (wasRunning && !delivered.get()) {
                 try {
                     VideoCompressor.cancel();
                 } catch (Exception e) {
                     Log.w(TAG, "Could not cancel compression", e);
-                    deliverCancelled();
                 }
-            } else {
-                // Chưa bắt đầu thì không có callback nào bắn, phải tự kết thúc.
-                deliverCancelled();
             }
+            // Luôn tự kết thúc: coroutine của LightCompressor bị huỷ thường ném
+            // CancellationException mà không bắn callback nào (trước onStart,
+            // hay lúc processAudio/finishMovie không đọc isRunning). claim()
+            // biến onCancelled tới sau thành no-op, còn onSuccess lỡ tới thì
+            // tự xoá output.
+            deliverCancelled();
         }
 
         private CompressionListener listener() {
@@ -334,6 +473,7 @@ public class NativeVideoCompressorPlugin extends Plugin {
                 @Override
                 public void onFailure(int i, @NonNull String failureMessage) {
                     if (!claim()) return;
+                    deleteOutput(fileName);
                     call.reject("Nén thất bại: " + failureMessage);
                 }
 
@@ -343,7 +483,12 @@ public class NativeVideoCompressorPlugin extends Plugin {
                     // đọc `compressed` ngay khi chốt đó mở để quyết định có ở
                     // lại chờ upload hay không.
                     compressed = s != null;
-                    if (!claim()) return;
+                    if (!claim()) {
+                        // Đã trả CANCELLED trước đó (stop() tự kết thúc):
+                        // không ai nhận file này.
+                        deleteOutput(fileName);
+                        return;
+                    }
                     // Nén xong, trả kết quả đường dẫn file mới về cho JS
                     JSObject ret = new JSObject();
                     ret.put("success", true);
@@ -379,6 +524,8 @@ public class NativeVideoCompressorPlugin extends Plugin {
         /** True đúng một lần, cho nhánh kết thúc đầu tiên tới đích. */
         private boolean claim() {
             if (!delivered.compareAndSet(false, true)) return false;
+            Set<String> before = copiesBefore;
+            if (before != null) deleteSourceCopiesSince(before);
             synchronized (NativeVideoCompressorPlugin.this) {
                 if (jobId.equals(currentJobId)) currentJobId = null;
             }
@@ -400,10 +547,12 @@ public class NativeVideoCompressorPlugin extends Plugin {
         }
     }
 
-    /** Best-effort: a partial file left in the cache is not worth failing over. */
+    /** Best-effort: a partial file left behind is not worth failing over. */
     private void deleteOutput(String fileName) {
         try {
-            File dir = new File(getContext().getExternalFilesDir(null), STORAGE_SUBFOLDER);
+            // Nơi LightCompressor 1.3.2 ghi với AppSpecificStorageConfiguration:
+            // File(context.filesDir, "<subFolder>/<name>").
+            File dir = new File(getContext().getFilesDir(), STORAGE_SUBFOLDER);
             File partial = new File(dir, fileName);
             if (partial.exists()) {
                 partial.delete();

package/android/src/main/java/com/atomic/videocompressor/VideoCompressionWorker.java

@@ -81,6 +81,19 @@ public class VideoCompressionWorker extends Worker {
         return true;
     }
 
+    /** Dừng và gỡ mọi job đang đăng ký - chúng thuộc một phiên WebView đã chết. */
+    static void stopAll() {
+        for (String jobId : pending.keySet()) stop(jobId);
+    }
+
+    /** Dừng và gỡ job của jobId; false khi không còn job nào mang id đó. */
+    static boolean stop(String jobId) {
+        Job job = pending.remove(jobId);
+        if (job == null) return false;
+        job.stop();
+        return true;
+    }
+
     @Nullable
     private volatile Job running = null;
 
@@ -106,7 +119,8 @@ public class VideoCompressionWorker extends Worker {
             job.run();
         } finally {
             running = null;
-            pending.remove(jobId);
+            // Hai tham số: một phiên mới có thể đã đăng ký lại cùng jobId.
+            pending.remove(jobId, job);
         }
         return Result.success();
     }

package/dist/docs.json

@@ -55,7 +55,7 @@
         ],
         "returns": "Promise<{ released: boolean; }>",
         "tags": [],
-        "docs": "Release the worker that `holdForUpload` kept alive for this job.\n\nCall it on every terminal branch of the upload, success or failure. A\nmissed call leaves the device feeding an idle job until the hold expires.\n`released` is false when no job by that id was still being held, which is\nthe normal outcome of a late or duplicate call, not an error.",
+        "docs": "Release the worker that `holdForUpload` kept alive for this job.\n\nCall it on every terminal branch of the upload, success or failure. A\nmissed call leaves the device feeding an idle job until the hold expires.\n`released` is false when no job by that id was still being held, which is\nthe normal outcome of a late or duplicate call, not an error.\n\nWeb: deletes the compressed output instead, so call it only once the File\nis no longer needed (not before a retry).",
         "complexTypes": [],
         "slug": "finishupload"
       },

package/dist/esm/definitions.d.ts

@@ -5,6 +5,20 @@ import type { PluginListenerHandle } from '@capacitor/core';
  * retry prompt — and tell it apart from a genuine compression failure.
  */
 export declare const CANCELLED = "CANCELLED";
+/**
+ * `code` on the error `compressVideo` rejects with on web when WebCodecs can't
+ * encode the video and it is larger than 200 MB, the cap for the ffmpeg.wasm
+ * fallback. ffmpeg.wasm copies the whole input into wasm memory (~2 GB
+ * ceiling), so a large file there crashes or hangs the tab rather than failing
+ * cleanly.
+ */
+export declare const TOO_LARGE_FOR_WEB = "TOO_LARGE_FOR_WEB";
+/**
+ * `code` on the error `compressVideo` rejects with on web when the browser
+ * refuses to store more of the output (storage quota). Retryable once space
+ * is freed.
+ */
+export declare const STORAGE_FULL = "STORAGE_FULL";
 export interface CompressOptions {
     sourcePath: string;
     destPath?: string;
@@ -74,6 +88,9 @@ export interface NativeVideoCompressorPlugin {
      * missed call leaves the device feeding an idle job until the hold expires.
      * `released` is false when no job by that id was still being held, which is
      * the normal outcome of a late or duplicate call, not an error.
+     *
+     * Web: deletes the compressed output instead, so call it only once the File
+     * is no longer needed (not before a retry).
      */
     finishUpload(options: {
         jobId: string;

package/dist/esm/definitions.js

@@ -4,4 +4,18 @@
  * retry prompt — and tell it apart from a genuine compression failure.
  */
 export const CANCELLED = 'CANCELLED';
+/**
+ * `code` on the error `compressVideo` rejects with on web when WebCodecs can't
+ * encode the video and it is larger than 200 MB, the cap for the ffmpeg.wasm
+ * fallback. ffmpeg.wasm copies the whole input into wasm memory (~2 GB
+ * ceiling), so a large file there crashes or hangs the tab rather than failing
+ * cleanly.
+ */
+export const TOO_LARGE_FOR_WEB = 'TOO_LARGE_FOR_WEB';
+/**
+ * `code` on the error `compressVideo` rejects with on web when the browser
+ * refuses to store more of the output (storage quota). Retryable once space
+ * is freed.
+ */
+export const STORAGE_FULL = 'STORAGE_FULL';
 //# sourceMappingURL=definitions.js.map

package/dist/esm/definitions.js.map

@@ -1 +1 @@
-{"version":3,"file":"definitions.js","sourceRoot":"","sources":["../../src/definitions.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,WAAW,CAAC","sourcesContent":["import type { PluginListenerHandle } from '@capacitor/core';\n\n/**\n * `code` on the error `compressVideo` rejects with when `cancel()` stopped it.\n * Callers should treat it as \"the user asked for this\" — no error toast, no\n * retry prompt — and tell it apart from a genuine compression failure.\n */\nexport const CANCELLED = 'CANCELLED';\n\nexport interface CompressOptions {\n  sourcePath: string;\n  destPath?: string;\n  quality?: 'VERY_HIGH' | 'HIGH' | 'MEDIUM' | 'LOW' | 'VERY_LOW' | '360P';\n  /**\n   * Names this compress so `cancel({ jobId })` can target it.\n   *\n   * Every platform compresses one video at a time, so cancellation is global\n   * by nature. Two independent callers in the same app (say a comment queue\n   * and a notes queue) therefore need a way to say *which* job they mean —\n   * without one, a cancel from either kills whatever the other is running.\n   */\n  jobId?: string;\n  /**\n   * Android only: keep the background worker alive after the compress ends,\n   * until `finishUpload({ jobId })` is called.\n   *\n   * The upload runs as JavaScript in the webview, and the moment the worker\n   * returns the process becomes cached and is frozen — measured on Android 16,\n   * an in-flight upload dies about five seconds later. Set this whenever the\n   * compressed file is about to be uploaded, and always pair it with a\n   * `finishUpload` in a `finally`.\n   */\n  holdForUpload?: boolean;\n}\n\nexport interface CompressResult {\n  success: boolean;\n  destPath: string;\n}\n\nexport interface CancelOptions {\n  /**\n   * Only cancel if this is the job currently running. Omit to cancel whatever\n   * is running, whoever started it.\n   */\n  jobId?: string;\n}\n\nexport interface CancelResult {\n  /** False when nothing was running, or when a different job was. */\n  cancelled: boolean;\n}\n\nexport interface NativeVideoCompressorPlugin {\n  /**\n   * Compress one video and resolve with the path of the result.\n   *\n   * Android: the work runs inside a WorkManager worker, which keeps the\n   * process out of the frozen cached state while the user is away — there is\n   * no foreground service and no notification, because Google Play classes\n   * this use case as data sync plus local processing and rejects\n   * `FOREGROUND_SERVICE_MEDIA_PROCESSING` for it. WorkManager stops a worker\n   * after 10 minutes, so a compress that runs longer rejects with\n   * {@link CANCELLED}.\n   */\n  compressVideo(options: CompressOptions): Promise<CompressResult>;\n\n  /**\n   * Stop the compress that is running now. `compressVideo` then rejects with\n   * code {@link CANCELLED} and its partial output is deleted.\n   *\n   * This is the only way to stop one: the work is synchronous WASM inside a\n   * web worker (web) or an AVFoundation / LightCompressor pass on its own\n   * thread (native), and none of them watch an AbortSignal.\n   */\n  cancel(options?: CancelOptions): Promise<CancelResult>;\n\n  /**\n   * Release the worker that `holdForUpload` kept alive for this job.\n   *\n   * Call it on every terminal branch of the upload, success or failure. A\n   * missed call leaves the device feeding an idle job until the hold expires.\n   * `released` is false when no job by that id was still being held, which is\n   * the normal outcome of a late or duplicate call, not an error.\n   */\n  finishUpload(options: { jobId: string }): Promise<{ released: boolean }>;\n\n  initialize(): Promise<{ success: boolean; message?: string }>;\n\n  // Đã sửa lại chuẩn cho Capacitor mới nhất (chỉ trả về Promise)\n  addListener(\n    eventName: 'onProgress',\n    listenerFunc: (info: { status: string; percent?: number }) => void,\n  ): Promise<PluginListenerHandle>;\n}\n"]}
+{"version":3,"file":"definitions.js","sourceRoot":"","sources":["../../src/definitions.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,WAAW,CAAC;AAErC;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,mBAAmB,CAAC;AAErD;;;;GAIG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,cAAc,CAAC","sourcesContent":["import type { PluginListenerHandle } from '@capacitor/core';\n\n/**\n * `code` on the error `compressVideo` rejects with when `cancel()` stopped it.\n * Callers should treat it as \"the user asked for this\" — no error toast, no\n * retry prompt — and tell it apart from a genuine compression failure.\n */\nexport const CANCELLED = 'CANCELLED';\n\n/**\n * `code` on the error `compressVideo` rejects with on web when WebCodecs can't\n * encode the video and it is larger than 200 MB, the cap for the ffmpeg.wasm\n * fallback. ffmpeg.wasm copies the whole input into wasm memory (~2 GB\n * ceiling), so a large file there crashes or hangs the tab rather than failing\n * cleanly.\n */\nexport const TOO_LARGE_FOR_WEB = 'TOO_LARGE_FOR_WEB';\n\n/**\n * `code` on the error `compressVideo` rejects with on web when the browser\n * refuses to store more of the output (storage quota). Retryable once space\n * is freed.\n */\nexport const STORAGE_FULL = 'STORAGE_FULL';\n\nexport interface CompressOptions {\n  sourcePath: string;\n  destPath?: string;\n  quality?: 'VERY_HIGH' | 'HIGH' | 'MEDIUM' | 'LOW' | 'VERY_LOW' | '360P';\n  /**\n   * Names this compress so `cancel({ jobId })` can target it.\n   *\n   * Every platform compresses one video at a time, so cancellation is global\n   * by nature. Two independent callers in the same app (say a comment queue\n   * and a notes queue) therefore need a way to say *which* job they mean —\n   * without one, a cancel from either kills whatever the other is running.\n   */\n  jobId?: string;\n  /**\n   * Android only: keep the background worker alive after the compress ends,\n   * until `finishUpload({ jobId })` is called.\n   *\n   * The upload runs as JavaScript in the webview, and the moment the worker\n   * returns the process becomes cached and is frozen — measured on Android 16,\n   * an in-flight upload dies about five seconds later. Set this whenever the\n   * compressed file is about to be uploaded, and always pair it with a\n   * `finishUpload` in a `finally`.\n   */\n  holdForUpload?: boolean;\n}\n\nexport interface CompressResult {\n  success: boolean;\n  destPath: string;\n}\n\nexport interface CancelOptions {\n  /**\n   * Only cancel if this is the job currently running. Omit to cancel whatever\n   * is running, whoever started it.\n   */\n  jobId?: string;\n}\n\nexport interface CancelResult {\n  /** False when nothing was running, or when a different job was. */\n  cancelled: boolean;\n}\n\nexport interface NativeVideoCompressorPlugin {\n  /**\n   * Compress one video and resolve with the path of the result.\n   *\n   * Android: the work runs inside a WorkManager worker, which keeps the\n   * process out of the frozen cached state while the user is away — there is\n   * no foreground service and no notification, because Google Play classes\n   * this use case as data sync plus local processing and rejects\n   * `FOREGROUND_SERVICE_MEDIA_PROCESSING` for it. WorkManager stops a worker\n   * after 10 minutes, so a compress that runs longer rejects with\n   * {@link CANCELLED}.\n   */\n  compressVideo(options: CompressOptions): Promise<CompressResult>;\n\n  /**\n   * Stop the compress that is running now. `compressVideo` then rejects with\n   * code {@link CANCELLED} and its partial output is deleted.\n   *\n   * This is the only way to stop one: the work is synchronous WASM inside a\n   * web worker (web) or an AVFoundation / LightCompressor pass on its own\n   * thread (native), and none of them watch an AbortSignal.\n   */\n  cancel(options?: CancelOptions): Promise<CancelResult>;\n\n  /**\n   * Release the worker that `holdForUpload` kept alive for this job.\n   *\n   * Call it on every terminal branch of the upload, success or failure. A\n   * missed call leaves the device feeding an idle job until the hold expires.\n   * `released` is false when no job by that id was still being held, which is\n   * the normal outcome of a late or duplicate call, not an error.\n   *\n   * Web: deletes the compressed output instead, so call it only once the File\n   * is no longer needed (not before a retry).\n   */\n  finishUpload(options: { jobId: string }): Promise<{ released: boolean }>;\n\n  initialize(): Promise<{ success: boolean; message?: string }>;\n\n  // Đã sửa lại chuẩn cho Capacitor mới nhất (chỉ trả về Promise)\n  addListener(\n    eventName: 'onProgress',\n    listenerFunc: (info: { status: string; percent?: number }) => void,\n  ): Promise<PluginListenerHandle>;\n}\n"]}

package/dist/esm/opfs-output.d.ts

@@ -0,0 +1,7 @@
+export interface OpfsOutput {
+    writable: FileSystemWritableFileStream;
+    read: () => Promise<Blob>;
+    discard: () => Promise<void>;
+}
+/** Null when OPFS or `createWritable` (missing on Safari's main thread) isn't there. */
+export declare const createOpfsOutput: () => Promise<OpfsOutput | null>;