capacitor-native-video-compressor 1.2.0 → 2.0.0

package/README.md

@@ -229,9 +229,9 @@ The `quality` parameter determines the output resolution and compression ratio.
 
 * [`compressVideo(...)`](#compressvideo)
 * [`cancel(...)`](#cancel)
+* [`finishUpload(...)`](#finishupload)
 * [`initialize()`](#initialize)
 * [`addListener('onProgress', ...)`](#addlisteneronprogress-)
-* [`addListener('onCancelRequested', ...)`](#addlisteneroncancelrequested-)
 * [Interfaces](#interfaces)
 
 </docgen-index>
@@ -245,6 +245,16 @@ The `quality` parameter determines the output resolution and compression ratio.
 compressVideo(options: CompressOptions) => Promise<CompressResult>
 ```
 
+Compress one video and resolve with the path of the result.
+
+Android: the work runs inside a WorkManager worker, which keeps the
+process out of the frozen cached state while the user is away — there is
+no foreground service and no notification, because Google Play classes
+this use case as data sync plus local processing and rejects
+`FOREGROUND_SERVICE_MEDIA_PROCESSING` for it. WorkManager stops a worker
+after 10 minutes, so a compress that runs longer rejects with
+{@link CANCELLED}.
+
 | Param         | Type                                                        |
 | ------------- | ----------------------------------------------------------- |
 | **`options`** | <code><a href="#compressoptions">CompressOptions</a></code> |
@@ -276,6 +286,28 @@ thread (native), and none of them watch an AbortSignal.
 --------------------
 
 
+### finishUpload(...)
+
+```typescript
+finishUpload(options: { jobId: string; }) => Promise<{ released: boolean; }>
+```
+
+Release the worker that `holdForUpload` kept alive for this job.
+
+Call it on every terminal branch of the upload, success or failure. A
+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.
+
+| Param         | Type                            |
+| ------------- | ------------------------------- |
+| **`options`** | <code>{ jobId: string; }</code> |
+
+**Returns:** <code>Promise&lt;{ released: boolean; }&gt;</code>
+
+--------------------
+
+
 ### initialize()
 
 ```typescript
@@ -303,29 +335,6 @@ addListener(eventName: 'onProgress', listenerFunc: (info: { status: string; perc
 --------------------
 
 
-### addListener('onCancelRequested', ...)
-
-```typescript
-addListener(eventName: 'onCancelRequested', listenerFunc: () => void) => Promise<PluginListenerHandle>
-```
-
-Android: user đã bấm "Huỷ" trên notification của foreground service.
-
-Pha nén được plugin tự huỷ trước khi event này bắn, nhưng việc caller định
-làm với kết quả nén - upload chẳng hạn - thì không ai dừng hộ được, nên
-caller phải tự abort. Bỏ qua event này nghĩa là nút Huỷ không thật sự huỷ,
-và Play đánh trượt tiêu chí "can be terminated or stopped by the user".
-
-| Param              | Type                             |
-| ------------------ | -------------------------------- |
-| **`eventName`**    | <code>'onCancelRequested'</code> |
-| **`listenerFunc`** | <code>() =&gt; void</code>       |
-
-**Returns:** <code>Promise&lt;<a href="#pluginlistenerhandle">PluginListenerHandle</a>&gt;</code>
-
---------------------
-
-
 ### Interfaces
 
 
@@ -339,12 +348,13 @@ và Play đánh trượt tiêu chí "can be terminated or stopped by the user".
 
 #### CompressOptions
 
-| Prop             | Type                                                                            | Description                                                                                                                                                                                                                                                                                                                                              |
-| ---------------- | ------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| **`sourcePath`** | <code>string</code>                                                             |                                                                                                                                                                                                                                                                                                                                                          |
-| **`destPath`**   | <code>string</code>                                                             |                                                                                                                                                                                                                                                                                                                                                          |
-| **`quality`**    | <code>'VERY_HIGH' \| 'HIGH' \| 'MEDIUM' \| 'LOW' \| 'VERY_LOW' \| '360P'</code> |                                                                                                                                                                                                                                                                                                                                                          |
-| **`jobId`**      | <code>string</code>                                                             | Names this compress so `cancel({ jobId })` can target it. Every platform compresses one video at a time, so cancellation is global by nature. Two independent callers in the same app (say a comment queue and a notes queue) therefore need a way to say *which* job they mean — without one, a cancel from either kills whatever the other is running. |
+| Prop                | Type                                                                            | Description                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| ------------------- | ------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| **`sourcePath`**    | <code>string</code>                                                             |                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| **`destPath`**      | <code>string</code>                                                             |                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| **`quality`**       | <code>'VERY_HIGH' \| 'HIGH' \| 'MEDIUM' \| 'LOW' \| 'VERY_LOW' \| '360P'</code> |                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| **`jobId`**         | <code>string</code>                                                             | Names this compress so `cancel({ jobId })` can target it. Every platform compresses one video at a time, so cancellation is global by nature. Two independent callers in the same app (say a comment queue and a notes queue) therefore need a way to say *which* job they mean — without one, a cancel from either kills whatever the other is running.                                                                                         |
+| **`holdForUpload`** | <code>boolean</code>                                                            | Android only: keep the background worker alive after the compress ends, until `finishUpload({ jobId })` is called. The upload runs as JavaScript in the webview, and the moment the worker returns the process becomes cached and is frozen — measured on Android 16, an in-flight upload dies about five seconds later. Set this whenever the compressed file is about to be uploaded, and always pair it with a `finishUpload` in a `finally`. |
 
 
 #### CancelResult

package/android/build.gradle

@@ -3,6 +3,7 @@ ext {
     androidxAppCompatVersion = project.hasProperty('androidxAppCompatVersion') ? rootProject.ext.androidxAppCompatVersion : '1.7.1'
     androidxJunitVersion = project.hasProperty('androidxJunitVersion') ? rootProject.ext.androidxJunitVersion : '1.3.0'
     androidxEspressoCoreVersion = project.hasProperty('androidxEspressoCoreVersion') ? rootProject.ext.androidxEspressoCoreVersion : '3.7.0'
+    androidxWorkVersion = project.hasProperty('androidxWorkVersion') ? rootProject.ext.androidxWorkVersion : '2.10.0'
 }
 
 buildscript {
@@ -21,10 +22,9 @@ android {
     namespace = "com.atomic.videocompressor"
     compileSdk = project.hasProperty('compileSdkVersion') ? rootProject.ext.compileSdkVersion : 36
     defaultConfig {
-        // 35, không phải 24: foreground service của pha nén khai mediaProcessing,
-        // type chỉ tồn tại từ API 35. Dưới mức đó hệ thống đọc ra "type unknown"
-        // và startForeground() ném InvalidForegroundServiceTypeException.
-        minSdkVersion project.hasProperty('minSdkVersion') ? rootProject.ext.minSdkVersion : 35
+        // 24 trở lại: mức 35 trước đây chỉ để đáp ứng foreground service type
+        // mediaProcessing, thứ đã gỡ hẳn. WorkManager chạy từ API 21.
+        minSdkVersion project.hasProperty('minSdkVersion') ? rootProject.ext.minSdkVersion : 24
         targetSdkVersion project.hasProperty('targetSdkVersion') ? rootProject.ext.targetSdkVersion : 36
         versionCode 1
         versionName "1.0"
@@ -60,4 +60,6 @@ dependencies {
     androidTestImplementation "androidx.test.ext:junit:$androidxJunitVersion"
     androidTestImplementation "androidx.test.espresso:espresso-core:$androidxEspressoCoreVersion"
     implementation 'com.github.AbedElazizShe:LightCompressor:1.3.2'
+    // Giữ process khỏi bị đóng băng trong lúc nén, thay cho foreground service.
+    implementation "androidx.work:work-runtime:$androidxWorkVersion"
 }

package/android/src/main/AndroidManifest.xml

@@ -1,20 +1,11 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android">
-    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
-    <!-- Chỉ mediaProcessing: service sống đúng bằng pha nén, là use case duy
-         nhất ở đây thực sự chạy khi user rời app. Không khai dataSync nữa, vì
-         pha upload chạy bằng JS trong webview nên nó đứng lại ngay khi app
-         xuống nền - giữ foreground service cho nó là khai một việc không diễn
-         ra, và Play xét FGS theo use case chứ không theo số service.
+    <!-- Cố ý rỗng. Google Play xếp "nén rồi upload video do user chọn" vào data
+         sync + local processing chứ không phải media transcoding, nên
+         FOREGROUND_SERVICE_MEDIA_PROCESSING bị từ chối ở version code 32 kèm
+         yêu cầu chuyển sang WorkManager.
 
-         mediaProcessing chỉ có từ API 35, và ở đây không còn type nào để hạ
-         xuống, nên minSdk của plugin là 35 (xem android/build.gradle). -->
-    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MEDIA_PROCESSING" />
-    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
-
-    <application>
-        <service
-            android:name="com.atomic.videocompressor.VideoCompressionService"
-            android:foregroundServiceType="mediaProcessing"
-            android:exported="false" />
-    </application>
+         Pha nén giờ chạy trong VideoCompressionWorker, thứ WorkManager tự
+         quản lý - không service nào để khai, và mọi permission plugin từng
+         thêm vào app (FOREGROUND_SERVICE, FOREGROUND_SERVICE_MEDIA_PROCESSING,
+         POST_NOTIFICATIONS) đều đã gỡ. Đừng thêm lại. -->
 </manifest>

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

@@ -1,10 +1,13 @@
 package com.atomic.videocompressor;
 
-import android.content.Intent;
 import android.net.Uri;
 import android.util.Log;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
+import androidx.work.Data;
+import androidx.work.ExistingWorkPolicy;
+import androidx.work.OneTimeWorkRequest;
+import androidx.work.WorkManager;
 import com.abedelazizshe.lightcompressorlibrary.CompressionListener;
 import com.abedelazizshe.lightcompressorlibrary.VideoCompressor;
 import com.abedelazizshe.lightcompressorlibrary.VideoQuality;
@@ -16,13 +19,17 @@ import com.getcapacitor.PluginCall;
 import com.getcapacitor.PluginMethod;
 import com.getcapacitor.annotation.CapacitorPlugin;
 import java.io.File;
-import java.lang.ref.WeakReference;
 import java.util.Arrays;
 import java.util.Collections;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
 
 @CapacitorPlugin(name = "NativeVideoCompressor")
 public class NativeVideoCompressorPlugin extends Plugin {
 
+    private static final String TAG = "NativeVideoCompressor";
+
     /**
      * Matches the `CANCELLED` constant the JS side exports, so one
      * `error.code` check covers web, iOS and Android alike.
@@ -32,51 +39,14 @@ public class NativeVideoCompressorPlugin extends Plugin {
     private static final String STORAGE_SUBFOLDER = "compressed_videos";
 
     /**
-     * Instance đang sống, để service gọi ngược khi user bấm "Huỷ" trên
-     * notification. WeakReference vì service sống lâu hơn bridge: giữ cứng ở
-     * đây là giữ luôn cả WebView sau khi Activity đã chết.
+     * 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 WeakReference<NativeVideoCompressorPlugin> active = new WeakReference<>(null);
+    private static final long HOLD_FOR_UPLOAD_TIMEOUT_MINUTES = 8;
 
     /** The job compressVideo is running right now, for cancel({ jobId }). */
     private String currentJobId = null;
 
-    @Override
-    public void load() {
-        super.load();
-        active = new WeakReference<>(this);
-    }
-
-    @Override
-    protected void handleOnDestroy() {
-        if (active.get() == this) active = new WeakReference<>(null);
-        super.handleOnDestroy();
-    }
-
-    /**
-     * User bấm "Huỷ" trên notification. Phải huỷ được cả hai pha:
-     *
-     *  - pha nén chạy trong LightCompressor (native) -> cancel() tĩnh, gọi được
-     *    kể cả khi bridge đã chết
-     *  - pha upload chạy trong JS -> chỉ có thể nhờ JS tự dừng, nên bắn
-     *    onCancelRequested; không có event này thì bấm Huỷ lúc đang upload chỉ
-     *    tắt được notification còn request vẫn chạy tiếp, và Play coi như
-     *    "không dừng được bởi user".
-     */
-    static void cancelAllFromNotification() {
-        try {
-            VideoCompressor.cancel();
-        } catch (Exception e) {
-            Log.w("NativeVideoCompressor", "Could not cancel compression", e);
-        }
-        NativeVideoCompressorPlugin plugin = active.get();
-        if (plugin == null) return;
-        synchronized (plugin) {
-            plugin.currentJobId = null;
-        }
-        plugin.notifyListeners("onCancelRequested", new JSObject());
-    }
-
     /**
      * Nothing to do natively; LightCompressor needs no warm-up. Answered
      * rather than left unimplemented so a caller can await it unconditionally
@@ -104,11 +74,15 @@ public class NativeVideoCompressorPlugin extends Plugin {
         // running job could finish and a new one start in the gap — and
         // VideoCompressor.cancel() being global, it would kill the newcomer.
         // That is exactly what checking the jobId is meant to prevent.
-        // The call is non-blocking (it cancels a coroutine job), so holding
-        // the lock across it costs nothing.
+        // Both calls are non-blocking (one cancels a coroutine job, the other
+        // returns an Operation), so holding the lock across them costs nothing.
         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();
             }
         }
@@ -117,6 +91,21 @@ public class NativeVideoCompressorPlugin extends Plugin {
         call.resolve(ret);
     }
 
+    /**
+     * Caller báo đã xong việc với kết quả nén - thường là upload xong - nên
+     * worker đang giữ process sống được phép kết thúc.
+     *
+     * Phải gọi trên MỌI nhánh kết thúc của pha upload, kể cả nhánh lỗi. Bỏ sót
+     * một nhánh nghĩa là máy phải nuôi một job rỗng tới khi hết hạn giữ.
+     */
+    @PluginMethod
+    public void finishUpload(PluginCall call) {
+        String jobId = call.getString("jobId");
+        JSObject ret = new JSObject();
+        ret.put("released", jobId != null && VideoCompressionWorker.release(jobId));
+        call.resolve(ret);
+    }
+
     @PluginMethod
     public void compressVideo(PluginCall call) {
         String sourcePath = call.getString("sourcePath");
@@ -127,9 +116,6 @@ public class NativeVideoCompressorPlugin extends Plugin {
         }
 
         String jobId = call.getString("jobId", "default");
-        synchronized (this) {
-            currentJobId = jobId;
-        }
 
         // 1. Chuẩn bị Uri và Tên file xuất ra
         Uri srcUri;
@@ -161,10 +147,7 @@ public class NativeVideoCompressorPlugin extends Plugin {
             }
         }
 
-        Log.d(
-            "NativeVideoCompressor",
-            "====== VIDEO COMPRESSION QUALITY RECEIVED: " + qualityString + "+ video quality: " + videoQuality + " ======"
-        );
+        Log.d(TAG, "====== VIDEO COMPRESSION QUALITY RECEIVED: " + qualityString + "+ video 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
@@ -182,38 +165,165 @@ public class NativeVideoCompressorPlugin extends Plugin {
         // 3. Cấu hình nơi lưu (Lưu an toàn vào thư mục nội bộ của App)
         AppSpecificStorageConfiguration storageConfig = new AppSpecificStorageConfiguration(STORAGE_SUBFOLDER);
 
-        // Khởi động Foreground Service để giữ app luôn sống khi chạy ngầm
-        Intent serviceIntent = new Intent(getContext(), VideoCompressionService.class);
-        serviceIntent.setAction(VideoCompressionService.ACTION_START);
-        serviceIntent.putExtra(VideoCompressionService.EXTRA_JOB_ID, jobId);
+        synchronized (this) {
+            currentJobId = jobId;
+        }
+
+        // 4. Giao pha nén cho WorkManager. Không nén thẳng ở đây: một thread
+        // thường bị đóng băng cùng process ngay khi user rời app, còn process
+        // đang chạy worker thì không. Đây là phương án Google Play chỉ đích
+        // danh khi từ chối foreground service ở version code 32.
+        boolean holdForUpload = Boolean.TRUE.equals(call.getBoolean("holdForUpload", false));
+        CompressionJob job = new CompressionJob(jobId, srcUri, fileName, configuration, storageConfig, call, holdForUpload);
+        VideoCompressionWorker.register(jobId, job);
+
+        OneTimeWorkRequest request = new OneTimeWorkRequest.Builder(VideoCompressionWorker.class)
+            .setInputData(new Data.Builder().putString(VideoCompressionWorker.KEY_JOB_ID, jobId).build())
+            .build();
+
         try {
-            if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.O) {
-                getContext().startForegroundService(serviceIntent);
+            WorkManager.getInstance(getContext()).enqueueUniqueWork(workName(jobId), ExistingWorkPolicy.REPLACE, request);
+        } catch (Exception e) {
+            VideoCompressionWorker.unregister(jobId);
+            synchronized (this) {
+                currentJobId = null;
+            }
+            call.reject("Cannot schedule video compression", e);
+        }
+    }
+
+    /**
+     * Một lần nén, chạy bên trong {@link VideoCompressionWorker}.
+     *
+     * Không phải static: nó cần notifyListeners và getContext của plugin đang
+     * sống để bắn progress và trả kết quả về đúng PluginCall.
+     */
+    private final class CompressionJob implements VideoCompressionWorker.Job {
+
+        private final String jobId;
+        private final Uri srcUri;
+        private final String fileName;
+        private final Configuration configuration;
+        private final AppSpecificStorageConfiguration storageConfig;
+        private final PluginCall call;
+        private final boolean holdForUpload;
+
+        /** Mở khi pha nén kết thúc, để worker biết lúc nào được trả về. */
+        private final CountDownLatch done = new CountDownLatch(1);
+
+        /** Mở khi caller gọi finishUpload - chỉ dùng khi holdForUpload. */
+        private final CountDownLatch released = new CountDownLatch(1);
+
+        /** Chốt một-lần cho mọi nhánh kết thúc; PluginCall chỉ được trả lời một lần. */
+        private final AtomicBoolean delivered = new AtomicBoolean(false);
+
+        /** True khi nén xong có kết quả dùng được, tức là có cái để upload. */
+        private volatile boolean compressed = false;
+
+        private boolean started = false;
+        private boolean stopped = false;
+
+        CompressionJob(
+            String jobId,
+            Uri srcUri,
+            String fileName,
+            Configuration configuration,
+            AppSpecificStorageConfiguration storageConfig,
+            PluginCall call,
+            boolean holdForUpload
+        ) {
+            this.jobId = jobId;
+            this.srcUri = srcUri;
+            this.fileName = fileName;
+            this.configuration = configuration;
+            this.storageConfig = storageConfig;
+            this.call = call;
+            this.holdForUpload = holdForUpload;
+        }
+
+        @Override
+        public void run() {
+            synchronized (this) {
+                // 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) {
+                    VideoCompressor.start(
+                        getContext(),
+                        Collections.singletonList(srcUri), // Nhận vào một List chứa đường dẫn
+                        false, // isStreamable
+                        null, // sharedStorageConfiguration (Không dùng)
+                        storageConfig, // Cấu hình lưu trữ
+                        configuration, // Cấu hình chất lượng
+                        listener()
+                    );
+                    started = true;
+                }
+            }
+
+            if (!started) {
+                deliverCancelled();
+                return;
+            }
+
+            try {
+                done.await();
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+                deliverCancelled();
+                return;
+            }
+
+            // Nén hỏng hoặc bị huỷ thì không có gì để upload - về ngay thay vì
+            // giữ process sống chờ một finishUpload không bao giờ tới.
+            if (!holdForUpload || !compressed) return;
+
+            try {
+                // Có hạn chứ không chờ vô tận: nếu caller chết giữa pha upload
+                // mà không gọi finishUpload, worker sẽ treo tới khi WorkManager
+                // cắt ở phút thứ 10. Về sớm hơn để trả quota job lại cho máy.
+                released.await(HOLD_FOR_UPLOAD_TIMEOUT_MINUTES, TimeUnit.MINUTES);
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+            }
+        }
+
+        @Override
+        public void release() {
+            released.countDown();
+        }
+
+        @Override
+        public void stop() {
+            boolean wasRunning;
+            synchronized (this) {
+                if (stopped) return;
+                stopped = true;
+                wasRunning = started;
+            }
+
+            // Trước mọi thứ khác: worker đang bị cắt, đừng để run() còn ngồi
+            // 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.
+                try {
+                    VideoCompressor.cancel();
+                } catch (Exception e) {
+                    Log.w(TAG, "Could not cancel compression", e);
+                    deliverCancelled();
+                }
             } else {
-                getContext().startService(serviceIntent);
+                // Chưa bắt đầu thì không có callback nào bắn, phải tự kết thúc.
+                deliverCancelled();
             }
-        } catch (Exception e) {
-            synchronized (this) { currentJobId = null; }
-            call.reject("Cannot start foreground video processing", e);
-            return;
         }
 
-        // 4. Bắt đầu nén (Đã cập nhật List Uri và int index)
-        VideoCompressor.start(
-            getContext(),
-            Collections.singletonList(srcUri), // Nhận vào một List chứa đường dẫn
-            false, // isStreamable
-            null, // sharedStorageConfiguration (Không dùng)
-            storageConfig, // Cấu hình lưu trữ
-            configuration, // Cấu hình chất lượng
-            new CompressionListener() {
+        private CompressionListener listener() {
+            return new CompressionListener() {
                 @Override
                 public void onProgress(int i, float v) {
-                    // Notification phải nhúc nhích theo đúng con số mà UI trong
-                    // app đang hiển thị: một notification đứng im là lý do Play
-                    // đánh trượt tiêu chí "user perceptible".
-                    VideoCompressionService.publishProgress(jobId, Math.round(v));
-
                     // Gửi % tiến độ về Javascript để vẽ thanh Progress
                     JSObject ret = new JSObject();
                     ret.put("status", "progress");
@@ -223,13 +333,17 @@ public class NativeVideoCompressorPlugin extends Plugin {
 
                 @Override
                 public void onFailure(int i, @NonNull String failureMessage) {
-                    finishJob(jobId);
+                    if (!claim()) return;
                     call.reject("Nén thất bại: " + failureMessage);
                 }
 
                 @Override
                 public void onSuccess(int i, long l, @Nullable String s) {
-                    finishJob(jobId);
+                    // Phải đặt TRƯỚC claim(): claim() mở chốt `done`, và run()
+                    // đọc `compressed` ngay khi chốt đó mở để quyết định có ở
+                    // lại chờ upload hay không.
+                    compressed = s != null;
+                    if (!claim()) 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);
@@ -246,43 +360,43 @@ public class NativeVideoCompressorPlugin extends Plugin {
 
                 @Override
                 public void onCancelled(int i) {
-                    finishJob(jobId);
-                    // LightCompressor leaves whatever it had already written
-                    // behind; without this the cache keeps a partial mp4 per
-                    // cancel, and nothing ever collects them.
-                    deleteOutput(fileName);
-                    // Coded so the caller can tell "the user asked for this"
-                    // apart from a real failure — same code on every platform.
-                    call.reject("Đã hủy nén", CANCELLED_CODE);
+                    deliverCancelled();
                 }
+            };
+        }
+
+        private void deliverCancelled() {
+            if (!claim()) return;
+            // LightCompressor leaves whatever it had already written behind;
+            // without this the cache keeps a partial mp4 per cancel, and
+            // nothing ever collects them.
+            deleteOutput(fileName);
+            // Coded so the caller can tell "the user asked for this" apart
+            // from a real failure — same code on every platform.
+            call.reject("Đã hủy nén", CANCELLED_CODE);
+        }
+
+        /** 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;
+            synchronized (NativeVideoCompressorPlugin.this) {
+                if (jobId.equals(currentJobId)) currentJobId = null;
             }
-        );
+            done.countDown();
+            return true;
+        }
     }
 
-    /** Every terminal callback ends here, so neither is ever left running. */
-    private void finishJob(String jobId) {
-        sendToService(VideoCompressionService.ACTION_FINISH, jobId);
-        synchronized (this) {
-            currentJobId = null;
-        }
+    private String workName(String jobId) {
+        return "video-compression:" + jobId;
     }
 
-    /**
-     * Lệnh gửi vào service, nuốt lỗi có chủ đích.
-     *
-     * startService() từ background bị chặn khi app không còn foreground service
-     * nào chạy - đúng tình huống xảy ra khi service đã tự tắt bằng watchdog rồi
-     * JS mới gọi finishUpload. Ném ra ở đây sẽ biến một lần dọn dẹp vô hại thành
-     * một lần nén báo lỗi cho user.
-     */
-    private void sendToService(String action, String jobId) {
+    /** Best-effort: huỷ một work đã xong là no-op, không đáng để hỏng lời gọi cancel. */
+    private void cancelWork(String jobId) {
         try {
-            Intent intent = new Intent(getContext(), VideoCompressionService.class);
-            intent.setAction(action);
-            intent.putExtra(VideoCompressionService.EXTRA_JOB_ID, jobId);
-            getContext().startService(intent);
+            WorkManager.getInstance(getContext()).cancelUniqueWork(workName(jobId));
         } catch (Exception e) {
-            Log.w("NativeVideoCompressor", "Could not send " + action + " to service", e);
+            Log.w(TAG, "Could not cancel work for " + jobId, e);
         }
     }
 
@@ -295,7 +409,7 @@ public class NativeVideoCompressorPlugin extends Plugin {
                 partial.delete();
             }
         } catch (Exception e) {
-            Log.w("NativeVideoCompressor", "Could not delete cancelled output", e);
+            Log.w(TAG, "Could not delete cancelled output", e);
         }
     }
 }